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

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

NCBI C++ ToolKit: include/util/bitset/bmbmatrix.h Source File

<

BV>

is_remap_support {

{

=

}; };

is_dynamic_splices {

{

=

}; };

bvector_type::statistics* stat = 0);

<

Val,

BVect,

MAX_SIZE>

{ (void)sz,(

)set_null; }

*idx_from = from; *idx_to = to;

;

<

Val,

BV,

MAX_SIZE>

bvector_type::optmode opt_mode = bvector_type::opt_compress,

bvector_type::statistics* stat = 0);

<

BV>

: bv_size_(bv_max_size),

<

BV>

<

BV>

: bv_size_(bbm.bv_size_),

<

BV>

: bv_size_(bbm.bv_size_),

is_dynamic_ = bbm.is_dynamic_;

<

BV>

bv_rows_[

];

<

BV>

bv_rows_[

];

<

BV>

bv_rows_[

];

<

BV>

null_idx_ = null_idx;

<

BV>

bv_rows_[

] = bv ? construct_bvector(bv) : 0;

<

BV>

r_to = (!erase_null && null_idx_) ? null_idx_ : rsize_;

<

BV>

bv->insert(idx,

);

<

BV>

bv->clear_bit_no_check(idx);

<

BV>

bv->swap(idx1, idx2);

<

BV>

(rsize <= rsize_prev)

((!null_idx_) || (rsize & 1u));

::memset(&bv_rows_[0], 0, rsize *

(bv_rows_[0]));

bv_rows_[

] = bv_rows_prev[

];

alloc_.free_ptr(bv_rows_prev,

(rsize_prev));

bv_rows_[rsize-1] = bv_rows_[null_idx_];

bv_rows_[null_idx_] = 0;

null_idx_ = rsize-1;

<

BV>

slices = rows();

clear_row(

, free_mem);

<

BV>

slices = (unsigned) this->rows();

arg_slices = (unsigned) bbm.rows();

max_slices(slices);

(max_slices < arg_slices)

max_slices = arg_slices;

(

j = 0;

&& (j < max_slices); ++j)

bv = (j < slices) ? this->get_row(j) : 0;

arg_bv = (j < arg_slices) ? bbm.get_row(j) : 0;

= bv->equal(*arg_bv);

<

BV>

osize = (7 + rows_not_null()) / 8;

<

BV>

destruct_bvector(bv);

alloc_.free_ptr(bv_rows_,

(rsize_));

<

BV>

(rsize_ != bbm.rsize_)

(null_idx_ != bbm.null_idx_)

(

(bv) !=

(bv_arg))

<

BV>

(pool_ != pool_ptr)

bv->set_allocator_pool(pool_ptr);

<

BV>

= rows_not_null();

(--

;

> 0; --

)

<

BV>

<

BV>

<

BV>

alloc_ = bbm.alloc_;

bbm.alloc_ = alloc_tmp;

bbm.pool_ = pool_tmp;

bv_rows_ = bbm.bv_rows_;

bbm.bv_rows_ = rtmp;

<

BV>

(

>= new_rsize)

allocate_rows(new_rsize);

bv = bv_rows_[

] = construct_bvector(0);

<

BV>

allocate_rows(

+ 8);

bv = bv_rows_[

] = construct_bvector(&bv_src);

<

BV>

destruct_bvector(bv);

bv_rows_[

] = 0;

<

BV>

destruct_bvector(bv);

bv_rows_[

] = 0;

<

BV>

BM_THROW(

, BM_ERR_BADALLOC);

rbv =

(mem)

(ap_.strat, ap_.glevel_len, bv_size_, alloc_);

rbv =

(ap_.strat, ap_.glevel_len, bv_size_, alloc_);

rbv->set_allocator_pool(pool_);

<

BV>

<

BV>

bv->get_blocks_manager().get_block_ptr(

, j);

<

BV>

slice_from,

slice_until,

(

p = slice_from; p < slice_until; ++p)

