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

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

<

SV>

sv_planes = svect.slices();

(sv_planes > high_bit && high_bit > 0);

SV::bvector_type bv_acc;

(

= high_bit+1;

< sv_planes; ++

)

(

SV::bvector_type* bv = svect.slice(

))

svect.free_slice(

);

(

= high_bit;

; --

)

SV::bvector_type* bv = svect.get_create_slice(

);

<

SV>

(low_bit == 0)

;

sv_planes = svect.slices();

SV::bvector_type bv_acc1;

(

= low_bit+1;

< sv_planes; ++

)

(

SV::bvector_type* bv = svect.slice(

))

SV::bvector_type bv_acc2;

SV::bvector_type* bv_low_plane = svect.get_create_slice(low_bit);

(

= low_bit-1;

; --

)

(

SV::bvector_type* bv = svect.slice(

))

svect.free_slice(

);

bv_acc1.bit_xor(bv_acc2);

bv_low_plane->bit_or(bv_acc1);

<

SV>

SV::size_type& midx,

SV::size_type mismatch =

;

planes1 = (unsigned)sv1.get_bmatrix().rows();

SV::bvector_type_const_ptr bv_null1 = sv1.get_null_bvector();

SV::bvector_type_const_ptr bv_null2 = sv2.get_null_bvector();

(bv_null1 && bv_null2)

= bv_null1->find_first_mismatch(*bv_null2, midx, mismatch);

(

&& (midx < mismatch))

found =

; mismatch = midx;

SV::bvector_type bv_tmp;

bv_tmp.resize(sv2.size());

= bv_null1->find_first_mismatch(bv_tmp, midx, mismatch);

(

&& (midx < mismatch))

found =

; mismatch = midx;

SV::bvector_type bv_tmp;

bv_tmp.resize(sv1.size());

= bv_null2->find_first_mismatch(bv_tmp, midx, mismatch);

(

&& (midx < mismatch))

found =

; mismatch = midx;

(

= 0; mismatch && (

< planes1); ++

)

SV::bvector_type_const_ptr bv1 = sv1.get_slice(

);

SV::bvector_type_const_ptr bv2 = sv2.get_slice(

);

= bv2->find(midx);

(

&& (midx < mismatch))

found =

; sv_idx = 2; mismatch = midx;

= bv1->find(midx);

(

&& (midx < mismatch))

found =

; sv_idx = 1; mismatch = midx;

= bv1->find_first_mismatch(*bv2, midx, mismatch);

(

&& (midx < mismatch))

found =

; mismatch = midx;

sv_idx = (bv1->test(mismatch)) ? 1 : 2;

found = sv1.find_rank(midx + 1, mismatch);

found = sv2.find_rank(midx + 1, mismatch);

= bv_null1->find_first_mismatch(*bv_null2, midx, mismatch);

(

&& (midx < mismatch))

found =

; mismatch = midx;

<

SV1,

SV2>

SV1::bvector_type bvector_type;

bvector_type::allocator_type allocator_type;

allocator_type::allocator_pool_type allocator_pool_type;

allocator_pool_type pool;

bvector_type::mem_pool_guard mp_guard_bv;

mp_guard_bv.assign_if_not_set(pool, bv);

planes = sv1.effective_slices();;

(planes < sv2.slices())

planes = sv2.slices();

(

= 0;

< planes; ++

)

SV1::bvector_type_const_ptr bv1 = sv1.get_slice(

);

SV2::bvector_type_const_ptr bv2 = sv2.get_slice(

);

bvector_type::mem_pool_guard mp_guard;

mp_guard.assign_if_not_set(pool, bv_xor);

bv_xor.bit_xor(*bv1, *bv2, SV1::bvector_type::opt_none);

SV1::size_type sz1 = sv1.size();

SV2::size_type sz2 = sv2.size();

bv.set_range(sz1, sz2-1);

SV1::bvector_type_const_ptr bv_null1 = sv1.get_null_bvector();

SV2::bvector_type_const_ptr bv_null2 = sv2.get_null_bvector();

(bv_null1 && bv_null2)

bvector_type::mem_pool_guard mp_guard;

mp_guard.assign_if_not_set(pool, bv_or);

bv_or.bit_or(*bv_null1, *bv_null2, bvector_type::opt_none);

(bv_null1 && bv_null2)

bvector_type::mem_pool_guard mp_guard;

mp_guard.assign_if_not_set(pool, bv_xor);

bv_xor.bit_xor(*bv_null1, *bv_null2, bvector_type::opt_none);

bvector_type bv_null;

bvector_type::mem_pool_guard mp_guard;

mp_guard.assign_if_not_set(pool, bv_null);

bv_null.resize(sv1.size());

bv_null.resize(sv2.size());

<

SV>

<

SV,

S_FACTOR>

<

Opt = bm::agg_run_options<> >

{

.set_search_count_limit(limit); }

{

.get_bv_res_vector(); }

{

.get_bv_count_vector(); }

