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

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

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

<

Val,

BV>

{

(*

) ==

(ref); }

{

(

== it.pos_) && (

== it.sv_); }

{

< it.pos_; }

{

<= it.pos_; }

{

> it.pos_; }

{

>= it.pos_; }

this->flush();

= bi.sv_; bv_null_ = bi.bv_null_;

this->set_not_null_ = bi.set_not_null_;

this->flush();

= bi.sv_; bv_null_ = bi.bv_null_;

this->buffer_.

(bi.buffer_);

this->buf_ptr_ = bi.buf_ptr_;

this->set_not_null_ = bi.set_not_null_;

set_not_null_ =

;

{

this->

(idx); }

set_not_null =

);

set_not_null =

);

zero_mem =

)

;

*idx_from = from; *idx_to = to;

;

set_not_null =

);

<

Val,

BV>

<

Val,

BV>

<

Val,

BV>

<

Val,

BV>

<

Val,

BV>

<

Val,

BV>

std::range_error(err_msg);

<

Val,

BV>

BV::throw_bad_alloc();

<

Val,

BV>

<

Val,

BV>

tmp_size = 1024;

(

< arr_size)

arr_tmp[k++] = this->s2u(

[

++]);

import_u(arr_tmp, k,

, set_not_null);

k = 0;

+= tmp_size;

import_u(arr_tmp, k,

, set_not_null);

<

Val,

BV>

throw_range_error(

);

(offset < this->size_)

this->import_u_nocheck(

, arr_size,

, set_not_null);

<

Val,

BV>

bit_capacity =

(Val)*8;

b_list[bit_capacity];

row_len[bit_capacity] = {0, };

transpose_window = 256;

(

= 0;

< arr_size; ++

)

(

j = 0; j < bcnt; ++j)

p = b_list[j];

rl = row_len[p];

tm.

(p)[rl] = bit_idx;

(rl == transpose_window)

bv = bv_slices[p] = this->get_create_slice(p);

bv->import_sorted(

, rl,

);

rows = tm.

();

(

k = 0; k < rows; ++k)

(

rl = row_len[k])

bv = this->get_create_slice(k);

bv->import_sorted(

, rl,

);

(

+

> this->size_)

<

Val,

BV>

* bv_null = this->get_null_bvector();

found = bv_null->find_reverse(this->size_);

this->size_ += found;

<

Val,

BV>

tmp_size = 1024;

(

< arr_size)

arr_tmp[k++] = this->s2u(

[

++]);

import_back_u(arr_tmp, k, set_not_null);

import_back_u(arr_tmp, k, set_not_null);

<

Val,

BV>

this->import_u_nocheck(

, arr_size, this->

(), set_not_null);

<

Val,

BV>

zero_mem)

extract(

, dec_size, idx_from, zero_mem);

<

Val,

BV>

[0] = this->get(idx[0]);

sorted_block =

;

(idx[

] < idx_prev)

sorted_block =

;

idx_prev = idx[

];

sorted_block =

;

eff_planes = this->effective_slices();

(

j = 0; j < eff_planes; ++j)

* blk = this->bmatr_.get_block(j, i0, j0);

gap_value = gap_blk[gidx];

(++k; k <

; ++k)

constexpr (parent_type::is_signed())

<

Val,

BV>

zero_mem)

(end > this->size_)

planes = this->effective_slices();

(

j = 0; j < planes; ++j)

blk = this->bmatr_.get_block(j, i0, j0);

(

k = start; k < end; ++k)

blk = this->bmatr_.get_block(j, i0, j0);

is_set = (blk[nword] & mask0);

constexpr (parent_type::is_signed())

<

Val,

BV>

zero_mem)

(end > this->size_)

(

= 0;

< parent_type::value_bits(); ++

)

BV::enumerator en(bv,

);

(;en.valid(); ++en)

<

Val,

BV>

sv_decode_visitor_func

: arr_(varr), mask_(

), sv_off_(off)

(

= 0;

< bits_size; ++

)

arr_[bits[

] + base] |= m;

base = bv_offset - sv_off_;

arr_[

+ base] |= m;

(end > this->size_)

sv_decode_visitor_func func(

, 0,

);

planes = this->effective_slices();

constexpr (parent_type::is_signed())

u2s_translate(

, exported_size);

exported_size;

<

Val,

BV>

::memcpy(&uv, &

[

],

(uv));

