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__compr_8h_source.html below:

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

<

Val,

SV>

{

(*

) ==

(ref); }

{

(

== it.pos_) && (

== it.csv_); }

{

< it.pos_; }

{

<= it.pos_; }

{

> it.pos_; }

{

>= it.pos_; }

value_type

()

;

{ this->

(v);

*

; }

->copy_from(*(csv.rs_idx_));

bvector_type::optmode opt_mode = bvector_type::opt_compress,

statistics* stat = 0);

{

.get_slice(

); }

{

.get_create_slice(

); }

{

.slice(

); }

{

.effective_slices(); }

{

sparse_vector_type::slices(); }

{

sparse_vector_type::stored_slices(); }

{

.get_bmatrix(); }

{

.get_bmatrix(); }

{

.mark_null_idx(null_idx); }

.resize_internal(sz);

{

sparse_vector_type::s2u(v); }

{

sparse_vector_type::u2s(v); }

<

Val,

SV>

<

Val,

SV>

found = bv->find_reverse(

);

<

Val,

SV>

<

Val,

SV>

: sv_(csv.sv_), size_(csv.size_), max_id_(csv.max_id_), in_sync_(csv.in_sync_)

<

Val,

SV>

max_id_(0), in_sync_(

)

size_ = csv.size_; max_id_ = csv.max_id_; in_sync_ = csv.in_sync_;

rs_idx_ = csv.rs_idx_; csv.rs_idx_ = 0;

<

Val,

SV>

<

Val,

SV>

(sv_.get_null_bvect()->none());

size_ = max_id_ = 0;

(new_size >= size_)

max_id_ = new_size - 1;

max_id_ = new_size - 1;

new_sv_size = sv_.size() - clear_size;

sv_.resize_internal(new_sv_size,

);

bv_null->clear_range(new_size,

-1);

max_id_ = new_size - 1;

<

Val,

SV>

(idx <= max_id_ && size_)

sv_.throw_range_error(

);

push_back_no_check(idx, v);

<

Val,

SV>

<

Val,

SV>

bv_null->set_bit_no_check(idx);

sv_.push_back_no_null(v);

<

Val,

SV>

found = bv_null->test(idx);

sv_idx = bv_null->count_range(0, idx);

bv_null->clear_bit_no_check(idx);

sv_.erase(--sv_idx,

);

size_ = max_id_ + 1;

<

Val,

SV>

bv_sub.bit_and(bv_idx, *bv_null);

rank_compr.

(bv_sub_rsc, *bv_null, bv_sub);

sv_.clear(bv_sub_rsc);

bvector_type::enumerator en(&bv_sub, 0);

sv_idx = bv_null->count_range(0, idx);

sv_.erase(--sv_idx,

);

bv_null->bit_sub(bv_sub);

<

Val,

SV>

bv_sub.bit_and(bv_idx, *bv_null);

rank_compr.

(bv_sub_rsc, *bv_null, bv_sub);

sv_.clear(bv_sub_rsc);

<

Val,

SV>

found = bv_null->test(idx);

sv_idx = in_sync_ ? bv_null->count_to(idx, *rs_idx_)

: bv_null->count_range(0, idx);

sv_.inc_no_null(--sv_idx);

sv_.insert_value_no_null(sv_idx, 1);

bv_null->set_bit_no_check(idx);

size_ = max_id_ + 1;

<

Val,

SV>

found = bv_null->test(idx);

sv_idx = in_sync_ ? bv_null->count_to(idx, *rs_idx_)

: bv_null->count_range(0, idx);

sv_.inc_no_null(--sv_idx, v);

sv_.insert_value_no_null(sv_idx, v);

bv_null->set_bit_no_check(idx);

size_ = max_id_ + 1;

<

Val,

SV>

sv_idx = in_sync_ ? bv_null->count_to(idx, *rs_idx_)

: bv_null->count_range(0, idx);

sv_.inc_no_null(sv_idx);

sv_.inc_no_null(sv_idx, v);

<

Val,

SV>

found = bv_null->test(idx);

sv_idx = in_sync_ ? bv_null->count_to(idx, *rs_idx_)

: bv_null->count_range(0, idx);

sv_.set_value_no_null(--sv_idx, v,

);

sv_.insert_value_no_null(sv_idx, v);

bv_null->set_bit_no_check(idx);

size_ = max_id_ + 1;

<

Val,

SV>

(max_id_ != csv.max_id_ || size_ != csv.size_)

