Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/SeqTable__sparse__index_8cpp_source.html below:

NCBI C++ ToolKit: src/objects/seqtable/SeqTable_sparse_index.cpp Source File

* tail_ptr =

*

(word_block_end);

* block_end = block +

;

( ; tail_ptr != block_end; ++tail_ptr ) {

(

= 0;

< 8; ++

,

<<= 1 ) {

(

= prev_i+1;

< 8; ++

,

<<= 1 ) {

* ptr = beg;

( ; ptr != end &&

(ptr)%

(TBig); ++ptr ) {

( ; ptr+

(TBig) <= end; ptr +=

(TBig) ) {

( *

TBig*

(ptr) != 0 ) {

( ; ptr != end; ++ptr ) {

= bytes.size();

* ptr = &bytes[0];

= bytes.size();

block_index = byte_count / kBlockSize;

block_offset = byte_count % kBlockSize;

( ; block_index >

.m_BlocksFilled; ) {

( !

.m_Blocks ) {

block_count =

/ kBlockSize;

.m_Blocks.reset(

[block_count]);

next_index =

.m_BlocksFilled;

( next_index > 0 ) {

.m_BlocksFilled = next_index+1;

ret = block_index?

.m_Blocks[block_index-1]: 0;

( block_offset ) {

( block_index !=

.m_CacheBlockIndex ) {

( !

.m_CacheBlockInfo ) {

.m_CacheBlockInfo.reset(

[kBlockSize]);

block_pos = block_index*kBlockSize;

block_size =

(kBlockSize,

-block_pos);

* block = &bytes[block_pos];

(

= 0;

< block_size; ++

) {

.m_CacheBlockIndex = block_index;

ret +=

.m_CacheBlockInfo[block_offset-1];

: m_Blocks(new

[(

+kBlockSize-1)/kBlockSize]),

m_CacheBlockInfo(new

[kBlockSize]),

m_CacheBlockIndex(size_t(0)-1)

= deltas.size();

(block_offset < block_size);

(

= 0;

< block_size; ++

) {

= deltas.size();

(block_offset < block_size);

(

= 0;

<= block_offset; ++

) {

(

= block_offset+1;

< block_size; ++

) {

= deltas.size();

( block_index < m_BlocksFilled && find_sum >

[block_index] ) {

( find_sum >

[block_index] ) {

(value_index < block_size);

block_pos + value_index;

(

= 0;

< block_size; ++

) {

( sum >= find_sum ) {

(

j =

+1; j < block_size; ++j ) {

(index < deltas.size());

= deltas.size();

block_index = lower_bound(&

[0],

(

() ) {

indexes.empty()? 0: indexes.back()+1;

(

() ) {

indexes.empty()?

: indexes.front();

deltas.empty()?

: deltas.front();

value_index)

(

() ) {

++value_index >= indexes.size()?

++value_index >= deltas.size()?

byte_index =

/ 8;

bit_index =

% 8;

byte_index*8 + bit_index;

(

() ) {

TIndexes::const_iterator iter =

lower_bound(indexes.begin(), indexes.end(),

);

( iter != indexes.end() && *iter ==

) {

iter - indexes.begin();

byte_index =

/8;

( byte_index >= bytes.size() ) {

= bytes[byte_index];

bit_index =

%8;

( !((

<<bit_index)&0x80) ) {

(

() ) {

TIndexes::const_iterator iter =

lower_bound(indexes.begin(), indexes.end(),

);

iter != indexes.end() && *iter ==

;

< bits.size() && ((bits[

]<<j)&0x80) != 0;

);

*it =

- prev_row;

indexes.push_back(

-prev_row);

bytes.reserve((

()+7)/8);

last_byte_index = 0;

= it.GetRow();

byte_index =

/ 8;

( byte_index != last_byte_index ) {

( bytes.capacity() < byte_index+1 ) {

bytes.reserve(

(bytes.capacity(), byte_index+1)*2);

bytes.resize(last_byte_index);

bytes.push_back(last_byte);

last_byte_index = byte_index;

bit_index =

% 8;

last_byte |= 0x80 >> bit_index;

bytes.reserve(last_byte_index+1);

bytes.resize(last_byte_index);

bytes.push_back(last_byte);

= it.GetRow();

bv->set_bit(

TBVSize

(

));

static size_t sx_CalcByteBitCount(Uint4 word)

static size_t sx_FindFirstNonZeroByte(const char *beg, const char *end)

static size_t sx_CalcBlockBitCount(const char *block, size_t size)

static size_t sx_FindNextNonZeroBit(Uint1 b, size_t prev_i)

static size_t sx_FindFirstNonZeroBit(Uint1 b)

DEFINE_STATIC_MUTEX(sx_PrepareMutex_sparse_index)

User-defined methods of the data storage class.

Bit manipulation primitives (internal)

Serialization / compression of bvector<>. Set theoretical operations on compressed BLOBs.

const bm::bvector & GetBitVector(void) const

void SetBitVector(const bm::bvector<> *bv)

TValue GetDeltaSum(const TDeltas &deltas, size_t index)

static const size_t kBlockSize

CSeqTable_sparse_index_Base::TIndexes_delta TDeltas

CIndexDeltaSumCache(size_t size)

static const size_t kInvalidRow

TValue x_GetDeltaSum2(const TDeltas &deltas, size_t block_index, size_t block_offset)

AutoArray< TValue > m_CacheBlockInfo

~CIndexDeltaSumCache(void)

static const size_t kBlockTooLow

AutoArray< TValue > m_Blocks

size_t x_FindDeltaSum2(const TDeltas &deltas, size_t block_index, TValue find_sum)

size_t FindDeltaSum(const TDeltas &deltas, TValue find_sum)

Seq-loc and seq-align mapper exceptions.

void ChangeToIndexes_delta(void)

TIndexes_delta & SetIndexes_delta(void)

void ChangeToBit_set_bvector(void)

size_t GetSize(void) const

TIndexes & SetIndexes(void)

static const size_t kSkipped

size_t GetIndexAt(size_t row) const

size_t x_FindDeltaSum(size_t sum) const

const_iterator begin(void) const

size_t x_GetFirstRowWithValue(void) const

void ChangeTo(E_Choice type)

void ChangeToIndexes(void)

CIndexDeltaSumCache & x_GetDeltaCache(void) const

size_t x_GetNextRowWithValue(size_t row, size_t value_index) const

TBit_set_bvector & SetBit_set_bvector(void)

TBit_set & SetBit_set(void)

size_t x_GetBitSetCache(size_t byte_count) const

bool HasValueAt(size_t row) const

~CSeqTable_sparse_index(void)

static const size_t kInvalidRow

size_t x_GetDeltaSum(size_t index) const

void ChangeToBit_set(void)

bool get_bit(size_type n) const noexcept

returns true if bit n is set and false is bit n is 0.

size_type size() const noexcept

Returns bvector's capacity (number of bits it can store)

size_type count_range(size_type left, size_type right, const rs_index_type &rs_idx) const noexcept

Returns count of 1 bits in the given range [left..right] Uses rank-select index to accelerate the sea...

bvector_size_type size_type

size_type get_next(size_type prev) const noexcept

Finds the number of the next bit ON.

size_type get_first() const noexcept

find first 1 bit in vector. Function may return 0 and this requires an extra check if bit 0 is actual...

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

element_type * release(void)

Release will release ownership of pointer to caller.

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

TObjectType * GetNCPointerOrNull(void) const THROWS_NONE

Get pointer value.

void Reset(void)

Reset reference object.

uint8_t Uint1

1-byte (8-bit) unsigned integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

uint64_t Uint8

8-byte (64-bit) unsigned integer

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

bm::id_t word_bitcount(bm::id_t w) noexcept

unsigned bit_count_min_unroll(const bm::word_t *block, const bm::word_t *block_end) noexcept

Bitcount for bit block without agressive unrolling.

bool IsBit_set_bvector(void) const

Check if variant Bit_set_bvector is selected.

vector< unsigned > TIndexes

E_Choice Which(void) const

Which variant is currently selected.

const TIndexes & GetIndexes(void) const

Get the variant data.

bool IsIndexes_delta(void) const

Check if variant Indexes_delta is selected.

vector< unsigned > TIndexes_delta

const TBit_set & GetBit_set(void) const

Get the variant data.

bool IsBit_set(void) const

Check if variant Bit_set is selected.

const TBit_set_bvector & GetBit_set_bvector(void) const

Get the variant data.

const TIndexes_delta & GetIndexes_delta(void) const

Get the variant data.

E_Choice

Choice variants.

TSize GetSize(void) const

Get the Size member data.

bool IsIndexes(void) const

Check if variant Indexes is selected.

@ e_Bit_set

Bitset of rows with values, set bit means the row has value. Most-significant bit in each octet comes...

@ e_Bit_set_bvector

Bitset of rows with values, as serialized bvector<>, see include/util/bitset/bm.h.

@ e_Indexes_delta

Indexes of rows with values, delta-encoded.

@ e_Indexes

Indexes of rows with values.

static void byte(MDB_val *v)

double value_type

The numeric datatype used by the parser.

const struct ncbi::grid::netcache::search::fields::SIZE size

#define row(bind, expected)

static const size_t kBlockSize

Structure to aid in counting bits table contains count of bits in 0-255 diapason of numbers.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4