[

] = parent_type::u2s(uv);

<

Val,

BV>

(idx >= this->size_)

throw_range_error(

);

this->get(idx);

<

Val,

BV>

get_no_check(

);

<

Val,

BV>

constexpr (parent_type::is_signed())

this->u2s(uv);

<

Val,

BV>

eff_planes = this->effective_slices();

(

j = 0; smask && j < eff_planes; j+=4, smask >>= 4)

<

Val,

BV>

eff_planes = this->effective_slices();

(N_bits > eff_planes)

N_bits = eff_planes;

(

j = 0; j < N_bits; ++j)

= bv->test(idx);

<

Val,

BV>

(this->is_null(idx))

<

Val,

BV>

this->size_ = idx+1;

need_clear =

;

set_value(idx, v, need_clear);

<

Val,

BV>

this->size_ = idx+1;

bv_null->clear_bit_no_check(idx);

<

Val,

BV>

set_value(this->size_, v,

);

<

Val,

BV>

this->size_ +=

;

<

Val,

BV>

this->swap_elements(idx1, idx2);

<

Val,

BV>

this->size_ = idx+1;

set_value(idx, v,

);

insert_value(idx, v);

<

Val,

BV>

insert_value_no_null(idx, v);

this->insert_null(idx,

);

<

Val,

BV>

(;

<= bsr; ++

)

bv->insert(idx,

);

bv->insert(idx,

);

eff_planes = this->effective_slices();

(;

< eff_planes; ++

)

bv->insert(idx,

);

<

Val,

BV>

(idx >= this->size_)

this->erase_column(idx, erase_null);

this->size_ -= erase_null;

<

Val,

BV>

set_value_no_null(this->size_, v,

);

<

Val,

BV>

set_value_no_null(idx, v, need_clear);

bv_null->set_bit_no_check(idx);

<

Val,

BV>

eff_planes = this->effective_slices();

this->bmatr_.clear_slices_range(bsr, eff_planes, idx);

(

j = 0; j <= bsr; ++j)

bv->set_bit_no_check(idx);

(need_clear)

(

* blk = this->bmatr_.get_block(j, i0, j0))

bv->clear_bit_no_check(idx);

<

Val,

BV>

(idx >= this->size_)

this->size_ = idx+1;

set_value_no_null(idx, 1,

);

bv_null->set_bit_no_check(idx);

<

Val,

BV>

constexpr (parent_type::is_signed())

set_value_no_null(idx, v,

);

(

= 0;

< parent_type::sv_value_slices; ++

)

(

carry_over = bv->inc(idx); !carry_over)

<

Val,

BV>

set_value_no_null(idx, v + v_prev,

);

<

Val,

BV>

parent_type::clear_all(free_mem);

<

Val,

BV>

<

Val,

BV>

parent_type::clear_range(left, right, set_null);

<

Val,

BV>

bvector_type::statistics stbv;

parent_type::calc_stat(&stbv);

<

Val,

BV>

bvector_type::optmode opt_mode,

bvector_type::statistics stbv;

parent_type::optimize(temp_block, opt_mode,

? &stbv : 0);

<

Val,

BV>

stored_slices = this->stored_slices();

(

j = 0; j < stored_slices; ++j)

bv->optimize_gap_size();

<

Val,

BV>

(this->size_ < arg_size)

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

(

j = 0; j < planes; ++j)

join_null_slice(sv);

<

Val,

BV>

(this->size_ < arg_size)

this->merge_matr(sv.

);

join_null_slice(sv);

<

Val,

BV>

bv_null->set_range(0, arg_size-1);

<

Val,

BV>

this->copy_range_slices(sv, left, right, slice_null);

<

Val,

BV>

this->keep_range_no_check(left, right, slice_null);

<

Val,

BV>

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

(

j = 0; j < slices

; ++j)

bv->bit_and(bv_mask);

<

Val,

BV>

(sv_value >

) - (sv_value <

);

<

Val,

BV>

parent_type::equal(sv, null_able);

<

Val,

BV>

it_type(

);

<

Val,

BV>

this->bmatr_.set_allocator_pool(pool_ptr);

<

Val,

BV>

: sv_(0), pos_(

::

), buf_ptr_(0)

<

Val,

BV>

: sv_(it.sv_), pos_(it.pos_), buf_ptr_(0)

<

Val,

