Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | Directories | File List | Namespace Members | Data Fields | Globals | Examples

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  bit_count_table
 Structure to aid in counting bits table contains count of bits in 0-255 diapason of numbers. More...
struct  block_set_table
 Structure keeps all-left/right ON bits masks. More...
struct  first_bit_table
 Structure keeps index of first ON bit for every byte. 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...
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  sse2_empty_guard
 SSE2 reinitialization guard class. More...

Typedefs

typedef bm::miniset< bm::block_allocator,
bm::set_total_blocks
mem_save_set
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 *, const gap_word_t *, gap_word_t *)
typedef bm::id_t(* bit_operation_count_func_type )(const bm::word_t *, const bm::word_t *, const bm::word_t *)
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 id64_t wordop_t

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...

Functions

template<class Alloc, class MS>
bvector< Alloc, MS > operator & (const bvector< Alloc, MS > &v1, const bvector< Alloc, MS > &v2)
template<class Alloc, class MS>
bvector< Alloc, MS > operator| (const bvector< Alloc, MS > &v1, const bvector< Alloc > &v2)
template<class Alloc, class MS>
bvector< Alloc, MS > operator^ (const bvector< Alloc, MS > &v1, const bvector< Alloc, MS > &v2)
template<class Alloc, class MS>
bvector< Alloc, MS > operator- (const bvector< Alloc, MS > &v1, const bvector< Alloc, MS > &v2)
BMFORCEINLINE bm::id_t word_bitcount (bm::id_t w)
bm::id_t word_bitcount64 (bm::id64_t w)
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, unsigned size2, F &f)
template<class T, class F>
bool for_each_nzblock_if (T ***root, unsigned size1, unsigned size2, F &f)
template<class T, class F>
void for_each_block (T ***root, unsigned size1, unsigned size2, F &f)
template<class T, class F>
bmfor_each (T first, T last, F f)
template<class T>
sum_arr (T *first, T *last)
template<typename T>
unsigned gap_bit_count (const T *buf)
 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<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)
 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>
unsigned gap_set_value (unsigned val, T *BMRESTRICT buf, unsigned pos, unsigned *BMRESTRICT is_set)
 Abstract distance(similarity) operation for GAP buffers. Receives functor F as a template argument Sets or clears bit in the GAP buffer.
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.
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 *dest, const T *buf)
 SUB (AND NOT) GAP block to bitblock.
template<typename T>
void gap_xor_to_bitset (unsigned *dest, const T *buf)
 XOR 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 (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, unsigned from, unsigned to, unsigned 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. Checks if GAP block is all-zero.
template<typename T>
bool gap_is_all_one (const T *buf, unsigned set_max)
 Checks if GAP block is all-one.
template<typename T>
unsigned 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<typename D, typename T>
gap_convert_to_arr (D *BMRESTRICT dest, const T *BMRESTRICT buf, unsigned dest_len)
 Convert gap block into array of ints corresponding to 1 bits.
template<typename T>
bit_convert_to_arr (T *BMRESTRICT dest, const unsigned *BMRESTRICT src, bm::id_t bits, unsigned dest_len)
 Convert bit block into an 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)
bm::id_t bit_block_calc_count_change (const bm::word_t *block, const bm::word_t *block_end)
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.
unsigned and_op (unsigned v1, unsigned v2)
 GAP and functor.
unsigned xor_op (unsigned v1, unsigned v2)
 GAP xor functor.
gap_word_tgap_operation_and (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2, gap_word_t *BMRESTRICT tmp_buf)
 GAP AND operation.