(

SV& sv,

sorted);

template<typename BII>

template<class TPipe>

template<typename It>

bvector_type::mem_pool_guard mp_guard;

mp_guard.assign_if_not_set(

, bv_out);

bvector_type::mem_pool_guard mp_guard1(

, bv1);

any_zero =

;

(; start < end; ++start)

any_zero |= (v == 0);

null_correct =

);

<

BOUND>

prefix_len);

octet_start,

template <

BOUND>

from,

total_planes);

from,

total_planes);

<

AGG>

bits[64];

(

= 0;

< bit_count_v; ++

)

bit_idx = bits[

];

plane_idx = (unsigned(octet_idx) * 8) + bit_idx;

(bv != sv.get_null_bvector());

vinv = unsigned(

);

vinv &= unsigned(planes_mask);

(

octet_plane = (

(octet_idx) * 8); vinv; vinv &= vinv-1)

plane_idx = octet_plane + bit_idx;

(bv != sv.get_null_bvector());

<

SV>

(bv_in, sv_brel, bv_out);

(

SV* sv_brel,

compute_stats =

);

<

BSIZE>

<

SV>

: sv_ptr_(0), gb_(0), have_stats_(

)

);

SV::throw_bad_alloc();

<

SV>

<

SV>

have_stats_ =

;

(sv_brel->empty() || !compute_stats)

* bv_non_null = sv_brel->get_null_bvector();

bvector_type::mem_pool_guard mp_g_z;

mp_g_z.assign_if_not_set(pool_, bv_zero_);

scanner.

(*sv_brel, bv_zero_);

have_stats_ =

;

<

SV>

(sv_brel.empty())

* bv_non_null = sv_brel.get_null_bvector();

(!bv_non_null->test(id_from))

idx = sv_brel.translate_address(id_from);

id_to = sv_brel.get(idx);

<

SV>

bvector_type::mem_pool_guard mp_g_out, mp_g_p, mp_g_z;

mp_g_out.assign_if_not_set(pool_, bv_out);

mp_g_p.assign_if_not_set(pool_, bv_product_);

mp_g_z.assign_if_not_set(pool_, bv_zero_);

attach_sv(&sv_brel);

remap(bv_in, bv_out);

<

SV>

(sv_ptr_ == 0 || sv_ptr_->empty())

bvector_type::mem_pool_guard mp_g_out, mp_g_p, mp_g_z;

mp_g_out.assign_if_not_set(pool_, bv_out);

mp_g_p.assign_if_not_set(pool_, bv_product_);

mp_g_z.assign_if_not_set(pool_, bv_zero_);

* bv_non_null = sv_ptr_->get_null_bvector();

bv_product_ = bv_in;

bv_product_.bit_and(*bv_non_null);

enum_bv = &bv_product_;

bv_product_ = bv_in;

bv_product_.bit_sub(bv_zero_);

bv_out.set_bit_no_check(0);

enum_bv = &bv_product_;

buf_cnt = nb_old = 0;

bvector_type::enumerator en(enum_bv->first());

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

SV::size_type idx = *en;

idx = sv_ptr_->translate_address(idx);

sv_ptr_->gather(&gb_->buffer_[0], &gb_->gather_idx_[0], buf_cnt,

);

bv_out.set(&gb_->buffer_[0], buf_cnt,

);

gb_->gather_idx_[buf_cnt++] = idx;

gb_->gather_idx_[buf_cnt++] = idx;

(buf_cnt == sv_g_size)

sv_ptr_->gather(&gb_->buffer_[0], &gb_->gather_idx_[0], buf_cnt,

);

sv_ptr_->gather(&gb_->buffer_[0], &gb_->gather_idx_[0], buf_cnt,

);

<

SV>

(sv_brel.empty())

SV::const_iterator it = sv_brel.begin();

(; it.valid(); ++it)

(bv_in.test(idx))

bv_out.set_bit_no_check(t_id);

<

SV,

S_FACTOR>

effective_str_max_ = 0;

<

SV,

S_FACTOR>

static_assert(S_FACTOR == 4 || S_FACTOR == 8 || S_FACTOR == 16

|| S_FACTOR == 32 || S_FACTOR == 64,

);

constexpr (SV::is_str())

effective_str_max_ = sv.effective_vector_max();

range_idx_.construct(sv, S_FACTOR);

vector_plane_masks_.resize(effective_str_max_);

(

= 0;

< effective_str_max_; ++

)

vector_plane_masks_[

] = sv.get_slice_mask(

);

<

SV,

S_FACTOR>

effective_str_max_ = 0;

<

SV,

S_FACTOR>

find_nonzero(sv, bv_out);

constexpr (SV::is_compressed())

bv_out.set_range(sv.effective_size(),

- 1,

);

decompress(sv, bv_out);

correct_nulls(sv, bv_out);

<

SV,

S_FACTOR>

old_sz = bv_out.size();

bv_out.resize(sv.size());

bv_out.resize(old_sz);