bv->clear_bit_no_check(idx);

<

BV>

octet)

(7u + octet_idx * 8u > rsize_)

allocate_rows(rsize_ + 16);

(;

< row_end; ++

)

bv = this->construct_row(

);

bv->set_bit_no_check(pos);

bv->clear_bit_no_check(pos);

(row_end > rsize_)

bv->clear_bit_no_check(pos);

<

BV>

octet)

(;

< row_end; ++

)

bv = this->construct_row(

);

bv->set_bit_no_check(pos);

bv->insert(pos,

);

bv->insert(pos,

);

(row_end > rsize_)

bv->insert(pos,

);

b1 = (blka[0] == FBADDR);

b2 = (blka[1] == FBADDR);

b1 |= (blka[2] == FBADDR);

b2 |= (blka[3] == FBADDR);

b1 |= (blka[4] == FBADDR);

b2 |= (blka[5] == FBADDR);

b1 |= (blka[6] == FBADDR);

b2 |= (blka[7] == FBADDR);

<

BV>

row_idx = unsigned(octet_idx * 8);

(row_idx + 7 >= rsize_ ||

(null_idx_ && (row_idx + 7 > null_idx_)))

(

)v;

blka[0] = get_block(row_idx+0, i0, j0);

blka[1] = get_block(row_idx+1, i0, j0);

blka[2] = get_block(row_idx+2, i0, j0);

blka[3] = get_block(row_idx+3, i0, j0);

blka[4] = get_block(row_idx+4, i0, j0);

blka[5] = get_block(row_idx+5, i0, j0);

blka[6] = get_block(row_idx+6, i0, j0);

blka[7] = get_block(row_idx+7, i0, j0);

(

* blk; (blk = blka[0])!=0)

v |= (unsigned)

(is_set);

(

* blk;(blk = blka[1])!=0)

v |= unsigned(

(is_set)) << 1u;

(

* blk;(blk = blka[2])!=0)

v |= unsigned(

(is_set)) << 2u;

(

* blk;(blk = blka[3])!=0)

v |= unsigned(

(is_set)) << 3u;

(

* blk;(blk = blka[4])!=0)

v |= unsigned(

(is_set)) << 4u;

(

* blk;(blk = blka[5])!=0)

v |= unsigned(

(is_set)) << 5u;

(

* blk;(blk = blka[6])!=0)

v |= unsigned(

(is_set)) << 6u;

(

* blk;(blk = blka[7])!=0)

v |= unsigned(

(is_set)) << 7u;

(

)v;

((blk = blka[0])!=0)

v |= (unsigned)

(is_set);

((blk = blka[1])!=0)

v |= unsigned(

(is_set)) << 1u;

((blk = blka[2])!=0)

v |= unsigned(

(is_set)) << 2u;

((blk = blka[3])!=0)

v |= unsigned(

(is_set)) << 3u;

((blk = blka[4])!=0)

v |= unsigned(

(is_set)) << 4u;

((blk = blka[5])!=0)

v |= unsigned(

(is_set)) << 5u;

((blk = blka[6])!=0)

v |= unsigned(

(is_set)) << 6u;

((blk = blka[7])!=0)

v |= unsigned(

(is_set)) << 7u;

(

)v;

<

BV>

= char(get_octet(pos, octet_idx));

<

BV>

blka[0] = get_block(row_idx+0, i0, j0);

blka[1] = get_block(row_idx+1, i0, j0);

blka[2] = get_block(row_idx+2, i0, j0);

blka[3] = get_block(row_idx+3, i0, j0);

(!

(blka[0], blka[1], blka[2], blka[3]))

(

(blka[0], blka[1], blka[2], blka[3]))

v = unsigned(

((blka[0][nword] & mask0))) |

unsigned(

((blka[1][nword] & mask0)) << 1u) |

unsigned(

((blka[2][nword] & mask0)) << 2u) |

unsigned(

((blka[3][nword] & mask0)) << 3u);