BV>

: sv_(sv), buf_ptr_(0)

<

Val,

BV>

: sv_(sv), buf_ptr_(0)

<

Val,

BV>

pos_ = (!sv_ || pos >= sv_->size()) ?

: pos;

<

Val,

BV>

(pos_ >= sv_->size())

<

Val,

BV>

sv_->extract(buf_ptr_,

, pos_,

);

<

Val,

BV>

(++buf_ptr_ < buf_end)

(pos_ >= sv_->size())

(buf_ptr_ >= buf_end)

<

Val,

BV>

sv_->is_null(pos_);

<

Val,

BV>

<

Val,

BV>

<

Val,

BV>

: sv_(bi.sv_), bv_null_(bi.bv_null_), buf_ptr_(0),

set_not_null_(bi.set_not_null_),

prev_nb_(bi.prev_nb_), opt_mode_(bi.opt_mode_)

<

Val,

BV>

: sv_(bi.sv_), bv_null_(bi.bv_null_), buf_ptr_(bi.buf_ptr_),

set_not_null_(bi.set_not_null_),

prev_nb_(bi.prev_nb_), opt_mode_(bi.opt_mode_)

buffer_.swap(bi.buffer_);

buf_ptr_ = bi.buf_ptr_;

<

Val,

BV>

<

Val,

BV>

this->add_value_no_null(v);

bv_null_->set_bit_no_check(sz + buf_idx);

<

Val,

BV>

<

Val,

BV>

<

Val,

BV>

sv_->push_back_null(

);

<

Val,

BV>

<

Val,

BV>

sv_->import_back_u(

, arr_size,

);

sv_->optimize_block(prev_nb_, opt_mode_);

ncbi::TMaskedQueryRegions mask

basic bit-matrix class and utilities

#define IS_FULL_BLOCK(addr)

#define BM_ASSERT_THROW(x, xerrcode)

#define FULL_BLOCK_FAKE_ADDR

Utilities for bit transposition (internal) (experimental!)

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

void freeze_matr()

Turn on RO mode.

void resize(size_type new_size, bool set_null)

const bmatrix_type & get_bmatrix() const noexcept

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

bvector_type::allocation_policy allocation_policy_type

void sync_ro() noexcept

Sybc read-only state.

bool is_nullable() const noexcept

check if container supports NULL(unassigned) values

bmatrix_type bmatr_

bit-transposed matrix

allocator_type::allocator_pool_type allocator_pool_type

static unsigned_value_type s2u(value_type v) noexcept

Convert signed value type to unsigned representation.

size_type size_

array size

std::make_unsigned< value_type >::type unsigned_value_type

void bit_sub_rows(const bvector_type &bv, bool use_null)

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

BV::allocator_type allocator_type

Basic dense bit-matrix class.

bool is_ro() const noexcept

return true if matrix is in read-only mode

const bvector_type * row(size_type i) const noexcept

bm::heap_matrix< unsigned char, sizeof(int), 256, typename bvector_type::allocator_type > remap_matrix_type

unused remap matrix type for compatibility with the sparse serializer

size_type get_null_idx() const noexcept

return index of the NULL vector

size_type rows() const noexcept

optmode

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

allocator_type::allocator_pool_type allocator_pool_type

bvector_size_type size_type

blocks_manager_type::block_idx_type block_idx_type

unsigned char * data() noexcept

Get write access to buffer memory.

void reserve(size_t new_capacity)

reserve new capacity (buffer content preserved)

Rank-Select compressed sparse vector.

Back insert iterator implements buffered insert, faster than generic access assignment.

back_insert_iterator & operator*()

noop

void add_null(size_type count)

add a series of consequitve NULLs (no-value) to the container

bm::byte_buffer< allocator_type > buffer_type

void disable_set_null() noexcept

Reconfigure back inserter not to touch the NULL vector.

bvector_type::allocator_type::allocator_pool_type allocator_pool_type

void operator=(value_type v)

push value to the vector

bvector_type::block_idx_type block_idx_type

void operator=(const back_insert_iterator &bi)

back_insert_iterator & operator++()

noop

bvector_type * get_null_bvect() const noexcept

Get access to not-null vector.

back_insert_iterator & operator++(int)

noop

sparse_vector_type::unsigned_value_type unsigned_value_type

void add_null()

add NULL (no-value) to the container

sparse_vector_type::size_type size_type