correct_nulls(sv, bv_out);

<

SV,

S_FACTOR>

bv_out.bit_and(*bv_null);

<

SV,

S_FACTOR>

find_zero(sv, bv_out);

bv_out.any();

found = prepare_and_sub_aggregator(sv,

);

any = (search_limit == 1);

found = agg_.combine_and_sub(bv_out, any);

<

SV,

S_FACTOR>

found = prepare_and_sub_aggregator(sv,

);

found = agg_.find_first_and_sub(idx);

<

SV,

S_FACTOR>

prefix_len)

common_prefix_len = 0;

* pref = remap_prefix_vect_.data();

(

agg_.set_range_hint(mask_from_, mask_to_))

(prefix_len == ~0u)

sv.template common_prefix_length<true>(mask_from_, mask_to_, pref);

(common_prefix_len)

= remap_value_vect_.data();

(

= 0;

< common_prefix_len; ++

)

(

[

] != pref[

])

pl; (void)pl;

(pl=sv.template common_prefix_length<true>(

mask_from_, mask_to_, pref)));

common_prefix_len = prefix_len;

(prefix_len != ~0u)

pl; (void)pl;

(pl=sv.template common_prefix_length<true>(

mask_from_, mask_to_, pref)));

common_prefix_len = prefix_len;

(common_prefix_len && (in_len <= common_prefix_len))

(in_len == common_prefix_len)

--common_prefix_len;

= remap_value_vect_.data();

(sv.is_remap() && (

!= remap_value_vect_.data()))

= sv.remap_tosv(

remap_value_vect_.data(), sv.effective_max_str(),

);

= remap_value_vect_.data();

found = prepare_and_sub_aggregator(sv,

, common_prefix_len,

);

found = agg_.find_first_and_sub(idx);

(found && idx > mask_to_)

= sv.compare(idx, search_str);

found = (

== 0);

<

SV,

S_FACTOR>

octet_start,

(

octet_idx =

-1; octet_idx >=

(octet_start); --octet_idx)

= unsigned(

[octet_idx]) & 0xFFu;

(&sv == bound_sv_)

planes_mask = vector_plane_masks_[unsigned(octet_idx)];

planes_mask = sv.get_slice_mask(

(octet_idx));

add_agg_char(agg_, sv, octet_idx, planes_mask,

);

SV::size_type planes = sv.get_bmatrix().rows_not_null();

(

plane_idx =

(

* 8);

plane_idx < planes; ++plane_idx)

<

SV,

S_FACTOR>

unsigned_value_type =

SV::unsigned_value_type;

bits[

(

) * 8];

unsigned_value_type uv = sv.s2u(

);

bit_count_v =

(uv, bits);

unsigned_value_type mask1 = 1;

(

= bit_count_v;

> 0; --

)

bit_idx = bits[

-1];

sv_planes = sv.effective_slices();

(

= 0;

< sv_planes; ++

)

unsigned_value_type

= mask1 <<

;

<

SV,

S_FACTOR>

find_zero(sv, bv_out);

bits[

(

) * 8];

SV::unsigned_value_type uv = sv.s2u(

);

bit_count_v =

(uv, bits);

(

* bv_plane = sv.get_slice(bits[--bit_count_v]))

(

= 0;

< bit_count_v; ++

)

bv_out &= *bv_plane;

sv_planes = sv.effective_slices();

(

= 0; (

< sv_planes) && uv; ++

)

(

* bv = sv.get_slice(

); bv && !(uv & (1u <<

)))

<

SV,

S_FACTOR>

find_gt_horizontal(sv,

, bv_out,

);

<

SV,

S_FACTOR>

find_eq(sv,

, bv_min);

find_gt_horizontal(sv,

, bv_out,

);

bv_out.merge(bv_min);

find_gt_horizontal(sv,

, bv_out,

);

find_gt_horizontal(sv,

, bv_out,

);

bv_out.set_range(0, sv.size()-1);

correct_nulls(sv, bv_out);

<

SV,

S_FACTOR>

find_ge(sv,

, bv_out);

<

SV,

S_FACTOR>

find_gt(sv,

, bv_out);

<

SV,

S_FACTOR>

find_ge(sv, from, bv_out);

find_gt(sv, to, bv_gt);

bv_out.bit_sub(bv_gt);

<

SV,

S_FACTOR>

blist[64];

bit_count_v;

find_zero(sv, bv_zero);

sz = sv.size();

bv_out.set_range(0, sz-1);

bv_out.bit_sub(bv_zero);

bv_out.bit_sub(*bv_sign);

correct_nulls(sv, bv_out);

find_positive(sv, gtz_bv);

bv_out.swap(gtz_bv);

correct_nulls(sv, bv_out);

find_eq(sv, -1, bv_out);

bv_out.bit_or(gtz_bv);

correct_nulls(sv, bv_out);

uvalue = SV::s2u(

+

(

< 0));

total_planes = sv.effective_slices();

