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

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

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

<

TOut>

= (*gap_buf >> 3);

tout <<

<< *gap_buf <<

<<

<<

;

(

= 0;

<

; ++

)

tout << *gap_buf <<

;

<

TOut>

= gap_len ? gap_len : (*gap_buf >> 3);

tout <<

<<

<<

;

= gap_len ? 0 : 1;

(;

<

; ++

)

tout << gap_buf[

] <<

;

( (

>>

) > 1 ) ++

;

<

TOut>

(

= 0;

<

; ++

)

(

= 0;

<

; ++

)

<

TOut>

= gap_len ? gap_len : (*gap_buf >> 3);

tout <<

<<

<<

;

= gap_len ? 0 : 1;

(;

<

; ++

)

v = gap_buf[

];

tout <<

<< total <<

<<

* 16;

std::ifstream fin(fname.c_str(),

| std::ios::binary);

fin.seekg(0, std::ios::end);

fsize = (size_t)fin.tellg();

fin.seekg(0, std::ios::beg);

fin.read((

*) &

[0], std::streamsize(fsize));

<

TBV>

std::ifstream bv_file (fname,

| std::ios::binary);

std::cerr <<

<< fname << std::endl;

bv_file.seekg(0, std::ios_base::end);

length = (unsigned)bv_file.tellg();

std::cerr <<

<< fname << std::endl;

bv_file.seekg(0, std::ios::beg);

*

=

[length];

bv_file.read(

, length);

<

TBV>

std::ofstream bfile (fname,

| std::ios::binary);

std::cerr <<

<< fname << std::endl;

TBV::statistics st1;

blob_size = sermem_buf.

();

bfile.write((

*)sermem_buf.

(), std::streamsize(blob_size));

(

* name_prefix,

num,

* ext,

* blob,

blob_size)

std::stringstream fname_str;

fname_str << name_prefix <<

<< num << ext;

* fname = s.c_str();

std::ofstream bfile (fname,

| std::ios::binary);

std::cerr <<

<< fname << std::endl;

bfile.write((

*)blob, std::streamsize(blob_size));

<

V,

TOut>

(

= 0;

<

(V)*8;

++)

tout << (unsigned)((

>>

) & 1);

(

== 15 && (

(V)*8 > 16)) tout <<

;

<

TOut>

<

TOut>

*

= distance[

];

tout << std::setw(4) << std::setfill(

) <<

[j] <<

;

<

TM,

TOut>

(

< 10) tout <<

;

(

j = 0; j <

; ++j)

tout << std::setw(4) << std::setfill(

) <<

[j] <<

;

bit_idx = 0;

|= (1 << bit_idx);

(bit_idx ==

(

) * 8)

<

BV,

TOut>

sz = 128000;

* bc_arr =

[sz];

(

x = 0; x < sz; ++x) bc_arr[x] = 0;

last_block = bv.count_blocks(bc_arr);

(

= 0;

<= last_block; ++

)

(;

<= last_block; ++

)

tout << std::setw(5) << std::setfill(

) << bc_arr[

] <<

;

(++j == 10)

;

tout <<

<< sum << std::endl;

tout <<

<< sum << std::endl;

<

TOut>

sum = 0;

row_idx = 0;

= 0;

tout << std::setw(5) << std::setfill(

) <<

<<

;

tout <<

<< sum << std::endl;

<

BV,

TOut>

BV::statistics

;

ssize =

.size();

tout <<

<<

<<

.bit_blocks

<<

<<

.gap_blocks <<

<<

<<

.memory_used <<

<< (

.memory_used / (1024 * 1024)) <<

<<

<<

.max_serialize_mem <<

<< (

.max_serialize_mem / (1024 * 1024)) <<

<<

<< ssize <<

<< (ssize / (1024 * 1024)) <<

<

BV,

TOut>

BV::blocks_manager_type& bman = bv.get_blocks_manager();

total_gap_eff = 0;

BV::block_idx_type nb;

BV::block_idx_type nb_prev = 0;

(nb = 0; nb <

; ++nb)

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

tout <<

<< nb <<

;

BV::block_idx_type start = nb;

blk = bman.get_block(i0, j0);

tout <<

<< nb <<

;

tout <<

<< start <<

<< nb <<

;

((nb-1) != nb_prev)

tout <<

<< (size_t)nb-nb_prev <<

;

raw_size=bc*2;

cmr_len=

*2;

mem_eff = raw_size - cmr_len;