((blk = blka[

])!=0)

v |= unsigned(

(is_set)) <<

;

((blk = blka[++

])!=0)

v |= unsigned(

(is_set)) <<

;

<

BV>

bvector_type::optmode opt_mode,

bvector_type::statistics*

)

(

k = 0; k < rsize_; ++k)

bvector_type::statistics stbv;

bv->optimize(temp_block, opt_mode,

? &stbv : 0);

<

BV>

(

k = 0; k < rsize_; ++k)

<

BV>

bvector_type::statistics stbv;

bv->calc_stat(&stbv);

.max_serialize_mem += 8;

<

BV>

BV::optmode opt_mode)

(

k = 0; k < rsize_; ++k)

bvector_type::blocks_manager_type& bman =

bv->get_blocks_manager();

bman.optimize_bit_block(

, j, opt_mode);

<

BV>

digest_bv.clear(

);

planes = (unsigned)rows();

(

= 0;

< planes; ++

)

digest_bv.set_bit_no_check(

);

<

Val,

BV,

MAX_SIZE>

<

Val,

BV,

MAX_SIZE>

: bmatr_(sv_slices, is_dynamic, ap, bv_max_size, alloc)

null_idx = (MAX_SIZE *

(Val) * 8);

<

Val,

BV,

MAX_SIZE>

: bmatr_(bsv.bmatr_),

slice_mask_(bsv.slice_mask_),

effective_slices_(bsv.effective_slices_)

<

Val,

BV,

MAX_SIZE>

bmatr_.null_idx_ = arg_null_idx;

bmatr_.allocate_rows(slices);

(

&& (

== arg_null_idx))

bv->set_range(0, size_-1);

bmatr_.destruct_row(

);

bmatr_.construct_row(

, *bv_src);

<

Val,

BV,

MAX_SIZE>

(rows < arg_rows)

bmatr_.allocate_rows(rows);

(this->bmatr_.rows() == arg_rows);

bv_null_arg = bmatr.

(null_idx);

bv_null->merge(*bv_null_arg);

(rows > arg_rows)

(

j = 0; j < rows; ++j)

(arg_bv && arg_bv != bv_null_arg)

<

Val,

BV,

MAX_SIZE>

bmatr_.swap(bsv.bmatr_);

(effective_slices_, bsv.effective_slices_);

<

Val,

BV,

MAX_SIZE>

slices = bmatr_.rows();

bmatr_.clear_row(

, free_mem);

slice_mask_ = 0; size_ = 0;

bv_null->clear(

);

this->bmatr_.is_ro_ =

;

<

Val,

BV,

MAX_SIZE>

clear_range(right, left, set_null);

planes = bmatr_.rows();

(

= 0;

< planes; ++

)

bv->clear_range_no_check(left, right);

(set_null && bv_null)

bv_null->clear_range_no_check(left, right);

<

Val,

BV,

MAX_SIZE>

this->clear_range(0, left-1, (slice_null ==

));

this->clear_range(right + 1, sz, (slice_null ==

));

<

Val,

BV,

MAX_SIZE>

clear_range(sz, this->size_, set_null);

<

Val,

BV,

MAX_SIZE>

(bv_null) ? (!bv_null->test(idx)) :

;

<

Val,

BV,

MAX_SIZE>

bv_null->insert(idx, not_null);

<

Val,

BV,

MAX_SIZE>

(

> effective_slices_)

effective_slices_ =

;

<

Val,

BV,

MAX_SIZE>

planes =

(

) * 8;

slice_size = (element_idx+1) * planes;

(slice_size > this->bmatr_.rows())

slice_size = (

) this->bmatr_.rows();

(

= element_idx * planes;

< slice_size; ++

, ++bidx)

|= get_slice(

) ? (mask1 << bidx) : 0ull;

<

Val,

BV,

MAX_SIZE>

bvector_type::optmode opt_mode,

bvector_type::statistics*

)

bvector_type::statistics stbv;

