# bm Namespace Reference

## Data Structures

class | bvector
| bitvector with runtime compression of bits. More...
struct | bv_statistics
| Structure with statistical information about bitset's memory allocation details. More...
struct | gap_len_table
| Default GAP lengths table. More...
struct | gap_len_table_min
| Alternative GAP lengths table. Good for for memory saver mode and very sparse bitsets. More...
struct | block_set_table
| Structure keeps all-left/right ON bits masks. More...
struct | all_set
| Structure carries pointer on bit block with all bits 1. More...
struct | _copyright
| Internal structure. More...
struct | globals
| Internal structure. More...
struct | d_copy_func
| d-Gap copy functor More...
class | copy_to_array_functor
| Adaptor to copy 1 bits to array. More...
class | copy_to_array_functor_inc
| Adaptor to copy 1 bits to array with base increment. More...
class | bitblock_get_adapter
| Bit-block get adapter, takes bitblock and represents it as a get_32() accessor function /internal. More...
class | bitblock_store_adapter
| Bit-block store adapter, takes bitblock and saves results into it /internal. More...
class | bitblock_sum_adapter
| Bit-block sum adapter, takes values and sums it /internal. More...
class | decoder_range_adapter
| Adapter to get words from a range stream (see range serialized bit-block). More...
struct | bit_AND
| Bit AND functor. More...
struct | bit_OR
| Bit OR functor. More...
struct | bit_SUB
| Bit SUB functor. More...
struct | bit_XOR
| Bit XOR functor. More...
struct | bit_ASSIGN
| Bit ASSIGN functor. More...
struct | bit_COUNT
| Bit COUNT functor. More...
struct | bit_COUNT_AND
| Bit COUNT AND functor. More...
struct | bit_COUNT_XOR
| Bit COUNT XOR functor. More...
struct | bit_COUNT_OR
| Bit COUNT OR functor. More...
struct | bit_COUNT_SUB_AB
| Bit COUNT SUB AB functor. More...
struct | bit_COUNT_SUB_BA
| Bit SUB BA functor. More...
struct | bit_COUNT_A
| Bit COUNT A functor. More...
struct | bit_COUNT_B
| Bit COUNT B functor. More...
struct | operation_functions
class | miniset
| Template class implements memory saving set functionality. More...
class | bvmini
| Mini bitvector used in bvector template to keep block type flags. More...
class | bvector_mini
| Bitvector class with very limited functionality. More...
class | encoder
| Memory encoding. More...
class | decoder_base
| Base class for all decoding functionality. More...
class | decoder
| Class for decoding data from memory buffer. More...
class | decoder_little_endian
| Class for decoding data from memory buffer. More...
class | bit_out
| Byte based writer for un-aligned bit streaming. More...
class | bit_in
| Byte based reader for un-aligned bit streaming. More...
class | gamma_encoder
| Functor for Elias Gamma encoding. More...
class | gamma_decoder
| Elias Gamma decoder. More...
struct | DeBruijn_bit_position
struct | first_bit_table
| Structure keeps index of first right 1 bit for every byte. More...
struct | bit_count_table
| Structure to aid in counting bits table contains count of bits in 0-255 diapason of numbers. More...
class | sse_empty_guard
| SSE2 reinitialization guard class. More...
struct | distance_metric_descriptor
| Distance metric descriptor, holds metric code and result. More...
struct | tmatrix
| Mini-matrix for bit transposition purposes. More...
struct | bit_grabber
struct | bit_grabber< unsigned, 32 >
struct | bit_grabber< unsigned short, 16 >
struct | bit_grabber< unsigned char, 8 >
struct | bit_trans_grabber
class | gap_transpose_engine
| Bit-plain splicing of a GAP block. More...
class | ptr_guard
| Mini auto-pointer for internal memory management. More...
class | serializer
| Bit-vector serialization class. More...
class | deseriaizer_base
| Base deserialization class. More...
class | deserializer
| Class deserializer. More...
class | iterator_deserializer
| Iterator to walk forward the serialized stream. More...
class | serial_stream_iterator
| Serialization stream iterator. More...
class | operation_deserializer
| Class deserializer, can perform logical operation on bit-vector and serialized bit-vector. More...
class | block_allocator
| Default malloc based bitblock allocator class. More...
class | ptr_allocator
| Default malloc based bitblock allocator class. More...
class | mem_alloc
| BM style allocator adapter. More...
class | random_subset

## Typedefs

typedef void(* | gap_operation_to_bitset_func_type )(unsigned *, const gap_word_t *)
typedef gap_word_t *(* | gap_operation_func_type )(const gap_word_t *BMRESTRICT, const gap_word_t *BMRESTRICT, gap_word_t *BMRESTRICT, unsigned &)
typedef bm::id_t(* | bit_operation_count_func_type )(const bm::word_t *BMRESTRICT, const bm::word_t *BMRESTRICT, const bm::word_t *BMRESTRICT)
typedef decoder | decoder_big_endian
| Class for decoding data from memory buffer.
typedef unsigned long long | id64_t
typedef unsigned int | id_t
typedef unsigned int | word_t
typedef unsigned short | short_t
typedef unsigned short | gap_word_t
typedef word_t | wordop_t
typedef mem_alloc < block_allocator, ptr_allocator > | standard_allocator

## Enumerations

enum | set_operation { set_AND = 0, set_OR = 1, set_SUB = 2, set_XOR = 3, set_ASSIGN = 4, set_COUNT = 5, set_COUNT_AND = 6, set_COUNT_XOR = 7, set_COUNT_OR = 8, set_COUNT_SUB_AB = 9, set_COUNT_SUB_BA = 10, set_COUNT_A = 11, set_COUNT_B = 12, set_END }
| Nomenclature of set operations. More...
enum | operation { BM_AND = set_AND, BM_OR = set_OR, BM_SUB = set_SUB, BM_XOR = set_XOR }
| Bit operations enumeration. More...
enum | ByteOrder { BigEndian = 0, LittleEndian = 1 }
| Byte orders recognized by the library. More...
enum | strategy { BM_BIT = 0, BM_GAP = 1 }
| Block allocation strategies. More...
enum | set_representation { set_bitset = 0, set_gap = 1, set_array1 = 2, set_array0 = 3 }
| set representation variants More...
enum | distance_metric { COUNT_AND = set_COUNT_AND, COUNT_XOR = set_COUNT_XOR, COUNT_OR = set_COUNT_OR, COUNT_SUB_AB = set_COUNT_SUB_AB, COUNT_SUB_BA = set_COUNT_SUB_BA, COUNT_A = set_COUNT_A, COUNT_B = set_COUNT_B }
| Distance metrics codes defined for vectors A and B. More...
enum | serialization_header_mask { BM_HM_DEFAULT = 1, BM_HM_RESIZE = (1 << 1), BM_HM_ID_LIST = (1 << 2), BM_HM_NO_BO = (1 << 3), BM_HM_NO_GAPL = (1 << 4) }
enum | serialization_flags { BM_NO_BYTE_ORDER = 1, BM_NO_GAP_LENGTH = (1 << 1) }
| Bit mask flags for serialization algorithm. More...

## Functions