total_gap_eff += unsigned(mem_eff);

tout <<

<< nb <<

<<

<<

<< j <<

<<

<< bc <<

<< level <<

<<

<<

<< mem_eff <<

;

zw += (blk[

] == 0);

tout <<

<< nb <<

<< bc <<

<< zw <<

;

tout << std::endl <<

<< total_gap_eff << std::endl;

*

= 0;

BV::size_type blob_size = 0;

BV::statistics

;

=

[

.max_serialize_mem];

blob_size = (unsigned)bvs.

(bv, (

*)

,

.max_serialize_mem);

<

SV,

TOut>

print_svector_xor_stat(TOut& toutconst SV& sv)

SV::size_type sz = sv.size();

(

SV::size_type nb = 0; nb < nb_max; ++nb)

tout <<

<< nb << std::endl;

planes = sv.planes();

(

= 0;

< planes; ++

)

SV::bvector_type* bv = sv.get_plane(

);

SV::bvector_type::blocks_manager_type& bman = bv->get_blocks_manager();

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

bm::compute_complexity_descr(block, x_descr);

bm::bit_block_change_bc32(block, &gc, &bc);

best_metric, block_metric;

block_metric = best_metric = gc < bc ? gc : bc;

kb_found =

;

(

k =

+ 1; k < planes; ++k)

SV::bvector_type* bv_x = sv.get_plane(

);

SV::bvector_type::blocks_manager_type& bman_x = bv_x->get_blocks_manager();

* block_x = bman_x.get_block_ptr(i0, j0);

bm::compute_xor_complexity_descr(block, block_x, x_descr);

bm::bit_block_xor_product(tb, block, block_x, kb_d64);

kb_bc, kb_gc;

bm::bit_block_change_bc32(tb, &kb_gc, &kb_bc);

tout <<

<<

<< std::endl;

<

SV,

TOut>

SV::bvector_type bvector_type;

bvector_type::size_type cnt_and = dmit->

;

bvector_type::size_type cnt_or = dmit->

;

(cnt_and == 0 || cnt_or == 0)

d = double(cnt_and) / double(cnt_or);

res = unsigned(d * 100);

(res > 100) res = 100;

similarity_batch_type sbatch;

similarity_batch_type::vector_type& sim_vec = sbatch.descr_vect_;

(

k = 0; k < sim_vec.size(); ++k)

sim = sim_vec[k].similarity();

SV::bvector_type* bv1 = sim_vec[k].get_first();

SV::bvector_type* bv2 = sim_vec[k].get_second();

SV::bvector_type bvx(*bv2);

(bv_size_x < bv_size2)

diff = bv_size2 - bv_size_x;

sz10p = bv_size2 / 10;

tout <<

<< sim_vec[k].get_first_idx()

<<

<< sim_vec[k].get_second_idx()

<<

<< sim_vec[k].get_second_idx() <<

<<

<< bv_size_x

SV::statistics

;

svect.calc_stat(&

);

tout <<

<< svect.size() << std::endl;

tout <<

<<

.bit_blocks << std::endl;

tout <<

<<

.gap_blocks << std::endl;

tout <<

;

0: tout <<

<<

.gap_levels[

] <<

;

;

1: tout <<

<<

.gap_levels[

] <<

;

;

2: tout <<

<<

.gap_levels[

] <<

;

;

3: tout <<

<<

.gap_levels[

] <<

;

;

tout <<

<<

<<

<<

.gap_levels[

] <<

;

;

tout <<

<<

.max_serialize_mem <<

<< (

.max_serialize_mem / (1024 * 1024)) <<

<< std::endl;

tout <<

<<

.memory_used <<

<< (

.memory_used / (1024 * 1024)) <<

<< std::endl;

eff_max_element = svect.effective_vector_max();

std_vect_size =

(

) * svect.size() * eff_max_element;

tout <<

<< std_vect_size <<

<< std_vect_size / (1024 * 1024) <<

(

(

) > 4 && (eff_max_element == 1))

tout <<

<<

(

long) * svect.size() << std::endl;

tout <<

<< std::endl;

ssize(0), octet_ssize(0);

SV::bvector_type bv_join;

planes = svect.get_bmatrix().rows();

octet_cnt(0), octet(0);

(

= 0;

< planes; ++

)

SV::bvector_type* bv_plane = svect.get_slice(

);

tout <<

<<

<< octet_cnt <<

;

any_else =

;

(

j =

+1; j < planes; ++j)