* bv_sign = sv.get_slice(0); (void)bv_sign;

bv_out.swap(gtz_bv);

correct_nulls(sv, bv_out);

aggregate_AND_OR_slices(top_or_bv, *bv_sign, sv, blist[bit_count_v-1]+1, total_planes);

aggregate_OR_slices(top_or_bv, sv, blist[bit_count_v-1]+1, total_planes);

(total_planes <

(blist[bit_count_v-1]+1))

aggregate_OR_slices(top_or_bv, sv, blist[bit_count_v-1]+1, total_planes);

bv_out.merge(top_or_bv);

(

=

(bit_count_v)-1;

>= 0; --

)

slice_idx = blist[

];

(slice_idx == gt_slice_limit())

* bv_base_plane = sv.get_slice(

(slice_idx));

and_eq_bv.bit_and(*bv_base_plane, *bv_sign);

and_eq_bv.bit_and(*bv_base_plane, gtz_bv);

and_eq_bv = *bv_base_plane;

and_eq_bv.bit_and(*bv_base_plane);

next_slice_idx = 0;

next_slice_idx = blist[

-1];

(slice_idx-1 == next_slice_idx)

(

j = slice_idx-1; j >= next_slice_idx; --j)

(

* bv_sub_plane = sv.get_slice(

(j)))

bv_out.bit_or_and(and_eq_bv, *bv_sub_plane);

top_or_bv.set_range(0, sv.size()-1);

top_or_bv.bit_sub(bv_out);

bv_out.swap(top_or_bv);

gtz_bv.resize(sv.size());

bv_out.bit_sub(gtz_bv);

decompress(sv, bv_out);

correct_nulls(sv, bv_out);

<

SV,

S_FACTOR>

from,

total_planes)

(

= from;

< total_planes; ++

)

(bv_slice != sv.get_null_bvector());

agg_.combine_or(bv_target);

<

SV,

S_FACTOR>

from,

total_planes)

(

= from;

< total_planes; ++

)

(bv_slice != sv.get_null_bvector());

bv_target.bit_or_and(bv_mask, *bv_slice);

<

SV,

S_FACTOR>

SV::bvector_type& bv_out)

find_eq_str_impl(sv,

, bv_out,

);

<

SV,

S_FACTOR>

SV::size_type& pos)

this->find_eq_str(*bound_sv_,

, pos);

<

SV,

S_FACTOR>

SV::size_type& pos)

found =

;

remaped =

;

(sv.is_remap() &&

!= remap_value_vect_.data())

str_len = sv.effective_vector_max();

remap_value_vect_.resize(str_len);

remaped = sv.remap_tosv(

remap_value_vect_.data(), str_len,

);

= remap_value_vect_.data();

in_len = ::strlen(

);

size_type found_pos;

found = find_first_eq(sv,

, in_len, found_pos, remaped, ~0u);

constexpr (sv.is_compressed())

found = sv.find_rank(found_pos + 1, pos);

SV::bvector_type bv_zero;

find_zero(sv, bv_zero);

found = bv_zero.find(pos);

<

SV,

S_FACTOR>

SV::bvector_type& bv_out)

find_eq_str(*bound_sv_,

, bv_out);

<

SV,

S_FACTOR>

SV::bvector_type& bv_out)

find_eq_str_impl(sv,

, bv_out,

);

<

SV,

S_FACTOR>

str_len = sv.effective_vector_max();

remap_vect_target.

(str_len);

remaped = sv.remap_tosv(remap_vect_target.

(), str_len,

);

<

SV,

S_FACTOR>

SV::bvector_type& bv_out,

found =

;

bv_out.clear(

);

(sv.is_remap() && (

!= remap_value_vect_.data()))

remaped = remap_tosv(remap_value_vect_,

, sv);

= remap_value_vect_.data();

common_prefix_len = 0;

found = prepare_and_sub_aggregator(sv,

, common_prefix_len,

found = agg_.combine_and_sub(bv_out);

find_zero(sv, bv_out);

found = bv_out.any();

<

SV,

S_FACTOR>

<

TPipe>

(pipe.bv_and_mask_)

any = pipe.bv_and_mask_->find_range(

,

);

agg_.combine_and_sub(pipe.agg_pipe_);

agg_.reset_range_hint();

<

SV,

S_FACTOR>

<

BOUND>

SV::size_type& pos)

found =

;

prefix_len = ~0u;

reset_search_range();

constexpr (BOUND)

found = range_idx_.bfind_range(

, in_len,

,

);

(unsigned) range_idx_.common_prefix_length(

, in_len,

,

);

((

==

) && (in_len == prefix_len))

range_idx_.recalc_range(

,

,

);

range_idx_.recalc_range(

,

,

);

set_search_range(

,

);

= 0;

= sv.size()-1;

(dist < min_distance_cutoff)

= this->compare_str<BOUND>(sv, mid,

);

(

= 0;

< (sub_bfind_block_cnt-1);

++

, mid += sub_block_l1_size)