same_sv = sv_.equal(csv.sv_);

<

Val,

SV>

max_id_ = size_ = 0;

* bv_null_src = sv_src.get_null_bvector();

sv_.clear_all(

, 0);

*bv_null = *bv_null_src;

src_planes = sv_src.slices();

(

= 0;

< src_planes; ++

)

rank_compr.

(*bv_plane, *bv_null, *bv_src_plane);

sv_.resize(

);

sync(

,

);

<

Val,

SV>

sv.clear_all(

, 0);

* bv_null_src = this->get_null_bvector();

*bv_null = *bv_null_src;

src_planes = sv_.slices();

(

= 0;

< src_planes; ++

)

(

* bv_src_plane = sv_.get_slice(

))

rank_compr.

(*bv_plane, *bv_null, *bv_src_plane);

sv.resize(this->

());

<

Val,

SV>

(in_sync_ && force ==

)

bv_null->build_rs_index(rs_idx_);

sv_.bmatr_.is_ro_ = bv_null->is_ro();

= size_ ? bv_null->count_range(0, size_-1, *rs_idx_)

is_dense_ = (

== size_);

<

Val,

SV>

found = bv_null->find_reverse(max_id_);

max_id_ = size_ = 0;

size_ = max_id_ + 1;

sync(

,

);

<

Val,

SV>

(bv_null->get_bit(idx) ==

);

resolve_sync(idx, idx_to);

found = bv_null->test(idx);

*idx_to = bv_null->count_range_no_check(0, idx);

<

Val,

SV>

(bv_null->get_bit(idx) ==

);

*idx_to = bv_null->count_to_test(idx, *rs_idx_);

(*idx_to);

<

Val,

SV>

copy_sz = bv_null->count_range(from, to, *rs_idx_);

copy_sz = bv_null->count_range(from, to);

sv_left = bv_null->rank_corrected(from, *rs_idx_);

sv_left = bv_null->count_range(0, from);

tl = bv_null->test(from);

*idx_from = sv_left; *idx_to = sv_left + copy_sz - 1;

<

Val,

SV>

sv_.throw_range_error(

);

found = resolve(idx, &sv_idx);

sv_.throw_range_error(

);

sv_.at(--sv_idx);

<

Val,

SV>

found = resolve(idx, &sv_idx);

sv_.get(--sv_idx);

<

Val,

SV>

found = resolve(idx, &sv_idx);

sv_.get_unsigned_bits(--sv_idx, N_bits);

<

Val,

SV>

(!resolve(idx, &sv_idx))

v = sv_.get(--sv_idx);

<

Val,

SV>

found = resolve_sync(idx, &sv_idx);

v = sv_.get(--sv_idx);

<

Val,

SV>

!(bv_null->test(idx));

<

Val,

SV>

bvector_type::optmode opt_mode,

sv_.optimize(temp_block, opt_mode, (

sparse_vector_type::statistics*)

);

->memory_used += rs_idx_->get_total() *

(

(

rs_index_type::size_type)

+

(

rs_index_type::sb_pair_type));

this->sync(

,

);

<

Val,

SV>

sv_.clear_all(free_mem, 0);

in_sync_ =

; max_id_ = size_ = 0;

<

Val,

SV>

sv_.calc_stat((

sparse_vector_type::statistics*)

);

->memory_used += rs_idx_->get_total() *

(

(

rs_index_type::size_type)

+

(

rs_index_type::sb_pair_type));

<

Val,

SV>

sv_.get_null_bvector();

<

Val,

SV>

= bv_null->select(rank, idx, *rs_idx_);

= bv_null->find_rank(rank, 0, idx);

<

Val,

SV>

std::domain_error(

);

<

Val,

SV>

zero_mem)

throw_no_rsc_index();

(idx_from >= this->

())

((idx_from +

) > this->

())

size = this->

() - idx_from;

rank = bv_null->rank_corrected(idx_from, *rs_idx_);

(rank == bv_null->count_range(0, idx_from) - bv_null->test(idx_from));

[

++] = it.value();

(!en_i.advance())

}

(

<

);

<

Val,

SV>

(!

|| (idx_from >= this->

()))

((idx_from +

) > this->

())

rank = bv_null->rank_corrected(idx_from, *rs_idx_);

(rank == bv_null->count_range(0, idx_from) - bv_null->test(idx_from));

(idx_from +

<=

)