(svect.get_slice(j))

bv_join |= *bv_plane;

octet_ssize += pssize;

tout <<

<< std::endl;

tout <<

<< octet <<

<< octet_ssize <<

<< octet_ssize/(1024*1024) <<

<< std::endl;

octet_cnt = 0; octet_ssize = 0;

tout <<

;

SV::bvector_type* bv_null = svect.get_null_bvector();

tout <<

;

SV::size_type not_null_cnt = bv_null->count();

tout <<

<< not_null_cnt << std::endl;

tout <<

<< ((

(

) +

(

)) * not_null_cnt) <<

<< ((

(

) +

(

)) * not_null_cnt) / (1024 * 1024) <<

tout <<

;

tout <<

<< ssize

<<

<< ssize / (1024 * 1024) <<

<< std::endl;

fr = double(bv_join_cnt) / double (svect.size());

tout <<

<< bv_join_cnt <<

non_zero_mem = size_t(bv_join_cnt) *

(

);

tout <<

<< non_zero_mem <<

<< non_zero_mem / (1024*1024) <<

<

SV,

TOut>

SV::octet_freq_matrix_type octet_stat_matr;

str_svect.calc_octet_stat(octet_stat_matr);

(

= 0;

< octet_stat_matr.rows(); ++

)

= octet_stat_matr.row(

);

(

j = 0; j < octet_stat_matr.cols(); ++j)

(

j = 0; j < octet_stat_matr.cols(); ++j)

tout <<

<<

;

tout <<

;

<

VECT>

std::ofstream fout(fname.c_str(), std::ios::binary);

sz = vect.size();

fout.write((

*)&sz,

(sz));

fout.write((

*)vect.data(),

<

VECT>

std::ifstream fin(fname.c_str(),

| std::ios::binary);

fin.read((

*) &sz,

(sz));

<

CBC>

CBC::buffer_type sbuf;

std::ofstream fout(fname.c_str(), std::ios::binary);

*

= (

*)sbuf.buf();

fout.write(

, sbuf.size());

*blob_size = sbuf.size();

<

CBC>

std::vector<unsigned char>

;

*

= &

[0];

<

SV>

* sv_blob_size=0,

use_xor =

)

std::ofstream fout(fname.c_str(), std::ios::binary);

*

= (

*)sv_lay.

();

sz = sv_lay.

();

fout.write(

, std::streamsize(sz));

*sv_blob_size = sv_lay.

();

<

SV>

std::vector<unsigned char>

;

(

.size() == 0)

*

= &

[0];

<

SV,

V>

(sv.size() != vect.size())

(

= 0;

< vect.size(); ++

)

v1 = sv[(unsigned)

];

= vect[

];

<

SV,

BV>

SV::back_insert_iterator bit = sv.get_back_inserter();

BV::enumerator en = bv.first();

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

v = en.value();

getCurrentRSS( )

( (

= fopen(

,

)) ==

)

(

)0L;

( fscanf(

,

, &rss ) != 1 )

(

)0L;

(

)rss * (size_t)sysconf( _SC_PAGESIZE);

<

BV,

TOut>

tout << bv.count() <<

;

BV::enumerator en = bv.first();

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

tout << *en <<

;

#define BM_DECLARE_TEMP_BLOCK(x)

#define IS_FULL_BLOCK(addr)

#define IS_VALID_ADDR(addr)

Serialization for sparse_vector<>

Bitvector Bit-vector container with runtime compression of bits.

void calc_stat(struct bm::bvector< Alloc >::statistics *st) const noexcept

Calculates bitvector statistics.

size_type count() const noexcept

population count (count of ON bits)

size_t size() const noexcept

Get buffer size.

const unsigned char * buf() const noexcept

Get read access to buffer memory.

Deseriaizer for compressed collections.

int deserialize(CBC &buffer_coll, const unsigned char *buf, bm::word_t *temp_block=0)

Seriaizer for compressed collections.

void serialize(const CBC &buffer_coll, buffer_type &buf, bm::word_t *temp_block=0)

Serialize compressed collection into memory buffer.

Bit-vector serialization class.

void set_compression_level(unsigned clevel) noexcept

Set compression level.

void set_bic_dynamic_range_reduce(bool flag) noexcept

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

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

Bitvector serialization into memory block.

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

void set_xor_ref(bool is_enabled) noexcept

Turn ON and OFF XOR compression of sparse vectors Enables XOR reference compression for the sparse ve...

