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

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

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

bvector_type::size_type

;

*

,

buf_size);

<

DEC,

BLOCK_IDX>

template<class BV, class DEC>

*

,

is_range_set_ = 1; idx_from_ = from; idx_to_ = to;

xor_chain_size_;

is_range_set_;

template<class BV, class SerialIterator>

exit_on_one =

);

{

; }

is_range_set_ =

;

<

DEC,

BLOCK_IDX>

()

{

end_of_stream_; }

get_bit_block(

::

* dst_block,

dec_size()

{

decoder_.size(); }

get_bit_block_COUNT(dst_block, tmp_block);

new_nb = parent_type::try_skip(decoder_, nb, expect_nb);

block_idx_ = new_nb; state_ = e_blocks;

<

BV>

*

,

exit_on_one =

);

*

,

*

,

exit_on_one =

)

*

,

*

,

*

,

<

BV>

compression_stat_(0),

gap_serial_(

),

byte_order_serial_(

),

sb_bookmarks_(

),

enc_header_pos_(0), header_flag_(0),

(temp_block == 0)

<

BV>

compression_stat_(0),

gap_serial_(

),

byte_order_serial_(

),

sb_bookmarks_(

),

enc_header_pos_(0), header_flag_(0),

(temp_block == 0)

<

BV>

tb_wflags_ = alloc_.alloc_bit_block(1);

idx_arr_ = alloc_.alloc_bit_block(1);

<

BV>

(own_temp_block_)

alloc_.free_bit_block(temp_block_);

(compression_stat_)

alloc_.free_bit_block((

*)compression_stat_);

alloc_.free_bit_block(xor_tmp_block_, 3);

(gap_recalc_tmp_block0_)

(gap_recalc_tmp_block1_)

(gap_ex0_tmp_block_)

(gap_ex1_tmp_block_)

alloc_.free_bit_block(tb_wflags_, 1);

alloc_.free_bit_block(idx_arr_, 1);

<

BV>

(

= 0;

< 256; ++

)

compression_stat_[

] = 0;

<

BV>

compression_level_ = clevel;

(compression_level_ == 5)

(compression_level_ == 6)

<

BV>

sparse_cutoff_ = cutoff;

<

BV>

gap_serial_ =

;

<

BV>

byte_order_serial_ =

;

<

BV>

sb_bookmarks_ = enable;

(bm_interval > 512)

(bm_interval < 4)

sb_range_ = bm_interval;

<

BV>

xor_scan_.set_ref_vector(

);

xor_tmp_block_ = alloc_.alloc_bit_block(3);

<

BV>

xor_scan_.compute_sim_model(sim_model,

, params);

<

BV>

sim_model_ = sim_model;

<

BV>

<

BV>

(!byte_order_serial_)

enc_header_pos_ = enc.get_pos();

enc.put_8(header_flag_);

(byte_order_serial_)

enc.put_8((

)bo);

enc.put_64(bv.size());

enc.put_32(bv.size());

<

BOUT>

: bout.delta16(min0);

: bout.delta16(min1);

<

BOUT>

bout.put_bits(min_v, 8)

: bout.put_16_no(min_v);

(tail_delta < 256) ?

bout.put_bits(tail_delta, 8)

:bout.put_16_no(tail_delta);

( tail_delta <= ((0xFF << 3) + 0b111) )

head_v3 |= (tail_delta & 0b111);

<

BV>

drange_gain_cutoff = 200;

h_limit = 3;

ex_limit = (

/ 4);

hist0[h_limit] = {0,};

hist1[h_limit] = {0,};

ex0_cnt, ex1_cnt;

gap_recalc_block, ex0_arr, ex1_arr, ex0_cnt, ex1_cnt);

(ex0_cnt + ex1_cnt < 5)

(gl1 < (gl2 + ex0_cnt + ex1_cnt))

head_v3 = 0;

min_v = gap_recalc_block[1];

max_v = gap_recalc_block[

-1]-1;

bout.

(gap_recalc_block[1]);

(

k = 2; k <

; ++k)

(gap_recalc_block[k] < 65535);

gap_recalc_block[k] - gap_recalc_block[k-1];

&gap_recalc_block[2],

-3, min_v+1, max_v);

end_fl = (ex1_cnt == 0);

ex0_cnt,

, end_fl);

ex1_cnt,

,

);

end_fl = (ex0_cnt == 0);

ex1_cnt,

, end_fl);

ex0_cnt,

,

);

enc.

((

)0xFF);

( (min0 > 1 || min1 > 1))

(delta_acc > drange_gain_cutoff)

enc_size = (unsigned)(enc_pos1 - enc_pos0);

gamma_gap_block(gap_block, enc);

enc.

((

)0xFF);

<

BV>

(tail_delta < 256)

(tail_delta < 256)

bout.

(tail_delta);

enc_size = (unsigned)(enc_pos1 - enc_pos0);

(enc_size > plain_size)

gamma_gap_block(gap_block, enc);

<

BV>

enc_try((

*)try_buf_, 65536);

interpolated_encode_gap_block_v3s(gap_block, enc_try,

);

s_size = size_t(enc_try_pos1 - enc_try_pos0);

v3_ok = interpolated_encode_gap_block_v3(gap_block, enc,

);

dr_size = size_t(enc_pos1 - enc_pos0);

(s_size && (s_size < dr_size))

gamma_gap_block(gap_block, enc);

<

BV>

= (*gap_block >> 3);

use_gamma =

;

(compression_level_ > 3)

use_gamma = (gamma_size_bits < size_16_bits);

bout.

(*gap_block & 1, 1);

(*pcurr == 65535)

= unsigned(*pcurr -

);

= (unsigned)(enc_pos1 - enc_pos0);

enc.set_pos(enc_pos0);

bout.

(*gap_block & 1, 1);

(

= 1;

<

; ++

)

enc_size = (unsigned)(enc_pos1 - enc_pos0); (void) enc_size;

enc_size = (unsigned)(enc_pos1 - enc_pos0); (void) enc_size;

<

BV>

(compression_level_ > 3 && arr_len > 1)

bout.

(arr_len);

(

= 1;

< arr_len; ++

)

= (unsigned)(enc_pos1 - enc_pos0);

enc.set_pos(enc_pos0);

compression_stat_[scode]++;

enc.put_prefixed_array_16(scode, gap_array, arr_len,

);

compression_stat_[scode]++;

<

BV>

bout.

(arr_len-4);

enc_size = (unsigned)(enc_pos1 - enc_pos0);

(enc_size >= raw_size)

enc.set_pos(enc_pos0);

compression_stat_[scode]++;

enc.put_prefixed_array_16(scode, gap_block, arr_len,

);

compression_stat_[scode]++;

<

BV>

(min_v >= 256 && tail >= 256)

interpolated_gap_array_v0(gap_block, arr_len, enc, inverted);

arr_len |= (1 << 1);

enc.put_8((

)min_v);

enc.put_8((

)tail);

enc_size = (unsigned)(enc_pos1 - enc_pos0);

(enc_size >= raw_size)

enc.set_pos(enc_pos0);

compression_stat_[scode]++;

scode =

enc.put_prefixed_array_16(scode, gap_block, arr_len,

);

compression_stat_[scode]++;

<

BV>

scores_[mod_size_] = score; models_[mod_size_] =

;

<

BV>

bie_bits_per_int =

compression_level_ < 6 ? 3.75f : this->bie_bits_per_int_;

bie_limit = unsigned(

(

) / bie_bits_per_int);

bc, ibc, gc;

(sub_stat.top_level_idx == i0);

bit_stat_.bit_model_0run_size_ =

bit_stat_.bit_model_d0_size_ = unsigned(8 + (32 * d0_bc *

(

)));

(sub_stat.top_level_idx == i0 && (block == sub_stat.blocks[j0]))

gc = sub_stat.gc_arr[j0]; bc = sub_stat.bc_arr[j0];

bit_stat_.gc = gc; bit_stat_.bc = bc;

arr_size_inv =

gcf=float(gc);

32 +

((gcf-1) * bie_bits_per_int));

(

bcf=

(bc), ibcf=

(ibc); bc < bie_limit)

16 * 3 +

(bcf * bie_bits_per_int));

(ibc < bie_limit)

16 * 3 +

(ibcf * bie_bits_per_int));

gc -= gc > 2 ? 2 : 0;

16 * 4 +

(gcf * bie_bits_per_int));

16 * 4 +

(gcf * bie_bits_per_int));

(

= 0;

< mod_size_; ++

)

(scores_[

] < min_score)

min_score = scores_[

]; model = models_[

];

std::cout <<

<< (bit_model_0run_size_ * 8) << std::endl;

std::cout <<

<< (16 * 4 + unsigned(gcf * bie_bits_per_int)) << std::endl;

std::cout <<

<< (16 * 3 + unsigned(bcf * bie_bits_per_int)) << std::endl;

std::cout <<

<< bc <<

<< gc <<

<< std::endl;

std::cout <<

<< bie_limit << std::endl;

: std::cout <<

<<

<< bc <<

<< gc <<

;

;

: std::cout <<

<< bc <<

<< gc <<

<< bie_limit <<

;

;

: std::cout <<

<<

(model);

;

((compression_level_ >= 6) && bic_drange_)

(bit_stat_.gc <= bit_stat_.bc || bit_stat_.gc <= bit_stat_.ibc))

model = (bit_stat_.bc <= bit_stat_.ibc) ?

<

BV>

(compression_level_ >= 5)

find_bit_best_encoding_l5(block, sub_stat, nb);

(compression_level_ <= 1)

(compression_level_ <= 5)

(compression_level_ >= 2)

bit_stat_.bit_model_d0_size_ = unsigned(8 + (32 * d0_bc *

(

)));

(compression_level_ >= 4)

bit_stat_.gc = 65535;

(bit_stat_.bc == 1)

(compression_level_ >= 3)

arr_size_inv =

(compression_level_ >= 4)

gamma_bits_per_int = 6;

(compression_level_ == 4)

16 + (bit_stat_.gc-1) * gamma_bits_per_int);

(bit_stat_.bc < bit_stat_.gc &&

16 + bit_stat_.bc * gamma_bits_per_int);

(bit_stat_.ibc > 3 &&

bit_stat_.ibc < bit_stat_.gc &&

16 + bit_stat_.ibc * gamma_bits_per_int);

(

= 0;

< mod_size_; ++

)

(scores_[

] < min_score)

min_score = scores_[

]; model = models_[

];

<

BV>

(compression_level_ <= 2)

(compression_level_ == 4)

<

BV>

enc_choice = find_gap_best_encoding(gap_block);

gamma_gap_block(gap_block, enc);

enc.

(gap_temp_block[0]);

gamma_gap_array(gap_temp_block, arr_len, enc,

);

interpolated_encode_gap_block(gap_block, enc, 0);

gamma_gap_block(gap_block, enc);

<

BV>

enc.put_8((blk[0]==0) ? 0 : 1);

enc.put_32(blk +

, j -

);

<

BV>

(bit_stat_.bit_model_0run_size_ < bit_stat_.bit_model_d0_size_)

encode_bit_interval(block, enc, 0);

enc.put_32(block[off+j+0]);

enc.put_32(block[off+j+1]);

enc.put_32(block[off+j+2]);

enc.put_32(block[off+j+3]);

encode_bit_interval(block, enc, 0);

<

BV>

enc.put_8(vbr_flag);

ridx = ref_vect_->get_row_idx(ridx);

1: enc.put_8((

)ridx);

;

2: enc.put_16((

)ridx);

;

0: enc.put_32((

)ridx);

;

enc.put_8((

) (chain_size-1));

(

ci = 1; ci < chain_size; ++ci)

ridx = mchain.ref_idx[ci];

d64 = mchain.xor_d64[ci];

ridx = ref_vect_->get_row_idx(ridx);

1: enc.put_8((

)ridx);

;

2: enc.put_16((

)ridx);

;

0: enc.put_32((

)ridx);