= this->compare_str<BOUND>(sv, mid,

);

set_search_range(

,

);

SV::size_type mid = dist/2+

;

mid = dist / 2 +

;

= this->compare_str<false>(sv, mid,

);

= this->compare_str<BOUND>(sv, mid,

);

set_search_range(

, mid);

found = find_first_eq(sv,

, in_len, found_pos, remaped, prefix_len);

constexpr (SV::is_compressed())

found = sv.find_rank(found_pos + 1, pos);

reset_search_range();

SV::bvector_type bv_zero;

find_zero(sv, bv_zero);

found = bv_zero.find(pos);

<

SV,

S_FACTOR>

= ::strlen(

);

effective_str_max_ = sv.effective_max_str();

(

> effective_str_max_)

remaped =

;

remap_value_vect_.resize_no_copy(

);

remaped = sv.remap_tosv(remap_value_vect_.data(),

effective_str_max_,

);

bfind_eq_str_impl<false>(sv,

,

, remaped, pos);

<

SV,

S_FACTOR>

SV::size_type& pos)

= ::strlen(

);

(

> effective_str_max_)

remaped =

;

(bound_sv_->is_remap())

remaped = bound_sv_->remap_tosv(remap_value_vect_.data(),

effective_str_max_,

);

bfind_eq_str_impl<true>(*bound_sv_,

,

, remaped, pos);

<

SV,

S_FACTOR>

(in_len > effective_str_max_)

remaped =

;

(bound_sv_->is_remap())

remaped = bound_sv_->remap_n_tosv_2way(

remap_value_vect_.data(),

(

= 0;

< in_len && *

; ++

)

bfind_eq_str_impl<true>(*bound_sv_, s, in_len, remaped, pos);

<

SV,

S_FACTOR>

SV::size_type& pos)

= this->compare(sv,

,

);

= this->compare(sv,

,

);

(;

>= 0; --

)

= this->compare(sv,

,

);

(dist < linear_cutoff1)

(;

<=

; ++

)

= this->compare(sv,

,

);

= this->compare(sv, mid,

);

= this->compare(sv,

,

);

(dist < linear_cutoff2)

SV::const_iterator it(&sv,

);

(; it.valid(); ++it, ++

)

(sv_value ==

)

(sv_value >

)

<

SV,

S_FACTOR>

SV::size_type& pos)

= this->compare_str<false>(sv,

,

);

= this->compare_str<false>(sv,

,

);

(;

>= 0; --

)

= this->compare_str<false>(sv,

,

);

(dist < linear_cutoff1)

(;

<=

; ++

)

= this->compare_str<false>(sv,

,

);

= this->compare_str<false>(sv, mid,

);

= this->compare_str<false>(sv,

,

);

(dist < linear_cutoff2)

(!hmatr_.is_init())

max_str = (unsigned)sv.effective_max_str();

hmatr_.resize(linear_cutoff2, max_str+1,

);

dist = sv.decode(hmatr_,

, dist+1);

(

= 0;

< dist; ++

, ++

)

= this->compare_str<false>(sv,

,

);

<

SV,

S_FACTOR>

<

BOUND>

constexpr (BOUND)

(

= 0;

; ++

)

octet =

[

];

= s0[

];

sv.compare(idx,

);

<

SV,

S_FACTOR>

sv.compare(idx,

);

<

SV,

S_FACTOR>

SV::bvector_type& bv_out)

find_zero(sv, bv_out);

find_eq_with_nulls(sv,

, bv_out, 0);

decompress(sv, bv_out);

correct_nulls(sv, bv_out);

<

SV,

S_FACTOR>

<

BII>

static_assert(!SV::is_compressed(),

);

SV::bvector_type bv_out;

find_zero(sv, bv_out);

SV::bvector_type::enumerator en = bv_out.get_enumerator(0);

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

found = prepare_and_sub_aggregator(sv,

);

found = agg_.combine_and_sub_bi(bi);

<

SV,

S_FACTOR>

SV::size_type& pos)

find_eq(sv,

, bv_zero);

found = bv_zero.find(pos);

found = find_first_eq(sv,

, found_pos);

constexpr (SV::is_compressed())

found = sv.find_rank(found_pos + 1, pos);

<

SV,

S_FACTOR>

SV::bvector_type& bv_out)

sz = sv.effective_slices();

(

= 0;

< sz; ++

)

agg_.add(sv.get_slice(

));

agg_.combine_or(bv_out);

<

SV,

S_FACTOR>

SV::bvector_type& bv_out)

bv_out.set_range(0, sv.size()-1);

bv_out.bit_sub(*bv_sign);

<

SV,

S_FACTOR>

SV::bvector_type& bv_out)

constexpr (SV::is_compressed())

* bv_non_null = sv.get_null_bvector();

rank_compr_.decompress(bv_tmp_, *bv_non_null, bv_out);

bv_out.swap(bv_tmp_);

(void)sv; (void)bv_out;