unsigned gap_operation_any_and (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
 GAP AND operation test.
gap_word_tgap_operation_xor (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2, gap_word_t *BMRESTRICT tmp_buf)
 GAP XOR operation.
unsigned gap_operation_any_xor (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
 GAP XOR operation test.
gap_word_tgap_operation_or (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2, gap_word_t *BMRESTRICT tmp_buf)
 GAP OR operation.
gap_word_tgap_operation_sub (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2, gap_word_t *BMRESTRICT tmp_buf)
 GAP SUB (AND NOT) operation.
unsigned gap_operation_any_sub (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2)
 GAP SUB 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_tbit_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_tbit_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_tbit_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_tbit_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.
void bit_find_head_tail (const bm::word_t *data, unsigned *head_idx, unsigned *tail_idx)
 Inspects bit block for zero words at the head and at the end.
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 B>
unsigned bit_list (T w, B *bits)
 Unpacks word into list of ON bit indexes.
template<typename T>
unsigned gap_overhead (const T *length, const T *length_end, const T *glevel_len)
 Calculates memory overhead for number of gap blocks sharing the same memory allocation table (level lengths table).
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.
bm::id_t sse2_bit_count (const __m128i *block, const __m128i *block_end)
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)
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)

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_word_shift = 5u
const unsigned set_word_mask = 0x1Fu
const unsigned gap_max_buff_len = 1280
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 id64_t all_bits_mask = 0xffffffffffffffff
const unsigned set_block_size_op = bm::set_block_size / 2


Typedef Documentation

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

Definition at line 4301 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 104 of file encoding.h.

typedef gap_word_t*(* bm::gap_operation_func_type)(const gap_word_t *, const gap_word_t *, gap_word_t *)
 

Definition at line 4296 of file bmfunc.h.

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

Definition at line 4292 of file bmfunc.h.

typedef unsigned short bm::gap_word_t
 

Definition at line 66 of file bmconst.h.

typedef unsigned long long bm::id64_t
 

Definition at line 39 of file bmconst.h.

typedef unsigned int bm::id_t
 

Definition at line 43 of file bmconst.h.

typedef bm::miniset<bm::block_allocator, bm::set_total_blocks> bm::mem_save_set
 

Definition at line 89 of file bm.h.

typedef unsigned short bm::short_t
 

Definition at line 45 of file bmconst.h.

typedef unsigned int bm::word_t
 

Definition at line 44 of file bmconst.h.

typedef id64_t bm::wordop_t
 

Definition at line 89 of file bmconst.h.


Enumeration Type Documentation

enum bm::ByteOrder
 

Byte orders recognized by the library.

Enumeration values:
BigEndian 
LittleEndian 

Definition at line 405 of file bmfunc.h.

enum bm::operation
 

Bit operations enumeration.

Enumeration values:
BM_AND 
BM_OR 
BM_SUB 
BM_XOR 

Definition at line 282 of file bmfunc.h.

enum bm::set_operation
 

Nomenclature of set operations.

Enumeration values:
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 253 of file bmfunc.h.


Function Documentation

unsigned and_op unsigned  v1,
unsigned  v2
[inline]
 

GAP and functor.

Definition at line 2749 of file bmfunc.h.

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
 

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

Definition at line 4158 of file bmfunc.h.

template<class T, class F>
F bmfor_each first,
last,
f
 

Special BM optimized analog of STL for_each

Definition at line 629 of file bmfunc.h.

template<class T, class F>
void for_each_block T ***  root,
unsigned  size1,
unsigned  size2,
F &  f
 

For each block executes supplied function.

Definition at line 600 of file bmfunc.h.

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

template<class T, class F>
void for_each_nzblock T ***  root,
unsigned  size1,
unsigned  size2,
F &  f
 

For each non-zero block executes supplied function.

Definition at line 535 of file bmfunc.h.

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

template<class T, class F>
bool for_each_nzblock_if T ***  root,
unsigned  size1,
unsigned  size2,
F &  f
 

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

Definition at line 575 of file bmfunc.h.

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

template<typename T>
unsigned gap_bfind const T *  buf,
unsigned  pos,
unsigned *  is_set
 

Definition at line 469 of file bmfunc.h.

References BM_ASSERT.

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

template<typename T>
unsigned gap_bit_count_range const T *  buf,
left,
right
 

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 691 of file bmfunc.h.

References BM_ASSERT, and gap_bfind().

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

bool is_const_set_operation set_operation  op  )  [inline]
 

Returns true if set operation is constant (bitcount).

Definition at line 274 of file bmfunc.h.

References set_COUNT.

template<class Alloc, class MS>
bvector<Alloc, MS> operator & const bvector< Alloc, MS > &  v1,
const bvector< Alloc, MS > &  v2
[inline]
 