;

<

BV>

s_block = xor_tmp1_;

* ref_block = xor_scan_.get_ref_block(ridx,

, j);

ref_block = xor_tmp2_;

(

k = 1; k < mchain.chain_size; ++k)

ridx = mchain.ref_idx[k];

ref_block = xor_scan_.get_ref_block(ridx,

, j);

ref_block = xor_tmp2_;

d64 = mchain.xor_d64[k];

<

BV>

bv.calc_stat(&stat);

.resize(bv_stat->max_serialize_mem,

);

optimize_ = free_ =

;

* data_buf =

.data();

buf_size =

.size();

<

BV>

bvector_type::mem_pool_guard mp_g_z;

mp_g_z.assign_if_not_set(pool_, bv);

bv.optimize(temp_block_, BV::opt_compress, &

);

optimize_ = free_ =

;

<

BV>

scode =

enc.put_prefixed_array_16(scode, bit_idx_arr_.data(), arr_len,

);

compression_stat_[scode]++;

encode_bit_digest(block, enc, bit_stat_.d0);

<

BV>

gamma_gap_block(bit_idx_arr_.data(), enc);

<

BV>

gamma_gap_array(bit_idx_arr_.data(), arr_len, enc, inverted);

<

BV>

interpolated_gap_array(bit_idx_arr_.data(), arr_len, enc, inverted);

encode_bit_digest(block, enc, bit_stat_.d0);

<

BV>

= bienc_gap_bit_block_enc(

, enc);

encode_bit_digest(block, enc, bit_stat_.d0);

interpolated_encode_gap_block(bit_idx_arr_.data(), enc,

);

enc_size = (unsigned)(enc_pos1 - enc_pos0);

enc.set_pos(enc_pos0);

<

BV>

= bienc_gap_bit_block_enc(

, enc);

encode_bit_digest(block, enc, bit_stat_.digest0_);

<

BV>

enc.put_8((

)

);

enc_size = (unsigned)(enc_pos1 - enc_pos0);

(enc_size >= raw_size)

enc.set_pos(enc_pos0);

compression_stat_[scode]++;

<

BV>

sb_flag = 0;

= (unsigned)sb_bit_idx_arr_.size();

min0 = 0;

delta_acc = 0; (void) delta_acc;

* sb_arr = sb_bit_idx_arr_.data();

min0 = (min0 > 1) ? (min0-1) : 0;

projected_delta_acc = (

- 1) * min0;

(min0 && projected_delta_acc > 250)

((max_v1 + delta_acc) == max_v0);

(sb > 65535)

(min_v <= 0xFFFFFF)

(min_v > 255)

(max_v_delta > 65535)

(max_v_delta <= 0xFFFFFF)

(max_v_delta > 255)

(min_v <= 0xFFFFFF)

(min_v > 255)

bout.

((

)min_v);

bout.

((

)min_v, 8);

(max_v_delta > 65535)

(max_v_delta <= 0xFFFFFF)

(max_v_delta > 255)

bout.

((

)max_v_delta);

bout.

(min0_code);

(

)sb_bit_idx_arr_.size()-2,

enc_size = (unsigned)(pos1 - pos0); (void) enc_size;

compression_stat_[scode]++;

<

BV>

sub_gap_len = 0;

(sub_stat.blocks[

])

bit_out_type bout(enc);

bout.gamma8(sub_gap_len);

bout.bic_encode_u16_cm(sub_idx, sub_gap_len, 0, 255);

(

= 0;

< sub_gap_len; ++

)

block_idx = sub_idx[

];

bout.put_bits(

, 1);

(

j = 1; j <

; ++j)

bout.gamma8(gap_block[j]);

bout.gamma8(tail_delta);

bout.bic_encode_u16(&gap_block[2],

-3, min_v, max_v);

enc_size = (unsigned)(enc_pos1 - enc_pos0); (void) enc_size;

compression_stat_[scode]++;

<

BV>

s_cnt, r_cnt;

split_cnt = s_cnt + (r_cnt * 2);

(split_cnt > bit_stat_.bc)

scode =

no_gap_EOC = (r_cnt == 0);

s_g_size = unsigned(enc_pos1_s - enc_pos0);

enc_size2 = (unsigned)(p2 - p1);

g_size = (r_cnt == 1) ? 0

use_gamma = (g_size <= enc_size2);

p3_rl0 = enc.

();

!inverted,

, use_gamma,

);

p3_rl1 = enc.

();

rl_g_size = unsigned(p3_rl1 - p3_rl0);

(

= 0;

< r_cnt; ++

)

(

(arr_rl[

]) + arr_r[

] <= 65535);

arr_rl[

] += arr_r[

];

!inverted,

, use_gamma,

);

enc_size3 = (unsigned)(p3 - p2);

(enc_size3 > g_size)

enc_size = (unsigned)(enc_pos1 - enc_pos0);

((enc_size >= raw_size) || (enc_size >= bit_stat_.bit_model_d0_size_))

enc.

((

)0xFF);

compression_stat_[scode]++;

<

BV>

bit_idx_arr_.data(), block, inverted);

scode =

need_min_max = min_v && (dr_reduct > (3 * 256) || arr_len < 4);

arr_len -= 2; min_v++; max_v--;

= &bit_idx_arr_[1];

= &bit_idx_arr_[0];

min_v = 0; max_v = 65535;

enc_size = (unsigned)(enc_pos1 - enc_pos0);

(enc_size >= raw_size)

(bit_stat_.d0 != ~0ull && enc_size > bit_stat_.bit_model_d0_size_)

compression_stat_[scode]++;

<

BV>

enc_try((

*)try_buf_, 65536);

= interpolated_arr_bit_block_v3s(enc_try, block, inverted);

s_size = size_t(enc_try_pos1 - enc_try_pos0);

= interpolated_arr_bit_block_v3(enc, block, inverted);

dr_size = size_t(enc_pos1 - enc_pos0);

(s_size && (s_size < dr_size))

encode_bit_digest(block, enc, bit_stat_.d0);

bit_idx_arr_.data(), block, inverted);

scode =

(!inverted && min_v <= 0xFF && max_delta <= 0xFF)

enc.

((

)min_v);

enc.

((

)max_delta);

bout.

(&bit_idx_arr_[1], arr_len-2, min_v, max_v);

enc_size = (unsigned)(enc_pos1 - enc_pos0);

(enc_size >= raw_size)

(bit_stat_.d0 != ~0ull && enc_size > bit_stat_.bit_model_d0_size_)

compression_stat_[scode]++;

encode_bit_digest(block, enc, bit_stat_.d0);

<

BV>

(bookm.ptr_ && nb_delta >= bookm.nb_range_)

* curr = enc.get_pos();

bytes_delta = size_t(curr - bookm.ptr_);

(bytes_delta > bookm.min_bytes_range_)

enc.set_pos(bookm.ptr_);

(bookm.bm_type_)

bytes_delta -=

(unsigned);

(bytes_delta < 0xFFFFFFFF)

enc.put_32(

(bytes_delta));

bytes_delta -= (

(unsigned)-1);

(bytes_delta < 0xFFFFFF)

enc.put_24(

(bytes_delta));

bytes_delta -=

(

short);

(bytes_delta < 0xFFFF)

enc.put_16((

)bytes_delta);

(nb_delta < 0xFF)

enc.put_8((

) nb_delta);

(nb_delta < 0xFFFF)

enc.put_16((

) nb_delta);

(nb_delta < 0xFFFFFF)

enc.put_24(

(nb_delta));

(nb_delta < ~0

)

enc.put_32(

(nb_delta));

(nb_delta < 0xFFFFFFFFFFFFUL)

enc.put_48(nb_delta);

enc.put_64(nb_delta);

bookm.ptr_ = enc.get_pos() + 1;

(bookm.bm_type_)

<

BV>

*

,

buf_size)

(allow_stat_reset_)

reset_compression_stats();

enc_header_pos_ = 0;

encode_header(bv, enc);

i_last = ~0u;

(i0 < bman.top_block_size())

process_bookmark(

, sb_bookmark, enc);

sub_stat.

((

*)&bv, i0);

is_sparse_sub =

bman.is_sparse_sblock(i0, sparse_cutoff_, sub_stat);

((compression_level_ >= 5) && (ref_vect_ == 0))

(is_sparse_sub && sub_stat.

< 65536)

bienc_arr_sblock(bv, i0, enc);

ibc = unsigned(sub_max_bc - sub_stat.

);

bienc_gaps_sblock(bv, i0, sub_stat, enc);

* blk = bman.get_block(i0, j0);

enc.

(enc_header_pos_);

enc.

(header_flag_);

(nb > 1 && nb < 128)

c = (

char)((1u << 7) | nb);

*** blk_root = bman.top_blocks_root();

* blk_next = bman.get_block(i0, j0);

nb_indexed = sim_model_->bv_blocks.test(

);

rank = sim_model_->bv_blocks.count_range(0,

);

sim_model_->matr.get(ref_idx_, rank);

(mchain.

)

plain_idx = ref_vect_->get_row_idx(ridx);

enc.

(

(plain_idx));

xor_tmp_product(blk, mchain, i0, j0);

plain_idx = ref_vect_->get_row_idx(ridx);

encode_xor_match_chain(enc, mchain);

blk = xor_tmp_block_;

encode_gap_block(

(blk), enc);

model = find_bit_best_encoding(blk, sub_stat,

);

bit_idx = 0;

encode_bit_array(blk, enc,

);

encode_bit_array(blk, enc,

);

gamma_gap_bit_block(blk, enc);

encode_bit_interval(blk, enc, 0);

gamma_arr_bit_block(blk, enc,

);

gamma_arr_bit_block(blk, enc,

);

bienc_arr_bit_block(blk, enc,

);

bienc_arr_bit_block(blk, enc,

);

interpolated_arr_bit_block(blk, enc,

);

interpolated_arr_bit_block(blk, enc,

);

interpolated_gap_bit_block(blk, enc);

interpolated_gap_bit_block(blk, enc);

encode_bit_digest(blk, enc, bit_stat_.d0);

enc.

(enc_header_pos_);

enc.

(header_flag_);

<

BV>

*

,

<

BV>

*

,

<

BV>

*

,

header_flag = dec.

();

(bo_current == bo)

<

BV>

*

,

BV::size_type from,

BV::size_type to,

header_flag = dec.

();

(bo_current == bo)

bv.keep_range(from, to);

<

DEC,

BLOCK_IDX>

block_type,

(k == 0) --bit_idx;

dst_arr[k] = bit_idx;

dst_arr[

-1] = max_v;

min_v = (

& 1) ?

max_v = (

& (1<<1)) ?

dst_arr[

-1] = max_v;

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

block_type)

min_v = dec.get_16();

max_v = dec.get_16();

min_v = dec.get_8();

max_delta = dec.get_8();

s_cnt, r_cnt;

bin.

(arr_rl, this->tb_wflags_, &s_cnt, r_cnt);

(

= 0;

< r_cnt; ++

)

arr_rl[

] -= arr_r[

];

control = dec.get_8();

(control != 0xFF)

std::cerr <<

<< std::endl;

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

need_min_max = bin.

(1);

min_v = 0; max_v = 65535;

arr_len = dec.get_16();

<

DEC,

BLOCK_IDX>

block_type,

(0), sb_flag(0);

sb_flag = dec.get_8();

*sb_idx = dec.get_32();

*sb_idx = dec.get_16();

*sb_idx = dec.get_8();

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

min_v = dec.get_32();

min_v = dec.get_24();

min_v = dec.get_16();

min_v = dec.get_8();

max_v = dec.get_32();

max_v = dec.get_24();

max_v = dec.get_16();

max_v = dec.get_8();

use_gamma = bin.

();

min0 = bin.

();

dst_arr[

-1] = max_v;

j = bin.

();

min_v = (j * 65536) + nbit;

min0_code = bin.

();

min0 = bin.

();

*sb_idx = bin.

()-1;