bv_null->count_range_no_check(idx_from, idx_from +

- 1, *rs_idx_);

ex_sz = sv_.decode(arr_buf_tmp, rank, extract_cnt,

);

(ex_sz == extract_cnt); (void) ex_sz;

(

= 0;

< extract_cnt; ++

)

[en_idx-idx_from] = arr_buf_tmp[

];

<

Val,

SV>

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

(idx[

] < size_)

idx_tmp_buf[

] = idx[

];

(resolve(idx[

], &sv_idx))

idx_tmp_buf[

] = sv_idx-1;

= sv_.gather(

, idx_tmp_buf,

, sorted_idx);

<

Val,

SV>

<

Val,

SV>

rs_idx_->~rs_index_type();

<

Val,

SV>

(left >= csv.

())

range_valid = csv.

(left, right, &sv_left, &sv_right);

sv_.clear_all(

, 0); sv_.resize(size_);

bv_null->copy_range(*arg_bv_null, 0, right);

bv_null->copy_range(*arg_bv_null, 0, right);

<

Val,

SV>

(sv_.get_null_bvector()->equal(*csv.

.get_null_bvector()));

sv_.merge(csv.

);

<

Val,

SV>

bv_null->count_range_no_check(left, right);

bv_null->count_range_no_check(left, right, *rs_idx_);

<

Val,

SV>

<

Val,

SV>

.disable_set_null();

<

Val,

SV>

<

Val,

SV>

<

Val,

SV>

sv_bi_.add_value_no_null(v);

bv_null->set_bit_no_check(csv_->size_);

<

Val,

SV>

csv_->max_id_++; csv_->size_++;

<

Val,

SV>

csv_->max_id_+=

;

csv_->size_+=

;

<

Val,

SV>

csv_->in_sync_ =

;

<

Val,

BV>

: csv_(0), pos_(

::

), buf_ptr_(0)

<

Val,

SV>

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

<

Val,

SV>

: csv_(csv), buf_ptr_(0)

<

Val,

SV>

: csv_(csv), buf_ptr_(0)

<

Val,

SV>

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

: pos;

<

Val,

SV>

(pos_ >= csv_->size())

(buf_ptr_ - ((

*)vbuffer_.data()) >= n_buf_size)

<

Val,

SV>

vbuffer_.reserve(n_buf_size *

(

));

tbuffer_.reserve(n_buf_size *

(

));

csv_->decode_buf(buf_ptr_, tmp_buf_ptr, pos_, n_buf_size,

);

<

Val,

SV>

(++buf_ptr_ < buf_end)

(pos_ >= csv_->size())

(buf_ptr_ >= buf_end)

<

Val,

SV>

csv_->is_null(pos_);

#define BM_ASSERT_THROW(x, xerrcode)

Sparse constainer sparse_vector<> for integer types using bit-transposition transform.

Heap allocated scalar-type matrix.

void decompress(BV &bv_target, const BV &bv_idx, const BV &bv_src)

Rank decompression.

void compress(BV &bv_target, const BV &bv_idx, const BV &bv_src)

Rank compression algorithm based on two palallel iterators/enumerators set of source vector gets re-m...

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

back_insert_iterator & operator++()

noop

back_insert_iterator() noexcept

void flush()

flush the accumulated buffer

bool empty() const

return true if insertion buffer is empty

rsc_sparse_vector_type * rsc_sparse_vector_type_ptr

rsc_sparse_vector_type::sparse_vector_type sparse_vector_type

add value to the buffer without changing the NULL vector

back_insert_iterator & operator++(int)

noop

void add(value_type v)

add value to the container

std::output_iterator_tag iterator_category

rsc_sparse_vector_type::bvector_type bvector_type

void add_null() noexcept

add NULL (no-value) to the container

rsc_sparse_vector< Val, SV > rsc_sparse_vector_type

sparse_vector_bi sv_bi_

!< pointer on the parent vector

rsc_sparse_vector_type::size_type size_type

back_insert_iterator & operator*()

noop

rsc_sparse_vector_type::value_type value_type

rsc_sparse_vector_type * csv_

back_insert_iterator & operator=(value_type v)

push value to the vector

sparse_vector_type::back_insert_iterator sparse_vector_bi

Const iterator to traverse the rsc sparse vector.

size_type pos_

!< ptr to parent

const rsc_sparse_vector_type * csv_

rsc_sparse_vector< Val, SV > rsc_sparse_vector_type

buffer_type tbuffer_