bmatr_.optimize(temp_block, opt_mode, &stbv);

slices = (unsigned)this->bmatr_.rows();

(

j = 0; j < slices; ++j)

(bv && (bv != bv_null))

this->bmatr_.destruct_row(j);

<

Val,

BV,

MAX_SIZE>

bvector_type::statistics*

)

slices = this->get_bmatrix().rows();

bmatr_.calc_stat(*

, slices);

->max_serialize_mem += 1 + 1 + 1 + 1 + 8 + (8 * slices);

->max_serialize_mem += 1 + 8;

<

Val,

BV,

MAX_SIZE>

bmatr_.clear_column(idx, plane_idx);

<

Val,

BV,

MAX_SIZE>

bmatr_.insert_column(idx, plane_idx);

<

Val,

BV,

MAX_SIZE>

bmatr_.erase_column(idx, erase_null);

<

Val,

BV,

MAX_SIZE>

(

arg_size = sv.size(); this->size_ != arg_size)

slices = (unsigned) this->bmatr_.rows();

arg_slices = (unsigned) sv.bmatr_.rows();

max_slices(slices);

(max_slices < arg_slices)

max_slices = arg_slices;

* bv_null = this->get_null_bvector();

* bv_null_arg = sv.get_null_bvector();

(

j = 0; j < max_slices; ++j)

bv = (j < slices) ? this->bmatr_.get_row(j) : 0;

arg_bv = (j < arg_slices) ? sv.bmatr_.get_row(j) : 0;

(arg_bv == bv_null_arg)

= bv->equal(*arg_bv);

(bv_null == bv_null_arg)

(!bv_null || !bv_null_arg)

= bv_null->equal(*bv_null_arg);

<

Val,

BV,

MAX_SIZE>

slices = (unsigned) this->bmatr_.rows();

(

j = 0; j < slices; ++j)

(

* bv = this->bmatr_.get_row(j))

bmatr_.is_ro_ =

;

<

Val,

BV,

MAX_SIZE>

spli = this->bmatr_.rows();

bv_null->copy_range(*bv_null_arg, left, right);

spli = this->bmatr_.rows();

(arg_bv == bv_null_arg)

* bv = this->get_create_slice(

(j));

bv->copy_range(*arg_bv, left, right);

<

Val,

BV,

MAX_SIZE>

constexpr (is_signed())

<

Val,

BV,

MAX_SIZE>

constexpr (is_signed())

ncbi::TMaskedQueryRegions mask

Compressed bit-vector bvector<> container, set algebraic methods, traversal iterators.

#define BM_DECLARE_TEMP_BLOCK(x)

Constants, lookup tables and typedefs.

#define FULL_BLOCK_FAKE_ADDR

Utilities for bit transposition (internal) (experimental!)

Base class for bit-transposed(bit-sliced) sparse vector construction.

allocator_pool_type * get_allocator_pool() const noexcept

Get allocation pool.

void freeze_matr()

Turn on RO mode.

void clear_all(bool free_mem=true) noexcept

resize to zero, free memory

bm::id64_t get_slice_mask(unsigned element_idx) const noexcept

void resize(size_type new_size, bool set_null)

unsigned_value_type slice_mask_

slice presence bit-mask

const bvector_type * bvector_type_const_ptr

void merge_matr(bmatrix_type &bmatr)

Merge plane bvectors from an outside base matrix Note: outside base matrix gets destroyed.

const bmatrix_type & get_bmatrix() const noexcept

bvector_type * bvector_type_ptr

const value_type & const_reference

void copy_from(const base_sparse_vector< Val, BV, MAX_SIZE > &bsv)

bool empty() const noexcept

bvector_type_ptr slice(unsigned i) noexcept

get access to bit-plane as is (can return NULL)

bvector_type_const_ptr slice(unsigned i) const noexcept

bvector_type::allocation_policy allocation_policy_type

void clear_range(size_type left, size_type right, bool set_null)