bool flush()

flush the accumulated buffer

bvector_type * bv_null_

!< pointer on the parent vector

back_insert_iterator(const back_insert_iterator &bi)

void add(value_type v)

add value to the container

bool empty() const

return true if insertion buffer is empty

sparse_vector_type * sparse_vector_type_ptr

unsigned_value_type * buf_ptr_

!< not NULL vector pointer

back_insert_iterator(sparse_vector_type *sv)

bvector_type::allocator_type allocator_type

void add_value_no_null(value_type v)

add value to the buffer without changing the NULL vector

sparse_vector< Val, BV > sparse_vector_type

back_insert_iterator(back_insert_iterator &&bi) noexcept

move constructor

std::output_iterator_tag iterator_category

sparse_vector_type::value_type value_type

bm::sparse_vector< Val, BV > * sv_

!< value buffer

sparse_vector_type::bvector_type bvector_type

Const iterator to traverse the sparse vector.

bool operator==(const const_iterator &it) const noexcept

std::input_iterator_tag iterator_category

const sparse_vector_type * sv_

const_iterator() noexcept

void invalidate() noexcept

Invalidate current iterator.

bvector_type::allocator_type allocator_type

sparse_vector< Val, BV > sparse_vector_type

void go_to(size_type pos) noexcept

re-position to a specified position

size_type pos() const noexcept

Current position (index) in the vector.

value_type operator*() const

Get current position (value)

sparse_vector_type::bvector_type bvector_type

buffer_type buffer_

!< Position

bool operator!=(const const_iterator &it) const noexcept

bool is_null() const noexcept

Get NULL status.

bool advance() noexcept

advance iterator forward by one

bool operator>(const const_iterator &it) const noexcept

bool operator<=(const const_iterator &it) const noexcept

void skip_zero_values() noexcept

const_iterator operator++(int)

Advance to the next available value.

bool valid() const noexcept

Returns true if iterator is at a valid position.

bool operator>=(const const_iterator &it) const noexcept

bm::byte_buffer< allocator_type > buffer_type

value_type value() const

Get current position (value)

bool operator<(const const_iterator &it) const noexcept

sparse_vector_type::size_type size_type

const_iterator & operator++() noexcept

Advance to the next available value.

sparse_vector_type * sparse_vector_type_ptr

sparse_vector_type::value_type value_type

bvector_type::allocator_type::allocator_pool_type allocator_pool_type

value_type * buf_ptr_

!< value buffer

size_type pos_

!< ptr to parent

Reference class to access elements via common [] operator.

bool is_null() const noexcept

reference & operator=(const reference &ref)

reference & operator=(value_type val)

reference(sparse_vector< Val, BV > &sv, size_type idx) noexcept

bool operator==(const reference &ref) const noexcept

sparse_vector< Val, BV > & sv_

sparse vector de-serializer

algorithms for sparse_vector scan/search

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

succinct sparse vector with runtime compression using bit-slicing / transposition method

void inc(size_type idx)

increment specified element by one

unsigned_value_type get_unsigned(size_type idx) const noexcept

get raw unsigned value

static void u2s_translate(value_type *arr, size_type sz) noexcept

bool empty() const noexcept

return true if vector is empty

int compare(size_type idx, const value_type val) const noexcept

Compare vector element with argument.

bvector_type::size_type size_type

void set_value(size_type idx, value_type v, bool need_clear)

set value without checking boundaries

void set_remap() noexcept

value_type at(size_type idx) const

access specified element with bounds checking

void set_null(size_type idx)

set specified element to unassigned value (NULL)

void set_value_no_null(size_type idx, value_type v, bool need_clear)

set value without checking boundaries or support of NULL

static constexpr bool is_str() noexcept

unsigned_value_type get_unsigned_bits(size_type idx, size_type N_bits) const noexcept

Get raw unsigned value first N bits.

value_type get_no_check(size_type idx) const noexcept

get specified element without checking boundary conditions

allocator_type::allocator_pool_type allocator_pool_type

void insert_value_no_null(size_type idx, value_type v)

insert value without checking boundaries or support of NULL

const_iterator begin() const noexcept

Provide const iterator access to container content.

const value_type & const_reference

void sync_size() noexcept

recalculate size to exclude tail NULL elements After this call size() will return the true size of th...

void push_back(value_type v)

push value back into vector