<

SV,

S_FACTOR>

mask_from_ = from; mask_to_ = to; mask_set_ =

;

<

SV,

S_FACTOR>

<

SV,

S_FACTOR>

<

Opt>

static_assert(Opt::is_masks(),

);

bv_and_mask_ = bv_mask;

<

SV,

S_FACTOR>

<

Opt>

aggregator_type::arg_groups* arg = agg_pipe_.add();

(sv_.is_remap() && (

!= remap_value_vect_.data()))

remaped = remap_tosv(remap_value_vect_,

, sv_);

= remap_value_vect_.data();

constexpr(Opt::is_masks())

arg->add(bv_and_mask_, 0);

arg->add(sv_.get_null_bvector(), 0);

(

octet_idx =

-1; octet_idx >= 0; --octet_idx)

= unsigned(

[octet_idx]) & 0xFF;

(&sv == bound_sv_)

planes_mask = vector_plane_masks_[unsigned(octet_idx)];

planes_mask = sv_.get_slice_mask(

(octet_idx));

*arg, sv_, octet_idx, planes_mask,

);

plane_idx = unsigned(

* 8);

(; plane_idx < planes; ++plane_idx)

<

SV>

s_factor_ = s_factor;

sv_size_ = sv.size();

effective_str_max = sv.effective_vector_max() + 1;

idx_size = total_nb * s_factor + 1;

s_cache_.init_resize(idx_size, effective_str_max);

s_cache_.set_zero();

* s_str = s_cache_.row(idx_size_);

sv.get(

, s_str, cols);

(

== sv_size_-1)

s_str = s_cache_.row(idx_size_);

sv.get(

, s_str, cols);

min_len = ::strlen(s);

idx_unique_ =

;

* str_prev = s_cache_.row(0);

curr_len = ::strlen(str_curr);

(curr_len < min_len)

= SV::compare_str(str_prev, str_curr);

idx_unique_ =

;

str_prev = str_curr;

min_key_len_ = min_len;

<

SV>

= 0;

= idx_size_ - 1;

min_len = this->min_key_len_;

(in_len < min_len)

= SV::compare_str(search_str,

, min_len);

= s_cache_.row(

);

= SV::compare_str(search_str,

, min_len);

(dist < linear_cutoff)

= SV::compare_str(search_str, str_i, min_len);

* str_m = s_cache_.row(mid);

= SV::compare_str(str_m, search_str, min_len);

<

SV>

min_len = (in_len < min_key_len_) ? in_len : min_key_len_;

(;

< min_len-3;

+=4)

::memcpy(&i2, &str_l[

],

(i2));

::memcpy(&i1, &str_r[

],

(i1));

::memcpy(&i2, &str_s[

],

(i2));

(;

; ++

)

= str_l[

];

= str_r[

];

chs = str_s[

];

<

SV>

(

== idx_size_-1)

= SV::compare_str(search_str,

);

-= (

&& idx_unique_);

ncbi::TMaskedQueryRegions mask

Algorithms for fast aggregation of N bvectors.

Algorithms for bvector<> (main include)

#define BM_VECT_ALIGN_ATTR

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

value_type * data() const noexcept

void resize(size_type new_size)

vector resize

value_type * resize_no_copy(size_type new_size)

resize without content preservation

Integer set to set transformation (functional image in groups theory) https://en.wikipedia....

bvector_type bv_zero_

bit-vector for zero elements

const bvector_type & get_bv_zero() const

Get read access to zero-elements vector Zero vector gets populated after attach_sv() is called or as ...

bvector_type bv_product_

temp vector

void attach_sv(const SV *sv_brel, bool compute_stats=false)

Attach a translation table vector for remapping (Image function)

allocator_pool_type pool_

const SV * sv_ptr_

current translation table vector

void remap(const bvector_type &bv_in, bvector_type &bv_out)

Perform remapping (Image function) (based on attached translation table)

SV::value_type value_type

bool have_stats_

flag of statistics presense

gather_buffer_type * gb_

intermediate buffers

bvector_type::allocator_type::allocator_pool_type allocator_pool_type

void operator=(const set2set_11_transform &)=delete

void one_pass_run(const bvector_type &bv_in, const SV &sv_brel, bvector_type &bv_out)

gather_buffer< sv_g_size > gather_buffer_type

void run(const bvector_type &bv_in, const SV &sv_brel, bvector_type &bv_out)

Run remap transformation.

set2set_11_transform(const set2set_11_transform &)=delete

SV::bvector_type bvector_type

Pipeline to run multiple searches against a particular SV faster using cache optimizations.

bv_count_vector_type & get_bv_count_vector() noexcept

Return results vector count used for pipeline execution.

void set_search_mask(const bvector_type *bv_mask) noexcept

Set pipeline mask bit-vector to restrict the search space.

void complete()

Prepare pipeline for the execution (resize and init internal structures) Once complete,...

bool is_complete() const noexcept

bvect_vector_type & get_bv_res_vector() noexcept