void serialize(const SV &sv, sparse_vector_serial_layout< SV > &sv_layout)

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

std::ofstream out("events_result.xml")

main entry point for tests

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

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

static const column_t columns[]

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

Bitcount for bit block.

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.

@ COUNT_AND

(A & B).count()

@ COUNT_OR

(A | B).count()

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

Calculates number of bits ON in GAP buffer.

unsigned gap_control_sum(const T *buf) noexcept

Calculates sum of all words in GAP block. (For debugging purposes)

T gap_level(const T *buf) noexcept

Returs GAP blocks capacity level.

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

Returs GAP block length.

int sparse_vector_deserialize(SV &sv, const unsigned char *buf, bm::word_t *temp_block=0)

Deserialize sparse vector.

const unsigned set_array_mask

const unsigned set_block_plane_cnt

void print_svector_stat(TOut &tout, const SV &svect, bool print_sim=false)

int svector_check(const SV &sv, const V &vect)

void PrintDGap(TOut &tout, const bm::gap_word_t *gap_buf, unsigned gap_len=0)

int file_save_compressed_collection(const CBC &cbc, const std::string &fname, size_t *blob_size=0)

unsigned BinStrLR(const char *str)

Binary code string converted to number Bits are expected left to right.

unsigned PrintGammaCode(TOut &tout, unsigned value)

void print_bc(TOut &tout, unsigned i, unsigned count)

void print_blocks_count(TOut &tout, const BV &bv)

void PrintTMatrix(TOut &tout, const TM &tmatrix, unsigned cols=0, bool binary=false)

void PrintGap(TOut &tout, const bm::gap_word_t *gap_buf)

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

Recalc linear bvector block index into 2D matrix coordinates.

int file_load_compressed_collection(CBC &cbc, const std::string &fname)

void print_bv(TOut &tout, const BV &bv)

void print_str_svector_stat(TOut &tout, const SV &str_svect)

size_t print_bvector_stat(TOut &tout, const BV &bvect)

const unsigned set_total_blocks

void PrintDGapGamma(TOut &tout, const bm::gap_word_t *gap_buf, unsigned gap_len=0)

void PrintDistanceMatrix(TOut &tout, const unsigned distance[bm::set_block_plane_cnt][bm::set_block_plane_cnt])

int load_vector(VECT &vect, const std::string &fname)

const unsigned bie_cut_off

const unsigned gap_levels

size_t compute_serialization_size(const BV &bv)

void convert_bv2sv(SV &sv, const BV &bv)

const unsigned set_block_size

unsigned long long int id64_t

int read_dump_file(const std::string &fname, VT &data)

Read dump file into an STL container (vector of some basic type)

void PrintBits32(TOut &tout, unsigned val)

void build_jaccard_similarity_batch(SIMBATCH &sbatch, const SV &sv)

Utility function to build jaccard similarity batch for sparse_vector<>

unsigned int iLog2(unsigned int value)

const unsigned set_array_shift

void print_stat(TOut &tout, const BV &bv, typename BV::block_idx_type blocks=0)

unsigned short gap_word_t

void LoadBVector(const char *fname, TBV &bvector, unsigned *file_size=0)

const unsigned set_block_shift

int file_save_svector(const SV &sv, const std::string &fname, size_t *sv_blob_size=0, bool use_xor=true)

void PrintBinary(TOut &tout, V val)

void SaveBVector(const char *fname, const TBV &bvector, bool safe_mode=false)

int save_vector(const VECT &vect, const std::string &fname)

void SaveBlob(const char *name_prefix, unsigned num, const char *ext, const unsigned char *blob, size_t blob_size)

int file_load_svector(SV &sv, const std::string &fname)

double value_type

The numeric datatype used by the parser.

const GenericPointer< typename T::ValueType > T2 value

std::istream & in(std::istream &in_, double &x_)

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

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

#define row(bind, expected)

static DP_BlockInfo * blocks

Structure to compute XOR gap-count profile by sub-block waves.

Distance metric descriptor, holds metric code and result.

layout class for serialization buffer structure

const unsigned char * buf() const noexcept

Return serialization buffer pointer.

size_t size() const noexcept

return current serialized size

Mini-matrix for bit transposition purposes.

static unsigned cols() noexcept

static unsigned rows() noexcept

const T * row(unsigned row_idx) const noexcept

int g(Seg_Gsm *spe, Seq_Mtf *psm, Thd_Gsm *tdg)

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