remap_matrix_type * get_remap_matrix()

void push_back_no_null(value_type v)

push value back into vector without NULL semantics

void insert_value(size_type idx, value_type v)

insert value without checking boundaries

bvector_type * bvector_type_ptr

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

check if another sparse vector has the same content and size

void optimize_gap_size()

Optimize sizes of GAP blocks.

sparse_vector(const sparse_vector< Val, BV > &sv)

sparse_vector(sparse_vector< Val, BV > &&sv) noexcept

sparse_vector< Val, BV > & operator=(const sparse_vector< Val, BV > &sv)

value_type get(size_type idx) const noexcept

get specified element without bounds checking

bvector_type::enumerator bvector_enumerator_type

void set(size_type idx, value_type v)

set specified element with bounds checking and automatic resize

static bool find_rank(size_type rank, size_type &pos) noexcept

find position of compressed element by its rank

void resize(size_type sz)

resize vector

void clear(size_type idx, bool set_null)

clear specified element with bounds checking and automatic resize

static void throw_range_error(const char *err_msg)

throw range error

back_insert_iterator get_back_inserter()

Provide back insert iterator Back insert iterator implements buffered insertion, which is faster,...

void resize_internal(size_type sz, bool set_null=true)

void inc_no_null(size_type idx, value_type v)

increment by v without chnaging NULL vector or size

void swap(size_type idx1, size_type idx2)

swap two vector elements between each other

friend back_insert_iterator

bvector_type::block_idx_type block_idx_type

void import_u_nocheck(const unsigned_value_type *arr, size_type arr_size, size_type offset, bool set_not_null)

void inc_no_null(size_type idx)

Increment element by 1 without chnaging NULL vector or size.

size_type gather(value_type *arr, const size_type *idx, size_type size, bm::sort_order sorted_idx) const

Gather elements to a C-style array.

const_iterator end() const noexcept

Provide const iterator access to the end.

size_t remap_size() const noexcept

unsigned char * init_remap_buffer() noexcept

void calc_stat(struct sparse_vector< Val, BV >::statistics *st) const noexcept

Calculates memory statistics.

void push_back_null(size_type count)

push back specified amount of NULL values

void clear() noexcept

resize to zero, free memory

sparse_vector< Val, BV > & merge(sparse_vector< Val, BV > &sv)

merge with another sparse vector using OR operation Merge is different from join(),...

parent_type::bmatrix_type::remap_matrix_type remap_matrix_type

unused remap matrix type for compatibility with the sparse serializer

void freeze()

Turn sparse vector into immutable mode Read-only (immutable) vector uses less memory and allows faste...

size_type effective_size() const noexcept

size of sparse vector (may be different for RSC)

void set_null(const bvector_type &bv_idx)

Set NULL all elements set as 1 in the argument vector.

sparse_vector< Val, BV > & join(const sparse_vector< Val, BV > &sv)

join all with another sparse vector using OR operation

void set_allocator_pool(allocator_pool_type *pool_ptr) noexcept

Set allocator pool for local (non-threaded) memory cyclic(lots of alloc-free ops) opertations.

~sparse_vector() noexcept

const unsigned char * get_remap_buffer() const noexcept

void insert(size_type idx, value_type v)

insert specified element into container

void import_back(const value_type *arr, size_type arr_size, bool set_not_null=true)

Import list of elements from a C-style array (pushed back)

static constexpr bool is_compressed() noexcept

various type traits

size_type extract(value_type *arr, size_type size, size_type offset=0, bool zero_mem=true) const

Bulk export list of elements to a C-style array.

base_sparse_vector< Val, BV, 1 > parent_type

size_type extract_range(value_type *arr, size_type size, size_type offset, bool zero_mem=true) const

extract small window without use of masking vector

static size_type translate_address(size_type i) noexcept

address translation for this type of container

size_type extract_planes(value_type *arr, size_type size, size_type offset, bool zero_mem=true) const

extract medium window without use of masking vector

void swap(sparse_vector< Val, BV > &sv) noexcept

content exchange

static void throw_bad_alloc()

throw bad alloc

constexpr bool is_remap() const noexcept

void keep_range(size_type left, size_type right, bm::null_support slice_null=bm::use_null)

Keep only specified interval in the sparse vector, clear all other elements.

void clear_all(bool free_mem, unsigned) noexcept

resize to zero, free memory