dst_arr[

-1] = max_v;

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

this->read_bic_arr(

, blk, block_type);

<

DEC,

BLOCK_IDX>

arr_len = dec.get_16();

id_array_[0] =

;

id_array_[1] = min_v;

id_array_[arr_len] = 65535;

<

DEC,

BLOCK_IDX>

block[off+j+0] |= dec.get_32();

block[off+j+1] |= dec.get_32();

block[off+j+2] |= dec.get_32();

block[off+j+3] |= dec.get_32();

<

DEC,

BLOCK_IDX>

run_type = dec.get_8();

run_length = dec.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

w = dec.get_32();

<

BIN>

<

BIN>

max_v <<= 3; max_v |= (head_v3 & 0b111);

<

DEC,

BLOCK_IDX>

block_type,

*dst_block = gap_head;

arr_len = read_id_list(

, block_type, id_array_);

= (gap_head >> 3);

*dst_block = gap_head;

(

= 1;

<

; ++

)

*(++gap_data_ptr) = gap_sum;

= (gap_head >> 3);

*dst_block = gap_head;

dst_block[1] = min_v;

= (gap_head >> 3);

dst_block[0] = gap_head;

dst_block[1] = min_v;

dst_block[

-1] = max_v;

= (gap_head >> 3);

dst_block[0] = gap_head;

dst_block[1] = min_v;

dst_block[

-1] = max_v;

head_v3 = (

char) bin.

(8);

= (gap_head >> 3);

ex0_cnt{0};

(

k = 2; k <

; ++k)

(dst_block[k] > dst_block[k-1]);

dst_block[1] = min_v;

dst_block[

-1] = max_v+1;

bin.

(&ex0_arr[0], this->tb_wflags_, &ex0_cnt);

(

k = 0; k < ex0_cnt; ++k)

bin.

(&ex0_arr[0], this->tb_wflags_, &ex0_cnt);

(

k = 0; k < ex0_cnt; ++k)

dst_block[1] = min_v;

dst_block[

-1] = max_v+1;

(control != 0xFF)

std::cerr <<

<< std::endl;

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

(

!= cnt_saved)

std::cerr <<

<< std::endl;

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

start_flag = bin.

();

use_gamma = bin.

();

(

= 2;

<

; ++

)

= dst_block[

];

(

= 1;

<

; ++

)

(

==1 || (dst_block[

-1] < dst_block[

]));

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(save_pos > skip_pos_)

(nb_sync <= expect_nb)

<

BV,

DEC>

<

BV,

DEC>

alloc_.free_bit_block(temp_block_);

alloc_.free_bit_block(xor_block_, 2);

<

BV,

DEC>

(ref_vect_ && !xor_block_)

xor_block_ = alloc_.alloc_bit_block(2);

<

BV,

DEC>

inv_flag =

;

bman.reserve_top_blocks(i0+1);

bman.check_alloc_top_subblock(i0);

(

(

) == 2 ? dec.get_16() : dec.get_32());

*gap_temp_block = gap_head;

dec.get_16(gap_temp_block+1,

- 1);

blk = bman.get_allocator().alloc_bit_block();

bman.set_block(nb, blk);

bv.combine_operation_block_or(i0, j0, blk, temp_block_);

bman.get_allocator().alloc_gap_block(

(level), bman.glen());

*gap_blk_ptr = gap_head;

dec.get_16(gap_blk + 1,

- 1);

*gap_temp_block = gap_head;

dec.get_16(gap_temp_block + 1,

- 1);

arr_len = this->read_id_list(dec, btype, this->id_array_);

gap_temp_block[0] = 0;

bv.combine_operation_block_or(i0, j0, blk, temp_block_);

gap_head = dec.get_16();

this->read_gap_block(dec, btype, gap_temp_block, gap_head);

gap_head = dec.get_16();

this->read_gap_block(dec, btype, gap_temp_block, gap_head);

this->read_gap_block(dec, btype, gap_temp_block, gap_head);

this->read_gap_block(dec, btype, gap_temp_block, gap_head);

this->read_gap_block(dec, btype, gap_temp_block, gap_head);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

blk = bman.get_allocator().alloc_bit_block();

bman.set_block_ptr(i0, j0, blk);

bv.combine_operation_block_or(i0, j0, blk, temp_block_);

bv.combine_operation_block_or(i0, j0, blk, tmp_blk);

<

BV,

DEC>

blk = bman.get_allocator().alloc_bit_block();

bman.set_block(nb, blk);

blk = bman.deoptimize_block(nb);

blk = bman.deoptimize_block(nb);

(

k = 0; k <

; ++k)

this->read_bic_arr(dec, blk, btype);

blk = bman.deoptimize_block(nb);

this->read_bic_arr(dec, temp_block_, btype);

this->read_bic_gap(dec, blk);

this->read_digest0_block(dec, blk);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

BV,

DEC>

*

= this->sb_id_array_;

= this->read_bic_sb_arr(dec, btype,

, &sb);

BV::size_type from = sb * sb_max_bc;

(

BV::size_type

= 0;

<

; ++

)

BV::size_type idx = from +

[

];

(idx < idx_from_)

bv.set_bit_no_check(idx);

(

BV::size_type

= 0;

<

; ++

)

BV::size_type idx = from +

[

];

bv.set_bit_no_check(idx);

<

BV,

DEC>

blk = bman.get_allocator().alloc_bit_block();

bman.set_block(nb, blk);

bv.combine_operation_with_block(nb, temp_block_, 0,

);

<

BV,

DEC>

head_idx = dec.get_16();

tail_idx = dec.get_16();

blk = bman.get_allocator().alloc_bit_block();

bman.set_block(nb, blk);

(

k = 0; k < head_idx; ++k)

dec.get_32(blk + head_idx, tail_idx - head_idx + 1);

dec.get_32(temp_block_ + head_idx, tail_idx - head_idx + 1);

bv.combine_operation_with_block(nb, temp_block_, 0,

);

<

BV,

DEC>

blk = bman.deoptimize_block(nb);

blk = bman.get_allocator().alloc_bit_block();

bman.set_block(nb, blk);

(

k = 0; k <

; ++k)

(

k = 0; k <

; ++k)

<

BV,

DEC>

*

,

(!bman.is_init())

bc = bman.compute_top_block_size(

-1);

bvector_type::mem_pool_guard mp_guard_bv;

mp_guard_bv.assign_if_not_set(pool_, bv);

header_flag = dec.get_8();

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

bv_size = dec.get_32();

(bv_size > bv.size())

(

= dec.get_32();

; --

)

dec.size()-1;

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

bv_size = dec.get_32();

(bv_size > bv.size())

xor_block_ = alloc_.alloc_bit_block();

row_idx(0);

btype;

dec_last_size = dec.size();

std::cout <<

<< dec_last_size;

btype = dec.get_8();

(btype & (1 << 7))

nb = btype & ~(1 << 7);

* blk = bman.get_block_ptr(i0, j0);

dec_size = dec.size();

std::cout <<

<< (dec_size - dec_last_size);

std::cout <<

<< unsigned(btype) <<

<< nb_i <<

<< std::flush;

dec_last_size = dec_size;

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

bman.set_block_all_set(nb_i);

full_blocks = dec.get_8();

process_full_blocks;

full_blocks = dec.get_16();

process_full_blocks;

full_blocks = dec.get_32();

process_full_blocks;

full_blocks = dec.get_64();

process_full_blocks;

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

process_full_blocks:

bv.set_range(from, to-1);

nb_i += full_blocks-1;

decode_block_bit(dec, bv, nb_i, blk);

bv.set_bit_no_check(bit_idx);

this->read_0runs_block(dec, temp_block);

bv.combine_operation_with_block(nb_i, temp_block, 0,

);

decode_block_bit_interval(dec, bv, nb_i, blk);

deserialize_gap(btype, dec, bv, bman, nb_i, blk);

decode_arrbit(dec, bv, nb_i, blk);

decode_bit_block(btype, dec, bman, nb_i, blk);

decode_bit_block(btype, dec, bman, nb_i, blk);

decode_arr_sblock(btype, dec, bv);

this->bookmark_idx_ = nb_i;

this->skip_offset_ = dec.get_32();

process_bookmark;

this->bookmark_idx_ = nb_i;

this->skip_offset_ = dec.get_24();

process_bookmark;

this->bookmark_idx_ = nb_i;

this->skip_offset_ = dec.get_16();

this->skip_pos_ = dec.get_pos() + this->skip_offset_;

nb_from = this->try_skip(dec, nb_i, nb_from);

nb_sync = dec.get_8();

process_nb_sync;

nb_sync = dec.get_16();

process_nb_sync;

nb_sync = dec.get_24();

process_nb_sync;

nb_sync = dec.get_32();

process_nb_sync;

process_nb_sync;

(nb_i == this->bookmark_idx_ + nb_sync);

(nb_i != this->bookmark_idx_ + nb_sync)

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

row_idx = dec.get_32();

idx = ref_vect_->find(row_idx);

(idx == ref_vect_->not_found())

* ref_blk = ref_bman.get_block_ptr(i0, j0);