Return results vector used for pipeline execution.

size_type size() const noexcept

void set_search_count_limit(size_type limit) noexcept

Set search limit for results.

pipeline(const pipeline &)=delete

void add(const typename SV::value_type *str)

Add new search string.

const bvector_type * bv_and_mask_

aggregator_pipeline_type agg_pipe_

traget aggregator pipeline

const run_options & get_options() const noexcept

Get pipeline run options.

remap_vector_type remap_value_vect_

remap buffer

pipeline & operator=(const pipeline &)=delete

aggregator_type::template pipeline< Opt > aggregator_pipeline_type

size_t eff_slices_

number of effectice NOT NULL value slices

void set_or_target(bvector_type *bv_or) noexcept

Attach OR (aggregator vector).

const SV & sv_

target sparse vector ref

aggregator_pipeline_type & get_aggregator_pipe() noexcept

get aggregator pipeline (access to compute internals)

run_options & options() noexcept

Set pipeline run options.

algorithms for sparse_vector scan/search

bm::dynamic_heap_matrix< value_type, allocator_type > matrix_search_buf_type

bm::dynamic_heap_matrix< value_type, allocator_type > heap_matrix_type

bm::rank_compressor< bvector_type > rank_compr_

mask_vector_type vector_plane_masks_

masks of allocated bit-planes (1 - means there is a bit-plane)

void reset_binding() noexcept

reset sparse vector binding

size_type effective_str_max_

void reset_search_range() noexcept

reset (disable) search range

SV::bvector_type bvector_type

void operator=(const sparse_vector_scanner &)=delete

bool prepare_and_sub_aggregator(const SV &sv, value_type value)

Prepare aggregator for AND-SUB (EQ) search.

void find_eq(const SV &sv, value_type value, bvector_type &bv_out)

find all sparse vector elements EQ to search value

allocator_pool_type pool_

bool bfind(const SV &sv, const value_type val, size_type &pos)

binary search for position in the sorted sparse vector

void bind(const SV &sv, bool sorted)

bind sparse vector for all searches

void correct_nulls(const SV &sv, bvector_type &bv_out)

Exclude possible NULL values from the result vector.

void find_range(const SV &sv, value_type from, value_type to, bvector_type &bv_out)

find all elements sparse vector element in closed range [left..right] interval

bm::heap_vector< bm::id64_t, typename bvector_type::allocator_type, true > mask_vector_type

const bvector_type * bvector_type_const_ptr

void aggregate_OR_slices(bvector_type &bv_target, const SV &sv, unsigned from, unsigned total_planes)

aggregator_type::bv_count_vector_type bv_count_vector_type

bm::heap_vector< bvector_type *, allocator_type, true > bvect_vector_type

void decompress(const SV &sv, bvector_type &bv_out)

Rank-Select decompression for RSC vectors.

void set_search_range(size_type from, size_type to) noexcept

set search boundaries (hint for the aggregator)

sparse_vector_scanner(const sparse_vector_scanner &)=delete

remap_vector_type remap_value_vect_

remap buffer

bvector_type * bvector_type_ptr

allocator_pool_type & get_bvector_alloc_pool() noexcept