void import_u(const unsigned_value_type *arr, size_type arr_size, size_type offset, bool set_not_null)

Import list of elements from a C-style array.

void join_null_slice(const sparse_vector< Val, BV > &sv)

BV::allocator_type allocator_type

bool try_get(size_type idx, value_type &v) const noexcept

get specified element with NOT NULL check

sparse_vector(bm::null_support null_able=bm::no_null, allocation_policy_type ap=allocation_policy_type(), size_type bv_max_size=bm::id_max, const allocator_type &alloc=allocator_type())

Sparse vector constructor.

void push_back_null()

push back NULL value

sparse_vector< Val, BV > & clear_range(size_type left, size_type right, bool set_null=false)

clear range (assign bit 0 for all planes)

void erase(size_type idx, bool erase_null=true)

erase specified element from container

size_type decode(value_type *arr, size_type idx_from, size_type dec_size, bool zero_mem=true) const

Bulk export list of elements to a C-style array.

size_type effective_vector_max() const noexcept

Always 1 (non-matrix type)

bool is_ro() const noexcept

Returns true if vector is in read-only mode.

const_iterator get_const_iterator(size_type idx) const noexcept

Get const_itertor re-positioned to specific element.

const remap_matrix_type * get_remap_matrix() const

bm::basic_bmatrix< BV > bmatrix_type

value_type operator[](size_type idx) const noexcept

get specified element without bounds checking

void clear(const bvector_type &bv_idx)

Set vector elements spcified by argument bit-vector to zero Note that set to 0 elements are NOT going...

size_type size_internal() const noexcept

void copy_range(const sparse_vector< Val, BV > &sv, size_type left, size_type right, bm::null_support slice_null=bm::use_null)

copy range of values from another sparse vector

parent_type::unsigned_value_type unsigned_value_type

bvector_type::allocation_policy allocation_policy_type

void import(const value_type *arr, size_type arr_size, size_type offset=0, bool set_not_null=true)

Import list of elements from a C-style array.

void import_back_u(const unsigned_value_type *arr, size_type arr_size, bool set_not_null=true)

Import list of elements from a C-style array (pushed back)

void filter(const bvector_type &bv_mask)

Apply value filter, defined by mask vector.

const bvector_type * bvector_type_const_ptr

void sync(bool, bool)

syncronize internal structures, build fast access index

size_type size() const noexcept

return size of the vector

void optimize(bm::word_t *temp_block=0, typename bvector_type::optmode opt_mode=bvector_type::opt_compress, typename sparse_vector< Val, BV >::statistics *stat=0)

run memory optimization for all vector planes

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

static vector< string > arr

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

void bit_block_gather_scatter(TRGW *arr, const bm::word_t *blk, const IDX *idx, SZ size, SZ start, unsigned bit_idx) noexcept

bit index to word gather-scatter algorithm

unsigned short bitscan(V w, B *bits) noexcept

Templated Bitscan with dynamic dispatch for best type.

unsigned bit_scan_reverse(T value) noexcept

sort_order

Sort order declaration.

null_support

NULL-able value support.

@ BM_UNSORTED

input set is NOT sorted

@ BM_SORTED

input set is sorted (ascending order)

@ BM_UNKNOWN

sort order unknown

@ BM_SORTED_UNIFORM

sorted and in one block (internal!)

@ 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.

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

XOR swap two variables.

int for_each_bit_range_no_check(const BV &bv, typename BV::size_type left, typename BV::size_type right, Func &bit_functor)

Implementation of for_each_bit_range without boilerplave checks.

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.

bm::id64_t idx_arr_block_lookup_u64(const bm::id64_t *idx, bm::id64_t size, bm::id64_t nb, bm::id64_t start) noexcept

block boundaries look ahead U32

unsigned idx_arr_block_lookup_u32(const unsigned *idx, unsigned size, unsigned nb, unsigned start) noexcept

block boundaries look ahead U32

const unsigned set_word_shift

unsigned gap_bfind(const T *buf, unsigned pos, unsigned *is_set) noexcept

unsigned short gap_word_t

const unsigned set_block_shift

const unsigned set_word_mask

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

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

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

#define row(bind, expected)

Structure with statistical information about memory allocation footprint, serialization projection,...

Mini-matrix for bit transposition purposes.

static unsigned rows() noexcept

const T * row(unsigned row_idx) const noexcept

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