bv.combine_operation_with_block(nb_i, ref_blk,

row_idx = dec.get_8();

row_idx = dec.get_16();

row_idx = dec.get_32();

x_ref_d64_ = dec.get_64();

x_ref_idx_ = ref_vect_->find(row_idx);

(x_ref_idx_ == ref_vect_->not_found())

or_block_ = bman.deoptimize_block(nb_i);

bman.set_block_ptr(nb_i, 0);

or_block_idx_ = nb_i;

row_idx = dec.get_8();

process_xor_ref;

row_idx = dec.get_16();

process_xor_ref;

row_idx = dec.get_32();

process_xor_ref;

vbr_flag = dec.get_8();

1: row_idx = dec.get_8();

;

2: row_idx = dec.get_16();

;

0: row_idx = dec.get_32();

;

acc64 = x_ref_d64_ = dec.get_h64(); (void) acc64;

xor_chain_size_ = dec.get_8();

(

ci = 0; ci < xor_chain_size_; ++ci)

1: xor_chain_[ci].ref_idx = dec.get_8();

;

2: xor_chain_[ci].ref_idx = dec.get_16();

;

0: xor_chain_[ci].ref_idx = dec.get_32();

;

xor_chain_[ci].xor_d64 = dec.get_h64();

((xor_chain_[ci].xor_d64 & acc64) == 0);

acc64 |= xor_chain_[ci].xor_d64;

process_xor_ref;

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

bv.set_new_blocks_strat(strat);

bman.shrink_top_blocks();

<

BV,

DEC>

(

ci = 0; ci < xor_chain_size_; ++ci)

ref_idx = (unsigned)ref_vect_->find(xor_chain_[ci].ref_idx);

ref_blk = xor_block_;

<

BV,

DEC>

* ref_bv = ref_vect_->get_bv(x_ref_idx_);

ref_blk = ref_bman.get_block_ptr(i0, j0);

(!or_block_ || or_block_idx_ == x_nb_);

* blk = bman.deoptimize_block(i0, j0,

);

alloc_.free_bit_block(or_block_);

bman.set_block_ptr(x_nb_, or_block_);

or_block_ = 0; or_block_idx_ = 0;

(xor_chain_size_)

* blk = bman.deoptimize_block(i0, j0,

);

xor_decode_chain(blk);

* blk = bman.get_block_ptr(i0, j0);

(

(blk) && (x_ref_d64_==~0ULL) && !or_block_)

bman.assign_gap_check(i0, j0, res, ++res_len, blk, tmp_buf);

ref_blk = xor_block_;

* blk = bman.deoptimize_block(i0, j0,

);

(xor_chain_size_)

xor_decode_chain(blk);

alloc_.free_bit_block(or_block_);

(nb_from == x_nb_ || nb_to == x_nb_)

bman.optimize_bit_block_nocheck(i0, j0);

<

BV,

DEC>

x_ref_idx_ = 0; x_ref_d64_ = 0; xor_chain_size_ = 0;

<

DEC,

BLOCK_IDX>

end_of_stream_(

),

std::bad_alloc();

BM_THROW(BM_ERR_BADALLOC);

(!this->ex0_arr_ || !this->ex1_arr_)

std::bad_alloc();

BM_THROW(BM_ERR_BADALLOC);

<

DEC,

BLOCK_IDX>

<

DEC,

BLOCK_IDX>

end_of_stream_ =

;

last_id_ = decoder_.get_32();

end_of_stream_ =

;

block_type_ = decoder_.get_8();

(block_type_ & (1u << 7u))

mono_block_cnt_ = (block_type_ & ~(1u << 7u)) - 1;

state_ = e_zero_blocks;

(block_type_)

end_of_stream_ =

; state_ = e_unknown;

state_ = e_zero_blocks;

mono_block_cnt_ = 0;

state_ = e_zero_blocks;

mono_block_cnt_ = decoder_.get_8()-1;

state_ = e_zero_blocks;

mono_block_cnt_ = decoder_.get_16()-1;

state_ = e_zero_blocks;

mono_block_cnt_ = decoder_.get_32()-1;

state_ = e_one_blocks;

state_ = e_one_blocks;

mono_block_cnt_ = 0;

state_ = e_one_blocks;

mono_block_cnt_ = decoder_.get_8()-1;

state_ = e_one_blocks;

mono_block_cnt_ = decoder_.get_16()-1;

state_ = e_one_blocks;

mono_block_cnt_ = decoder_.get_32()-1;

state_ = e_one_blocks;

state_ = e_bit_block;

gap_head_ = decoder_.get_16();

state_ = e_gap_block;

state_ = e_gap_block;

state_ = e_gap_block;

this->bookmark_idx_ = block_idx_;

this->skip_offset_ = decoder_.get_32();

this->skip_pos_ = decoder_.get_pos() + this->skip_offset_;

this->bookmark_idx_ = block_idx_;

this->skip_offset_ = decoder_.get_24();

this->skip_pos_ = decoder_.get_pos() + this->skip_offset_;

this->bookmark_idx_ = block_idx_;

this->skip_offset_ = decoder_.get_16();

this->skip_pos_ = decoder_.get_pos() + this->skip_offset_;

nb_sync = decoder_.get_8();

process_nb_sync;

nb_sync = decoder_.get_16();

process_nb_sync;

nb_sync = decoder_.get_24();

process_nb_sync;

nb_sync = decoder_.get_32();

process_nb_sync;

process_nb_sync;

(block_idx_ == this->bookmark_idx_ + nb_sync);

(block_idx_ != this->bookmark_idx_ + nb_sync)

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

(!mono_block_cnt_)

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(state_ == e_zero_blocks || state_ == e_one_blocks);

(!mono_block_cnt_)

block_idx_ += mono_block_cnt_+1;

mono_block_cnt_ = 0;

<

DEC,

BLOCK_IDX>

(

k = 0; k <

; ++k)

(

k = 0; k <

; ++k)

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(this->block_type_)

run_type = decoder_.get_8();

run_length = decoder_.get_16();

decoder_.get_32(dst_block ? dst_block + j : dst_block, run_length);

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= 0;

< head_idx; ++

)

decoder_.get_32(dst_block + head_idx,

tail_idx - head_idx + 1);

pos =

(tail_idx - head_idx) + 1;

get_arr_bit(dst_block,

);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

get_inv_arr(dst_block);

this->read_bic_arr(decoder_, dst_block, this->block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_bic_gap(decoder_, dst_block);

this->read_digest0_block(decoder_, dst_block);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= head_idx;

<= tail_idx; ++

)

dst_block[

] |= decoder_.get_32();

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

dst_block[j] |= decoder_.get_32();

get_arr_bit(dst_block,

);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, dst_block, this->block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, this->block_type_);

this->read_bic_gap(decoder_, dst_block);

this->read_digest0_block(decoder_, dst_block);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

dst_block[j] &= decoder_.get_32();

(;j < run_end; ++j)

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= 0;

< head_idx; ++

)

(

= head_idx;

<= tail_idx; ++

)

dst_block[

] &= decoder_.get_32();

get_arr_bit(tmp_block,

);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr(decoder_, 0, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_bic_gap(decoder_, tmp_block);

this->read_bic_gap(decoder_, 0);

this->read_digest0_block(decoder_, tmp_block);

this->read_digest0_block(decoder_, 0);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

dst_block[

] ^= decoder_.get_32();

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

dst_block[j] ^= decoder_.get_32();

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= head_idx;

<= tail_idx; ++

)

dst_block[

] ^= decoder_.get_32();

get_arr_bit(tmp_block,

);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_bic_gap(decoder_, tmp_block);

this->read_bic_gap(decoder_, 0);

this->read_digest0_block(decoder_, tmp_block);

this->read_digest0_block(decoder_, 0);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

dst_block[

] &= ~decoder_.get_32();

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

dst_block[j] &= ~decoder_.get_32();

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= head_idx;

<= tail_idx; ++

)

dst_block[

] &= ~decoder_.get_32();

get_arr_bit(tmp_block,

);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_bic_gap(decoder_, tmp_block);

this->read_bic_gap(decoder_, 0);

this->read_digest0_block(decoder_, tmp_block);

this->read_digest0_block(decoder_, 0);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= head_idx;

<= tail_idx; ++

)

+= get_arr_bit(0);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_digest0_block(decoder_, tmp_block);

this->read_bic_gap(decoder_, tmp_block);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= head_idx;

<= tail_idx; ++

)

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_bic_gap(decoder_, tmp_block);

this->read_digest0_block(decoder_, 0);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= head_idx;

<= tail_idx; ++

)

get_arr_bit(tmp_block,

);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_digest0_block(decoder_, tmp_block);

this->read_bic_gap(decoder_, tmp_block);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

(;j < run_end; ++j)

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= 0;

< head_idx; ++

)

(

= head_idx;

<= tail_idx; ++

)

get_arr_bit(tmp_block,

);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_digest0_block(decoder_, tmp_block);

this->read_bic_gap(decoder_, tmp_block);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

count_adapter.

();

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

(;j < run_end; ++j)

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= 0;

< head_idx; ++

)

(

= head_idx;

<= tail_idx; ++

)

get_arr_bit(tmp_block,

);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_digest0_block(decoder_, tmp_block);

this->read_bic_gap(decoder_, tmp_block);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

count_adapter.

();

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

(;j < run_end; ++j)

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= 0;

< head_idx; ++

)

(

= head_idx;

<= tail_idx; ++

)

get_arr_bit(tmp_block,

);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_digest0_block(decoder_, tmp_block);

this->read_bic_gap(decoder_, tmp_block);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

count_adapter.

();

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

(block_type_)

run_type = decoder_.get_8();

run_length = decoder_.get_16();

run_end = j + run_length;

(;j < run_end; ++j)

head_idx = decoder_.get_16();

tail_idx = decoder_.get_16();

(

= head_idx;

<= tail_idx; ++

)

get_arr_bit(tmp_block,

);

get_inv_arr(tmp_block);

this->read_bic_arr(decoder_, tmp_block, block_type_);

this->read_bic_arr_inv(decoder_, tmp_block, block_type_);

this->read_digest0_block(decoder_, tmp_block);

this->read_bic_gap(decoder_, tmp_block);