Return allocator pool for blocks (Can be used to improve performance of repeated searches with the sa...

void find_gt(const SV &sv, value_type val, bvector_type &bv_out)

find all elements sparse vector element greater (>) than value

bool find_eq_str_impl(const SV &sv, const value_type *str, bvector_type &bv_out, bool prefix_sub)

find EQ str / prefix impl

void find_zero(const SV &sv, bvector_type &bv_out, bool null_correct=true)

find all sparse vector elements EQ to 0

void find_eq_with_nulls_horizontal(const SV &sv, value_type value, bvector_type &bv_out)

For testing purposes only.

bm::heap_vector< value_type, typename bvector_type::allocator_type, true > remap_vector_type

remap_vector_type value_vect_

value buffer

void find_lt(const SV &sv, value_type val, bvector_type &bv_out)

find all elements sparse vector element less (<) than value

bool find_eq_with_nulls(const SV &sv, value_type value, bvector_type &bv_out, size_type search_limit=0)

find value (may include NULL indexes)

bool bfind_eq_str(const SV &sv, const value_type *str, size_type &pos)

binary find first sparse vector element (string).

int compare(const SV &sv, size_type idx, const value_type val) noexcept

compare sv[idx] with input value

bool bfind_eq_str_impl(const SV &sv, const value_type *str, size_t in_len, bool remaped, size_type &pos)

void find_gt_horizontal(const SV &sv, value_type value, bvector_type &bv_out, bool null_correct=true)

For testing purposes only.

static constexpr int gt_slice_limit() noexcept

Return the slice limit for signed/unsigned vector value types.

static bool remap_tosv(remap_vector_type &remap_vect_target, const value_type *str, const SV &sv)

Remap input value into SV char encodings.

static void add_agg_char(AGG &agg, const SV &sv, int octet_idx, bm::id64_t planes_mask, unsigned value)

Addd char to aggregator (AND-SUB)

bm::aggregator< bvector_type > aggregator_type

aggregator_type::run_options run_options

Scanner options to control execution.

bool lower_bound_str(const SV &sv, const value_type *str, size_type &pos)

lower bound search for an array position

void find_positive(const SV &sv, bvector_type &bv_out)

Find positive (greter than zero elements) Output vector is computed as a logical OR (join) of all pla...

bvector_type::allocator_type allocator_type

matrix_search_buf_type hmatr_

heap matrix for string search linear stage

bm::sv_sample_index< SV > range_idx_

range index

bool find_eq_str(const SV &sv, const value_type *str, bvector_type &bv_out)

find sparse vector elements (string)

void find_nonzero(const SV &sv, bvector_type &bv_out)

Find non-zero elements Output vector is computed as a logical OR (join) of all planes.

bool find_first_eq(const SV &sv, value_type value, size_type &idx)

find first value (may include NULL indexes)

void invert(const SV &sv, bvector_type &bv_out)

invert search result ("EQ" to "not EQ")

allocator_type::allocator_pool_type allocator_pool_type

SV::value_type value_type

bool find_eq_str_prefix(const SV &sv, const value_type *str, bvector_type &bv_out)

find sparse vector elements with a given prefix (string)

void find_le(const SV &sv, value_type val, bvector_type &bv_out)

find all elements sparse vector element less or equal (<=) than value

void find_ge(const SV &sv, value_type val, bvector_type &bv_out)

find all elements sparse vector element greater or equal (>=) than value

int compare_str(const SV &sv, size_type idx, const value_type *str) const noexcept

compare sv[idx] with input str

static void aggregate_AND_OR_slices(bvector_type &bv_target, const bvector_type &bv_mask, const SV &sv, unsigned from, unsigned total_planes)

remap_vector_type remap_prefix_vect_

common prefix buffer

Index for SV sorted vectors for approximate range queries.

heap_matrix_type s_cache_

cache for SV sampled elements

SV::bvector_type bvector_type

SV::value_type value_type

size_type sv_size() const noexcept

Original SV size.

size_t min_key_len_

minimal key size in index

size_type common_prefix_length(const value_type *search_str, size_t in_len, size_type l, size_type r) const noexcept

find common prefix between index elements and search string

bool idx_unique_

inx value unique or there are dups?

size_type size() const noexcept

Index size (number of sampled elements)

size_t get_min_len() const noexcept

Return length of minimal indexed string.

sv_sample_index(const SV &sv, unsigned s_factor)

void recalc_range(const value_type *search_str, size_type &l, size_type &r) const noexcept

recalculate range into SV coordinates range [from..to)

size_type idx_size_

index size

size_type sv_size_

original sv size

bool bfind_range(const value_type *search_str, size_t in_len, size_type &l, size_type &r) const noexcept

find range (binary)

bm::dynamic_heap_matrix< value_type, allocator_type > heap_matrix_type

bool is_unique() const noexcept

returns true if all index values are unique

void construct(const SV &sv, unsigned s_factor)

Build sampling index for the sorted sprase vector.

bvector_type::allocator_type allocator_type

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)

static const char * str(char *buf, int n)

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

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

Templated Bitscan with dynamic dispatch for best type.

null_support

NULL-able value support.

@ BM_SORTED

input set is sorted (ascending order)

@ BM_SORTED_UNIFORM

sorted and in one block (internal!)

@ use_null

support "non-assigned" or "NULL" logic

@ no_null

do not support NULL values

unsigned int

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

bool sparse_vector_find_first_mismatch(const SV &sv1, const SV &sv2, typename SV::size_type &midx, bm::null_support null_proc=bm::use_null)

Find first mismatch (element which is different) between two sparse vectors (uses linear scan in bit-...

void dynamic_range_clip_low(SV &svect, unsigned low_bit)

Clip dynamic range for signal lower than specified (boost)

void dynamic_range_clip_high(SV &svect, unsigned high_bit)

Clip dynamic range for signal higher than specified.

void sparse_vector_find_mismatch(typename SV1::bvector_type &bv, const SV1 &sv1, const SV2 &sv2, bm::null_support null_proc)

Find mismatch vector, indicating positions of mismatch between two sparse vectors (uses linear scan i...

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

XOR swap two variables.

const unsigned set_block_mask

unsigned long long int id64_t

const unsigned gap_max_bits

const unsigned set_block_shift

bool has_zero_byte_u64(bm::id64_t v) noexcept

Returns true if INT64 contains 0 octet.

double value_type

The numeric datatype used by the parser.

const GenericPointer< typename T::ValueType > T2 value

int strcmp(const char *str1, const char *str2)

static const BitmapCharRec ch1

static const BitmapCharRec ch2

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

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

ad-hoc conditional expressions

value_type buffer_[BSIZE]

size_type gather_idx_[BSIZE]

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