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

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

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

bit_list_size,

bvector_type::rs_index_type

;

[] sub_block_;

(sample_count == 0)

bv_out.clear(

);

bv_in.build_rs_index(&rsi_, &bv_nb_);

(in_count <= sample_count)

pick_ratio = float(sample_count) / float(in_count);

(pick_ratio < 0.054f)

simple_pick(bv_out, bv_in, sample_count,

,

);

(sample_count > in_count/2)

delta_count = in_count - sample_count;

get_subset(tmp_bv, bv_in, in_count, delta_count);

bv_out.bit_sub(bv_in, tmp_bv);

get_subset(bv_out, bv_in, in_count, sample_count);

bv_out.clear(

);

std::random_device rd;

std::mt19937_64 mt_rand(rd());

std::mt19937 mt_rand(rd());

std::uniform_int_distribution<size_type> dist(

,

);

= bv_in.find(ridx, fidx);

is_set = bv_out.set_bit_conditional(fidx,

,

);

sample_count -= is_set;

= bv_in.find(fidx, fidx);

is_set = bv_out.set_bit_conditional(fidx,

,

);

sample_count -= is_set;

bv_out.clear(

);

bv_out.resize(bv_in.size());

* tmp_block = bman_out.check_allocate_tempblock();

= bv_nb_.find_range(first_nb, last_nb);

std::random_device rd;

std::mt19937_64 mt_rand(rd());

std::mt19937 mt_rand(rd());

std::uniform_int_distribution<size_type> dist_nb(first_nb, last_nb);

curr_sample_count = sample_count;

(

take_count = 0; curr_sample_count; curr_sample_count -= take_count)

(ridx >= first_nb && ridx <= last_nb);

= bv_nb_.find(ridx, nb);

= bv_nb_.find(first_nb, nb);

bv_nb_.clear_bit_no_check(nb);

bc = rsi_.count(nb);

take_count = compute_take_count(bc, in_count, sample_count);

(take_count > curr_sample_count)

take_count = unsigned(curr_sample_count);

* blk_src = bman_in.get_block(i0, j0);

* blk_out = bman_out.get_block_ptr(i0, j0);

blk_out = bman_out.deoptimize_block(nb);

blk_out = bman_out.get_allocator().alloc_bit_block();

bman_out.set_block(nb, blk_out);

(take_count == bc)

get_random_array(blk_out, bit_list_, arr_len, take_count);

get_block_subset(blk_out, blk_src, take_count);

block_percent = float(bc) / float(in_count);

bits_to_take = float(sample_count) * block_percent;

bits_to_take += 0.99f;

to_take = unsigned(bits_to_take);

to_take = unsigned(sample_count);

(

rounds = 0; take_count && rounds < 10; ++rounds)

(blk_src[

] && (blk_out[

] != blk_src[

]))

new_count = process_word(blk_out, blk_src,

, take_count);

take_count -= new_count;

sub_block_[

] = blk_src[

] & ~blk_out[

];

get_random_array(blk_out, bit_list_, arr_len, take_count);

new_bits,

;

= unsigned(rand());

}

(

== 0);

std::random_device rd;

std::mt19937_64 mt_rand(rd());

std::mt19937 mt_rand(rd());

src_rand = blk_src[nword] &

;

new_bits = src_rand & ~blk_out[nword];

(new_count > take_count)

blist[64];

std::shuffle(blist, blist + arr_size, mt_rand);

(

j = 0; j < take_count; ++j)

|= (1u << blist[j]);

new_count = take_count;

((new_bits & ~blk_src[nword]) == 0);

blk_out[nword] |= new_bits;

bit_list_size,

std::random_device rd;

std::mt19937_64 mt_rand(rd());

std::mt19937 mt_rand(rd());

(

= 0;

<

; ++

)

ncbi::TMaskedQueryRegions mask

Bit manipulation primitives (internal)

void get_block_subset(bm::word_t *blk_out, const bm::word_t *blk_src, unsigned count)

static unsigned process_word(bm::word_t *blk_out, const bm::word_t *blk_src, unsigned nword, unsigned take_count) noexcept

random_subset & operator=(const random_subset &)

bvector_type bv_nb_

blocks vector

void get_subset(BV &bv_out, const BV &bv_in, size_type in_count, size_type sample_count)

bm::gap_word_t bit_list_[bm::gap_max_bits]

BV::blocks_manager_type blocks_manager_type

static void get_random_array(bm::word_t *blk_out, bm::gap_word_t *bit_list, unsigned bit_list_size, unsigned count)

void sample(BV &bv_out, const BV &bv_in, size_type sample_count)

Get random subset of input vector.

static unsigned compute_take_count(unsigned bc, size_type in_count, size_type sample_count) noexcept

void simple_pick(BV &bv_out, const BV &bv_in, size_type sample_count, size_type first, size_type last)

simple picking algorithm for small number of items in [first,last] range

bvector_type::rs_index_type rsi_

RS index (block counts)

random_subset(const random_subset &)

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

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

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

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.

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

Templated Bitscan with dynamic dispatch for best type.

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 set_bit(unsigned *dest, unsigned bitpos) noexcept

Set 1 bit in a block.

unsigned bit_list(T w, B *bits) noexcept

Unpacks word into list of ON bit indexes.

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

GAP block to bitblock conversion.

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.

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

Recalc linear bvector block index into 2D matrix coordinates.

const unsigned set_block_size

unsigned short gap_word_t

const unsigned gap_max_bits

const GenericPointer< typename T::ValueType > T2 value

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