!< value buffer

bool is_null() const noexcept

Get NULL status.

rsc_sparse_vector_type::value_type value_type

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

bm::byte_buffer< allocator_type > buffer_type

const_iterator & operator++(int)

Advance to the next available value.

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

bool operator>(const const_iterator &it) const noexcept

rsc_sparse_vector_type::bvector_type bvector_type

std::input_iterator_tag iterator_category

void go_to(size_type pos) noexcept

re-position to a specified position

bool valid() const noexcept

Returns true if iterator is at a valid position.

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

void skip_zero_values() noexcept

rsc_sparse_vector_type * rsc_sparse_vector_type_ptr

size_type pos() const noexcept

Current position (index) in the vector.

bool advance() noexcept

advance iterator forward by one

const_iterator & operator++() noexcept

Advance to the next available value.

buffer_type vbuffer_

!< Position

value_type * buf_ptr_

!< temp buffer

rsc_sparse_vector_type::size_type size_type

void invalidate() noexcept

Invalidate current iterator.

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

bvector_type::allocator_type::allocator_pool_type allocator_pool_type

value_type operator*() const

Get current position (value)

value_type value() const

Get current position (value)

const_iterator() noexcept

bvector_type::allocator_type allocator_type

bool operator<(const const_iterator &it) const noexcept

Reference class to access elements via common [] operator.

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

reference(rsc_sparse_vector< Val, SV > &csv, size_type idx) noexcept

rsc_sparse_vector< Val, SV > & csv_

bool is_null() const noexcept

Rank-Select compressed sparse vector.

static unsigned stored_slices()

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

bvector_type * bvector_type_ptr

size_t remap_size() const noexcept

bool in_sync_

flag if prefix sum is in-sync with vector

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

const bmatrix_type & get_bmatrix() const noexcept

void load_from(const sparse_vector_type &sv_src)

Load compressed vector from a sparse vector (with NULLs)

remap_matrix_type * get_remap_matrix()

void clear() noexcept

resize to zero, free memory

void sync_size() noexcept

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

static value_type u2s(unsigned_value_type v) noexcept

unsigned effective_slices() const noexcept

bool is_nullable() const

if container supports NULL(unassigned) values (true)

void merge_not_null(rsc_sparse_vector< Val, SV > &csv)

merge two vectors (argument gets destroyed) It is important that both vectors have the same NULL vect...

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

get specified element with NOT NULL check

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

C-style decode.

void freeze()

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

void push_back(size_type idx, value_type v)

set specified element with bounds checking and automatic resize

bool equal(const rsc_sparse_vector< Val, SV > &csv) const noexcept

check if another vector has the same content

back_insert_iterator get_back_inserter()

void load_to(sparse_vector_type &sv) const

Exort compressed vector to a sparse vector (with NULLs)

SV::bmatrix_type bmatrix_type

void set(size_type idx, value_type v)

set specified element with bounds checking and automatic resize

void set_remap() noexcept

bm::heap_matrix< unsigned char, 1, 1, typename bvector_type::allocator_type > remap_matrix_type

unused remap matrix type for compatibility with the sparse serializer

value_type at(size_type idx) const

access specified element with bounds checking

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

run memory optimization for all vector slices

const_iterator end() const noexcept

Provide const iterator access to the end.

bool empty() const noexcept

return true if vector is empty

SV::unsigned_value_type unsigned_value_type

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