std::logic_error(this->err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

count_adapter.

();

<

DEC,

BLOCK_IDX>

(

k = 0; k <

; ++k)

decoder_.seek(

* 2);

<

DEC,

BLOCK_IDX>

++(this->block_idx_);

this->state_ = e_blocks;

decoder_.get_16();

<

DEC,

BLOCK_IDX>

(this->state_ == e_gap_block ||

this->read_gap_block(decoder_, block_type_, dst_block, gap_head_);

++(this->block_idx_);

this->state_ = e_blocks;

<

DEC,

BLOCK_IDX>

(this->state_ == e_bit_block);

get_bit_func_type bit_func = bit_func_table_[op];

= ((*this).*(bit_func))(dst_block, tmp_block);

this->state_ = e_blocks;

++(this->block_idx_);

<

BV>

: temp_block_(0), ref_vect_(0)

<

BV>

alloc_.free_bit_block(temp_block_);

<

BV>

BV::size_type

= 0;

bv.bit_and(bv_tmp, BV::opt_compress);

= bv_tmp.count();

BM_THROW(BM_ERR_SERIALFORMAT);

<

BV>

*

,

deserialize_xor(bv, bv_tmp, op);

<

BV>

*

,

header_flag = dec.

();

(bo_current == bo)

de_.set_ref_vectors(ref_vect_);

de_.set_range(idx_from, idx_to);

de_.deserialize(bv,

);

bv.keep_range_no_check(idx_from, idx_to);

<

BV>

bv.bit_and(bv_tmp, bvector_type::opt_compress);

= bv_tmp.count();

std::logic_error(

);

BM_THROW(BM_ERR_SERIALFORMAT);

<

BV>

*

,

header_flag = dec.

();

deserialize_xor(bv,

, op, exit_on_one);

(bo_current == bo)

de_.deserialize(bv,

);

bv_tmp_.clear(

);

de_.deserialize(bv_tmp_,

);

(bo_current == bo)

it_d_.deserialize(bv, ss, temp_block_, op, exit_on_one);

it_d_be_.deserialize(bv, ss, temp_block_, op, exit_on_one);

it_d_le_.deserialize(bv, ss, temp_block_, op, exit_on_one);

std::logic_error(

);

BM_THROW(BM_ERR_SERIALFORMAT);

<

BV>

*

,

header_flag = dec.

();

(!bman.is_init())

bv.set_range(idx_from, idx_to);

deserialize_xor_range(bv_tmp,

, idx_from, idx_to);

bv.bit_and(bv_tmp, bvector_type::opt_compress);

(bo_current == bo)

bv_tmp_.clear(

);

de_.set_range(idx_from, idx_to);

de_.deserialize(bv_tmp_,

);

bv.bit_and(bv_tmp_, bvector_type::opt_compress);

(bo_current == bo)

it_d_.set_range(idx_from, idx_to);

it_d_.deserialize(bv, ss, temp_block_, op,

);

it_d_.unset_range();

it_d_be_.set_range(idx_from, idx_to);

it_d_be_.deserialize(bv, ss, temp_block_, op,

);

it_d_be_.unset_range();

it_d_le_.set_range(idx_from, idx_to);

it_d_le_.deserialize(bv, ss, temp_block_, op,

);

it_d_le_.unset_range();

std::logic_error(

);

BM_THROW(BM_ERR_SERIALFORMAT);

<

BV,

SerialIterator>

is_range_set_ =

;

<

BV,

SerialIterator>

win_size = 64;

(

= 0;

<= id_count;)

(j = 0; j < win_size &&

<= id_count; ++j, ++

)

id_buffer[j] = sit.get_id();

(

= 0;

<= id_count;)

(j = 0; j < win_size &&

<= id_count; ++j, ++

)

id_buffer[j] = sit.get_id();

<

BV,

SerialIterator>

(bv_block_idx <= nblock_last)

bman.set_all_zero(bv_block_idx, nblock_last);

*** blk_root = bman.top_blocks_root();

top_size = bman.top_block_size();

(;

< top_size; ++

)

+= bman.block_bitcount(blk_blk[j]);

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

BV,

SerialIterator>

id_count = sit.get_id_count();

set_clear =

;

load_id_list(bv_tmp, sit, id_count,

);

load_id_list(bv, sit, id_count, set_clear);

(

= 0;

< id_count; ++

)

(

= 0;

< id_count; ++

)

+= bv.get_bit(

);

load_id_list(bv_tmp, sit, id_count,

);

load_id_list(bv_tmp, sit, id_count,

);

load_id_list(bv_tmp, sit, id_count,

);

+= bv_tmp.count();

load_id_list(bv_tmp, sit, id_count,

);

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

<

BV,

SerialIterator>

gap_temp_block[0] = 0;

(!bman.is_init())

(sit.bv_size() && (sit.bv_size() > bv.size()))

bv.resize(sit.bv_size());

serial_iterator_type::iterator_state

;

= sit.get_state();

(

== serial_iterator_type::e_list_ids)

= process_id_list(bv, sit, op);

+= finalize_target_vector(bman, op, bv_block_idx);

serial_iterator_type::e_blocks:

(is_range_set_ && (bv_block_idx < nb_range_from_))

skip_flag = sit.try_skip(bv_block_idx, nb_range_from_);

bv_block_idx = sit.block_idx();

(bv_block_idx <= nb_range_from_);

(sit.state() == serial_iterator_type::e_blocks);

serial_iterator_type::e_bit_block:

(sit.block_idx() == bv_block_idx);

* blk = bman.get_block_ptr(i0, j0);

blk = bman.make_bit_block(bv_block_idx);

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

blk = bman.deoptimize_block(bv_block_idx);

c = sit.get_bit_block(blk, temp_block, sop);

(exit_on_one &&

)

bman.optimize_bit_block(i0, j0, bvector_type::opt_compress);

serial_iterator_type::e_zero_blocks:

(bv_block_idx == sit.block_idx());

bv_block_idx = sit.skip_mono_blocks();

bv_block_idx = sit.skip_mono_blocks();

bman.set_all_zero(nb_start, bv_block_idx-1);

* blk = bman.get_block_ptr(i0, j0);

bman.zero_block(bv_block_idx);

+= blk ? bman.block_bitcount(blk) : 0;

(exit_on_one &&

)

serial_iterator_type::e_one_blocks:

(bv_block_idx == sit.block_idx());

* blk = bman.get_block_ptr(i0, j0);

bman.set_block_all_set(bv_block_idx);

bman.zero_block(bv_block_idx);

(++empty_op_cnt > 64)

= bv.find_reverse(last_id);

(last_nb < bv_block_idx)

+= blk ? bman.block_bitcount(blk) : 0;

blk = bman.deoptimize_block(bv_block_idx);

bman.set_block_all_set(bv_block_idx);

(exit_on_one &&

)

serial_iterator_type::e_gap_block:

(bv_block_idx == sit.block_idx());

* blk = bman.get_block(i0, j0);

sit.get_gap_block(gap_temp_block);

(exit_on_one &&

)

bman.zero_block(bv_block_idx);

bv_block_idx, gap_temp_block, level);

bv.combine_operation_with_block(bv_block_idx,

bv.combine_operation_with_block(

blk = bman.get_block_ptr(i0, j0);

std::logic_error(err_msg());

BM_THROW(BM_ERR_SERIALFORMAT);

(is_range_set_ && (bv_block_idx > nb_range_to_))

#define BM_DECLARE_TEMP_BLOCK(x)

Algorithms for bvector<> (main include)

#define IS_FULL_BLOCK(addr)

#define IS_VALID_ADDR(addr)

#define BMPTR_SETBIT0(ptr)

#define BMSET_PTRGAP(ptr)

#define FULL_BLOCK_FAKE_ADDR

#define FULL_BLOCK_REAL_ADDR

Bit manipulation primitives (internal)

#define BM_SER_NEXT_GRP(enc, nb, B_1ZERO, B_8ZERO, B_16ZERO, B_32ZERO, B_64ZERO)

Utilities for bit transposition (internal) (experimental!)

Bit manipulation primitives (internal)

Functions and utilities for XOR filters (internal)

Byte based reader for un-aligned bit streaming.

unsigned gamma() noexcept

decode unsigned value using Elias Gamma coding

unsigned get_24_no() noexcept

get 24 bits neutral order from the bit-stream

void bic_decode_u32_cm(bm::word_t *arr, unsigned sz, bm::word_t lo, bm::word_t hi) noexcept

Binary Interpolative array decode (32-bit)

unsigned delta16() noexcept

Custome variant of delta decoding.

unsigned delta16s() noexcept

Custome variant of delta decoding.

void bic_decode_u16(bm::gap_word_t *arr, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi) noexcept

Binary Interpolative array decode.

unsigned gamma8() noexcept

decode unsigned value using Elias Gamma coding

void bic_decode_u16_dry(unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi) noexcept

unsigned decode_array(bm::gap_word_t *arr, bm::word_t *tb_wflags, unsigned *sz, unsigned default_sz=0) noexcept

Selective array decode.

unsigned get_bit() noexcept

read 1 bit

unsigned get_16_no() noexcept

get 16 bits neutral order from the bit-stream

void bic_decode_u16_bitset(bm::word_t *block, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi) noexcept

unsigned get_32_no() noexcept

get 32 bits neutral order from the bit-stream

unsigned get_bits(unsigned count) noexcept

read number of bits out of the stream

Byte based writer for un-aligned bit streaming.

void put_16_no(unsigned value) noexcept

put 16 bits neutral byte order

void put_32_no(unsigned value) noexcept

put 32 bits neutral byte order

void flush_if_full() noexcept

void delta16s(unsigned value) noexcept

Custome variant of delta encoding (safe for 8-bit values)

void encode_array(const bm::gap_word_t *arr, bm::gap_word_t *recalc_arr, bm::word_t *tb_wflags, bm::gap_word_t *tmp_arr, unsigned sz, bool one_flag, bool EOC_flag, unsigned force_code=0, bool save_size=true) noexcept

Selective array serialization (BIC encoding is used)

void put_24_no(unsigned value) noexcept

put 24 bits neutral byte order

void gamma(unsigned value) noexcept

Elias Gamma encode the specified value.

void bic_encode_u16(const bm::gap_word_t *arr, unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi) noexcept

Binary Interpolative array decode.

void bic_encode_u32_cm(const bm::word_t *arr, unsigned sz, bm::word_t lo, bm::word_t hi) noexcept

Binary Interpolative encoding (array of 32-bit ints) cm - "center-minimal".

void flush() noexcept

Flush the incomplete 32-bit accumulator word.

void delta16(unsigned value) noexcept

Custome variant of delta encoding.

void put_bits(unsigned value, unsigned count) noexcept

issue count bits out of value

void gamma8(unsigned value) noexcept

Elias Gamma encode the specified value.

Bit-block get adapter, takes bitblock and represents it as a get_32() accessor function.

Bit-block sum adapter, takes values and sums it /internal.

bm::word_t sum() const noexcept

Get accumulated sum.

List of reference bit-vectors with their true index associations.

const unsigned char * get_pos() const noexcept

Return current buffer pointer.

unsigned char get_8() noexcept

Reads character from the decoding buffer.

void set_pos(const unsigned char *pos) noexcept

Set current buffer pointer.

Class for decoding data from memory buffer.

bm::id64_t get_48() noexcept

Reads 64-bit word from the decoding buffer.

bm::id64_t get_64() noexcept

Reads 64-bit word from the decoding buffer.

bm::word_t get_24() noexcept

Reads 32-bit word from the decoding buffer.

bm::short_t get_16() noexcept

Reads 16-bit word from the decoding buffer.

bm::word_t get_32() noexcept

Reads 32-bit word from the decoding buffer.

Base deserialization class.

static void read_0runs_block(decoder_type &decoder, bm::word_t *blk) noexcept

read bit-block encoded as runs

const unsigned char * skip_pos_

decoder skip position

block_idx_type try_skip(decoder_type &decoder, block_idx_type nb, block_idx_type expect_nb) noexcept

Try to skip if skip bookmark is available within reach.

void read_bic_arr(decoder_type &decoder, bm::word_t *blk, unsigned block_type)

Read binary interpolated list into a bit-set.

bm::word_t * ex1_arr_

array for exceptions

bm::bit_block_t tb_wflags_

temp flags for sub-block DR compression

void read_bic_gap(decoder_type &decoder, bm::word_t *blk) noexcept

Read binary interpolated gap blocks into a bitset.

static const char * err_msg() noexcept

block_idx_type bookmark_idx_

last bookmark block index

unsigned skip_offset_

bookmark to skip 256 encoded blocks

void read_digest0_block(decoder_type &decoder, bm::word_t *blk) noexcept

Read digest0-type bit-block.

void read_bic_arr_inv(decoder_type &decoder, bm::word_t *blk, unsigned block_type) noexcept

Read inverted binary interpolated list into a bit-set.

bm::bit_in< DEC > bit_in_type

unsigned * sb_id_array_

ptr to super-block idx array (temp)

unsigned read_bic_sb_arr(decoder_type &decoder, unsigned block_type, unsigned *dst_arr, unsigned *sb_idx)

Read list of bit ids for super-blocks.

void read_gap_block(decoder_type &decoder, unsigned block_type, bm::gap_word_t *dst_block, bm::gap_word_t &gap_head)

Read GAP block from the stream.

bm::word_t * ex0_arr_

array for exceptions

unsigned read_id_list(decoder_type &decoder, unsigned block_type, bm::gap_word_t *dst_arr)

Read list of bit ids.

bm::gap_word_t * id_array_

ptr to idx array for temp decode use

Deserializer for bit-vector.

void xor_reset() noexcept

void set_ref_vectors(const bv_ref_vector_type *ref_vect)

Attach collection of reference vectors for XOR de-serialization (no transfer of ownership for the poi...

block_arridx_type bit_idx_arr_

allocator_type::allocator_pool_type allocator_pool_type

void xor_decode_chain(bm::word_t *blk) noexcept

void xor_decode(blocks_manager_type &bman)

deseriaizer_base< DEC, block_idx_type > parent_type

bm::bv_ref_vector< BV > bv_ref_vector_type

void decode_arr_sblock(unsigned char btype, decoder_type &dec, bvector_type &bv)

void reset() noexcept

reset range deserialization and reference vectors

void deserialize_gap(unsigned char btype, decoder_type &dec, bvector_type &bv, blocks_manager_type &bman, block_idx_type nb, bm::word_t *blk)

bvector_type::allocator_type allocator_type

parent_type::decoder_type decoder_type

void unset_range() noexcept

Disable range deserialization.

allocator_pool_type pool_

sblock_arridx_type sb_bit_idx_arr_

BV::blocks_manager_type blocks_manager_type

void set_range(size_type from, size_type to) noexcept

set deserialization range [from, to] This is NOT exact, approximate range, content outside range is n...

block_arridx_type gap_temp_block_

size_t deserialize(bvector_type &bv, const unsigned char *buf, bm::word_t *temp_block=0)

bvector_type::block_idx_type block_idx_type

void decode_arrbit(decoder_type &dec, bvector_type &bv, block_idx_type nb, bm::word_t *blk)

void decode_bit_block(unsigned char btype, decoder_type &dec, blocks_manager_type &bman, block_idx_type nb, bm::word_t *blk)

void decode_block_bit(decoder_type &dec, bvector_type &bv, block_idx_type nb, bm::word_t *blk)

void decode_block_bit_interval(decoder_type &dec, bvector_type &bv, block_idx_type nb, bm::word_t *blk)

void move_from(encoder &enc) noexcept

Move content from another encoder.

unsigned char * position_type

void put_prefixed_array_32(unsigned char c, const bm::word_t *w, unsigned count) noexcept

Encode 8-bit prefix + an array.

void put_16(bm::short_t s) noexcept

Puts short word (16 bits) into the encoding buffer.

void put_32(bm::word_t w) noexcept

Puts 32 bits word into encoding buffer.

void put_64(bm::id64_t w) noexcept

Puts 64 bits word into encoding buffer.

size_t size() const noexcept

Returns size of the current encoding stream.

void put_8(unsigned char c) noexcept

Puts one character into the encoding buffer.

void set_pos(unsigned char *buf_pos) noexcept

Set current memory stream position.

unsigned char * get_pos() const noexcept

Get current memory stream position.

void put_8_16_32(unsigned w, unsigned char c8, unsigned char c16, unsigned char c32) noexcept

but gat plus value based on its VBR evaluation

Functor for Elias Gamma encoding.

value_type * data() const noexcept

void resize(size_type new_size)

vector resize

Iterator to walk forward the serialized stream.

void set_range(size_type from, size_type to)

set deserialization range [from, to]

void unset_range() noexcept

disable range filtration

SerialIterator serial_iterator_type

BV::blocks_manager_type blocks_manager_type

bvector_type::size_type size_type

size_type deserialize(bvector_type &bv, serial_iterator_type &sit, bm::word_t *temp_block, set_operation op=bm::set_OR, bool exit_on_one=false)

static void load_id_list(bvector_type &bv, serial_iterator_type &sit, unsigned id_count, bool set_clear)

load data from the iterator of type "id list"

bvector_type::block_idx_type block_idx_type

static size_type process_id_list(bvector_type &bv, serial_iterator_type &sit, set_operation op)

Process (obsolete) id-list serialization format.

static const char * err_msg() noexcept

static size_type finalize_target_vector(blocks_manager_type &bman, set_operation op, size_type bv_block_idx)

Finalize the deserialization (zero target vector tail or bit-count tail)

Deserializer, performs logical operations between bit-vector and serialized bit-vector.

bm::iterator_deserializer< BV, serial_stream_le > it_d_le_

little-endian stream iterator

bm::bv_ref_vector< BV > bv_ref_vector_type

void set_ref_vectors(const bv_ref_vector_type *ref_vect)

Attach collection of reference vectors for XOR serialization (no transfer of ownership for the pointe...

void deserialize_range(bvector_type &bv, const unsigned char *buf, size_type idx_from, size_type idx_to)

BV::blocks_manager_type blocks_manager_type

BV::allocator_type allocator_type

bm::deserializer< BV, bm::decoder_little_endian > deserializer_le

~operation_deserializer()

bvector_type::block_idx_type block_idx_type

serial_stream_iterator< bm::decoder_little_endian, block_idx_type > serial_stream_le

void deserialize_xor_range(bvector_type &bv, const unsigned char *buf, size_type idx_from, size_type idx_to)

size_type deserialize(bvector_type &bv, const unsigned char *buf, set_operation op, bool exit_on_one=false)

Deserialize bvector using buffer as set operation argument.

void deserialize_range(bvector_type &bv, const unsigned char *buf, bm::word_t *, size_type idx_from, size_type idx_to)

bvector_type::size_type size_type

const bv_ref_vector_type * ref_vect_

xor ref.vector

size_type deserialize(bvector_type &bv, const unsigned char *buf, bm::word_t *, set_operation op=bm::set_OR, bool exit_on_one=false)

Obsolete! Deserialize bvector using buffer as set operation argument.

bm::deserializer< BV, bm::decoder_big_endian > deserializer_be

deserializer< BV, bm::decoder > de_

serial_stream_iterator< bm::decoder_big_endian, block_idx_type > serial_stream_be

bm::iterator_deserializer< BV, serial_stream_be > it_d_be_

big-endian stream iterator

size_type deserialize_xor(bvector_type &bv, const unsigned char *buf, set_operation op, bool exit_on_one)

bm::iterator_deserializer< BV, serial_stream_current > it_d_

default stream iterator (same endian)

serial_stream_iterator< bm::decoder, block_idx_type > serial_stream_current

static size_type deserialize_xor(bvector_type &bv, bvector_type &bv_tmp, set_operation op)

Serialization stream iterator.

bm::id_t last_id_

Last id from the id list.

unsigned get_bit_block_COUNT_B(bm::word_t *dst_block, bm::word_t *tmp_block)

deseriaizer_base< DEC, block_idx_type > parent_type

deseriaizer_base< DEC, BLOCK_IDX >::decoder_type decoder_type

unsigned char header_flag_

decoder_type & decoder()

Get low level access to the decoder (use carefully)

unsigned get_id_count() const noexcept

Number of ids in the inverted list (valid for e_list_ids)

void get_inv_arr(bm::word_t *block) noexcept

void next()

get next block

serial_stream_iterator(const unsigned char *buf)

block_idx_type mono_block_cnt_

number of 0 or 1 blocks

unsigned block_type_

current block type

block_idx_type skip_mono_blocks() noexcept

skip all zero or all-one blocks

unsigned get_bit_block_SUB(bm::word_t *dst_block, bm::word_t *tmp_block)

unsigned get_bit_block_COUNT_SUB_AB(bm::word_t *dst_block, bm::word_t *tmp_block)

unsigned get_bit_block_AND(bm::word_t *dst_block, bm::word_t *tmp_block)

unsigned get_bit_block_COUNT_SUB_BA(bm::word_t *dst_block, bm::word_t *tmp_block)

unsigned get_bit_block_COUNT_OR(bm::word_t *dst_block, bm::word_t *tmp_block)

unsigned get_bit_block_COUNT(bm::word_t *dst_block, bm::word_t *tmp_block)

bool is_eof() const

Returns true if end of bit-stream reached.

unsigned get_bit() noexcept

block_idx_type block_idx_

current block index

unsigned get_bit_block_XOR(bm::word_t *dst_block, bm::word_t *tmp_block)

iterator_state get_state() const noexcept

unsigned get_bit_block_OR(bm::word_t *dst_block, bm::word_t *tmp_block)

unsigned get_bit_block_ASSIGN(bm::word_t *dst_block, bm::word_t *tmp_block)

block_idx_type block_idx() const noexcept

Get current block index.

gap_word_t * block_idx_arr_

unsigned get_arr_bit(bm::word_t *dst_block, bool clear_target=true) noexcept

Get array of bits out of the decoder into bit block (Converts inverted list into bits) Returns number...

iterator_state state() const noexcept

Returns iterator internal state.

unsigned get_bit_block_COUNT_A(bm::word_t *dst_block, bm::word_t *tmp_block)

~serial_stream_iterator()

gap_word_t glevels_[bm::gap_levels]

GAP levels.

iterator_state

iterator is a state machine, this enum encodes its key value

@ e_bit_block

one bit block

@ e_list_ids

plain int array

@ e_zero_blocks

one or more zero bit blocks

@ e_one_blocks

one or more all-1 bit blocks

@ e_blocks

stream of blocks

void get_gap_block(bm::gap_word_t *dst_block)

Read gap block data (with head)

get_bit_func_type bit_func_table_[bm::set_END]

unsigned id_cnt_

Id counter for id list.

unsigned get_bit_block_COUNT_XOR(bm::word_t *dst_block, bm::word_t *tmp_block)

unsigned get_bit_block_COUNT_AND(bm::word_t *dst_block, bm::word_t *tmp_block)

bm::id_t get_id() const noexcept

Get last id from the id list.

block_idx_type bv_size() const

serialized bitvector size

unsigned get_bit_block(bm::word_t *dst_block, bm::word_t *tmp_block, set_operation op)

read bit block, using logical operation

Bit-vector serialization class.

unsigned compression_level_

void xor_tmp_product(const bm::word_t *s_block, const block_match_chain_type &mchain, unsigned i, unsigned j) noexcept

Compute digest based XOR product, place into tmp XOR block.

unsigned char find_gap_best_encoding(const bm::gap_word_t *gap_block) noexcept

Determine best representation for GAP block based on current set compression level.

void serialize(const BV &bv, typename serializer< BV >::buffer &buf, const statistics_type *bv_stat=0)

Bitvector serialization into buffer object (resized automatically)

void interpolated_gap_array(const bm::gap_word_t *gap_block, unsigned arr_len, bm::encoder &enc, bool inverted) noexcept

Encode GAP block as an array with binary interpolated coder.

size_type ref_idx_

current reference index

void set_sim_model(const xor_sim_model_type *sim_model) noexcept

Atach XOR similarity model (must be computed by the same ref vector)

bm::gamma_encoder< bm::gap_word_t, bit_out_type > gamma_encoder_func

serializer(bm::word_t *temp_block)

bm::bit_out< bm::encoder > bit_out_type

bm::word_t * gap_recalc_tmp_block1_

tmp area for GAP reduction

bool interpolated_arr_bit_block_v3s(bm::encoder &enc, const bm::word_t *block, bool inverted)

void set_sparse_cutoff(unsigned cutoff) noexcept

Fine tuning for Binary Interpolative Compression (levels 5+) The parameter sets average population co...

bm::heap_vector< bm::gap_word_t, allocator_type, true > block_arridx_type

unsigned bit_model_d0_size_

memory (bytes) by d0 method (bytes)

allocator_type::allocator_pool_type allocator_pool_type

bm::word_t * idx_arr_

temp space for bit-block decode into idxs

void reset_compression_stats() noexcept

Reset all accumulated compression statistics.

void gamma_gap_block(const bm::gap_word_t *gap_block, bm::encoder &enc) noexcept

unsigned char * enc_header_pos_

pos of top level header to roll back

bool bienc_gap_bit_block_enc(unsigned len, bm::encoder &enc) noexcept

encode bit-block as interpolated bit block of gaps

void reset_models() noexcept

void encode_bit_array(const bm::word_t *block, bm::encoder &enc, bool inverted) noexcept

Encode bit-block as an array of bits.

bvector_type::block_idx_type block_idx_type

bvector_type::size_type size_type

void gamma_gap_bit_block(const bm::word_t *block, bm::encoder &enc) noexcept

unsigned char find_bit_best_encoding_l5(const bm::word_t *block, const bm::bv_sub_survey &sub_stat, block_idx_type nb) noexcept

Determine best representation for a bit-block (level 5)

size_type * compression_stat_

void interpolated_encode_gap_block_v3s(const bm::gap_word_t *gap_block, bm::encoder &enc, unsigned len)

allocator_pool_type pool_

bm::bv_ref_vector< BV > bv_ref_vector_type

unsigned char header_flag_

set of masks used to save

unsigned char models_[bm::block_waves]

void encode_bit_interval(const bm::word_t *blk, bm::encoder &enc, unsigned size_control) noexcept

Encode BIT block with repeatable runs of zeroes.

bm::xor_scanner< BV > xor_scan_

scanner for XOR similarity

void gamma_gap_array(const bm::gap_word_t *gap_block, unsigned arr_len, bm::encoder &enc, bool inverted=false) noexcept

Encode GAP block as delta-array with Elias Gamma coder.

void set_bookmarks(bool enable, unsigned bm_interval=256) noexcept

Add skip-markers to serialization BLOB for faster range decode at the expense of some BLOB size incre...

void encode_xor_match_chain(bm::encoder &enc, const block_match_chain_type &mchain) noexcept

Encode XOR match chain.

void byte_order_serialization(bool value) noexcept

Set byte-order serialization (for cross platform compatibility)

void interpolated_gap_array_v0(const bm::gap_word_t *gap_block, unsigned arr_len, bm::encoder &enc, bool inverted) noexcept

void optimize_serialize_destroy(BV &bv, typename serializer< BV >::buffer &buf)

Bitvector serialization into buffer object (resized automatically) Input bit-vector gets optimized an...

bm::word_t * gap_ex1_tmp_block_

tmp area for GAP reduction

bvector_type::allocator_type allocator_type

byte_buffer< allocator_type > buffer

block_arridx_type bit_idx_arr_

unsigned ibc

inverse bit-count

bool bic_drange_

bic dynamic range compression flag

void set_compression_level(unsigned clevel) noexcept

Set compression level.

bm::heap_vector< unsigned, allocator_type, true > sblock_arridx_type

bool compute_sim_model(xor_sim_model_type &sim_model, const bv_ref_vector_type &ref_vect, const bm::xor_sim_params &params)

Calculate XOR similarity model for ref_vector refernece vector must be associated before.

void set_bic_dynamic_range_reduce(bool flag) noexcept

enable/disable dynamic range reduction for BIC compression where possible.

bm::word_t * xor_tmp_block_

tmp area for xor product

float bie_bits_per_int_

default coefficient for choosing BIC coding (2.2)

static void process_bookmark(block_idx_type nb, bookmark_state &bookm, bm::encoder &enc) noexcept

Check if bookmark needs to be placed and if so, encode it into serialization BLOB.

bool allow_stat_reset_

controls zeroing of telemetry

bvector_type::blocks_manager_type blocks_manager_type

unsigned bit_model_0run_size_

memory (bytes) by run-0 method (bytes)

void encode_gap_block(const bm::gap_word_t *gap_block, bm::encoder &enc)

void bienc_gap_bit_block(const bm::word_t *block, bm::encoder &enc) noexcept

encode bit-block as interpolated bit block of gaps

serializer(const serializer &)

bool free_

flag to free the input vector

void interpolated_gap_bit_block(const bm::word_t *block, bm::encoder &enc) noexcept

encode bit-block as interpolated gap block

struct bm::serializer::@939 bit_stat_

saved bit-block statistics (mostly for debugging)

bm::word_t * gap_ex0_tmp_block_

tmp area for GAP reduction

xor_sim_model_type::block_match_chain_type block_match_chain_type

void bienc_arr_bit_block(const bm::word_t *block, bm::encoder &enc, bool inverted) noexcept

bool optimize_

flag to optimize the input vector

void encode_bit_digest(const bm::word_t *blk, bm::encoder &enc, bm::id64_t d0) noexcept

Encode bit-block using digest (hierarchical compression)

void allow_stat_reset(bool allow) noexcept

Enable/disable statistics reset on each serilaization.

serializer(const allocator_type &alloc=allocator_type(), bm::word_t *temp_block=0)

Constructor.

void add_model(unsigned char mod, unsigned score) noexcept

bm::word_t * tb_wflags_

temp flags for sub-block DR compression

unsigned char find_bit_best_encoding(const bm::word_t *block, const bm::bv_sub_survey &sub_stat, block_idx_type nb) noexcept

Determine best representation for a bit-block.

sblock_arridx_type sb_bit_idx_arr_

bool interpolated_arr_bit_block_v3(bm::encoder &enc, const bm::word_t *block, bool inverted)

const bv_ref_vector_type * ref_vect_

ref.vector for XOR compression

const xor_sim_model_type * sim_model_

similarity model matrix

void gap_length_serialization(bool value) noexcept

Set GAP length serialization (serializes GAP levels of the original vector)

void bienc_gaps_sblock(const BV &bv, unsigned sb, const bm::bv_sub_survey &sub_stat, bm::encoder &enc) noexcept

bm::xor_sim_model< BV > xor_sim_model_type

bool sb_bookmarks_

Bookmarks flag.

void interpolated_arr_bit_block(const bm::word_t *block, bm::encoder &enc, bool inverted)

void set_bic_coeff(float bie_bits_per_int) noexcept

Coeffcicient to help choose if bit-block should be encoded using binary interpolative coder.

void bienc_arr_sblock(const BV &bv, unsigned sb, bm::encoder &enc) noexcept

unsigned sparse_cutoff_

number of bits per blocks to consider sparse

void gamma_arr_bit_block(const bm::word_t *block, bm::encoder &enc, bool inverted) noexcept

bm::word_t * try_buf_

temp space for trying alternative compressors

const size_type * get_compression_stat() const noexcept

Return serialization counter vector.

bm::word_t * gap_recalc_tmp_block0_

tmp area for GAP reduction

unsigned sb_range_

Desired bookmarks interval.

bvector_type::statistics statistics_type

bool interpolated_encode_gap_block_v3(const bm::gap_word_t *gap_block, bm::encoder &enc, unsigned len)

serializer & operator=(const serializer &)

void set_ref_vectors(const bv_ref_vector_type *ref_vect)

Attach collection of reference vectors for XOR serialization (no transfer of ownership for the pointe...

void encode_header(const BV &bv, bm::encoder &enc) noexcept

Encode serialization header information.

void set_curr_ref_idx(size_type ref_idx) noexcept

Set current index in rer.vector collection (not a row idx or plain idx)

unsigned scores_[bm::block_waves]

size_type serialize(const BV &bv, unsigned char *buf, size_t buf_size)

Bitvector serialization into memory block.

void alloc_temp_buffers()

Allocate serialization temp buffers.

unsigned get_compression_level() const noexcept

Get current compression level.

void interpolated_encode_gap_block(const bm::gap_word_t *gap_block, bm::encoder &enc, unsigned len)

XOR scanner to search for complement-similarities in collections of bit-vectors.

static vector< string > arr

Encoding utilities for serialization (internal)

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

bm::id_t bit_block_count(const bm::word_t *block) noexcept

Bitcount for bit block.

unsigned bit_count_nonzero_size(const T *blk, unsigned data_size) noexcept

Inspects block for full zero words.

unsigned word_bitcount64(bm::id64_t x) noexcept

bm::id_t bit_operation_sub_count(const bm::word_t *src1, const bm::word_t *src2) noexcept

Performs bitblock SUB operation and calculates bitcount of the result.

bm::id64_t bit_block_xor(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock XOR operation. Function does not analyse availability of source and destination blocks...

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

void bit_invert(T *start) noexcept

bool bit_block_or(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock OR operation. Function does not analyse availability of source and destination blocks.

bm::id64_t bit_block_and(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock AND operation. Function does not analyse availability of source and destination blocks...

unsigned bit_block_convert_to_arr(T *dest, const unsigned *src, bool inverted) noexcept

Convert bit block into an array of ints corresponding to 1 bits.

void bit_block_rle_split(T *dst_s, T *dst_r, T *rlen, unsigned &s_cnt, unsigned &r_cnt, const unsigned *src, bool inverted) noexcept

Convert bit block into two arrays of ints( corresponding to 1 bits)

unsigned bit_block_find(const bm::word_t *block, unsigned nbit, unsigned *pos) noexcept

Searches for the next 1 bit in the BIT block.

void bit_block_set(bm::word_t *dst, bm::word_t value) noexcept

Bitblock memset operation.

void bit_block_copy(bm::word_t *dst, const bm::word_t *src) noexcept

Bitblock copy operation.

void clear_bit(unsigned *dest, unsigned bitpos) noexcept

Set 1 bit in a block.

void set_bit(unsigned *dest, unsigned bitpos) noexcept

Set 1 bit in a block.

bm::id_t bit_operation_xor_count(const bm::word_t *src1, const bm::word_t *src2) noexcept

Performs bitblock XOR operation and calculates bitcount of the result.

void bit_block_rle_set(unsigned *blk, const T *s, const T *r, const T *rlen, unsigned s_cnt, unsigned r_cnt) noexcept

Set bits using rle split scheme (reverse of bit_block_rle_split)

bm::id_t bit_operation_or_count(const bm::word_t *src1, const bm::word_t *src2) noexcept

Performs bitblock OR operation and calculates bitcount of the result.

bm::id64_t calc_block_digest0(const bm::word_t *const block) noexcept

Compute digest for 64 non-zero areas.

bm::id_t bit_operation_and_count(const bm::word_t *src1, const bm::word_t *src2) noexcept

Performs bitblock AND operation and calculates bitcount of the result.

bm::id64_t bit_block_sub(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock SUB (AND NOT) operation. Function does not analyse availability of source and destinat...

operation

Bit operations.

set_operation

Codes of set operations.

strategy

Block allocation strategies.

@ BM_GAP

GAP compression is ON.

size_t serialize(const BV &bv, unsigned char *buf, bm::word_t *temp_block=0, unsigned serialization_flags=0)

Saves bitvector into memory.

serialization_flags

Bit mask flags for serialization algorithm.

size_t deserialize(BV &bv, const unsigned char *buf, bm::word_t *temp_block=0, const bm::bv_ref_vector< BV > *ref_vect=0)

Bitvector deserialization from a memory BLOB.

void deserialize_range(BV &bv, const unsigned char *buf, typename BV::size_type from, typename BV::size_type to, const bm::bv_ref_vector< BV > *ref_vect=0)

Bitvector range deserialization from a memory BLOB.

@ BM_NO_GAP_LENGTH

save no GAP info (save some space)

@ BM_NO_BYTE_ORDER

save no byte-order info (save some space)

distance_metric

Distance metrics codes defined for vectors A and B.

distance_metric operation2metric(set_operation op) noexcept

Convert set operation into compatible distance metric.

@ COUNT_XOR

(A ^ B).count()

@ COUNT_SUB_BA

(B - A).count()

gap_word_t * gap_operation_xor(const gap_word_t *vect1, const gap_word_t *vect2, gap_word_t *tmp_buf, unsigned &dsize) noexcept

GAP XOR operation.

void gap_invert(T *buf) noexcept

Inverts all bits in the GAP buffer.

void gap_add_to_bitset(unsigned *dest, const T *pcurr, unsigned len) noexcept

Adds(OR) GAP block to bitblock.

void set_gap_level(T *buf, int level) noexcept

Sets GAP block capacity level.

unsigned gap_set_array(T *buf, const T *arr, unsigned len) noexcept

Convert array to GAP buffer.

unsigned gap_bit_count(const T *buf, unsigned dsize=0) noexcept

Calculates number of bits ON in GAP buffer.

void gap_convert_to_bitset(unsigned *dest, const T *buf, unsigned len=0) noexcept

GAP block to bitblock conversion.

unsigned gap_bit_count_unr(const T *buf) noexcept

Calculates number of bits ON in GAP buffer. Loop unrolled version.

unsigned gap_set_value(unsigned val, T *buf, unsigned pos) noexcept

Sets or clears bit in the GAP buffer.

bool gap_split(const T *buf, unsigned len, unsigned h_limit, const unsigned *hist0, const unsigned *hist1, T *tbuf, T *ex0_arr, T *ex1_arr, unsigned &ex0_cnt, unsigned &ex1_cnt) noexcept

split GAP block into pure GAPs and exceptions

int gap_calc_level(unsigned len, const T *glevel_len) noexcept

Calculates GAP block capacity level.

bool arr_calc_delta_min(const T *arr, unsigned arr_len, T &min0) noexcept

calculate minimal delta between monotonic growing numbers

void gap_calc_mins(const T *buf, T &min0, T &min1) noexcept

minimal delta sizes

void gap_calc_hist(const T *buf, unsigned len, unsigned *hist0, unsigned *hist1, unsigned hist_len) noexcept

compute histogram of exceptions on GAP block

void gap_restore_mins(T *buf, T min0, T min1) noexcept

Restore GAP block using two minimal GAP lens.

T gap_recalc_mins(T *tbuf, const T *buf, T min0, T min1) noexcept

Recalculate GAP block using two minimal GAP lens.

bm::gap_word_t gap_length(const bm::gap_word_t *buf) noexcept

Returs GAP block length.

void gap_set_all(T *buf, unsigned set_max, unsigned value) noexcept

Sets all bits to 0 or 1 (GAP)

D gap_convert_to_arr(D *dest, const T *buf, unsigned dest_len, bool invert=false) noexcept

Convert gap block into array of ints corresponding to 1 bits.

unsigned gap_add_value(T *buf, unsigned pos) noexcept

Add new value to the end of GAP buffer.

unsigned int

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

BV::size_type count_and(const BV &bv1, const BV &bv2) noexcept

Computes bitcount of AND operation of two bitsets.

void combine_sub(BV &bv, It first, It last)

SUB Combine bitvector and the iterable sequence.

bm::distance_metric_descriptor::size_type count_xor(const BV &bv1, const BV &bv2) noexcept

Computes bitcount of XOR operation of two bitsets.

BV::size_type count_sub(const BV &bv1, const BV &bv2) noexcept

Computes bitcount of SUB operation of two bitsets.

void combine_or(BV &bv, It first, It last)

OR Combine bitvector and the iterable sequence.

BV::size_type count_or(const BV &bv1, const BV &bv2) noexcept

Computes bitcount of OR operation of two bitsets.

const unsigned char set_block_ref_eq

block is a copy of a reference block

const unsigned char set_block_xor_ref32_um

..... 32-bit (should never happen)

const unsigned set_block_digest_wave_size

const unsigned char set_block_gap

Plain GAP block.

BV::size_type process_operation(BV &bv, BV &bv_tmp, bm::set_operation op)

Utility function to process operation using temp vector.

const unsigned char set_block_arrbit_inv

List of bits OFF.

const unsigned char set_nb_sync_mark8

bookmark sync point (8-bits)

const unsigned sblock_flag_max16

const unsigned sblock_flag_sb16

16-bit SB index (8-bit by default)

const unsigned char set_block_bit_interval

Interval block.

const unsigned char set_sblock_bienc_v3

super-block interpolated list v3

const unsigned char set_block_bit_digest0

H-compression with digest mask.

const unsigned char set_block_xor_ref32

..... 32-bit (should never happen)

const unsigned char set_block_arrgap_bienc_inv_v2

Interpolated GAP array (inverted)

const unsigned char set_block_bitgap_bienc

Interpolated bit-block as GAPs.

unsigned char check_pair_vect_vbr(const BMChain &mchain, const RVect &ref_vect)

Check effective bit-rate for the XOR encode vector.

const unsigned char set_block_arrgap_egamma_inv

Gamma compressed inverted delta GAP array.

const unsigned char set_block_arr_bienc_inv_v3

Interpolated array (v3)

void bit_recomb(It1 &it1, It2 &it2, BinaryOp &op, Encoder &enc, unsigned block_size=bm::set_block_size) noexcept

const unsigned set_block_mask

const unsigned short h3f_min0_8bit

min0 is not applied

const unsigned char set_sblock_bienc_gaps_v3

super-block of sparse GAPs

unsigned gamma_size(const T v) noexcept

Compute gamma size( in bytes)

T arr_recalc_min(T *tarr, const T *arr, unsigned arr_len, T min0, T delta_acc=0) noexcept

Recalculate array using minimal delta for better BIC compression.

const unsigned sblock_flag_sbgamma

const unsigned char set_block_arr_bienc_inv

Interpolated inverted block int array.

const unsigned set_sub_array_size

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

Recalc linear bvector block index into 2D matrix coordinates.

const unsigned char set_block_gap_egamma_v3

Gamma compressed GAP block (v3)

const unsigned sblock_flag_sb32

32-bit SB index

bool check_block_zero(const bm::word_t *blk, bool deep_scan) noexcept

Checks all conditions and returns true if block consists of only 0 bits.

bm::gap_word_t recalc_tail_delta(bm::gap_word_t tail_delta, bm::gap_word_t &head, unsigned char &head_v3) noexcept

recalculate tail_delta for VBR compression: if tail_delta < 2048 then part of it (3 bits) is stored i...

const unsigned char set_block_16one

UP to 65536 all-set blocks.

const unsigned short h2f_max_v_8bit

min_v is 1 char, 8-bit (0 - 16-bit)

unsigned char compute_min_flags(bm::gap_word_t min0, bm::gap_word_t min1, unsigned char head_v3) noexcept

compute bienc_v3 serialization flags

bool is_const_set_operation(bm::set_operation op) noexcept

Returns true if set operation is constant (bitcount)

const unsigned short h3f_min1_8bit

min0 is 1 char, 8-bit (0 - 16-bit)

void encode_mins(BOUT &bout, unsigned head_v3, bm::gap_word_t min0, bm::gap_word_t min1) noexcept

save drange compression info

const unsigned char set_block_gap_bienc_v3s

Interpolated GAP array (v3)

const unsigned set_total_blocks

const unsigned char set_nb_sync_mark48

const unsigned char set_block_arrgap_bienc

Interpolated GAP array.

ByteOrder

Byte orders recognized by the library.

const unsigned char set_block_8one

Up to 256 all-set blocks.

const unsigned char set_nb_sync_mark16

const unsigned char set_block_32one

UP to 4G all-set blocks.

const unsigned char set_block_arr_bienc_v3

Interpolated array (v3)

const unsigned short h3f_min1_skip

min1 is 1 char, 8-bit (0 - 16-bit)

const unsigned char set_block_bit_0runs

Bit block with encoded zero intervals.

const unsigned char set_block_xor_ref8_um

block is un-masked XOR of a reference block (8-bit)

unsigned long long bmi_bslr_u64(unsigned long long w) noexcept

const unsigned char set_block_64one

lots of all-set blocks

const unsigned char set_block_gap_bienc

Interpolated GAP block (legacy)

const unsigned char set_block_xor_gap_ref16

..... 16-bit

bool check_block_one(const bm::word_t *blk, bool deep_scan) noexcept

Checks if block has only 1 bits.

const unsigned set_compression_default

Default compression level.

const unsigned char set_block_arrbit

List of bits ON.

const unsigned char set_block_1one

One block all-set (1111...)

void encode_min_max(BOUT &bout, bm::gap_word_t min_v, bm::gap_word_t tail_delta) noexcept

save range compression info [min_v..max_v]

const unsigned char set_block_arrgap_inv

List of bits OFF (GAP block)

void bit_block_change_bc(const bm::word_t *block, unsigned *gc, unsigned *bc) noexcept

void convert_sub_to_arr(const BV &bv, unsigned sb, VECT &vect)

convert sub-blocks to an array of set 1s (32-bit)

const unsigned gap_levels

const unsigned char set_block_gapbit

GAP compressed bitblock.

const unsigned char set_block_arr_bienc_8bh

BIC block 8bit header.

const unsigned char set_sblock_bienc

super-block interpolated list

const unsigned char set_block_xor_chain

XOR chain (composit of sub-blocks)

const unsigned char h3f_ex_upper2

void decode_min_max(BIN &bin, bm::gap_word_t gap_head, unsigned head_v3, bm::gap_word_t &min_v, bm::gap_word_t &max_v) noexcept

const unsigned char set_nb_bookmark32

jump ahead mark (32-bit)

const unsigned sblock_flag_max24

const unsigned set_sub_total_bits

const unsigned gap_len_cut_off_v3

const unsigned set_block_size

unsigned bit_to_gap(gap_word_t *dest, const unsigned *block, unsigned dest_len) noexcept

Convert bit block to GAP representation.

unsigned long long int id64_t

const unsigned block_waves

const unsigned char set_block_xor_ref16

block is masked XOR of a reference block (16-bit)

const unsigned char set_block_arrgap_bienc_inv

Interpolated GAP array (inverted)

const unsigned char set_block_arrgap_egamma

Gamma compressed delta GAP array.

const unsigned gap_equiv_len

const unsigned char set_block_1zero

One all-zero block.

const unsigned sblock_flag_min24

24-bit minv

const unsigned char set_block_end

End of serialization.

void arr_restore_min(T *arr, unsigned arr_len, T min0, T delta_acc=0) noexcept

Restore array using two minimal delta for better BIC compression.

const unsigned gap_max_buff_len

const unsigned char set_block_arrgap_bienc_v2

//!< Interpolated GAP array (v2)

const unsigned char set_block_xor_gap_ref32

..... 32-bit (should never happen)

bm::operation setop2op(bm::set_operation op) noexcept

Convert set operation to operation.

const unsigned char set_block_arrgap

List of bits ON (GAP block)

const unsigned char set_nb_sync_mark64

..... 64-bit (should never happen)

const unsigned char set_nb_sync_mark32

const unsigned char set_block_sgapgap

SGAP compressed GAP block.

const unsigned char h3f_ex_arr_1

const unsigned sparse_max_l5

serialization_header_mask

@ BM_HM_NO_GAPL

no GAP levels

@ BM_HM_ID_LIST

id list stored

@ BM_HM_NO_BO

no byte-order

@ BM_HM_SPARSE

very sparse vector

@ BM_HM_64_BIT

64-bit vector

@ BM_HM_RESIZE

resized vector

@ BM_HM_HXOR

horizontal XOR compression turned ON

const unsigned char set_block_arr_bienc

Interpolated block as int array.

const unsigned char set_block_64zero

lots of zero blocks

const unsigned sblock_flag_dr_min

const unsigned short h3f_exceptions

min0 is not applied

const unsigned char set_block_gap_bienc_v2

Interpolated GAP block (v2)

const unsigned gap_max_safe_len

const unsigned char set_block_xor_ref8

block is masked XOR of a reference block (8-bit)

const unsigned char set_block_gap_egamma

Gamma compressed GAP block.

unsigned short gap_word_t

const unsigned char set_block_32zero

Up to 4G zero blocks.

const unsigned char set_block_8zero

Up to 256 zero blocks.

const unsigned char set_block_xor_ref16_um

block is un-masked XOR of a reference block (16-bit)

const unsigned gap_max_bits

const unsigned short h3f_min0_skip

max_v is 1 char, 8-bit (0 - 16-bit)

const unsigned char set_block_bit_1bit

Bit block with 1 bit ON.

const unsigned char set_block_aone

All other blocks one.

const unsigned char set_nb_bookmark16

jump ahead mark (16-bit)

const unsigned char set_block_gap_bienc_v3

Interpolated GAP array (v3)

const unsigned set_block_shift

const unsigned char set_block_arr_bienc_inv_v3s

Interpolated array (v3)

void decode_mins(BIN &bin, unsigned head_v3, bm::gap_word_t &min0, bm::gap_word_t &min1) noexcept

const unsigned sblock_flag_len16

16-bit len (8-bit by default)

const unsigned set_compression_max

Maximum supported compression level.

const unsigned short h2f_min_v_8bit

bit 0 is reserved (used for head start bit)

const unsigned char set_nb_sync_mark24

const unsigned char set_block_xor_gap_ref8

..... 8-bit

const unsigned sparse_max_l6

const unsigned char set_block_azero

All other blocks zero.

unsigned calc_hist_limit(const unsigned *hist0, const unsigned *hist1, unsigned hist_len, unsigned ex_limit, unsigned *ex_sum) noexcept

claculate the effective exceptions limit using two histograms

const unsigned bits_in_block

const unsigned char h3f_ex_arr_ex_EOC

use gamma code for size

const unsigned tmp_buff_alloc_factor

multiplier for alloc_bit_block()

const unsigned char set_block_16zero

Up to 65536 zero blocks.

const unsigned char set_block_bit

Plain bit block.

const unsigned char set_block_bitgap_bienc_v2

Interpolated bit-block as GAPs (v2 - reseved)

const unsigned char set_nb_bookmark24

jump ahead mark (24-bit)

unsigned long long bmi_blsi_u64(unsigned long long w)

void combine_count_operation_with_block(const bm::word_t *blk, const bm::word_t *arg_blk, distance_metric_descriptor *dmit, distance_metric_descriptor *dmit_end) noexcept

Internal function computes different distance metrics.

const unsigned sblock_flag_min16

16-bit minv

const unsigned char set_block_arr_bienc_v3s

Interpolated array (v3)

const unsigned char set_block_sgapbit

SGAP compressed bitblock.

void gap_survey(const T *gap_buf, unsigned &gamma_size_bits) noexcept

Compute various GAP encoding characteristics.

const GenericPointer< typename T::ValueType > T2 value

Int4 delta(size_t dimension_, const Int4 *score_)

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)

std::vector< bm::id64_t > ref_vect

Bit COUNT SUB AB functor.

bm::xor_complement_match match

Basic stats on second level group of blocks.

unsigned avg_gap_len() const noexcept

average length of GAP blocks

void init(void *bv, unsigned i) noexcept

void * bv_ptr

pointer to bit-vector

unsigned top_level_idx

index of the sub-block of blocks

bool is_only_gaps() const noexcept

true if sub contains multiple gap blocks and nothing else

static ByteOrder byte_order()

Bookmark state structure.

unsigned bm_type_

0:32-bit, 1: 24-bit, 2: 16-bit

size_t min_bytes_range_

minumal distance (bytes) between marks

block_idx_type nb_

bookmark block idx

unsigned char * ptr_

bookmark pointer

block_idx_type nb_range_

target bookmark range in blocks

bookmark_state(block_idx_type nb_range) noexcept

Parameters for XOR similarity search.

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