bvector_type_ptr get_create_slice(unsigned i)

get access to bit-plain, function checks and creates a plane

static constexpr unsigned value_bits() noexcept

Number of total bit-planes in the value type.

static unsigned slices() noexcept

get total number of bit-planes in the vector

static value_type u2s(unsigned_value_type v) noexcept

Convert unsigned value type to signed representation.

size_type size() const noexcept

void sync_ro() noexcept

Sybc read-only state.

base_sparse_vector(const base_sparse_vector< Val, BV, MAX_SIZE > &bsv)

unsigned effective_slices() const noexcept

Number of effective bit-planes in the value type.

bool is_nullable() const noexcept

check if container supports NULL(unassigned) values

void free_slice(unsigned i)

free memory in bit-plane

void optimize_block(block_idx_type nb, typename BV::optmode opt_mode)

plane index for the "NOT NULL" flags plane

bool is_null(size_type idx) const noexcept

test if specified element is NULL

unsigned effective_slices_

number of bit slices actually allocated

void calc_stat(typename bvector_type::statistics *st) const noexcept

Calculates memory statistics.

bvector_type_const_ptr get_slice(unsigned i) const noexcept

get read-only access to bit-plane

bmatrix_type bmatr_

bit-transposed matrix

void erase_column(size_type idx, bool erase_null)

allocator_type::allocator_pool_type allocator_pool_type

base_sparse_vector(bm::null_support null_able, bool is_dynamic, allocation_policy_type ap=allocation_policy_type(), size_type bv_max_size=bm::id_max, const allocator_type &alloc=allocator_type())

void swap_elements(size_type idx1, size_type idx2)

swap two vector elements

void swap(base_sparse_vector< Val, BV, MAX_SIZE > &bsv) noexcept

bmatrix_type & get_bmatrix() noexcept

access to internal bit-matrix

static unsigned_value_type s2u(value_type v) noexcept

Convert signed value type to unsigned representation.

void copy_range_slices(const base_sparse_vector< Val, BV, MAX_SIZE > &bsv, typename base_sparse_vector< Val, BV, MAX_SIZE >::size_type left, typename base_sparse_vector< Val, BV, MAX_SIZE >::size_type right, bm::null_support slice_null)

Perform copy_range() on a set of planes.

void set_allocator_pool(allocator_pool_type *pool_ptr) noexcept

Set allocation pool.

size_type size_

array size

void bit_and_rows(const bvector_type &bv)

Set AND (intersect) operation on all existing bit-slices.

bool equal(const base_sparse_vector< Val, BV, MAX_SIZE > &sv, bm::null_support null_able=bm::use_null) const noexcept

check if another sparse vector has the same content and size

void keep_range_no_check(size_type left, size_type right, bm::null_support slice_null)

std::make_unsigned< value_type >::type unsigned_value_type

void set_ro_flag(bool b) noexcept

Force RO flag without running freeze ops on content.

bvector_type::enumerator bvector_enumerator_type

void bit_sub_rows(const bvector_type &bv, bool use_null)

Set SUB (MINUS) operation on all existing bit-slices.

bm::basic_bmatrix< BV > bmatrix_type

static constexpr bool is_signed() noexcept

returns true if value type is signed integral type

static unsigned stored_slices() noexcept