get specified element with NOT NULL check Caller guarantees that the vector is in sync mode (RS-index...

static constexpr bool is_compressed() noexcept

various type traits

bvector_type_ptr slice(unsigned i)

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

static unsigned slices() noexcept

get total number of bit-slices in the vector

void push_back_null()

push back NULL value

rsc_sparse_vector< Val, SV > & operator=(rsc_sparse_vector< Val, SV > &&csv) noexcept

const bvector_type * get_null_bvector() const noexcept

Get bit-vector of assigned values (or NULL)

bool is_ro() const noexcept

Returns true if vector is read-only.

bool resolve(size_type idx, size_type *idx_to) const noexcept

Resolve logical address to access via rank compressed address.

void set_ro_flag(bool b) noexcept

size_type size_

vector size (logical)

void set_null(size_type idx)

set specified element to NULL RSC vector actually erases element when it is set to NULL (expensive).

void mark_null_idx(unsigned null_idx) noexcept

void inc_not_null(size_type idx, value_type v)

increment specified element by one, element MUST be NOT NULL Faster than just inc() if element is NUL...

size_type count_range_notnull(size_type left, size_type right) const noexcept

void resize(size_type new_size)

change vector size

void resize_internal(size_type sz)

SV::const_iterator sparse_vector_const_iterator

bvector_type_ptr get_create_slice(unsigned i)

void construct_rs_index()

Allocate memory for RS index.

void unsync() noexcept

Unsync the prefix sum table.

bool find_rank(size_type rank, size_type &idx) const noexcept

find position of compressed element by its rank

const value_type & const_reference

unsigned char * init_remap_buffer() noexcept

const bvector_type * bvector_type_const_ptr

const_iterator get_const_iterator(size_type idx) const noexcept

Get const_itertor re-positioned to specific element.

void sync()

Re-calculate prefix sum table used for rank search (if necessary)

const remap_matrix_type * get_remap_matrix() const

bool resolve_sync(size_type idx, size_type *idx_to) const noexcept

void free_rs_index()

Free rs-index.

const sparse_vector_type & get_sv() const noexcept

access dense vector

static void throw_no_rsc_index()

throw error that RSC index not constructed (call sync())

constexpr bool is_remap() const noexcept

static unsigned_value_type s2u(value_type v) noexcept

Convert signed value type to unsigned representation.

sparse_vector_type sv_

transpose-sparse vector for "dense" packing

bvector_type_const_ptr get_slice(unsigned i) const noexcept

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

bvector_type::allocator_type allocator_type

size_type decode_buf(value_type *arr, value_type *arr_buf_tmp, size_type idx_from, size_type size, bool zero_mem=true) const noexcept

C-style decode (variant with external memory) Analog of decode, but requires two arrays.

size_type size_internal() const noexcept

bool is_sync() const noexcept

returns true if prefix sum table is in sync with the vector

void push_back(value_type v)

add element with automatic resize

rs_index_type * rs_idx_

prefix sum for rank-select translation

rsc_sparse_vector< Val, SV > & operator=(const rsc_sparse_vector< Val, SV > &csv)

bvector_type::rs_index_type rs_index_type

size_type max_id_

control variable for sorted load

value_type get(size_type idx) const noexcept

get specified element without bounds checking

bool is_null(size_type idx) const noexcept

test if specified element is NULL

bool is_dense_

flag if vector is dense

bvector_type::enumerator bvector_enumerator_type

unsigned_value_type get_unsigned_bits(size_type idx, size_type N_bits) const noexcept

Get raw unsigned value first N bits.

void clear_all(bool free_mem, unsigned) noexcept

resize to zero, free memory

const unsigned char * get_remap_buffer() const noexcept

void copy_range(const rsc_sparse_vector< Val, SV > &csv, size_type left, size_type right)

copy range of values from another sparse vector

void inc(size_type idx)

increment specified element by one

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

Gather elements to a C-style array.

void push_back_no_check(size_type idx, value_type v)

size_type effective_size() const noexcept

size of internal dense vector

bmatrix_type & get_bmatrix() noexcept

size_type size() const noexcept

return size of the vector

bvector_type::allocation_policy allocation_policy_type

SV::bvector_type bvector_type

bool in_sync() const noexcept

returns true if prefix sum table is in sync with the vector

void calc_stat(struct rsc_sparse_vector< Val, SV >::statistics *st) const noexcept

Calculates memory statistics.

static constexpr bool is_str() noexcept

const rs_index_type * get_RS() const noexcept

size_type effective_vector_max() const noexcept

Always 1 (non-matrix type)

const_iterator begin() const

Provide const iterator access to container content.

sparse vector de-serializer

algorithms for sparse_vector scan/search

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

static vector< string > arr

sort_order

Sort order declaration.

null_support

NULL-able value support.

@ BM_SORTED

input set is sorted (ascending order)

@ BM_UNKNOWN

sort order unknown

@ use_null

support "non-assigned" or "NULL" logic

@ no_null

do not support NULL values

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

XOR swap two variables.

void aligned_free(void *ptr) BMNOEXCEPT

Aligned free.

void * aligned_new_malloc(size_t size)

Aligned malloc (unlike classic malloc it throws bad_alloc exception)

unsigned long long int id64_t

const unsigned rs3_border0

double value_type

The numeric datatype used by the parser.

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

const GenericPointer< typename T::ValueType > T2 value

Int4 delta(size_t dimension_, const Int4 *score_)

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

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

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