Definition at line 1552 of file bm.h.

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

template<class Alloc, class MS>
bvector<Alloc, MS> operator- const bvector< Alloc, MS > &  v1,
const bvector< Alloc, MS > &  v2
[inline]
 

Definition at line 1597 of file bm.h.

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

template<class Alloc, class MS>
bvector<Alloc, MS> operator^ const bvector< Alloc, MS > &  v1,
const bvector< Alloc, MS > &  v2
[inline]
 

Definition at line 1582 of file bm.h.

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

template<class Alloc, class MS>
bvector<Alloc, MS> operator| const bvector< Alloc, MS > &  v1,
const bvector< Alloc > &  v2
[inline]
 

Definition at line 1567 of file bm.h.

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

bm::operation setop2op bm::set_operation  op  )  [inline]
 

Convert set operation to operation.

Definition at line 294 of file bmfunc.h.

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

BMFORCEINLINE __m128i sse2_and __m128i  a,
__m128i  b
 

Definition at line 472 of file bmsse2.h.

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
 

Definition at line 498 of file bmsse2.h.

BMFORCEINLINE __m128i sse2_or __m128i  a,
__m128i  b
 

Definition at line 478 of file bmsse2.h.

BMFORCEINLINE __m128i sse2_sub __m128i  a,
__m128i  b
 

Definition at line 491 of file bmsse2.h.

BMFORCEINLINE __m128i sse2_xor __m128i  a,
__m128i  b
 

Definition at line 485 of file bmsse2.h.

template<class T>
T sum_arr T *  first,
T *  last
 

Computes SUM of all elements of the sequence

Definition at line 641 of file bmfunc.h.

unsigned xor_op unsigned  v1,
unsigned  v2
[inline]
 

GAP xor functor.

Definition at line 2756 of file bmfunc.h.

template<typename W>
void xor_swap W &  x,
W &  y
 

XOR swap two scalar variables.

Definition at line 329 of file bmfunc.h.

References BM_ASSERT.

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


Variable Documentation

const id64_t bm::all_bits_mask = 0xffffffffffffffff
 

Definition at line 90 of file bmconst.h.

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

Definition at line 84 of file bmconst.h.

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

Definition at line 83 of file bmconst.h.

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

const unsigned bm::gap_equiv_len
 

Initial value:

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

Definition at line 70 of file bmconst.h.

const unsigned bm::gap_levels = 4
 

Definition at line 72 of file bmconst.h.

Referenced by bm::bvector< Alloc, MS >::optimize_gap_size().

const unsigned bm::gap_max_bits = 65536
 

Definition at line 69 of file bmconst.h.

const unsigned bm::gap_max_buff_len = 1280
 

Definition at line 68 of file bmconst.h.

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

Definition at line 73 of file bmconst.h.

const unsigned bm::id_max = 0xFFFFFFFF
 

Definition at line 49 of file bmconst.h.

Referenced by bm::bvector< Alloc, MS >::iterator_base::iterator_base().

const unsigned bm::set_array_mask = 0xFFu
 

Definition at line 80 of file bmconst.h.

const unsigned bm::set_array_shift = 8u
 

Definition at line 79 of file bmconst.h.

const unsigned bm::set_array_size = 256u
 

Definition at line 78 of file bmconst.h.

const unsigned bm::set_blkblk_mask = 0xFFFFFFu
 

Definition at line 56 of file bmconst.h.

const unsigned bm::set_block_mask = 0xFFFFu
 

Definition at line 55 of file bmconst.h.

const unsigned bm::set_block_shift = 16u
 

Definition at line 54 of file bmconst.h.

const unsigned bm::set_block_size = 2048u
 

Definition at line 53 of file bmconst.h.

const unsigned bm::set_block_size_op = bm::set_block_size / 2
 

Definition at line 93 of file bmconst.h.

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

Definition at line 81 of file bmconst.h.

const unsigned bm::set_word_mask = 0x1Fu
 

Definition at line 61 of file bmconst.h.

const unsigned bm::set_word_shift = 5u
 

Definition at line 60 of file bmconst.h.


Generated on Sun Aug 5 14:12:37 2007 for BitMagic by  doxygen 1.4.1