template<class Alloc >
bvector< Alloc > | operator& (const bvector< Alloc > &v1, const bvector< Alloc > &v2)
template<class Alloc >
bvector< Alloc > | operator| (const bvector< Alloc > &v1, const bvector< Alloc > &v2)
template<class Alloc >
bvector< Alloc > | operator^ (const bvector< Alloc > &v1, const bvector< Alloc > &v2)
template<class Alloc >
bvector< Alloc > | operator- (const bvector< Alloc > &v1, const bvector< Alloc > &v2)
BMFORCEINLINE bm::id_t | word_bitcount (bm::id_t w)
int | parallel_popcnt_32 (unsigned int n)
bool | is_const_set_operation (set_operation op)
| Returns true if set operation is constant (bitcount).
bm::operation | setop2op (bm::set_operation op)
| Convert set operation to operation.
template<typename W >
void | xor_swap (W &x, W &y)
| XOR swap two scalar variables.
template<typename T >
int | wordcmp0 (T w1, T w2)
| Lexicographical comparison of two words as bit strings. Auxiliary implementation for testing and reference purposes.
template<typename T >
int | wordcmp (T a, T b)
| Lexicographical comparison of two words as bit strings. Auxiliary implementation for testing and reference purposes.
template<typename T >
unsigned | gap_bfind (const T *buf, unsigned pos, unsigned *is_set)
template<typename T >
unsigned | gap_test (const T *buf, unsigned pos)
| Tests if bit = pos is true.
template<class T , class F >
void | for_each_nzblock (T ***root, unsigned size1, F &f)
template<class T , class F >
void | for_each_nzblock2 (T ***root, unsigned size1, F &f)
template<class T , class F >
bool | for_each_nzblock_if (T ***root, unsigned size1, F &f)
template<class T , class F >
void | for_each_block (T ***root, unsigned size1, F &f)
template<class T , class F >
F | bmfor_each (T first, T last, F f)
template<class T >
T | sum_arr (T *first, T *last)
template<typename T >
unsigned | gap_bit_count (const T *buf, unsigned dsize=0)
| Calculates number of bits ON in GAP buffer.
template<typename T >
unsigned | gap_bit_count_range (const T *buf, T left, T right)
| Counts 1 bits in GAP buffer in the closed [left, right] diapason.
template<class T , class Func >
void | for_each_dgap (const T *gap_buf, Func &func)
template<typename T >
T * | gap_2_dgap (const T *gap_buf, T *dgap_buf, bool copy_head=true)
| Convert GAP buffer into D-GAP buffer.
template<typename T >
void | dgap_2_gap (const T *dgap_buf, T *gap_buf, T gap_header=0)
| Convert D-GAP buffer into GAP buffer.
template<typename T >
int | gapcmp (const T *buf1, const T *buf2)
| Lexicographical comparison of GAP buffers.
template<typename T , class F >
void | gap_buff_op (T *BMRESTRICT dest, const T *BMRESTRICT vect1, unsigned vect1_mask, const T *BMRESTRICT vect2, unsigned vect2_mask, F &f, unsigned &dlen)
| Abstract operation for GAP buffers. Receives functor F as a template argument.
template<typename T , class F >
unsigned | gap_buff_any_op (const T *BMRESTRICT vect1, unsigned vect1_mask, const T *BMRESTRICT vect2, unsigned vect2_mask, F f)
| Abstract distance test operation for GAP buffers. Receives functor F as a template argument.
template<typename T , class F >
unsigned | gap_buff_count_op (const T *vect1, const T *vect2, F f)
| Abstract distance(similarity) operation for GAP buffers. Receives functor F as a template argument.
template<typename T >
unsigned | gap_set_value (unsigned val, T *BMRESTRICT buf, unsigned pos, unsigned *BMRESTRICT is_set)
| Sets or clears bit in the GAP buffer.
template<typename T >
unsigned | gap_add_value (T *buf, T pos)
| Add new value to the end of GAP buffer.
template<typename T >
unsigned | gap_set_array (T *buf, const T *arr, unsigned len)
| Convert array to GAP buffer.
template<typename T >
unsigned | bit_array_compute_gaps (const T *arr, unsigned len)
| Compute number of GAPs in bit-array.
template<typename T >
int | gap_find_in_block (const T *buf, unsigned nbit, bm::id_t *prev)
| Searches for the next 1 bit in the GAP block.
BMFORCEINLINE void | set_bit (unsigned *dest, unsigned bitpos)
| Set 1 bit in a block.
BMFORCEINLINE unsigned | test_bit (const unsigned *block, unsigned bitpos)
| Test 1 bit in a block.
void | or_bit_block (unsigned *dest, unsigned bitpos, unsigned bitcount)
| Sets bits to 1 in the bitblock.
void | sub_bit_block (unsigned *dest, unsigned bitpos, unsigned bitcount)
| SUB (AND NOT) bit interval to 1 in the bitblock.
void | xor_bit_block (unsigned *dest, unsigned bitpos, unsigned bitcount)
| XOR bit interval to 1 in the bitblock.
template<typename T >
void | gap_sub_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT buf)
| SUB (AND NOT) GAP block to bitblock.
template<typename T >
void | gap_xor_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT buf)
| XOR GAP block to bitblock.
template<typename T >
void | gap_add_to_bitset_l (unsigned *dest, const T *buf, unsigned buf_len)
| Adds(OR) GAP block to bitblock.
template<typename T >
void | gap_add_to_bitset (unsigned *dest, const T *buf)
| Adds(OR) GAP block to bitblock.
template<typename T >
void | gap_and_to_bitset (unsigned *dest, const T *buf)
| ANDs GAP block to bitblock.
template<typename T >
bm::id_t | gap_bitset_and_count (const unsigned *block, const T *buf)
| Compute bitcount of bit block AND masked by GAP block.
template<typename T >
bm::id_t | gap_bitset_and_any (const unsigned *block, const T *buf)
| Bitcount test of bit block AND masked by GAP block.
template<typename T >
bm::id_t | gap_bitset_sub_count (const unsigned *block, const T *buf)
| Compute bitcount of bit block SUB masked by GAP block.
template<typename T >
bm::id_t | gap_bitset_sub_any (const unsigned *block, const T *buf)
| Compute bitcount test of bit block SUB masked by GAP block.
template<typename T >
bm::id_t | gap_bitset_xor_count (const unsigned *block, const T *buf)
| Compute bitcount of bit block XOR masked by GAP block.
template<typename T >
bm::id_t | gap_bitset_xor_any (const unsigned *block, const T *buf)
| Compute bitcount test of bit block XOR masked by GAP block.
template<typename T >
bm::id_t | gap_bitset_or_count (const unsigned *block, const T *buf)
| Compute bitcount of bit block OR masked by GAP block.
template<typename T >
bm::id_t | gap_bitset_or_any (const unsigned *block, const T *buf)
| Compute bitcount test of bit block OR masked by GAP block.
void | bit_block_set (bm::word_t *BMRESTRICT dst, bm::word_t value)
| Bitblock memset operation.
template<typename T >
void | gap_convert_to_bitset (unsigned *dest, const T *buf)
| GAP block to bitblock conversion.
template<typename T >
void | gap_convert_to_bitset_l (unsigned *dest, const T *buf, unsigned buf_len)
| GAP block to bitblock conversion.
template<typename T >
void | gap_convert_to_bitset (unsigned *dest, const T *buf, unsigned dest_len)
| GAP block to bitblock conversion.
template<typename T >
unsigned * | gap_convert_to_bitset_smart (unsigned *dest, const T *buf, id_t set_max)
| Smart GAP block to bitblock conversion.
template<typename T >
unsigned | gap_control_sum (const T *buf)
| Calculates sum of all words in GAP block. (For debugging purposes).
template<class T >
void | gap_set_all (T *buf, unsigned set_max, unsigned value)
| Sets all bits to 0 or 1 (GAP).
template<class T >
void | gap_init_range_block (T *buf, T from, T to, T value, unsigned set_max)
| Init gap block so it has block in it (can be whole block).
template<typename T >
void | gap_invert (T *buf)
| Inverts all bits in the GAP buffer.
template<typename T >
bool | gap_is_all_zero (const T *buf, unsigned set_max)
| Temporary inverts all bits in the GAP buffer.
template<typename T >
bool | gap_is_all_one (const T *buf, unsigned set_max)
| Checks if GAP block is all-one.
template<typename T >
T | gap_length (const T *buf)
| Returs GAP block length.
template<typename T >
unsigned | gap_capacity (const T *buf, const T *glevel_len)
| Returs GAP block capacity.
template<typename T >
unsigned | gap_limit (const T *buf, const T *glevel_len)
| Returs GAP block capacity limit.
template<typename T >
unsigned | gap_level (const T *buf)
| Returs GAP blocks capacity level.
template<typename T >
void | set_gap_level (T *buf, unsigned level)
| Sets GAP block capacity level.
template<typename T >
int | gap_calc_level (int len, const T *glevel_len)
| Calculates GAP block capacity level.
template<typename T >
unsigned | gap_free_elements (const T *buf, const T *glevel_len)
| Returns number of free elements in GAP block array. Difference between GAP block capacity on this level and actual GAP length.
template<typename T >
int | bitcmp (const T *buf1, const T *buf2, unsigned len)
| Lexicographical comparison of BIT buffers.
template<typename T >
unsigned | bit_convert_to_gap (T *BMRESTRICT dest, const unsigned *BMRESTRICT src, bm::id_t bits, unsigned dest_len)
| Converts bit block to GAP.
template<class T , class F >
void | for_each_gap_dbit (const T *buf, F &func)
| Iterate gap block as delta-bits with a functor.
template<typename D , typename T >
D | gap_convert_to_arr (D *BMRESTRICT dest, const T *BMRESTRICT buf, unsigned dest_len, bool invert=false)
| Convert gap block into array of ints corresponding to 1 bits.
bm::id_t | bit_block_calc_count (const bm::word_t *block, const bm::word_t *block_end)
| Bitcount for bit string.
bm::id_t | bit_count_change (bm::word_t w)
void | bit_count_change32 (const bm::word_t *block, const bm::word_t *block_end, unsigned *bit_count, unsigned *gap_count)
bm::id_t | bit_block_calc_count_change (const bm::word_t *block, const bm::word_t *block_end, unsigned *bit_count)
bm::id_t | bit_block_calc_count_range (const bm::word_t *block, bm::word_t left, bm::word_t right)
bm::id_t | bit_block_any_range (const bm::word_t *block, bm::word_t left, bm::word_t right)
template<typename T >
void | bit_invert (T *start, T *end)
bool | is_bits_one (const bm::wordop_t *start, const bm::wordop_t *end)
| Returns "true" if all bits in the block are 1.
bool | bit_is_all_zero (const bm::wordop_t *start, const bm::wordop_t *end)
| Returns "true" if all bits in the block are 0.
BMFORCEINLINE unsigned | and_op (unsigned v1, unsigned v2)
| GAP and functor.
BMFORCEINLINE unsigned | xor_op (unsigned v1, unsigned v2)
| GAP xor functor.
BMFORCEINLINE unsigned | or_op (unsigned v1, unsigned v2)
| GAP or functor.
BMFORCEINLINE unsigned | sub_op (unsigned v1, unsigned v2)
| GAP or functor.
BMFORCEINLINE gap_word_t * | gap_operation_and (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2, gap_word_t *BMRESTRICT tmp_buf, unsigned &dsize)
| GAP AND operation.
BMFORCEINLINE unsigned | gap_operation_any_and (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
| GAP AND operation test.
BMFORCEINLINE unsigned | gap_count_and (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
| GAP bitcount AND operation test.
BMFORCEINLINE gap_word_t * | gap_operation_xor (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2, gap_word_t *BMRESTRICT tmp_buf, unsigned &dsize)
| GAP XOR operation.
BMFORCEINLINE unsigned | gap_operation_any_xor (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
| GAP XOR operation test.
BMFORCEINLINE unsigned | gap_count_xor (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
| GAP bitcount XOR operation test.
gap_word_t * | gap_operation_or (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2, gap_word_t *BMRESTRICT tmp_buf, unsigned &dsize)
| GAP OR operation.
BMFORCEINLINE unsigned | gap_count_or (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
| GAP bitcount OR operation test.
gap_word_t * | gap_operation_sub (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2, gap_word_t *BMRESTRICT tmp_buf, unsigned &dsize)
| GAP SUB (AND NOT) operation.
BMFORCEINLINE unsigned | gap_operation_any_sub (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
| GAP SUB operation test.
BMFORCEINLINE unsigned | gap_count_sub (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
| GAP bitcount SUB (AND NOT) operation test.
void | bit_block_copy (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src)
| Bitblock copy operation.
void | bit_block_and (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src)
| Plain bitblock AND operation. Function does not analyse availability of source and destination blocks.
unsigned | bit_block_and_count (const bm::word_t *src1, const bm::word_t *src1_end, const bm::word_t *src2)
| Function ANDs two bitblocks and computes the bitcount. Function does not analyse availability of source blocks.
unsigned | bit_block_and_any (const bm::word_t *src1, const bm::word_t *src1_end, const bm::word_t *src2)
| Function ANDs two bitblocks and tests for any bit. Function does not analyse availability of source blocks.
unsigned | bit_block_xor_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Function XORs two bitblocks and computes the bitcount. Function does not analyse availability of source blocks.
unsigned | bit_block_xor_any (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Function XORs two bitblocks and and tests for any bit. Function does not analyse availability of source blocks.
unsigned | bit_block_sub_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Function SUBs two bitblocks and computes the bitcount. Function does not analyse availability of source blocks.
unsigned | bit_block_sub_any (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Function SUBs two bitblocks and and tests for any bit. Function does not analyse availability of source blocks.
unsigned | bit_block_or_count (const bm::word_t *src1, const bm::word_t *src1_end, const bm::word_t *src2)
| Function ORs two bitblocks and computes the bitcount. Function does not analyse availability of source blocks.
unsigned | bit_block_or_any (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Function ORs two bitblocks and and tests for any bit. Function does not analyse availability of source blocks.
bm::word_t * | bit_operation_and (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src)
| bitblock AND operation.
bm::id_t | bit_operation_and_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Performs bitblock AND operation and calculates bitcount of the result.
bm::id_t | bit_operation_and_any (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Performs bitblock AND operation test.
bm::id_t | bit_operation_sub_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Performs bitblock SUB operation and calculates bitcount of the result.
bm::id_t | bit_operation_sub_count_inv (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Performs inverted bitblock SUB operation and calculates bitcount of the result.
bm::id_t | bit_operation_sub_any (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Performs bitblock test of SUB operation.
bm::id_t | bit_operation_or_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Performs bitblock OR operation and calculates bitcount of the result.
bm::id_t | bit_operation_or_any (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Performs bitblock OR operation test.
void | bit_block_or (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src)
| Plain bitblock OR operation. Function does not analyse availability of source and destination blocks.
bm::word_t * | bit_operation_or (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src)
| Block OR operation. Makes analysis if block is 0 or FULL.
void | bit_block_sub (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src)
| Plain bitblock SUB (AND NOT) operation. Function does not analyse availability of source and destination blocks.
bm::word_t * | bit_operation_sub (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src)
| bitblock SUB operation.
void | bit_block_xor (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src)
| Plain bitblock XOR operation. Function does not analyse availability of source and destination blocks.
bm::word_t * | bit_operation_xor (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src)
| bitblock XOR operation.
bm::id_t | bit_operation_xor_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Performs bitblock XOR operation and calculates bitcount of the result.
bm::id_t | bit_operation_xor_any (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src1_end, const bm::word_t *BMRESTRICT src2)
| Performs bitblock XOR operation test.
template<class T >
unsigned | bit_count_nonzero_size (const T *blk, unsigned data_size)
| Inspects block for full zero words.
int | bit_find_in_block (const bm::word_t *data, unsigned nbit, bm::id_t *prev)
| Searches for the next 1 bit in the BIT block.
template<typename T , typename F >
void | bit_for_each_4 (T w, F &func)
| Templated algorithm to unpacks octet based word into list of ON bit indexes.
template<typename T , typename F >
void | bit_for_each (T w, F &func)
| Templated algorithm to unpacks word into list of ON bit indexes.
template<typename T , typename B >
unsigned | bit_list_4 (T w, B *bits)
| Unpacks word into list of ON bit indexes (quad-bit based).
template<typename T , typename B >
unsigned | bit_list (T w, B *bits)
| Unpacks word into list of ON bit indexes.
bm::set_representation | best_representation (unsigned bit_count, unsigned total_possible_bitcount, unsigned gap_count, unsigned block_size)
| Choose best representation for a bit-block.
template<typename T >
T | bit_convert_to_arr (T *BMRESTRICT dest, const unsigned *BMRESTRICT src, bm::id_t bits, unsigned dest_len, unsigned mask=0)
| Convert bit block into an array of ints corresponding to 1 bits.
template<typename T >
unsigned | gap_overhead (const T *length, const T *length_end, const T *glevel_len)
| Convert bit block into an array of ints corresponding to 1 bits.
template<typename T >
bool | improve_gap_levels (const T *length, const T *length_end, T *glevel_len)
| Finds optimal gap blocks lengths.
template<class It1 , class It2 , class BinaryOp , class Encoder >
void | bit_recomb (It1 &it1, It2 &it2, BinaryOp &op, Encoder &enc, unsigned block_size=bm::set_block_size)
BMFORCEINLINE void | sse2_xor_arr_2_mask (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end, bm::word_t mask)
| XOR array elements to specified mask dst = *src ^ mask.
BMFORCEINLINE void | sse2_andnot_arr_2_mask (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end, bm::word_t mask)
| Inverts array elements and NOT them to specified mask dst = ~*src & mask.
BMFORCEINLINE void | sse2_and_arr (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end)
| AND array elements against another array dst &= *src.
BMFORCEINLINE void | sse2_or_arr (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end)
| OR array elements against another array dst |= *src.
BMFORCEINLINE void | sse2_xor_arr (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end)
| OR array elements against another array dst ^= *src.
BMFORCEINLINE void | sse2_sub_arr (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end)
| AND-NOT (SUB) array elements against another array dst &= ~*src.
BMFORCEINLINE void | sse2_set_block (__m128i *BMRESTRICT dst, __m128i *BMRESTRICT dst_end, bm::word_t value)
| SSE2 block memset dst = value.
BMFORCEINLINE void | sse2_copy_block (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end)
| SSE2 block copy dst = *src.
BMFORCEINLINE void | sse2_invert_arr (bm::word_t *first, bm::word_t *last)
| Invert array elements dst = ~*dst or dst ^= *dst.
BMFORCEINLINE __m128i | sse2_and (__m128i a, __m128i b)
BMFORCEINLINE __m128i | sse2_or (__m128i a, __m128i b)
BMFORCEINLINE __m128i | sse2_xor (__m128i a, __m128i b)
BMFORCEINLINE __m128i | sse2_sub (__m128i a, __m128i b)
bm::id_t | sse4_bit_count (const __m128i *block, const __m128i *block_end)
BMFORCEINLINE unsigned | op_xor (unsigned a, unsigned b)
BMFORCEINLINE unsigned | op_or (unsigned a, unsigned b)
BMFORCEINLINE unsigned | op_and (unsigned a, unsigned b)
template<class Func >
bm::id_t | sse4_bit_count_op (const __m128i *BMRESTRICT block, const __m128i *BMRESTRICT block_end, const __m128i *BMRESTRICT mask_block, Func sse2_func)
bm::id_t | sse4_bit_block_calc_count_change (const __m128i *BMRESTRICT block, const __m128i *BMRESTRICT block_end, unsigned *BMRESTRICT bit_count)
bm::id_t | sse2_bit_count (const __m128i *block, const __m128i *block_end)
template<class Func >
bm::id_t | sse2_bit_count_op (const __m128i *BMRESTRICT block, const __m128i *BMRESTRICT block_end, const __m128i *BMRESTRICT mask_block, Func sse2_func)
bm::id_t | sse2_bit_block_calc_count_change (const __m128i *BMRESTRICT block, const __m128i *BMRESTRICT block_end, unsigned *BMRESTRICT bit_count)
distance_metric | operation2metric (set_operation op)
| Convert set operation into compatible distance metric.
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)
| Internal function computes different distance metrics.
unsigned | combine_count_and_operation_with_block (const bm::word_t *blk, const bm::word_t *arg_blk)
| Internal function computes AND distance.
void | combine_any_operation_with_block (const bm::word_t *blk, unsigned gap, const bm::word_t *arg_blk, int arg_gap, distance_metric_descriptor *dmit, distance_metric_descriptor *dmit_end)
| Internal function computes different existense of distance metric.
unsigned | combine_count_operation_with_block (const bm::word_t *blk, const bm::word_t *arg_blk, distance_metric metric)
unsigned | combine_any_operation_with_block (const bm::word_t *blk, unsigned gap, const bm::word_t *arg_blk, int arg_gap, distance_metric metric)
void | distance_stage (const distance_metric_descriptor *dmit, const distance_metric_descriptor *dmit_end, bool *is_all_and)
| Staging function for distance operation.
template<class BV >
void | distance_operation (const BV &bv1, const BV &bv2, distance_metric_descriptor *dmit, distance_metric_descriptor *dmit_end)
| Distance computing template function.
template<class BV >
unsigned | distance_and_operation (const BV &bv1, const BV &bv2)
| Distance AND computing template function.
template<class BV >
void | distance_operation_any (const BV &bv1, const BV &bv2, distance_metric_descriptor *dmit, distance_metric_descriptor *dmit_end)
| Distance screening template function.
template<class BV >
bm::id_t | count_and (const BV &bv1, const BV &bv2)
| Computes bitcount of AND operation of two bitsets.
template<class BV >
bm::id_t | any_and (const BV &bv1, const BV &bv2)
| Computes if there is any bit in AND operation of two bitsets.
template<class BV >
bm::id_t | count_xor (const BV &bv1, const BV &bv2)
| Computes bitcount of XOR operation of two bitsets.
template<class BV >
bm::id_t | any_xor (const BV &bv1, const BV &bv2)
| Computes if there is any bit in XOR operation of two bitsets.
template<class BV >
bm::id_t | count_sub (const BV &bv1, const BV &bv2)
| Computes bitcount of SUB operation of two bitsets.
template<class BV >
bm::id_t | any_sub (const BV &bv1, const BV &bv2)
| Computes if there is any bit in SUB operation of two bitsets.
template<class BV >
bm::id_t | count_or (const BV &bv1, const BV &bv2)
| Computes bitcount of OR operation of two bitsets.
template<class BV >
bm::id_t | any_or (const BV &bv1, const BV &bv2)
| Computes if there is any bit in OR operation of two bitsets.
template<class It >
It | block_range_scan (It first, It last, unsigned nblock, unsigned *max_id)
| Internal algorithms scans the input for the block range limit.
template<class BV , class It >
void | combine_or (BV &bv, It first, It last)
| OR Combine bitvector and the iterable sequence.
template<class BV , class It >
void | combine_xor (BV &bv, It first, It last)
| XOR Combine bitvector and the iterable sequence.
template<class BV , class It >
void | combine_sub (BV &bv, It first, It last)
| SUB Combine bitvector and the iterable sequence.
template<class BV , class It >
void | combine_and_sorted (BV &bv, It first, It last)
| AND Combine bitvector and the iterable sequence.
template<class BV , class It >
void | combine_and (BV &bv, It first, It last)
| AND Combine bitvector and the iterable sequence.
template<class BV >
bm::id_t | count_intervals (const BV &bv)
| Compute number of bit intervals (GAPs) in the bitvector.
template<class BV , class It >
void | export_array (BV &bv, It first, It last)
| Export bitset from an array of binary data representing the bit vector.
template<typename T , unsigned BPC, unsigned BPS>
void | vect_bit_transpose (const T *arr, unsigned arr_size, T tmatrix[BPC][BPS])
| Generic bit-array transposition function T - array type (any int) BPC - bit plain count BPS - bit plain size.
template<typename T , unsigned BPC, unsigned BPS>
void | vect_bit_trestore (const T tmatrix[BPC][BPS], T *arr)
| Restore bit array from the transposition matrix T - array type (any int) BPC - bit plain count BPS - bit plain size.
template<typename T , unsigned BPC, unsigned BPS>
void | tmatrix_distance (const T tmatrix[BPC][BPS], unsigned distance[BPC][BPC])
| Compute pairwise Row x Row Humming distances on plains(rows) of the transposed bit block.
template<typename T , unsigned BPC, unsigned BPS>
void | bit_iblock_make_pcv (const unsigned distance[BPC][BPC], unsigned char *pc_vector)
| !< ibpc limiter
void | bit_iblock_pcv_stat (const unsigned char *BMRESTRICT pc_vector, const unsigned char *BMRESTRICT pc_vector_end, unsigned *BMRESTRICT pc_vector_stat)
| Compute number of ibpc codes in pc_vector.
void | bit_iblock_reduce (const unsigned tmatrix[bm::set_block_plain_cnt][bm::set_block_plain_size], const unsigned char *BMRESTRICT pc_vector, const unsigned char *BMRESTRICT pc_vector_end, unsigned tmatrix_out[bm::set_block_plain_cnt][bm::set_block_plain_size])
| Matrix reduction based on transformation pc vector.
template<class TMatrix >
void | tmatrix_reduce (TMatrix &tmatrix, const unsigned char *pc_vector, const unsigned effective_cols)
| Transposed Matrix reduction based on transformation pc vector.
template<class TMatrix >
void | tmatrix_restore (TMatrix &tmatrix, const unsigned char *pc_vector, const unsigned effective_cols)
| Transposed Matrix restore based on transformation pc vector.
template<typename GT >
void | gap_2_bitblock (const GT *BMRESTRICT gap_buf, GT *BMRESTRICT block, unsigned block_size)
| Copy GAP block body to bit block with DGap transformation.
template<class TMatrix >
void | compute_tmatrix_rstat (const TMatrix &tmatrix, const unsigned char *pc_vector, typename TMatrix::rstat *rstat, unsigned effective_cols)
| Compute t-matrix rows statistics used for compression.
template<typename TM >
unsigned | find_effective_columns (const TM &tmatrix)
| Compute effective right column border of the t-matrix.
template<typename T >
T | bit_scan_fwd (T v)
template<typename T >
T | min_value (T v1, T v2)
| Get minimum of 2 values.
template<typename T >
T | ilog2 (T x)
| Fast loop-less function to find LOG2.
template<>
bm::gap_word_t | ilog2 (gap_word_t x)
template<typename T >
T | ilog2_LUT (T x)
| Lookup table based integer LOG2.
template<>
bm::gap_word_t | ilog2_LUT< bm::gap_word_t > (bm::gap_word_t x)
| Lookup table based short integer LOG2.
template<class BV >
unsigned | serialize (const BV &bv, unsigned char *buf, bm::word_t *temp_block, unsigned serialization_flags=0)
| Saves bitvector into memory.
template<class BV >
unsigned | serialize (BV &bv, unsigned char *buf, unsigned serialization_flags=0)
| Saves bitvector into memory. Allocates temporary memory block for bvector.
template<class BV >
unsigned | deserialize (BV &bv, const unsigned char *buf, bm::word_t *temp_block=0)
| Bitvector deserialization from memory.

## Variables

const unsigned | id_max = 0xFFFFFFFF
const unsigned | set_block_size = 2048u
const unsigned | set_block_shift = 16u
const unsigned | set_block_mask = 0xFFFFu
const unsigned | set_blkblk_mask = 0xFFFFFFu
const unsigned | set_block_plain_size = set_block_size / 32u
const unsigned | set_block_plain_cnt = sizeof(bm::word_t) * 8u
const unsigned | set_word_shift = 5u
const unsigned | set_word_mask = 0x1Fu
const unsigned | gap_max_buff_len = 1280
const unsigned | gap_length_threashold = set_block_size * 3
const unsigned | gap_max_bits = 65536
const unsigned | gap_equiv_len
const unsigned | gap_levels = 4
const unsigned | gap_max_level = bm::gap_levels - 1
const unsigned | set_array_size = 256u
const unsigned | set_array_shift = 8u
const unsigned | set_array_mask = 0xFFu
const unsigned | set_total_blocks = (bm::set_array_size * bm::set_array_size)
const unsigned | bits_in_block = bm::set_block_size * sizeof(bm::word_t) * 8
const unsigned | bits_in_array = bm::bits_in_block * bm::set_array_size
const word_t | all_bits_mask = 0xffffffff
const unsigned | set_block_size_op = bm::set_block_size
const unsigned char | ibpc_uncompr = 0
const unsigned char | ibpc_all_zero = 1
| !< plain uncompressed
const unsigned char | ibpc_all_one = 2
| !< plain ALL ZERO
const unsigned char | ibpc_equiv = 3
| !< plain ALL ONE
const unsigned char | ibpc_close = 4
| !< plain is equal to plain M
const unsigned char | ibpc_end = 8
| !< plain is close to plain M
const unsigned char | set_block_end = 0
| End of serialization.
const unsigned char | set_block_1zero = 1
| One all-zero block.
const unsigned char | set_block_1one = 2
| One block all-set (1111...).
const unsigned char | set_block_8zero = 3
| Up to 256 zero blocks.
const unsigned char | set_block_8one = 4
| Up to 256 all-set blocks.
const unsigned char | set_block_16zero = 5
| Up to 65536 zero blocks.
const unsigned char | set_block_16one = 6
| UP to 65536 all-set blocks.
const unsigned char | set_block_32zero = 7
| Up to 4G zero blocks.
const unsigned char | set_block_32one = 8
| UP to 4G all-set blocks.
const unsigned char | set_block_azero = 9
| All other blocks zero.
const unsigned char | set_block_aone = 10
| All other blocks one.
const unsigned char | set_block_bit = 11
| Plain bit block.
const unsigned char | set_block_sgapbit = 12
| SGAP compressed bitblock.
const unsigned char | set_block_sgapgap = 13
| SGAP compressed GAP block.
const unsigned char | set_block_gap = 14
| Plain GAP block.
const unsigned char | set_block_gapbit = 15
| GAP compressed bitblock.
const unsigned char | set_block_arrbit = 16
| List of bits ON.
const unsigned char | set_block_bit_interval = 17
| Interval block.
const unsigned char | set_block_arrgap = 18
| List of bits ON (GAP block).
const unsigned char | set_block_bit_1bit = 19
| Bit block with 1 bit ON.
const unsigned char | set_block_gap_egamma = 20
| Gamma compressed GAP block.
const unsigned char | set_block_arrgap_egamma = 21
| Gamma compressed delta GAP array.
const unsigned char | set_block_bit_0runs = 22
| Bit block with encoded zero intervals.
const unsigned char | set_block_arrgap_egamma_inv = 23
| Gamma compressed inverted delta GAP array.
const unsigned char | set_block_arrgap_inv = 24
| List of bits OFF (GAP block).

## Typedef Documentation

typedef bm::id_t(* bm::bit_operation_count_func_type)(const bm::word_t *BMRESTRICT, const bm::word_t *BMRESTRICT, const bm::word_t *BMRESTRICT)

Definition at line 5197 of file bmfunc.h.

typedef decoder bm::decoder_big_endian

Class for decoding data from memory buffer.

Properly handles aligment issues with integer data types. Converts data to big endian architecture (presumed it was encoded as little endian)

Definition at line 114 of file encoding.h.

typedef gap_word_t*(* bm::gap_operation_func_type)(const gap_word_t *BMRESTRICT, const gap_word_t *BMRESTRICT, gap_word_t *BMRESTRICT, unsigned &)

Definition at line 5191 of file bmfunc.h.

typedef void(* bm::gap_operation_to_bitset_func_type)(unsigned *, const gap_word_t *)

Definition at line 5187 of file bmfunc.h.

typedef unsigned short bm::gap_word_t

Definition at line 68 of file bmconst.h.

typedef unsigned long long bm::id64_t

Definition at line 38 of file bmconst.h.

typedef unsigned int bm::id_t

Definition at line 42 of file bmconst.h.

typedef unsigned short bm::short_t

Definition at line 44 of file bmconst.h.

typedef unsigned int bm::word_t

Examples:
  sample6.cpp.

Definition at line 43 of file bmconst.h.

typedef word_t bm::wordop_t

Definition at line 101 of file bmconst.h.

## Enumeration Type Documentation

enum bm::ByteOrder

Byte orders recognized by the library.

Enumerator:

  BigEndian |
  LittleEndian |

Definition at line 397 of file bmfunc.h.

enum bm::operation

Bit operations enumeration.

Enumerator:

  BM_AND |
  BM_OR |
  BM_SUB |
  BM_XOR |

Definition at line 274 of file bmfunc.h.

enum bm::serialization_header_mask

Enumerator:

  BM_HM_DEFAULT |
  BM_HM_RESIZE | resized vector
  BM_HM_ID_LIST | id list stored
  BM_HM_NO_BO | no byte-order
  BM_HM_NO_GAPL | no GAP levels

Definition at line 96 of file bmserial.h.

enum bm::set_operation

Nomenclature of set operations.

Enumerator:

  set_AND |
  set_OR |
  set_SUB |
  set_XOR |
  set_ASSIGN |
  set_COUNT |
  set_COUNT_AND |
  set_COUNT_XOR |
  set_COUNT_OR |
  set_COUNT_SUB_AB |
  set_COUNT_SUB_BA |
  set_COUNT_A |
  set_COUNT_B |
  set_END |

Definition at line 245 of file bmfunc.h.

enum bm::set_representation

set representation variants

Enumerator:

  set_bitset | Simple bitset.
  set_gap | GAP-RLE compression.
  set_array1 | array of set 1 values
  set_array0 | array of 0 values

Definition at line 126 of file bmconst.h.

## Function Documentation

BMFORCEINLINE unsigned bm::and_op | ( | unsigned | v1,
|  | unsigned | v2 |
| ) |  |  |

GAP and functor.

Definition at line 3143 of file bmfunc.h.

Referenced by gap_count_and(), gap_operation_and(), gap_operation_any_and(), gap_operation_any_sub(), gap_operation_or(), and gap_operation_sub().

void bm::bit_count_change32 | ( | const bm::word_t * | block,
|  | const bm::word_t * | block_end,
|  | unsigned * | bit_count,
|  | unsigned * | gap_count |
| ) |  |  | `[inline]`

Function calculates number of times when bit value changed

Definition at line 2802 of file bmfunc.h.

References BM_ASSERT, and BM_INCWORD_BITCOUNT.

Referenced by bit_block_calc_count_change(), and compute_tmatrix_rstat().

void bm::bit_iblock_pcv_stat | ( | const unsigned char *BMRESTRICT | pc_vector,
|  | const unsigned char *BMRESTRICT | pc_vector_end,
|  | unsigned *BMRESTRICT | pc_vector_stat |
| ) |  |  | `[inline]`

Compute number of ibpc codes in pc_vector.

Definition at line 478 of file bmtrans.h.

References BM_ASSERT.

Referenced by bm::gap_transpose_engine< GT, BT, BLOCK_SIZE >::compute_distance_matrix().

void bm::bit_iblock_reduce | ( | const unsigned | tmatrix[bm::set_block_plain_cnt][bm::set_block_plain_size],
|  | const unsigned char *BMRESTRICT | pc_vector,
|  | const unsigned char *BMRESTRICT | pc_vector_end,
|  | unsigned | tmatrix_out[bm::set_block_plain_cnt][bm::set_block_plain_size] |
| ) |  |  | `[inline]`

Matrix reduction based on transformation pc vector.

Definition at line 498 of file bmtrans.h.

References BM_ASSERT, ibpc_all_one, ibpc_all_zero, ibpc_close, ibpc_equiv, and ibpc_uncompr.

template<class It1 , class It2 , class BinaryOp , class Encoder >

void bm::bit_recomb | ( | It1 & | it1,
|  | It2 & | it2,
|  | BinaryOp & | op,
|  | Encoder & | enc,
|  | unsigned | block_size = `bm::set_block_size` |
| ) |  |  | `[inline]`

Abstract recombination algorithm for two bit-blocks Bit blocks can come as dserialization decoders or bit-streams

Definition at line 5053 of file bmfunc.h.

Referenced by bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_AB(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_BA(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_XOR(), and bm::serial_stream_iterator< DEC >::get_bit_block_OR().

template<typename T >

T bm::bit_scan_fwd | ( | T | v | ) | `[inline]`

Definition at line 58 of file bmutil.h.

Referenced by bm::bit_in< TDecoder >::gamma().

template<class It >

It bm::block_range_scan | ( | It | first,
|  | It | last,
|  | unsigned | nblock,
|  | unsigned * | max_id |
| ) |  |  | `[inline]`

Internal algorithms scans the input for the block range limit.

Definition at line 1111 of file bmalgo_impl.h.

References BM_ASSERT, id_max, and set_block_shift.

Referenced by combine_or(), combine_sub(), and combine_xor().

template<class T , class F >

F bm::bmfor_each | ( | T | first,
|  | T | last,
|  | F | f |
| ) |  |  | `[inline]`

Special BM optimized analog of STL for_each

Definition at line 646 of file bmfunc.h.

unsigned bm::combine_any_operation_with_block | ( | const bm::word_t * | blk,
|  | unsigned | gap,
|  | const bm::word_t * | arg_blk,
|  | int | arg_gap,
|  | distance_metric | metric |
| ) |  |  | `[inline]`

Convenience internal function to compute combine any for one metric

Definition at line 638 of file bmalgo_impl.h.

References combine_any_operation_with_block(), and bm::distance_metric_descriptor::result.

void bm::combine_any_operation_with_block | ( | const bm::word_t * | blk,
|  | unsigned | gap,
|  | const bm::word_t * | arg_blk,
|  | int | arg_gap,
|  | distance_metric_descriptor * | dmit,
|  | distance_metric_descriptor * | dmit_end |
| ) |  |  | `[inline]`

Internal function computes different existense of distance metric.

Definition at line 366 of file bmalgo_impl.h.

References bit_is_all_zero(), bit_operation_and_any(), bit_operation_or_any(), bit_operation_sub_any(), bit_operation_xor_any(), BM_ALIGN16ATTR, BMGAP_PTR, COUNT_A, COUNT_AND, COUNT_B, COUNT_OR, COUNT_SUB_AB, COUNT_SUB_BA, COUNT_XOR, gap_bitset_and_any(), gap_bitset_or_any(), gap_bitset_sub_any(), gap_bitset_xor_any(), gap_convert_to_bitset(), gap_is_all_zero(), gap_max_bits, gap_max_buff_len, gap_operation_any_and(), gap_operation_any_sub(), gap_operation_any_xor(), gap_operation_or(), bm::distance_metric_descriptor::metric, bm::distance_metric_descriptor::result, and set_block_size.

Referenced by combine_any_operation_with_block(), and distance_operation_any().

unsigned bm::combine_count_and_operation_with_block | ( | const bm::word_t * | blk,
|  | const bm::word_t * | arg_blk |
| ) |  |  | `[inline]`

Internal function computes AND distance.

Definition at line 329 of file bmalgo_impl.h.

References bit_operation_and_count(), BM_IS_GAP, BMGAP_PTR, gap_bitset_and_count(), gap_count_and(), and set_block_size.

Referenced by distance_and_operation().

unsigned bm::combine_count_operation_with_block | ( | const bm::word_t * | blk,
|  | const bm::word_t * | arg_blk,
|  | distance_metric | metric |
| ) |  |  | `[inline]`

Convenience internal function to compute combine count for one metric

Definition at line 619 of file bmalgo_impl.h.

References combine_count_operation_with_block(), and bm::distance_metric_descriptor::result.

void bm::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 |
| ) |  |  | `[inline]`

Internal function computes different distance metrics.

Definition at line 116 of file bmalgo_impl.h.

References bit_block_calc_count(), bm::operation_functions< T >::bit_operation_count(), bit_operation_sub_count(), BM_ALIGN16ATTR, BM_ASSERT, BM_IS_GAP, BMGAP_PTR, COUNT_A, COUNT_AND, COUNT_B, COUNT_OR, COUNT_SUB_AB, COUNT_SUB_BA, COUNT_XOR, gap_bit_count(), gap_bitset_and_count(), gap_bitset_or_count(), gap_bitset_sub_count(), gap_bitset_xor_count(), gap_convert_to_bitset(), gap_count_and(), gap_count_or(), gap_count_sub(), gap_count_xor(), bm::distance_metric_descriptor::metric, bm::distance_metric_descriptor::result, and set_block_size.

Referenced by combine_count_operation_with_block(), bm::iterator_deserializer< BV, SerialIterator >::deserialize(), and distance_operation().

template<class TMatrix >

void bm::compute_tmatrix_rstat | ( | const TMatrix & | tmatrix,
|  | const unsigned char * | pc_vector,
|  | typename TMatrix::rstat * | rstat,
|  | unsigned | effective_cols |
| ) |  |  | `[inline]`

Compute t-matrix rows statistics used for compression.

Parameters:

  | tmatrix | - transposed matrix
  | pc_vector | - row content vector
  | rstat | - output row vector

Definition at line 687 of file bmtrans.h.

References best_representation(), bit_count_change32(), BM_ASSERT, ibpc_all_one, ibpc_all_zero, ibpc_close, ibpc_equiv, ibpc_uncompr, and set_bitset.

Referenced by bm::gap_transpose_engine< GT, BT, BLOCK_SIZE >::reduce().

template<typename T >

void bm::dgap_2_gap | ( | const T * | dgap_buf,
|  | T * | gap_buf,
|  | T | gap_header = `0` |
| ) |  |  | `[inline]`

Convert D-GAP buffer into GAP buffer.

GAP representation is GAP[N] = DGAP[N] + DGAP[N-1]

Parameters:

  | dgap_buf | - Delta-GAP buffer
  | gap_buf | - GAP buffer

Definition at line 826 of file bmfunc.h.

void bm::distance_stage | ( | const distance_metric_descriptor * | dmit,
|  | const distance_metric_descriptor * | dmit_end,
|  | bool * | is_all_and |
| ) |  |  | `[inline]`

Staging function for distance operation.

Returns:
  temp block allocated (or NULL)

Definition at line 659 of file bmalgo_impl.h.

References COUNT_AND.

Referenced by distance_operation(), and distance_operation_any().

template<typename TM >

unsigned bm::find_effective_columns | ( | const TM & | tmatrix | ) | `[inline]`

Compute effective right column border of the t-matrix.

Definition at line 745 of file bmtrans.h.

Referenced by bm::gap_transpose_engine< GT, BT, BLOCK_SIZE >::transpose().

template<class T , class F >

void bm::for_each_block | ( | T *** | root,
|  | unsigned | size1,
|  | F & | f |
| ) |  |  | `[inline]`

For each block executes supplied function.

Definition at line 617 of file bmfunc.h.

References set_array_size.

Referenced by count_intervals(), and bm::bvector< Alloc >::invert().

template<class T , class Func >

void bm::for_each_dgap | ( | const T * | gap_buf,
|  | Func & | func |
| ) |  |  | `[inline]`

D-GAP block for_each algorithm

D-Gap Functor is called for each element but last one.

Parameters:

  | gap_buf | - GAP buffer

Definition at line 761 of file bmfunc.h.

Referenced by bm::serializer< BV >::gamma_gap_block().

template<class T , class F >

void bm::for_each_nzblock | ( | T *** | root,
|  | unsigned | size1,
|  | F & | f |
| ) |  |  | `[inline]`

For each non-zero block executes supplied function.

Definition at line 528 of file bmfunc.h.

References set_array_size.

Referenced by bm::bvector< Alloc >::count_blocks(), bm::bvector< Alloc >::optimize(), and bm::bvector< Alloc >::set_gap_levels().

template<class T , class F >

void bm::for_each_nzblock2 | ( | T *** | root,
|  | unsigned | size1,
|  | F & | f |
| ) |  |  | `[inline]`

For each non-zero block executes supplied function.

Definition at line 564 of file bmfunc.h.

References set_array_size.

Referenced by bm::bvector< Alloc >::count().

template<class T , class F >

bool bm::for_each_nzblock_if | ( | T *** | root,
|  | unsigned | size1,
|  | F & | f |
| ) |  |  | `[inline]`

For each non-zero block executes supplied function-predicate. Function returns if function-predicate returns true

Definition at line 593 of file bmfunc.h.

References set_array_size.

Referenced by bm::bvector< Alloc >::any().

template<typename GT >

void bm::gap_2_bitblock | ( | const GT *BMRESTRICT | gap_buf,
|  | GT *BMRESTRICT | block,
|  | unsigned | block_size |
| ) |  |  | `[inline]`

Copy GAP block body to bit block with DGap transformation.

Definition at line 660 of file bmtrans.h.

Referenced by bm::gap_transpose_engine< GT, BT, BLOCK_SIZE >::transpose().

template<typename T >

T* bm::gap_2_dgap | ( | const T * | gap_buf,
|  | T * | dgap_buf,
|  | bool | copy_head = `true` |
| ) |  |  | `[inline]`

Convert GAP buffer into D-GAP buffer.

Delta GAP representation is DGAP[N] = GAP[N] - GAP[N-1]

Parameters:

  | gap_buf | - GAP buffer
  | dgap_buf | - Delta-GAP buffer
  | copy_head | - flag to copy GAP header

Definition at line 802 of file bmfunc.h.

References bm::d_copy_func< T >::dgap_buf_.

template<typename T >

unsigned bm::gap_bfind | ( | const T * | buf,
|  | unsigned | pos,
|  | unsigned * | is_set |
| ) |  |  | `[inline]`

Definition at line 461 of file bmfunc.h.

References BM_ASSERT, and gap_max_bits.

Referenced by gap_bit_count_range(), gap_find_in_block(), and gap_set_value().

template<typename T >

unsigned bm::gap_bit_count_range | ( | const T * | buf,
|  | T | left,
|  | T | right |
| ) |  |  | `[inline]`

Counts 1 bits in GAP buffer in the closed [left, right] diapason.

Parameters:

  | buf | - GAP buffer pointer.
  | left | - leftmost bit index to start from
  | right- | rightmost bit index

Returns:
  Number of non-zero bits.

Definition at line 714 of file bmfunc.h.

References BM_ASSERT, and gap_bfind().

Referenced by bm::bvector< Alloc >::count_range().

template<typename T , class F >

void bm::gap_buff_op | ( | T *BMRESTRICT | dest,
|  | const T *BMRESTRICT | vect1,
|  | unsigned | vect1_mask,
|  | const T *BMRESTRICT | vect2,
|  | unsigned | vect2_mask,
|  | F & | f,
|  | unsigned & | dlen |
| ) |  |  | `[inline]`

Abstract operation for GAP buffers. Receives functor F as a template argument.

Parameters:

  | dest | - destination memory buffer.
  | vect1 | - operand 1 GAP encoded buffer.
  | vect1_mask | - XOR mask for starting bitflag for vector1 can be 0 or 1 (1 inverts the vector)
  | vect2 | - operand 2 GAP encoded buffer.
  | vect2_mask | - same as vect1_mask
  | f | - operation functor.
  | dlen | - destination length after the operation

Note:
  Internal function.

Definition at line 933 of file bmfunc.h.

References gap_max_bits.

Referenced by gap_operation_and(), gap_operation_or(), gap_operation_sub(), and gap_operation_xor().

template<>

bm::gap_word_t bm::ilog2 | ( | gap_word_t | x | ) | `[inline]`

Definition at line 90 of file bmutil.h.

template<typename T >

T bm::ilog2 | ( | T | x | ) | `[inline]`

Fast loop-less function to find LOG2.

Definition at line 78 of file bmutil.h.

template<typename T >

T bm::ilog2_LUT | ( | T | x | ) | `[inline]`

Lookup table based integer LOG2.

Definition at line 121 of file bmutil.h.

Referenced by bm::bit_out< TEncoder >::gamma().

template<>

bm::gap_word_t bm::ilog2_LUT< bm::gap_word_t > | ( | bm::gap_word_t | x | ) | `[inline]`

Lookup table based short integer LOG2.

bool bm::is_const_set_operation | ( | set_operation | op | ) | `[inline]`

Returns true if set operation is constant (bitcount).

Definition at line 266 of file bmfunc.h.

References set_COUNT.

Referenced by bm::iterator_deserializer< BV, SerialIterator >::deserialize(), and operation2metric().

template<typename T >

T bm::min_value | ( | T | v1,
|  | T | v2 |
| ) |  |  | `[inline]`

Get minimum of 2 values.

Definition at line 68 of file bmutil.h.

Referenced by distance_and_operation().

BMFORCEINLINE unsigned bm::op_and | ( | unsigned | a,
|  | unsigned | b |
| ) |  |  |

Definition at line 108 of file bmsse4.h.

BMFORCEINLINE unsigned bm::op_or | ( | unsigned | a,
|  | unsigned | b |
| ) |  |  |

Definition at line 99 of file bmsse4.h.

BMFORCEINLINE unsigned bm::op_xor | ( | unsigned | a,
|  | unsigned | b |
| ) |  |  |

Definition at line 89 of file bmsse4.h.

template<class Alloc >

bvector<Alloc> bm::operator& | ( | const bvector< Alloc > & | v1,
|  | const bvector< Alloc > & | v2 |
| ) |  |  | `[inline]`

Definition at line 1561 of file bm.h.

References bm::bvector< Alloc >::bit_and().

template<class Alloc >

bvector<Alloc> bm::operator- | ( | const bvector< Alloc > & | v1,
|  | const bvector< Alloc > & | v2 |
| ) |  |  | `[inline]`

Definition at line 1606 of file bm.h.

References bm::bvector< Alloc >::bit_sub().

template<class Alloc >

bvector<Alloc> bm::operator^ | ( | const bvector< Alloc > & | v1,
|  | const bvector< Alloc > & | v2 |
| ) |  |  | `[inline]`

Definition at line 1591 of file bm.h.

References bm::bvector< Alloc >::bit_xor().

template<class Alloc >

bvector<Alloc> bm::operator| | ( | const bvector< Alloc > & | v1,
|  | const bvector< Alloc > & | v2 |
| ) |  |  | `[inline]`

Definition at line 1576 of file bm.h.

References bm::bvector< Alloc >::bit_or().

BMFORCEINLINE unsigned bm::or_op | ( | unsigned | v1,
|  | unsigned | v2 |
| ) |  |  |

GAP or functor.

Definition at line 3157 of file bmfunc.h.

Referenced by gap_count_or().

int bm::parallel_popcnt_32 | ( | unsigned int | n | ) | `[inline]`

Definition at line 179 of file bmfunc.h.

bm::operation bm::setop2op | ( | bm::set_operation | op | ) | `[inline]`

Convert set operation to operation.

Definition at line 286 of file bmfunc.h.

References BM_ASSERT, set_AND, set_OR, set_SUB, and set_XOR.

Referenced by bm::iterator_deserializer< BV, SerialIterator >::deserialize().

BMFORCEINLINE __m128i bm::sse2_and | ( | __m128i | a,
|  | __m128i | b |
| ) |  |  |

Definition at line 384 of file bmsse_util.h.

bm::id_t bm::sse2_bit_block_calc_count_change | ( | const __m128i *BMRESTRICT | block,
|  | const __m128i *BMRESTRICT | block_end,
|  | unsigned *BMRESTRICT | bit_count |
| ) |  |  | `[inline]`

Definition at line 237 of file bmsse2.h.

References BM_ALIGN16ATTR, and BM_INCWORD_BITCOUNT.

Referenced by bit_block_calc_count_change().

template<class Func >

bm::id_t bm::sse2_bit_count_op | ( | const __m128i *BMRESTRICT | block,
|  | const __m128i *BMRESTRICT | block_end,
|  | const __m128i *BMRESTRICT | mask_block,
|  | Func | sse2_func |
| ) |  |  | `[inline]`

Definition at line 125 of file bmsse2.h.

References BM_ALIGN16ATTR.

BMFORCEINLINE __m128i bm::sse2_or | ( | __m128i | a,
|  | __m128i | b |
| ) |  |  |

Definition at line 390 of file bmsse_util.h.

BMFORCEINLINE __m128i bm::sse2_sub | ( | __m128i | a,
|  | __m128i | b |
| ) |  |  |

Definition at line 403 of file bmsse_util.h.

BMFORCEINLINE __m128i bm::sse2_xor | ( | __m128i | a,
|  | __m128i | b |
| ) |  |  |

Definition at line 397 of file bmsse_util.h.

template<class Func >

bm::id_t bm::sse4_bit_count_op | ( | const __m128i *BMRESTRICT | block,
|  | const __m128i *BMRESTRICT | block_end,
|  | const __m128i *BMRESTRICT | mask_block,
|  | Func | sse2_func |
| ) |  |  | `[inline]`

Definition at line 115 of file bmsse4.h.

BMFORCEINLINE unsigned bm::sub_op | ( | unsigned | v1,
|  | unsigned | v2 |
| ) |  |  |

GAP or functor.

Definition at line 3163 of file bmfunc.h.

Referenced by gap_count_sub().

template<class T >

T bm::sum_arr | ( | T * | first,
|  | T * | last |
| ) |  |  | `[inline]`

Computes SUM of all elements of the sequence

Definition at line 658 of file bmfunc.h.

template<class TMatrix >

void bm::tmatrix_reduce | ( | TMatrix & | tmatrix,
|  | const unsigned char * | pc_vector,
|  | const unsigned | effective_cols |
| ) |  |  | `[inline]`

Transposed Matrix reduction based on transformation pc vector.

Definition at line 554 of file bmtrans.h.

References BM_ASSERT, ibpc_all_one, ibpc_all_zero, ibpc_close, ibpc_equiv, and ibpc_uncompr.

Referenced by bm::gap_transpose_engine< GT, BT, BLOCK_SIZE >::reduce().

template<class TMatrix >

void bm::tmatrix_restore | ( | TMatrix & | tmatrix,
|  | const unsigned char * | pc_vector,
|  | const unsigned | effective_cols |
| ) |  |  | `[inline]`

Transposed Matrix restore based on transformation pc vector.

Definition at line 601 of file bmtrans.h.

References BM_ASSERT, ibpc_all_one, ibpc_all_zero, ibpc_close, ibpc_equiv, and ibpc_uncompr.

Referenced by bm::gap_transpose_engine< GT, BT, BLOCK_SIZE >::restore().

template<typename T , unsigned BPC, unsigned BPS>

void bm::vect_bit_transpose | ( | const T * | arr,
|  | unsigned | arr_size,
|  | T | tmatrix[BPC][BPS] |
| ) |  |  | `[inline]`

Generic bit-array transposition function T - array type (any int) BPC - bit plain count BPS - bit plain size.

Parameters:

  | arr | - source array start
  | arr_size | - source array size
  | tmatrix | - destination bit matrix

Definition at line 294 of file bmtrans.h.

References BM_ASSERT.

template<typename T , unsigned BPC, unsigned BPS>

void bm::vect_bit_trestore | ( | const T | tmatrix[BPC][BPS],
|  | T * | arr |
| ) |  |  | `[inline]`

Restore bit array from the transposition matrix T - array type (any int) BPC - bit plain count BPS - bit plain size.

Parameters:

  | arr | - dest array
  | tmatrix | - source bit-slice matrix

Definition at line 327 of file bmtrans.h.

BMFORCEINLINE unsigned bm::xor_op | ( | unsigned | v1,
|  | unsigned | v2 |
| ) |  |  |

GAP xor functor.

Definition at line 3150 of file bmfunc.h.

Referenced by gap_count_xor(), gap_operation_any_xor(), and gap_operation_xor().

template<typename W >

void bm::xor_swap | ( | W & | x,
|  | W & | y |
| ) |  |  | `[inline]`

XOR swap two scalar variables.

Definition at line 321 of file bmfunc.h.

References BM_ASSERT.

Referenced by bm::bvector< Alloc >::swap().

## Variable Documentation

const word_t bm::all_bits_mask = 0xffffffff

Definition at line 102 of file bmconst.h.

Referenced by is_bits_one().

const unsigned bm::bits_in_array = bm::bits_in_block * bm::set_array_size

Definition at line 87 of file bmconst.h.

Referenced by bm::bvector< Alloc >::enumerator::go_first(), and bm::bvector< Alloc >::enumerator::go_up().

const unsigned bm::bits_in_block = bm::set_block_size * sizeof(bm::word_t) * 8

Definition at line 86 of file bmconst.h.

Referenced by bm::bvector< Alloc >::count_range(), bm::iterator_deserializer< BV, SerialIterator >::deserialize(), bm::deserializer< BV, DEC >::deserialize(), bm::bvector< Alloc >::enumerator::go_first(), and bm::bvector< Alloc >::enumerator::go_up().

const unsigned bm::gap_equiv_len

Initial value:

       (sizeof(bm::word_t) * bm::set_block_size) / sizeof(gap_word_t)

Definition at line 73 of file bmconst.h.

Referenced by bm::iterator_deserializer< BV, SerialIterator >::deserialize(), bm::serializer< BV >::encode_gap_block(), and bm::serializer< BV >::serialize().

const unsigned bm::gap_length_threashold = set_block_size * 3

Definition at line 71 of file bmconst.h.

Referenced by bm::deserializer< BV, DEC >::deserialize_gap().

const unsigned bm::gap_levels = 4

Definition at line 75 of file bmconst.h.

Referenced by bm::mem_alloc< BA, PA >::alloc_gap_block(), bm::bvector< Alloc >::calc_stat(), bm::deserializer< BV, DEC >::deserialize(), bm::serializer< BV >::encode_header(), gap_calc_level(), gap_overhead(), improve_gap_levels(), bm::bvector< Alloc >::optimize(), bm::bvector< Alloc >::optimize_gap_size(), bm::serial_stream_iterator< DEC >::serial_stream_iterator(), and set_gap_level().

const unsigned bm::gap_max_bits = 65536

Definition at line 72 of file bmconst.h.

Referenced by combine_any_operation_with_block(), bm::bvector< Alloc >::compare(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::encode_gap_block(), gap_add_value(), gap_bfind(), gap_buff_any_op(), gap_buff_count_op(), gap_buff_op(), gap_find_in_block(), gap_set_array(), gap_set_value(), gap_test(), bm::bvector< Alloc >::enumerator::go_up(), bm::deseriaizer_base< DEC >::read_gap_block(), and bm::serializer< BV >::serialize().

const unsigned bm::gap_max_buff_len = 1280

Definition at line 70 of file bmconst.h.

Referenced by combine_any_operation_with_block(), and improve_gap_levels().

const unsigned bm::gap_max_level = bm::gap_levels - 1

Definition at line 76 of file bmconst.h.

const unsigned char bm::ibpc_all_one = 2

!< plain ALL ZERO

Definition at line 390 of file bmtrans.h.

Referenced by bit_iblock_make_pcv(), bit_iblock_reduce(), compute_tmatrix_rstat(), tmatrix_reduce(), and tmatrix_restore().

const unsigned char bm::ibpc_all_zero = 1

!< plain uncompressed

Definition at line 389 of file bmtrans.h.

Referenced by bit_iblock_make_pcv(), bit_iblock_reduce(), compute_tmatrix_rstat(), tmatrix_reduce(), and tmatrix_restore().

const unsigned char bm::ibpc_close = 4

!< plain is equal to plain M

Definition at line 392 of file bmtrans.h.

Referenced by bit_iblock_make_pcv(), bit_iblock_reduce(), compute_tmatrix_rstat(), tmatrix_reduce(), and tmatrix_restore().

const unsigned char bm::ibpc_end = 8

!< plain is close to plain M

Definition at line 394 of file bmtrans.h.

const unsigned char bm::ibpc_equiv = 3

!< plain ALL ONE

Definition at line 391 of file bmtrans.h.

Referenced by bit_iblock_make_pcv(), bit_iblock_reduce(), compute_tmatrix_rstat(), tmatrix_reduce(), and tmatrix_restore().

const unsigned char bm::ibpc_uncompr = 0

Definition at line 388 of file bmtrans.h.

Referenced by bit_iblock_make_pcv(), bit_iblock_reduce(), compute_tmatrix_rstat(), tmatrix_reduce(), and tmatrix_restore().

const unsigned bm::id_max = 0xFFFFFFFF

Definition at line 48 of file bmconst.h.

Referenced by block_range_scan(), combine_or(), combine_sub(), combine_xor(), bm::serializer< BV >::encode_header(), bm::bvector< Alloc >::extract_next(), bm::bvector< Alloc >::get_next(), bm::bvector< Alloc >::iterator_base::invalidate(), bm::bvector< Alloc >::invert(), bm::bvector< Alloc >::insert_iterator::operator=(), and bm::bvector< Alloc >::iterator_base::valid().

const unsigned bm::set_array_mask = 0xFFu

Definition at line 83 of file bmconst.h.

Referenced by bm::bvector< Alloc >::enumerator::go_up().

const unsigned bm::set_array_shift = 8u

Definition at line 82 of file bmconst.h.

Referenced by bm::iterator_deserializer< BV, SerialIterator >::deserialize(), and bm::bvector< Alloc >::enumerator::go_up().

const unsigned bm::set_array_size = 256u

Definition at line 81 of file bmconst.h.

Referenced by bm::bvector< Alloc >::calc_stat(), bm::bvector< Alloc >::combine_operation(), bm::bvector< Alloc >::compare(), distance_and_operation(), distance_operation(), distance_operation_any(), for_each_block(), for_each_nzblock(), for_each_nzblock2(), for_each_nzblock_if(), bm::bvector< Alloc >::enumerator::go_first(), and bm::bvector< Alloc >::enumerator::go_up().

const unsigned bm::set_blkblk_mask = 0xFFFFFFu

Definition at line 55 of file bmconst.h.

const unsigned char bm::set_block_16one = 6

UP to 65536 all-set blocks.

Definition at line 73 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_16zero = 5

Up to 65536 zero blocks.

Definition at line 72 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_1one = 2

One block all-set (1111...).

Definition at line 69 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_1zero = 1

One all-zero block.

Definition at line 68 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_32one = 8

UP to 4G all-set blocks.

Definition at line 75 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_32zero = 7

Up to 4G zero blocks.

Definition at line 74 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_8one = 4

Up to 256 all-set blocks.

Definition at line 71 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_8zero = 3

Up to 256 zero blocks.

Definition at line 70 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_aone = 10

All other blocks one.

Definition at line 77 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_arrbit = 16

List of bits ON.

Definition at line 83 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::get_arr_bit(), bm::serial_stream_iterator< DEC >::get_bit_block_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_ASSIGN(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_A(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_AB(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_BA(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_XOR(), bm::serial_stream_iterator< DEC >::get_bit_block_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_SUB(), bm::serial_stream_iterator< DEC >::get_bit_block_XOR(), and bm::serial_stream_iterator< DEC >::next().

const unsigned char bm::set_block_arrgap = 18

List of bits ON (GAP block).

Definition at line 85 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::gamma_gap_array(), bm::serial_stream_iterator< DEC >::next(), bm::deseriaizer_base< DEC >::read_gap_block(), and bm::deseriaizer_base< DEC >::read_id_list().

const unsigned char bm::set_block_arrgap_egamma = 21

Gamma compressed delta GAP array.

Definition at line 88 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::gamma_gap_array(), bm::serial_stream_iterator< DEC >::next(), bm::deseriaizer_base< DEC >::read_gap_block(), and bm::deseriaizer_base< DEC >::read_id_list().

const unsigned char bm::set_block_arrgap_egamma_inv = 23

Gamma compressed inverted delta GAP array.

Definition at line 90 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::gamma_gap_array(), bm::serial_stream_iterator< DEC >::next(), bm::deseriaizer_base< DEC >::read_gap_block(), and bm::deseriaizer_base< DEC >::read_id_list().

const unsigned char bm::set_block_arrgap_inv = 24

List of bits OFF (GAP block).

Definition at line 91 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::gamma_gap_array(), bm::serial_stream_iterator< DEC >::next(), bm::deseriaizer_base< DEC >::read_gap_block(), and bm::deseriaizer_base< DEC >::read_id_list().

const unsigned char bm::set_block_azero = 9

All other blocks zero.

Definition at line 76 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_bit = 11

Plain bit block.

Definition at line 78 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::get_bit_block_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_ASSIGN(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_A(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_AB(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_BA(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_XOR(), bm::serial_stream_iterator< DEC >::get_bit_block_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_SUB(), bm::serial_stream_iterator< DEC >::get_bit_block_XOR(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_bit_0runs = 22

Bit block with encoded zero intervals.

Definition at line 89 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serializer< BV >::encode_bit_interval(), bm::serial_stream_iterator< DEC >::get_bit_block_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_ASSIGN(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_A(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_AB(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_BA(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_XOR(), bm::serial_stream_iterator< DEC >::get_bit_block_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_SUB(), bm::serial_stream_iterator< DEC >::get_bit_block_XOR(), and bm::serial_stream_iterator< DEC >::next().

const unsigned char bm::set_block_bit_1bit = 19

Bit block with 1 bit ON.

Definition at line 86 of file bmserial.h.

Referenced by bm::iterator_deserializer< BV, SerialIterator >::deserialize(), bm::deserializer< BV, DEC >::deserialize(), bm::serializer< BV >::encode_gap_block(), bm::serial_stream_iterator< DEC >::get_arr_bit(), bm::serial_stream_iterator< DEC >::get_bit(), bm::serial_stream_iterator< DEC >::get_bit_block_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_ASSIGN(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_A(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_AB(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_BA(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_XOR(), bm::serial_stream_iterator< DEC >::get_bit_block_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_SUB(), bm::serial_stream_iterator< DEC >::get_bit_block_XOR(), bm::serial_stream_iterator< DEC >::get_gap_block(), bm::serial_stream_iterator< DEC >::next(), bm::deseriaizer_base< DEC >::read_gap_block(), bm::deseriaizer_base< DEC >::read_id_list(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_bit_interval = 17

Interval block.

Definition at line 84 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::get_bit_block_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_ASSIGN(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_A(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_AB(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_BA(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_XOR(), bm::serial_stream_iterator< DEC >::get_bit_block_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_SUB(), bm::serial_stream_iterator< DEC >::get_bit_block_XOR(), and bm::serial_stream_iterator< DEC >::next().

const unsigned char bm::set_block_end = 0

End of serialization.

Definition at line 67 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned char bm::set_block_gap = 14

Plain GAP block.

Definition at line 81 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::gamma_gap_block(), bm::serial_stream_iterator< DEC >::next(), and bm::deseriaizer_base< DEC >::read_gap_block().

const unsigned char bm::set_block_gap_egamma = 20

Gamma compressed GAP block.

Definition at line 87 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::gamma_gap_block(), bm::serial_stream_iterator< DEC >::next(), and bm::deseriaizer_base< DEC >::read_gap_block().

const unsigned char bm::set_block_gapbit = 15

GAP compressed bitblock.

Definition at line 82 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serial_stream_iterator< DEC >::get_bit_block_ASSIGN(), and bm::serial_stream_iterator< DEC >::next().

const unsigned bm::set_block_mask = 0xFFFFu

Definition at line 54 of file bmconst.h.

Referenced by combine_or(), combine_sub(), combine_xor(), bm::bvector< Alloc >::count_range(), bm::bvector< Alloc >::get_bit(), or_bit_block(), set_bit(), sub_bit_block(), test_bit(), and xor_bit_block().

const unsigned bm::set_block_plain_cnt = sizeof(bm::word_t) * 8u

Definition at line 58 of file bmconst.h.

const unsigned bm::set_block_plain_size = set_block_size / 32u

Definition at line 57 of file bmconst.h.

const unsigned char bm::set_block_sgapbit = 12

SGAP compressed bitblock.

Definition at line 79 of file bmserial.h.

const unsigned char bm::set_block_sgapgap = 13

SGAP compressed GAP block.

Definition at line 80 of file bmserial.h.

const unsigned bm::set_block_shift = 16u

Definition at line 53 of file bmconst.h.

Referenced by block_range_scan(), combine_or(), combine_sub(), combine_xor(), bm::bvector< Alloc >::count_range(), bm::iterator_deserializer< BV, SerialIterator >::deserialize(), and bm::bvector< Alloc >::get_bit().

const unsigned bm::set_block_size = 2048u

Definition at line 52 of file bmconst.h.

Referenced by bm::bv_statistics::add_bit_block(), bm::mem_alloc< BA, PA >::alloc_bit_block(), bit_block_and(), bit_block_copy(), bit_block_or(), bit_block_set(), bit_block_sub(), bit_block_xor(), bit_find_in_block(), bit_operation_or(), combine_any_operation_with_block(), combine_count_and_operation_with_block(), combine_count_operation_with_block(), bm::deserializer< BV, DEC >::deserialize(), bm::serializer< BV >::encode_bit_interval(), export_array(), bm::mem_alloc< BA, PA >::free_bit_block(), bm::serial_stream_iterator< DEC >::get_bit_block_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_ASSIGN(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_A(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_AND(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_AB(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_SUB_BA(), bm::serial_stream_iterator< DEC >::get_bit_block_COUNT_XOR(), bm::serial_stream_iterator< DEC >::get_bit_block_OR(), bm::serial_stream_iterator< DEC >::get_bit_block_SUB(), bm::serial_stream_iterator< DEC >::get_bit_block_XOR(), bm::bvector< Alloc >::enumerator::go_up(), and bm::serializer< BV >::serialize().

const unsigned bm::set_block_size_op = bm::set_block_size

Definition at line 105 of file bmconst.h.

Referenced by bm::bvector< Alloc >::compare().

const unsigned bm::set_total_blocks = (bm::set_array_size * bm::set_array_size)

Definition at line 84 of file bmconst.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), export_array(), bm::serial_stream_iterator< DEC >::next(), and bm::serializer< BV >::serialize().

const unsigned bm::set_word_mask = 0x1Fu

Definition at line 63 of file bmconst.h.

Referenced by bit_block_any_range(), bit_block_calc_count_range(), bit_find_in_block(), combine_or(), combine_sub(), combine_xor(), bm::bvector< Alloc >::get_bit(), or_bit_block(), bm::bvmini< N >::set(), bm::miniset< A, N >::set(), set_bit(), sub_bit_block(), bm::bvmini< N >::test(), bm::miniset< A, N >::test(), test_bit(), and xor_bit_block().

const unsigned bm::set_word_shift = 5u

Definition at line 62 of file bmconst.h.

Referenced by bit_block_any_range(), bit_block_calc_count_range(), bit_find_in_block(), combine_or(), combine_sub(), combine_xor(), bm::bvector< Alloc >::get_bit(), or_bit_block(), bm::bvmini< N >::set(), bm::miniset< A, N >::set(), set_bit(), sub_bit_block(), bm::bvmini< N >::test(), bm::miniset< A, N >::test(), test_bit(), and xor_bit_block().