Number of stored bit-planes (value planes + extra.

const bvector_type * get_null_bvector() const noexcept

Get bit-vector of assigned values or NULL (if not constructed that way)

bm::null_support get_null_support() const noexcept

check if container supports NULL (unassigned) values

base_sparse_vector(base_sparse_vector< Val, BV, MAX_SIZE > &&bsv) noexcept

bvector_type * get_null_bvect() noexcept

BV::allocator_type allocator_type

void optimize(bm::word_t *temp_block=0, typename bvector_type::optmode opt_mode=bvector_type::opt_compress, typename bvector_type::statistics *stat=0)

run memory optimization for all bit-vector rows

void insert_null(size_type idx, bool not_null)

void clear_value_planes_from(unsigned plane_idx, size_type idx)

void mark_null_idx(unsigned null_idx) noexcept

Set NULL plain index.

void insert_clear_value_planes_from(unsigned plane_idx, size_type idx)

bvector_type::block_idx_type block_idx_type

Basic dense bit-matrix class.

void insert_octet(size_type pos, size_type octet_idx, unsigned char octet)

void insert_column(size_type idx, size_type row_from)

allocator_pool_type * get_allocator_pool() const noexcept

bool is_ro() const noexcept

return true if matrix is in read-only mode

unsigned char get_octet(size_type pos, size_type octet_idx) const noexcept

bvector_type::block_idx_type block_idx_type

bool equal(const basic_bmatrix< BV > &bbm) const noexcept

basic_bmatrix< BV > & operator=(const basic_bmatrix< BV > &bbm)

int compare_octet(size_type pos, size_type octet_idx, char octet) const noexcept

bool is_same_structure(const basic_bmatrix< BV > &bbm) const noexcept

Debugging function to check if two matrixes have the same rows created.

void set_allocator_pool(allocator_pool_type *pool_ptr) noexcept

bvector_type * bvector_type_ptr

bvector_type_ptr * bv_rows_

void calc_stat(typename bvector_type::statistics *st) const noexcept

const unsigned char * get_remap_buffer() const noexcept

void swap_columns(size_type idx1, size_type idx2)

bool is_dynamic_

if rsize is dynamic (variable length)

void swap(basic_bmatrix< BV > &bbm) noexcept

unsigned get_half_octet(size_type pos, size_type row_idx) const noexcept

bvector_type_ptr construct_row(size_type row)

static constexpr bool is_compressed() noexcept

void set_null_idx(size_type null_idx) noexcept

set index of the NULL vector

const bvector_type * row(size_type i) const noexcept

void calc_stat(typename bvector_type::statistics &st, size_type rsize) const noexcept

size_type rows_not_null() const noexcept

BV::allocator_type allocator_type

void mark_null_idx(unsigned null_idx) noexcept

bvector_type::allocation_policy allocation_policy_type

remap_matrix_type * get_remap_matrix()

size_type null_idx_

Index of the NULL row.

allocator_type::allocator_pool_type allocator_pool_type

void destruct_row(size_type row)

const bvector_type * bvector_type_const_ptr

unsigned char * init_remap_buffer() noexcept

bvector_type * construct_bvector(const bvector_type *bv) const

const bm::word_t * get_block(size_type p, unsigned i, unsigned j) const noexcept

Get low level internal access to.

void bit_and_rows(const bvector_type &bv)

Set AND (intersect) operation on all existing rows.

const basic_bmatrix< BV > & get_bmatrix() const noexcept

return *this (for serializer compat)

void build_plane_digest(bvector_type &digest_bv) const

Construct digest vector of 1s for every row in the matrix.

size_type size() const noexcept

return size of the vector (always bm::id_max )

size_t remap_size() const noexcept

bvector_type_ptr get_create_slice(unsigned i)

allocator_pool_type * pool_

size_type size_internal() const noexcept

same as size()

void sync(bool, bool) noexcept

syncronize internal structures, build fast access index

void free_rows() noexcept

Free all rows.

void copy_from(const basic_bmatrix< BV > &bbm)

static void throw_bad_alloc()

void optimize(bm::word_t *temp_block=0, typename bvector_type::optmode opt_mode=bvector_type::opt_compress, typename bvector_type::statistics *stat=0)

run memory optimization for all bit-vector rows

const remap_matrix_type * get_remap_matrix() const

static constexpr bool is_str() noexcept

void clear_slices_range(unsigned slice_from, unsigned slize_until, size_type idx)

Clear bit-planes bit.

~basic_bmatrix() noexcept

bvector_type * get_row(size_type i) noexcept

void clear_column(size_type idx, size_type row_from)

void set_ro_flag(bool b) noexcept

Force RO flag without running freeze ops on content.

void clear_row(size_type row, bool free_mem)

void clear() noexcept

resize to zero, free memory

void allocate_rows(size_type rsize)

allocate matrix rows of bit-vectors (new rows are NULLs)

void optimize_block(block_idx_type nb, typename BV::optmode opt_mode)

bvector_type * get_null_bvector() noexcept

always return 0 as basic matrix does not support the notion of NULL plane (as sparse_vectors do)

size_type calc_effective_rows_not_null() const noexcept

allocation_policy_type ap_

bvector_type_const_ptr get_row(size_type i) const noexcept

void destruct_bvector(bvector_type *bv) const

void resize_internal(size_type sz, bool set_null=true) noexcept

size_type octet_size() const noexcept

void set_octet(size_type pos, size_type octet_idx, unsigned char octet)

bool is_dynamic() const noexcept

Return if matrix is dynamic resizable.

void erase_column(size_type idx, bool erase_null)

void set_remap() noexcept

basic_bmatrix(basic_bmatrix< BV > &&bbm) noexcept

size_type get_null_idx() const noexcept

return index of the NULL vector

basic_bmatrix(size_type rsize, bool is_dynamic=true, allocation_policy_type ap=allocation_policy_type(), size_type bv_max_size=bm::id_max, const allocator_type &alloc=allocator_type())

void bit_sub_rows(const bvector_type &bv, bool use_null)

Set SUB (MINUS) operation on all existing rows.

bool is_nullable() const noexcept

check if container supports NULL(unassigned) values

void clear_all(bool free_mem, unsigned) noexcept

resize to zero, free memory

bvector_type::statistics statistics

size_type rows() const noexcept

constexpr bool is_remap() const noexcept

various type traits

bool resolve_range(size_type from, size_type to, size_type *idx_from, size_type *idx_to) const noexcept

Nominal function for serializer compatibility.

bvector_type::size_type size_type

basic_bmatrix< BV > & get_bmatrix() noexcept

return *this (for serializer compat)

static unsigned stored_slices() noexcept

optmode

Optimization mode Every next level means additional checks (better compression vs time)

bvector_size_type size_type

blocks_manager_type::block_idx_type block_idx_type

Heap allocated scalar-type matrix.

Rank-Select compressed sparse vector.

sparse vector de-serializer

Serialize sparse vector into a memory buffer(s) structure.

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

null_support

NULL-able value support.

@ use_null

support "non-assigned" or "NULL" logic

@ no_null

do not support NULL values

unsigned gap_test_unr(const T *buf, const unsigned pos) noexcept

Tests if bit = pos is true. Analog of bm::gap_test with SIMD unrolling.

unsigned int

A callback function used to compare two keys in a database.

bool test_4gaps(const bm::word_t *p0, const bm::word_t *p1, const bm::word_t *p2, const bm::word_t *p3) noexcept

Test 4 pointers are all marked as GAPs.

void xor_swap(W &x, W &y) noexcept

XOR swap two variables.

const unsigned set_block_mask

void get_block_coord(BI_TYPE nb, unsigned &i, unsigned &j) noexcept

Recalc linear bvector block index into 2D matrix coordinates.

bool check_any_fullb(const bm::word_t *blka[8], const bm::word_t *FBADDR)

const unsigned set_word_shift

unsigned long long int id64_t

const unsigned set_block_shift

const unsigned set_word_mask

bool test_4bits(const bm::word_t *p0, const bm::word_t *p1, const bm::word_t *p2, const bm::word_t *p3) noexcept

Test 4 pointers are not NULL and not marked as FULLBLOCK.

double value_type

The numeric datatype used by the parser.

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

void resize(vector< SMethodDef > &container)

const GenericPointer< typename T::ValueType > T2 value

bool eq(T x_, T y_, T round_)

static SLJIT_INLINE sljit_ins st(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

#define row(bind, expected)

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