bm Namespace Reference

## Data Structures

class | bvector
| Bitvector Bit-vector container with runtime compression of bits. More...
struct | bv_statistics
| Structure with statistical information about memory allocation footprint, serialization projection, number of vectors. More...
struct | bv_arena_statistics
| Structure with statistical information about memory allocation for arena based vectors. More...
struct | pair
| Pair type. More...
struct | bit_decode_cache
| bit-decode cache structure More...
class | copy_to_array_functor
| Adaptor to copy 1 bits to array. More...
struct | all_set
| Structure carries pointer on bit block with all bits 1. More...
struct | d_copy_func
| d-Gap copy functor More...
class | bitblock_get_adapter
| Bit-block get adapter, takes bitblock and represents it as a get_32() accessor function. More...
class | bitblock_store_adapter
| Bit-block store adapter, takes bitblock and saves results into it. 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
union | ptr_payload_t
| helper union to interpret pointer as integers More...
struct | xor_sim_params
| Parameters for XOR similarity search. More...
struct | block_waves_xor_descr
| Structure to compute XOR gap-count profile by sub-block waves. More...
struct | block_xor_match_descr
| Capture the XOR filter results (xor block against ref.block). More...
struct | match_pair
| XOR match pair. More...
struct | block_match_chain
| XOR match chain. More...
class | bv_ref_vector
| List of reference bit-vectors with their true index associations. More...
struct | xor_sim_model
| XOR similarity model. More...
class | xor_scanner
| XOR scanner to search for complement-similarities in collections of bit-vectors. More...
class | miniset
| Template class implements memory saving set functionality. More...
class | bvmini
| Mini bit-vector for auxiliary purposes. 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...
class | basic_bmatrix
| Basic dense bit-matrix class. More...
class | base_sparse_vector
| Base class for bit-transposed(bit-sliced) sparse vector construction. More...
struct | _copyright
| Internal structure. More...
struct | DeBruijn_bit_position
| DeBruijn majic table. More...
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...
struct | lzcnt_table
| Structure for LZCNT constants (4-bit). More...
struct | tzcnt_table
| Structure for TZCNT constants. More...
struct | block_set_table
| Structure keeps all-left/right ON bits masks. 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 | gap_len_table_nl
| Non-linear size growth GAP lengths table. More...
struct | globals
| Internal structure. More...
class | sse_empty_guard
| SSE2 reinitialization guard class. More...
struct | bit_vistor_copy_functor
| Functor for bit-copy (for testing). More...
class | rank_compressor
| Algorithms for rank compression of bit-vector. More...
struct | distance_metric_descriptor
| Distance metric descriptor, holds metric code and result. More...
struct | bit_visitor_callback_adaptor
| functor-adaptor for C-style callbacks More...
struct | bit_visitor_back_inserter_adaptor
| functor-adaptor for back-inserter More...
class | similarity_descriptor
struct | similarity_batch
class | interval_enumerator
| forward iterator class to traverse bit-vector as ranges More...
struct | task_descr
| BitMagic task with a captured function. More...
class | task_batch_base
| Interface definition (base class) for a group of tasks (batch). More...
class | task_batch
| Basic implementation for collection of tasks for parallel execution. More...
struct | is_lock_noexcept
| "noexcept" traits detection for T::lock() More...
class | lock_guard
| Simple scoped lock guard. More...
struct | pad60_struct
| Pad 60 bytes so that the final ocupiles 64 bytes (1 cache line). More...
struct | pad0_struct
| Empty padding. More...
class | spin_lock
| Spin-lock with two-phase acquire (read + cas) padding parameter optionally adds a buffer to avoid CPU cache line contention. More...
class | thread_pool
| Thread pool with custom (thread safe) queue. More...
class | queue_sync
| Thread-sync queue with MT access protecion. More...
class | thread_pool_executor
| Utility class to submit task batch to the running thread pool and optionally wait for it getting done. More...
class | optimize_plan_builder
| Builder class to prepare a batch of tasks for parallel optimization of a sparse vector. More...
class | compute_sim_matrix_plan_builder
| Parallel plan builder for the XOR filter scanner. More...
class | sv_serialization_plan_builder
| Parallel plan builder for succinct sparse vector serialization. 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-plane splicing of a GAP block. More...
struct | bit_block_t
| bit-block array wrapped into union for correct interpretation of 32-bit vs 64-bit access vs SIMD More...
struct | conditional
| ad-hoc conditional expressions More...
struct | conditional< false >
class | ptr_guard
| Mini auto-pointer for internal memory management. More...
struct | and_func
| and functor More...
struct | xor_func
| xor functor More...
struct | or_func
| or functor More...
struct | sub_func
| sub functor More...
struct | agg_run_options
| Aggregation options to control execution Default settings are to support only result bit-vector filters. More...
class | aggregator
| Algorithms for fast aggregation of a group of bit-vectors. More...
class | serializer
| Bit-vector serialization class. More...
class | deseriaizer_base
| Base deserialization class. More...
class | deserializer
| Deserializer for bit-vector. More...
class | iterator_deserializer
| Iterator to walk forward the serialized stream. More...
class | serial_stream_iterator
| Serialization stream iterator. More...
class | operation_deserializer
| Deserializer, performs logical operations between 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 | pointer_pool_array
| Pool of pointers to buffer cyclic allocations. More...
class | alloc_pool
| Allocation pool object. More...
class | mem_alloc
| BM style allocator adapter. More...
class | random_subset
class | sparse_vector
| succinct sparse vector with runtime compression using bit-slicing / transposition method More...
class | sv_sample_index
| Index for SV sorted vectors for approximate range queries. More...
class | sparse_vector_scanner
| algorithms for sparse_vector scan/search More...
class | set2set_11_transform
| Integer set to set transformation (functional image in groups theory) https://en.wikipedia.org/wiki/Image_(mathematics). More...
struct | sparse_vector_serial_layout
| layout class for serialization buffer structure More...
class | sparse_vector_serializer
class | sparse_vector_deserializer
| sparse vector de-serializer More...
class | compressed_collection_serializer
| Seriaizer for compressed collections. More...
class | compressed_collection_deserializer
| Deseriaizer for compressed collections. More...
class | rsc_sparse_vector
| Rank-Select compressed sparse vector. More...
class | str_sparse_vector
| succinct sparse vector for strings with compression using bit-slicing ( transposition) method More...
class | bvps_addr_resolver
| Bit-bector prefix sum address resolver using bit-vector prefix sum as a space compactor. More...
class | sv_addr_resolver
| sparse vector based address resolver (no space compactor, just bit-plane compressors provided by sparse_vector) More...
class | compressed_collection
| Compressed (sparse collection of objects). More...
class | compressed_buffer_collection
| Compressed (sparse collection of objects). More...
class | chrono_taker
| Utility class to collect performance measurements and statistics. More...

## Typedefs

typedef bm::id_t | bvector_size_type
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)
typedef decoder | decoder_big_endian
| Class for decoding data from memory buffer.
typedef unsigned long long int | 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
typedef void *(* | task_func_type) (void *)
| Typedef for a call-back function pointer (pthread conformant signature).
typedef std::function< int(void *)> | task_function_t
| Typedef for a call-back functional for lambda capture.
typedef bm::alloc_pool< block_allocator, ptr_allocator > | standard_alloc_pool
typedef bm::mem_alloc< block_allocator, ptr_allocator, standard_alloc_pool > | standard_allocator

## Enumerations

enum | bit_representation { e_bit_GAP = 0 , e_bit_INT , e_bit_IINT , e_bit_1 , e_bit_0 , e_bit_bit , e_bit_end }
| Possible representations for bit sets. More...
enum | xor_complement_match { e_no_xor_match = 0 , e_xor_match_GC , e_xor_match_BC , e_xor_match_iBC , e_xor_match_EQ }
| XOR complementarity type between 2 blocks. More...
enum | strategy { BM_BIT = 0 , BM_GAP = 1 }
| Block allocation strategies. More...
enum class | finalization { finalization::UNDEFINED = 0 , finalization::READONLY = 1 , finalization::READWRITE = 2 }
| copy strategy More...
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 }
| Codes of set operations. More...
enum | operation { BM_AND = set_AND , BM_OR = set_OR , BM_SUB = set_SUB , BM_XOR = set_XOR }
| Bit operations. More...
enum | sort_order { BM_UNSORTED = 0 , BM_SORTED = 1 , BM_SORTED_UNIFORM = 2 , BM_UNKNOWN = 3 }
| Sort order declaration. More...
enum | set_representation { set_bitset = 0 , set_gap = 1 , set_array1 = 2 , set_array0 = 3 }
| set representation variants More...
enum | null_support { use_null = 0 , no_null = 1 }
| NULL-able value support. More...
enum | simd_codes { simd_none = 0 , simd_sse2 = 1 , simd_sse42 = 2 , simd_avx2 = 5 , simd_avx512 = 6 , simd_wasm128 = 7 , simd_neon = 8 }
| codes for supported SIMD optimizations More...
enum | ByteOrder { BigEndian = 0 , LittleEndian = 1 }
| Byte orders recognized by the library. 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) , BM_HM_64_BIT = (1 << 5) , BM_HM_HXOR = (1 << 6) , BM_HM_SPARSE = (1 << 7) }
enum | serialization_flags { BM_NO_BYTE_ORDER = 1 , BM_NO_GAP_LENGTH = (1 << 1) }
| Bit mask flags for serialization algorithm. More...
enum class | remap_setup { COPY_RTABLES }

## Functions

template<class Alloc>
bvector< Alloc > | operator& (const bvector< Alloc > &bv1, const bvector< Alloc > &bv2)
template<class Alloc>
bvector< Alloc > | operator| (const bvector< Alloc > &bv1, const bvector< Alloc > &bv2)
template<class Alloc>
bvector< Alloc > | operator^ (const bvector< Alloc > &bv1, const bvector< Alloc > &bv2)
template<class Alloc>
bvector< Alloc > | operator- (const bvector< Alloc > &bv1, const bvector< Alloc > &bv2)
template<bool LWA = false, bool RWA = false>
bm::id_t | bit_block_calc_count_range (const bm::word_t *block, bm::word_t left, bm::word_t right) BMNOEXCEPT
bm::id_t | bit_block_any_range (const bm::word_t *block, bm::word_t left, bm::word_t right) BMNOEXCEPT
template<typename BI_TYPE>
BMFORCEINLINE void | get_block_coord (BI_TYPE nb, unsigned &i, unsigned &j) BMNOEXCEPT
| Recalc linear bvector block index into 2D matrix coordinates.
template<typename RTYPE>
BMFORCEINLINE RTYPE | get_super_block_start (unsigned i) BMNOEXCEPT
| Compute bit address of the first bit in a superblock.
template<typename RTYPE>
BMFORCEINLINE RTYPE | get_block_start (unsigned i, unsigned j) BMNOEXCEPT
| Compute bit address of the first bit in a block.
int | parallel_popcnt_32 (unsigned int n) BMNOEXCEPT
| 32-bit paralle, bitcount
unsigned | bitcount64_4way (bm::id64_t x, bm::id64_t y, bm::id64_t u, bm::id64_t v) BMNOEXCEPT
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.
unsigned | bitscan_nibble (unsigned w, unsigned *bits) BMNOEXCEPT
| portable, switch based bitscan
template<typename T, typename B>
unsigned | bit_list (T w, B *bits) BMNOEXCEPT
| Unpacks word into list of ON bit indexes.
template<typename T, typename B>
unsigned | bit_list_4 (T w, B *bits) BMNOEXCEPT
| Unpacks word into list of ON bit indexes (quad-bit based).
template<typename B>
unsigned short | bitscan_popcnt (bm::id_t w, B *bits, unsigned short offs) BMNOEXCEPT
| Unpacks word into list of ON bit indexes using popcnt method.
template<typename B>
unsigned short | bitscan_popcnt (bm::id_t w, B *bits) BMNOEXCEPT
| Unpacks word into list of ON bit indexes using popcnt method.
template<typename B>
unsigned short | bitscan_popcnt64 (bm::id64_t w, B *bits) BMNOEXCEPT
| Unpacks 64-bit word into list of ON bit indexes using popcnt method.
template<typename B>
unsigned short | bitscan_bsf (unsigned w, B *bits) BMNOEXCEPT
| Unpacks word into list of ON bits (BSF/__builtin_ctz).
template<typename B, typename OT>
unsigned short | bitscan_bsf (unsigned w, B *bits, OT offs) BMNOEXCEPT
template<typename B>
unsigned short | bitscan_bsf64 (bm::id64_t w, B *bits) BMNOEXCEPT
| Unpacks word into list of ON bits (BSF/__builtin_ctz).
template<typename B>
unsigned short | bitscan_popcnt64 (bm::id64_t w, B *bits, unsigned short offs) BMNOEXCEPT
| Unpacks 64-bit word into list of ON bit indexes using popcnt method.
template<typename V, typename B>
unsigned short | bitscan (V w, B *bits) BMNOEXCEPT
| Templated Bitscan with dynamic dispatch for best type.
unsigned | word_select64_linear (bm::id64_t w, unsigned rank) BMNOEXCEPT
| word find index of the rank-th bit set by bit-testing
unsigned | word_select64_bitscan_popcnt (bm::id64_t w, unsigned rank) BMNOEXCEPT
| word find index of the rank-th bit set by bit-testing
unsigned | word_select64_bitscan_tz (bm::id64_t w, unsigned rank) BMNOEXCEPT
| word find index of the rank-th bit set by bit-testing
unsigned | word_select32_bitscan_popcnt (unsigned w, unsigned rank) BMNOEXCEPT
| word find index of the rank-th bit set by bit-testing
unsigned | word_select32_bitscan_tz (unsigned w, unsigned rank) BMNOEXCEPT
| word find index of the rank-th bit set by bit-testing
unsigned | word_select64 (bm::id64_t w, unsigned rank) BMNOEXCEPT
| word find index of the rank-th bit set by bit-testing
unsigned | word_select32 (unsigned w, unsigned rank) BMNOEXCEPT
| word find index of the rank-th bit set by bit-testing
BMFORCEINLINE bm::id64_t | widx_to_digest_mask (unsigned w_idx) BMNOEXCEPT
| Compute digest mask for word address in block.
bm::id64_t | dm_control (unsigned from, unsigned to) BMNOEXCEPT
| digest mask control generation (for debug and test only)
BMFORCEINLINE bm::id64_t | digest_mask (unsigned from, unsigned to) BMNOEXCEPT
| Compute digest mask for [from..to] positions.
BMFORCEINLINE bool | check_zero_digest (bm::id64_t digest, unsigned bitpos_from, unsigned bitpos_to) BMNOEXCEPT
| check if all digest bits for the range [from..to] are 0
bool | is_digest_one_range (bm::id64_t digest) BMNOEXCEPT
| Is one range of 1s ( 0000110000 - one range, 000011000010 - more than one).
void | block_init_digest0 (bm::word_t *const block, bm::id64_t digest) BMNOEXCEPT
| Init block with 000111000 pattren based on digest.
bm::id64_t | calc_block_digest0 (const bm::word_t *const block) BMNOEXCEPT
| Compute digest for 64 non-zero areas.
bm::id64_t | update_block_digest0 (const bm::word_t *const block, bm::id64_t digest) BMNOEXCEPT
| Compute digest for 64 non-zero areas based on existing digest (function revalidates zero areas).
void | block_compact_by_digest (bm::word_t *t_block, const bm::word_t *block, bm::id64_t digest, bool zero_tail) BMNOEXCEPT
| Compact sub-blocks by digest (rank compaction).
void | block_expand_by_digest (bm::word_t *t_block, const bm::word_t *block, bm::id64_t digest, bool zero_subs) BMNOEXCEPT
| expand sub-blocks by digest (rank expansion)
bool | is_const_set_operation (set_operation op) BMNOEXCEPT
| Returns true if set operation is constant (bitcount).
bm::operation | setop2op (bm::set_operation op) BMNOEXCEPT
| Convert set operation to operation.
template<typename N>
bool | find_not_null_ptr (const bm::word_t *const *const *arr, N start, N size, N *pos) BMNOEXCEPT
template<typename T>
int | wordcmp0 (T w1, T w2) BMNOEXCEPT
| Lexicographical comparison of two words as bit strings (reference) Auxiliary implementation for testing and reference purposes.
template<typename T>
int | wordcmp (T a, T b) BMNOEXCEPT
| Lexicographical comparison of two words as bit strings. Auxiliary implementation for testing and reference purposes.
bool | bit_is_all_zero (const bm::word_t *BMRESTRICT start) BMNOEXCEPT
| Returns "true" if all bits in the block are 0.
BMFORCEINLINE bool | gap_is_all_zero (const bm::gap_word_t *BMRESTRICT buf) BMNOEXCEPT
| Checks if GAP block is all-zero.
BMFORCEINLINE bool | gap_is_all_one (const bm::gap_word_t *BMRESTRICT buf) BMNOEXCEPT
| Checks if GAP block is all-one.
BMFORCEINLINE bm::gap_word_t | gap_length (const bm::gap_word_t *BMRESTRICT buf) BMNOEXCEPT
| Returs GAP block length.
template<typename T>
unsigned | gap_capacity (const T *BMRESTRICT buf, const T *BMRESTRICT glevel_len) BMNOEXCEPT
| Returs GAP block capacity.
template<typename T>
unsigned | gap_limit (const T *BMRESTRICT buf, const T *BMRESTRICT glevel_len) BMNOEXCEPT
| Returs GAP block capacity limit.
template<typename T>
T | gap_level (const T *BMRESTRICT buf) BMNOEXCEPT
| Returs GAP blocks capacity level.
template<typename T>
unsigned | gap_find_last (const T *BMRESTRICT buf, unsigned *BMRESTRICT last) BMNOEXCEPT
| GAP block find the last set bit.
template<typename T>
unsigned | gap_find_first (const T *BMRESTRICT buf, unsigned *BMRESTRICT first) BMNOEXCEPT
| GAP block find the first set bit.
template<typename T>
unsigned | gap_bfind (const T *BMRESTRICT buf, unsigned pos, unsigned *BMRESTRICT is_set) BMNOEXCEPT
template<typename T>
unsigned | gap_test (const T *BMRESTRICT buf, unsigned pos) BMNOEXCEPT
| Tests if bit = pos is true.
template<typename T>
unsigned | gap_test_unr (const T *BMRESTRICT buf, const unsigned pos) BMNOEXCEPT
| Tests if bit = pos is true. Analog of bm::gap_test with SIMD unrolling.
template<typename T, typename N, typename F>
void | for_each_nzblock_range (T ***root, N top_size, N nb_from, N nb_to, F &f) BMNOEXCEPT
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<typename T, typename BI, typename F>
bool | for_each_nzblock_if (T ***root, BI size1, F &f) BMNOEXCEPT
template<class T, class F, typename BLOCK_IDX>
void | for_each_block (T ***root, unsigned size1, F &f, BLOCK_IDX start)
template<class T, class F>
F | bmfor_each (T first, T last, F f)
template<typename T>
bm::id64_t | sum_arr (const T *first, const T *last) BMNOEXCEPT
template<typename T>
void | gap_split (const T *buf, T *arr0, T *arr1, T &arr0_cnt, T &arr1_cnt) BMNOEXCEPT
template<typename T>
unsigned | gap_bit_count (const T *buf, unsigned dsize=0) BMNOEXCEPT
| Calculates number of bits ON in GAP buffer.
template<typename T>
unsigned | gap_bit_count_unr (const T *buf) BMNOEXCEPT
| Calculates number of bits ON in GAP buffer. Loop unrolled version.
template<typename T, bool RIGHT_END = false>
unsigned | gap_bit_count_range (const T *const buf, unsigned left, unsigned right) BMNOEXCEPT
| Counts 1 bits in GAP buffer in the closed [left, right] range.
template<typename T>
unsigned | gap_bit_count_range_hint (const T *const buf, unsigned left, unsigned right, unsigned hint) BMNOEXCEPT
| Counts 1 bits in GAP buffer in the closed [left, right] range using position hint to avoid bfind.
template<typename T>
bool | gap_is_all_one_range (const T *const BMRESTRICT buf, unsigned left, unsigned right) BMNOEXCEPT
| Test if all bits are 1 in GAP buffer in the [left, right] range.
template<typename T>
bool | gap_any_range (const T *const BMRESTRICT buf, unsigned left, unsigned right) BMNOEXCEPT
| Test if any bits are 1 in GAP buffer in the [left, right] range.
template<typename T>
bool | gap_is_interval (const T *const BMRESTRICT buf, unsigned left, unsigned right) BMNOEXCEPT
| Test if any bits are 1 in GAP buffer in the [left, right] range and flanked with 0s.
template<typename T>
bool | gap_find_interval_end (const T *const BMRESTRICT buf, unsigned nbit, unsigned *BMRESTRICT pos) BMNOEXCEPT
| Searches for the last 1 bit in the 111 interval of a GAP block.
template<typename T>
bool | gap_find_interval_start (const T *const BMRESTRICT buf, unsigned nbit, unsigned *BMRESTRICT pos) BMNOEXCEPT
| Searches for the first 1 bit in the 111 interval of a GAP block.
template<typename T>
bool | gap_find_prev (const T *const BMRESTRICT buf, unsigned nbit, unsigned *BMRESTRICT pos) BMNOEXCEPT
| reverse search for the first 1 bit of a GAP block
template<typename T, typename SIZE_TYPE>
SIZE_TYPE | gap_find_rank (const T *const block, SIZE_TYPE rank, unsigned nbit_from, unsigned &nbit_pos) BMNOEXCEPT
| GAP block find position for the rank.
template<typename T, bool TCORRECT = false>
unsigned | gap_bit_count_to (const T *const buf, T right) BMNOEXCEPT
template<class T, class Func>
void | for_each_dgap (const T *gap_buf, Func &func)
template<typename T>
T * | gap_2_dgap (const T *BMRESTRICT gap_buf, T *BMRESTRICT dgap_buf, bool copy_head=true) BMNOEXCEPT
| Convert GAP buffer into D-GAP buffer.
template<typename T>
void | dgap_2_gap (const T *BMRESTRICT dgap_buf, T *BMRESTRICT gap_buf, T gap_header=0) BMNOEXCEPT
| Convert D-GAP buffer into GAP buffer.
template<typename T>
int | gapcmp (const T *buf1, const T *buf2) BMNOEXCEPT
| Lexicographical comparison of GAP buffers.
template<typename T>
bool | gap_find_first_diff (const T *BMRESTRICT buf1, const T *BMRESTRICT buf2, unsigned *BMRESTRICT pos) BMNOEXCEPT
| Find first bit which is different between two GAP-blocks.
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, unsigned &dlen) BMNOEXCEPT2
| 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) BMNOEXCEPT2
| 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) BMNOEXCEPT2
| Abstract distance(similarity) operation for GAP buffers. Receives functor F as a template argument.
template<typename T>
unsigned | gap_set_value_cpos (unsigned val, T *BMRESTRICT buf, unsigned pos, unsigned *BMRESTRICT is_set, unsigned curr) BMNOEXCEPT
| Sets or clears bit in the GAP buffer.
template<typename T>
unsigned | gap_set_value (unsigned val, T *BMRESTRICT buf, unsigned pos, unsigned *BMRESTRICT is_set) BMNOEXCEPT
| Sets or clears bit in the GAP buffer.
template<typename T>
unsigned | gap_set_value (unsigned val, T *BMRESTRICT buf, unsigned pos) BMNOEXCEPT
| Sets or clears bit in the GAP buffer.
template<typename T>
unsigned | gap_add_value (T *buf, unsigned pos) BMNOEXCEPT
| Add new value to the end of GAP buffer.
template<typename T>
bool | gap_shift_r1 (T *BMRESTRICT buf, unsigned co_flag, unsigned *BMRESTRICT new_len) BMNOEXCEPT
| Right shift GAP block by 1 bit.
template<typename T>
bool | gap_insert (T *BMRESTRICT buf, unsigned pos, unsigned val, unsigned *BMRESTRICT new_len) BMNOEXCEPT
| isnert bit into GAP compressed block
template<typename T>
bool | gap_shift_l1 (T *BMRESTRICT buf, unsigned co_flag, unsigned *BMRESTRICT new_len) BMNOEXCEPT
| Left shift GAP block by 1 bit.
template<typename T>
unsigned | gap_set_array (T *buf, const T *arr, unsigned len) BMNOEXCEPT
| Convert array to GAP buffer.
template<typename T>
unsigned | bit_array_compute_gaps (const T *arr, unsigned len) BMNOEXCEPT
| Compute number of GAPs in bit-array.
template<typename T>
unsigned | gap_block_find (const T *BMRESTRICT buf, unsigned nbit, bm::id_t *BMRESTRICT prev) BMNOEXCEPT
| Searches for the next 1 bit in the GAP block.
BMFORCEINLINE void | set_bit (unsigned *dest, unsigned bitpos) BMNOEXCEPT
| Set 1 bit in a block.
BMFORCEINLINE void | clear_bit (unsigned *dest, unsigned bitpos) BMNOEXCEPT
| Set 1 bit in a block.
BMFORCEINLINE unsigned | test_bit (const unsigned *block, unsigned bitpos) BMNOEXCEPT
| Test 1 bit in a block.
void | or_bit_block (unsigned *dest, unsigned bitpos, unsigned bitcount) BMNOEXCEPT
| Sets bits to 1 in the bitblock.
void | sub_bit_block (unsigned *dest, unsigned bitpos, unsigned bitcount) BMNOEXCEPT
| SUB (AND NOT) bit interval to 1 in the bitblock.
void | xor_bit_block (unsigned *dest, unsigned bitpos, unsigned bitcount) BMNOEXCEPT
| XOR bit interval to 1 in the bitblock.
template<typename T>
void | gap_sub_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr) BMNOEXCEPT
| SUB (AND NOT) GAP block to bitblock.
template<typename T>
bm::id64_t | gap_sub_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr, bm::id64_t digest0) BMNOEXCEPT
| SUB (AND NOT) GAP block to bitblock with digest assist.
template<typename T>
void | gap_xor_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr) BMNOEXCEPT
| XOR GAP block to bitblock.
template<typename T>
void | gap_add_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr, unsigned len) BMNOEXCEPT
| Adds(OR) GAP block to bitblock.
template<typename T>
void | gap_add_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr) BMNOEXCEPT
| Adds(OR) GAP block to bitblock.
template<typename T>
void | gap_and_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr) BMNOEXCEPT
| ANDs GAP block to bitblock.
template<typename T>
bm::id64_t | gap_and_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr, bm::id64_t digest0) BMNOEXCEPT
| ANDs GAP block to bitblock with digest assist.
template<typename T>
bm::id_t | gap_bitset_and_count (const unsigned *BMRESTRICT block, const T *BMRESTRICT pcurr) BMNOEXCEPT
| Compute bitcount of bit block AND masked by GAP block.
template<typename T>
bm::id_t | gap_bitset_and_any (const unsigned *BMRESTRICT block, const T *BMRESTRICT pcurr) BMNOEXCEPT
| Bitcount test of bit block AND masked by GAP block.
template<typename T>
bm::id_t | gap_bitset_sub_count (const unsigned *BMRESTRICT block, const T *BMRESTRICT buf) BMNOEXCEPT
| Compute bitcount of bit block SUB masked by GAP block.
template<typename T>
bm::id_t | gap_bitset_sub_any (const unsigned *BMRESTRICT block, const T *BMRESTRICT buf) BMNOEXCEPT
| Compute bitcount test of bit block SUB masked by GAP block.
template<typename T>
bm::id_t | gap_bitset_xor_count (const unsigned *BMRESTRICT block, const T *BMRESTRICT buf) BMNOEXCEPT
| Compute bitcount of bit block XOR masked by GAP block.
template<typename T>
bm::id_t | gap_bitset_xor_any (const unsigned *BMRESTRICT block, const T *BMRESTRICT buf) BMNOEXCEPT
| Compute bitcount test of bit block XOR masked by GAP block.
template<typename T>
bm::id_t | gap_bitset_or_count (const unsigned *BMRESTRICT block, const T *BMRESTRICT buf) BMNOEXCEPT
| Compute bitcount of bit block OR masked by GAP block.
template<typename T>
bm::id_t | gap_bitset_or_any (const unsigned *BMRESTRICT block, const T *BMRESTRICT buf) BMNOEXCEPT
| Compute bitcount test of bit block OR masked by GAP block.
void | bit_block_set (bm::word_t *BMRESTRICT dst, bm::word_t value) BMNOEXCEPT
| Bitblock memset operation.
template<typename T>
void | gap_convert_to_bitset (unsigned *BMRESTRICT dest, const T *BMRESTRICT buf, unsigned len=0) BMNOEXCEPT
| GAP block to bitblock conversion.
template<typename T>
unsigned * | gap_convert_to_bitset_smart (unsigned *BMRESTRICT dest, const T *BMRESTRICT buf, id_t set_max) BMNOEXCEPT
| Smart GAP block to bitblock conversion.
template<typename T>
unsigned | gap_control_sum (const T *buf) BMNOEXCEPT
| 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) BMNOEXCEPT
| Sets all bits to 0 or 1 (GAP).
template<class T>
void | gap_init_range_block (T *buf, T from, T to, T value) BMNOEXCEPT
| Init gap block so it has block in it (can be whole block).
template<typename T>
void | gap_invert (T *buf) BMNOEXCEPT
| Inverts all bits in the GAP buffer.
template<typename T>
void | set_gap_level (T *buf, int level) BMNOEXCEPT
| Sets GAP block capacity level.
template<typename T>
int | gap_calc_level (unsigned len, const T *glevel_len) BMNOEXCEPT
| Calculates GAP block capacity level.
template<typename T>
unsigned | gap_free_elements (const T *BMRESTRICT buf, const T *BMRESTRICT glevel_len) BMNOEXCEPT
| 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) BMNOEXCEPT
| Lexicographical comparison of BIT buffers.
bool | bit_find_first_diff (const bm::word_t *BMRESTRICT blk1, const bm::word_t *BMRESTRICT blk2, unsigned *BMRESTRICT pos) BMNOEXCEPT
| Find first bit which is different between two bit-blocks.
unsigned | bit_block_to_gap (gap_word_t *BMRESTRICT dest, const unsigned *BMRESTRICT block, unsigned dest_len) BMNOEXCEPT
| Converts bit block to GAP.
unsigned | bit_to_gap (gap_word_t *BMRESTRICT dest, const unsigned *BMRESTRICT block, unsigned dest_len) BMNOEXCEPT
| Convert bit block to GAP representation.
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) BMNOEXCEPT
| Convert gap block into array of ints corresponding to 1 bits.
BMFORCEINLINE unsigned | bit_count_min_unroll (const bm::word_t *BMRESTRICT block, const bm::word_t *BMRESTRICT block_end) BMNOEXCEPT
| Bitcount for bit block without agressive unrolling.
bm::id_t | bit_block_count (const bm::word_t *block) BMNOEXCEPT
| Bitcount for bit block.
bm::id_t | bit_block_count (const bm::word_t *BMRESTRICT const block, bm::id64_t digest) BMNOEXCEPT
| Bitcount for bit block.
bm::id_t | bit_count_change (bm::word_t w) BMNOEXCEPT
unsigned | bit_block_change32 (const bm::word_t *BMRESTRICT block, unsigned size) BMNOEXCEPT
unsigned | bit_block_change64 (const bm::word_t *BMRESTRICT in_block, unsigned size) BMNOEXCEPT
void | bit_block_change_bc (const bm::word_t *BMRESTRICT block, unsigned *BMRESTRICT gc, unsigned *BMRESTRICT bc) BMNOEXCEPT
unsigned | bit_block_calc_change (const bm::word_t *block) BMNOEXCEPT
bool | bit_block_is_all_one_range (const bm::word_t *const BMRESTRICT block, bm::word_t left, bm::word_t right) BMNOEXCEPT
bm::id_t | bit_block_calc_count_to (const bm::word_t *block, bm::word_t right) BMNOEXCEPT
void | bit_block_rotate_left_1 (bm::word_t *block) BMNOEXCEPT
void | bit_block_rotate_left_1_unr (bm::word_t *block) BMNOEXCEPT
| Unrolled cyclic rotation of bit-block left by 1 bit.
bm::word_t | bit_block_insert (bm::word_t *BMRESTRICT block, unsigned bitpos, bool value) BMNOEXCEPT
| insert bit into position and shift the rest right with carryover
bool | bit_block_shift_r1 (bm::word_t *BMRESTRICT block, bm::word_t *BMRESTRICT empty_acc, bm::word_t co_flag) BMNOEXCEPT
| Right bit-shift bitblock by 1 bit (reference).
bool | bit_block_shift_r1_unr_min (bm::word_t *BMRESTRICT block, bm::word_t *BMRESTRICT empty_acc, bm::id64_t co_flag) BMNOEXCEPT
| Right bit-shift bitblock by 1 bit (minimum unroll).
bool | bit_block_shift_r1_unr (bm::word_t *BMRESTRICT block, bm::word_t *BMRESTRICT empty_acc, bm::word_t co_flag) BMNOEXCEPT
| Right bit-shift of bit-block by 1 bit (loop unrolled).
bool | bit_block_shift_l1 (bm::word_t *block, bm::word_t *empty_acc, bm::word_t co_flag) BMNOEXCEPT
| Left bit-shift bitblock by 1 bit (reference).
bool | bit_block_shift_l1_unr_min (bm::word_t *BMRESTRICT block, bm::word_t *BMRESTRICT empty_acc, unsigned co_flag) BMNOEXCEPT
| Left bit-shift bitblock by 1 bit (minimum unroll).
bool | bit_block_shift_l1_unr (bm::word_t *block, bm::word_t *empty_acc, bm::word_t co_flag) BMNOEXCEPT
| Left bit-shift of bit-block by 1 bit (loop unrolled).
void | bit_block_erase (bm::word_t *block, unsigned bitpos, bool carry_over) BMNOEXCEPT
| erase bit from position and shift the rest right with carryover
bool | bit_block_shift_r1_and (bm::word_t *BMRESTRICT block, bm::word_t co_flag, const bm::word_t *BMRESTRICT mask_block, bm::id64_t *BMRESTRICT digest) BMNOEXCEPT
| Right bit-shift of bit-block by 1 bit (reference) + AND.
bool | bit_block_shift_r1_and_unr (bm::word_t *BMRESTRICT block, bm::word_t co_flag, const bm::word_t *BMRESTRICT mask_block, bm::id64_t *BMRESTRICT digest) BMNOEXCEPT
| Right bit-shift bitblock by 1 bit (reference) + AND.
bm::id_t | bit_block_any_range (const bm::word_t *const BMRESTRICT block, bm::word_t left, bm::word_t right) BMNOEXCEPT
template<typename T>
void | bit_invert (T *start) BMNOEXCEPT
bool | is_bits_one (const bm::wordop_t *start) BMNOEXCEPT
| Returns "true" if all bits in the block are 1.
bool | block_is_all_one_range (const bm::word_t *const BMRESTRICT block, unsigned left, unsigned right) BMNOEXCEPT
| Returns "true" if all bits are 1 in the block [left, right] Function check for block varieties.
bool | block_is_interval (const bm::word_t *const BMRESTRICT block, unsigned left, unsigned right) BMNOEXCEPT
| Returns "true" if all bits are 1 in the block [left, right] and border bits are 0.
bool | bit_block_find_interval_end (const bm::word_t *BMRESTRICT block, unsigned nbit, unsigned *BMRESTRICT pos) BMNOEXCEPT
| Searches for the last 1 bit in the 111 interval of a BIT block.
unsigned | block_find_interval_end (const bm::word_t *BMRESTRICT block, unsigned nbit_from, unsigned *BMRESTRICT found_nbit) BMNOEXCEPT
| Find end of the current 111 interval.
bool | bit_block_find_interval_start (const bm::word_t *BMRESTRICT block, unsigned nbit, unsigned *BMRESTRICT pos) BMNOEXCEPT
| Searches for the first 1 bit in the 111 interval of a BIT block.
bool | bit_block_find_prev (const bm::word_t *BMRESTRICT block, unsigned nbit, unsigned *BMRESTRICT pos) BMNOEXCEPT
| Reverse search for the previous 1 bit.
unsigned | block_find_interval_start (const bm::word_t *BMRESTRICT block, unsigned nbit_from, unsigned *BMRESTRICT found_nbit) BMNOEXCEPT
| Find start of the current 111 interval.
bool | block_find_reverse (const bm::word_t *BMRESTRICT block, unsigned nbit_from, unsigned *BMRESTRICT found_nbit) BMNOEXCEPT
| Reverse find 1.
bool | block_any_range (const bm::word_t *const BMRESTRICT block, unsigned left, unsigned right) BMNOEXCEPT
| Returns "true" if one bit is set in the block [left, right] Function check for block varieties.
bool | block_any (const bm::word_t *const BMRESTRICT block) BMNOEXCEPT
| Returns "true" if one bit is set in the block Function check for block varieties.
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) BMNOEXCEPT
| GAP AND operation.
unsigned | gap_operation_any_and (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2) BMNOEXCEPT
| GAP AND operation test.
unsigned | gap_count_and (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2) BMNOEXCEPT
| GAP bitcount AND operation test.
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) BMNOEXCEPT
| GAP XOR operation.
BMFORCEINLINE unsigned | gap_operation_any_xor (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2) BMNOEXCEPT
| GAP XOR operation test.
BMFORCEINLINE unsigned | gap_count_xor (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2) BMNOEXCEPT
| 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) BMNOEXCEPT
| GAP OR operation.
BMFORCEINLINE unsigned | gap_count_or (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2) BMNOEXCEPT
| 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) BMNOEXCEPT
| GAP SUB (AND NOT) operation.
unsigned | gap_operation_any_sub (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2) BMNOEXCEPT
| GAP SUB operation test.
BMFORCEINLINE unsigned | gap_count_sub (const gap_word_t *BMRESTRICT vect1, const gap_word_t *BMRESTRICT vect2) BMNOEXCEPT
| GAP bitcount SUB (AND NOT) operation test.
void | bit_block_copy (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| Bitblock copy operation.
void | bit_block_copy_unalign (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| Bitblock copy operation (unaligned src).
void | bit_block_stream (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| Bitblock copy/stream operation.
void | bit_block_stream_unalign (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| Bitblock copy/stream operation (unaligned src).
bm::id64_t | bit_block_and (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| Plain bitblock AND operation. Function does not analyse availability of source and destination blocks.
bm::id64_t | bit_block_and (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src, bm::id64_t digest) BMNOEXCEPT
| digest based bit-block AND
bm::id64_t | bit_block_and_5way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src0, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2, const bm::word_t *BMRESTRICT src3, bm::id64_t digest) BMNOEXCEPT
| digest based bit-block AND 5-way
bm::id64_t | bit_block_and_3way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2, bm::id64_t digest) BMNOEXCEPT
| digest based bit-block AND
bm::id64_t | bit_block_and_2way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2, bm::id64_t digest) BMNOEXCEPT
| digest based bit-block AND
bm::id64_t | bit_block_init_and_2way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2, bm::id64_t digest) BMNOEXCEPT
| digest based bit-block AND (0 elements of digest will be zeroed)
bm::id64_t | bit_block_and_or_2way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2, bm::id64_t digest) BMNOEXCEPT
| digest based bit-block AND - OR
unsigned | bit_block_and_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
| 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 *src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| 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 *src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| 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) BMNOEXCEPT
| bitblock AND operation.
bm::id_t | bit_operation_and_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| Performs bitblock AND operation test.
bm::id_t | bit_operation_sub_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| Performs bitblock test of SUB operation.
bm::id_t | bit_operation_or_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| Performs bitblock OR operation test.
bool | bit_block_or (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| Plain bitblock OR operation. Function does not analyse availability of source and destination blocks.
bool | bit_block_or_2way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
| 2 way (target := source1 | source2) bitblock OR operation.
bm::id64_t | bit_block_xor_2way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
| 2 way (target := source1 ^ source2) bitblock XOR operation.
bool | bit_block_or_3way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
| 3 way (target | source1 | source2) bitblock OR operation. Function does not analyse availability of source and destination blocks.
bool | bit_block_or_5way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2, const bm::word_t *BMRESTRICT src3, const bm::word_t *BMRESTRICT src4) BMNOEXCEPT
| 5 way (target, source1, source2) 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) BMNOEXCEPT
| Block OR operation. Makes analysis if block is 0 or FULL.
bm::id64_t | bit_block_sub (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| Plain bitblock SUB (AND NOT) operation. Function does not analyse availability of source and destination blocks.
bm::id64_t | bit_block_sub (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src, bm::id64_t digest) BMNOEXCEPT
| digest based bitblock SUB (AND NOT) operation
bm::id64_t | bit_block_sub_2way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2, bm::id64_t digest) BMNOEXCEPT
| digest based bitblock SUB (AND NOT) operation (3 operand)
bm::id64_t | bit_block_sub_5way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src0, const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2, const bm::word_t *BMRESTRICT src3, bm::id64_t digest) BMNOEXCEPT
| digest based bit-block SUB 5-way
bm::id64_t | bit_block_sub_3way (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src0, const bm::word_t *BMRESTRICT src1, bm::id64_t digest) BMNOEXCEPT
| digest based bit-block SUB 3-way
bm::word_t * | bit_operation_sub (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| bitblock SUB operation.
bm::id64_t | bit_block_xor (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| Plain bitblock XOR operation. Function does not analyse availability of source and destination blocks.
void | bit_andnot_arr_ffmask (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| bitblock AND NOT with constant ~0 mask operation.
bm::word_t * | bit_operation_xor (bm::word_t *BMRESTRICT dst, const bm::word_t *BMRESTRICT src) BMNOEXCEPT
| bitblock XOR operation.
bm::id_t | bit_operation_xor_count (const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
| 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 src2) BMNOEXCEPT
| Performs bitblock XOR operation test.
template<class T>
unsigned | bit_count_nonzero_size (const T *blk, unsigned data_size) BMNOEXCEPT
| Inspects block for full zero words.
unsigned | bit_block_find (const bm::word_t *BMRESTRICT block, unsigned nbit, unsigned *BMRESTRICT pos) BMNOEXCEPT
| Searches for the next 1 bit in the BIT block.
unsigned | bit_find_last (const bm::word_t *BMRESTRICT block, unsigned *BMRESTRICT last) BMNOEXCEPT
| BIT block find the last set bit (backward search).
bool | bit_find_first (const bm::word_t *BMRESTRICT block, unsigned *BMRESTRICT pos) BMNOEXCEPT
| BIT block find the first set bit.
unsigned | bit_find_first (const bm::word_t *BMRESTRICT block, unsigned *BMRESTRICT first, bm::id64_t digest) BMNOEXCEPT
| BIT block find the first set bit.
bool | bit_find_first_if_1 (const bm::word_t *BMRESTRICT block, unsigned *BMRESTRICT first, bm::id64_t digest) BMNOEXCEPT
| BIT block find the first set bit if only 1 bit is set.
template<typename SIZE_TYPE>
SIZE_TYPE | bit_find_rank (const bm::word_t *const block, SIZE_TYPE rank, unsigned nbit_from, unsigned &nbit_pos) BMNOEXCEPT
| BIT block find position for the rank.
template<typename SIZE_TYPE>
SIZE_TYPE | block_find_rank (const bm::word_t *const block, SIZE_TYPE rank, unsigned nbit_from, unsigned &nbit_pos) BMNOEXCEPT
| Find rank in block (GAP or BIT).
bm::set_representation | best_representation (unsigned bit_count, unsigned total_possible_bitcount, unsigned gap_count, unsigned block_size) BMNOEXCEPT
| Choose best representation for a bit-block.
template<typename T>
unsigned | bit_block_convert_to_arr (T *BMRESTRICT dest, const unsigned *BMRESTRICT src, bool inverted) BMNOEXCEPT
| Convert bit block into an array of ints corresponding to 1 bits.
bool | check_block_zero (const bm::word_t *blk, bool deep_scan) BMNOEXCEPT
| Checks all conditions and returns true if block consists of only 0 bits.
bool | check_block_one (const bm::word_t *blk, bool deep_scan) BMNOEXCEPT
| Checks if block has only 1 bits.
template<typename T>
unsigned | gap_overhead (const T *length, const T *length_end, const T *glevel_len) BMNOEXCEPT
| 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) BMNOEXCEPT
| Finds optimal gap blocks lengths.
bool | block_find_first_diff (const bm::word_t *BMRESTRICT blk, const bm::word_t *BMRESTRICT arg_blk, unsigned *BMRESTRICT pos) BMNOEXCEPT
| Find first bit which is different between two blocks (GAP or bit).
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) BMNOEXCEPT
unsigned short | bitscan_wave (const bm::word_t *BMRESTRICT w_ptr, unsigned char *BMRESTRICT bits) BMNOEXCEPT
| Unpacks word wave (Nx 32-bit words).
void | bit_block_gather_scatter (unsigned *BMRESTRICT arr, const bm::word_t *BMRESTRICT blk, const unsigned *BMRESTRICT idx, unsigned size, unsigned start, unsigned bit_idx) BMNOEXCEPT
| bit index to word gather-scatter algorithm (SIMD)
template<typename TRGW, typename IDX, typename SZ>
void | bit_block_gather_scatter (TRGW *BMRESTRICT arr, const bm::word_t *BMRESTRICT blk, const IDX *BMRESTRICT idx, SZ size, SZ start, unsigned bit_idx) BMNOEXCEPT
| bit index to word gather-scatter algorithm
bm::id64_t | idx_arr_block_lookup_u64 (const bm::id64_t *idx, bm::id64_t size, bm::id64_t nb, bm::id64_t start) BMNOEXCEPT
| block boundaries look ahead U32
unsigned | idx_arr_block_lookup_u32 (const unsigned *idx, unsigned size, unsigned nb, unsigned start) BMNOEXCEPT
| block boundaries look ahead U32
void | set_block_bits_u64 (bm::word_t *BMRESTRICT block, const bm::id64_t *BMRESTRICT idx, bm::id64_t start, bm::id64_t stop) BMNOEXCEPT
| set bits in a bit-block using global index
void | set_block_bits_u32 (bm::word_t *BMRESTRICT block, const unsigned *BMRESTRICT idx, unsigned start, unsigned stop) BMNOEXCEPT
| set bits in a bit-block using global index
bool | block_ptr_array_range (bm::word_t **arr, unsigned &left, unsigned &right) BMNOEXCEPT
| array range detector
unsigned | lower_bound_linear_u32 (const unsigned *arr, unsigned target, unsigned from, unsigned to) BMNOEXCEPT
| Linear lower bound search in unsigned array.
unsigned | lower_bound_linear_u64 (const unsigned long long *arr, unsigned long long target, unsigned from, unsigned to) BMNOEXCEPT
| Linear lower bound search in unsigned LONG array.
unsigned | lower_bound_u32 (const unsigned *arr, unsigned target, unsigned from, unsigned to) BMNOEXCEPT
| Hybrid, binary-linear lower bound search in unsigned array.
unsigned | lower_bound_u64 (const unsigned long long *arr, unsigned long long target, unsigned from, unsigned to) BMNOEXCEPT
| Hybrid, binary-linear lower bound search in unsigned LONG array.
bool | find_ptr (const void *const *p_arr, size_t arr_size, const void *ptr, size_t *idx) BMNOEXCEPT
| Scan search for pointer value in unordered array.
bm::id_t | block_to_global_index (unsigned i, unsigned j, unsigned block_idx) BMNOEXCEPT
| calculate bvector<> global bit-index from block-local coords
unsigned | min_delta_u32 (const unsigned *arr, size_t arr_size)
| Calculate minimal delta between elements of sorted array.
void | min_delta_apply (unsigned *arr, size_t arr_size, unsigned delta) BMNOEXCEPT
| Recalculate the array to decrement delta as arr[i] = arr[i] - delta + 1 so that array remains monotonically growing (fit for interpolative compression).
template<typename VT, typename SZ>
bool | find_max_nz (const VT *arr, SZ arr_size, SZ *found_idx) BMNOEXCEPT
| Find max non-zero value in an array.
template<typename VT, typename SZ>
bool | find_first_nz (const VT *arr, SZ arr_size, SZ *found_idx) BMNOEXCEPT
| Find max non-zero value in an array.
template<typename VT, typename SZ>
SZ | count_nz (const VT *arr, SZ arr_size) BMNOEXCEPT
| Find count of non-zero elements in the array.
bm::bit_representation | best_representation (unsigned gc, unsigned bc, unsigned max_bits, float bie_bits_per_int, unsigned *best_metric) BMNOEXCEPT
| Detect best representation for serialization for a block or sub-block.
void | set_nibble (unsigned char *arr, unsigned idx, unsigned char v) BMNOEXCEPT
| set nibble in the array
unsigned char | get_nibble (const unsigned char *arr, unsigned idx) BMNOEXCEPT
| get nibble from the array
bm::id64_t | ptrp_test (ptr_payload_t ptr, bm::gap_word_t v) BMNOEXCEPT
int | simd_version ()
| return SIMD optimization used for building BitMagic
void | bit_block_xor_change32 (const bm::word_t *BMRESTRICT block, const bm::word_t *BMRESTRICT xor_block, unsigned size, unsigned *BMRESTRICT gc, unsigned *BMRESTRICT bc) BMNOEXCEPT
void | bit_block_xor_change64 (const bm::word_t *BMRESTRICT s_block, const bm::word_t *BMRESTRICT ref_block, unsigned size, unsigned *BMRESTRICT gc, unsigned *BMRESTRICT bc) BMNOEXCEPT
void | bit_block_xor_change (const bm::word_t *BMRESTRICT block, const bm::word_t *BMRESTRICT xor_block, unsigned size, unsigned *BMRESTRICT gc, unsigned *BMRESTRICT bc) BMNOEXCEPT
template<typename PVT, typename VT>
VT::size_type | greedy_refine_match_vector (PVT &match_pairs_vect, VT &match_vect, typename VT::size_type best_ref_idx, bm::id64_t d64, bm::xor_complement_match match_type)
| Greedy algorithm to find additional matches improving the inital best match block on its match type.
template<typename BMChain, typename RVect>
unsigned char | check_pair_vect_vbr (const BMChain &mchain, const RVect &ref_vect)
| Check effective bit-rate for the XOR encode vector.
void | compute_s_block_descr (const bm::word_t *BMRESTRICT block, block_waves_xor_descr &BMRESTRICT x_descr, unsigned *BMRESTRICT s_gc, unsigned *BMRESTRICT s_bc) BMNOEXCEPT
| Compute reference (non-XOR) 64-dim complexity descriptor for the s-block.
void | bit_block_xor (bm::word_t *target_block, const bm::word_t *block, const bm::word_t *xor_block, bm::id64_t digest) BMNOEXCEPT
| Build partial XOR product of 2 bit-blocks using digest mask.
void | bit_block_xor (bm::word_t *target_block, const bm::word_t *xor_block, bm::id64_t digest) BMNOEXCEPT
| Build partial XOR product of 2 bit-blocks using digest mask.
bool | check_any_fullb (const bm::word_t *blka[8], const bm::word_t *FBADDR)
bool | test_4gaps (const bm::word_t *p0, const bm::word_t *p1, const bm::word_t *p2, const bm::word_t *p3) BMNOEXCEPT
| Test 4 pointers are all marked as GAPs.
bool | test_4bits (const bm::word_t *p0, const bm::word_t *p1, const bm::word_t *p2, const bm::word_t *p3) BMNOEXCEPT
| Test 4 pointers are not NULL and not marked as FULLBLOCK.
void | sse2_xor_arr_2_mask (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end, bm::word_t mask) BMNOEXCEPT
| XOR array elements to specified mask dst = *src ^ mask.
void | sse2_andnot_arr_2_mask (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end, bm::word_t mask) BMNOEXCEPT
| Inverts array elements and NOT them to specified mask dst = ~*src & mask.
unsigned | sse2_and_block (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| AND blocks2 dst &= *src.
unsigned | sse2_and_arr_unal (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end) BMNOEXCEPT
| AND array elements against another array (unaligned) dst &= *src.
unsigned | sse2_and_block (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end) BMNOEXCEPT
bool | sse2_or_block (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| OR array elements against another array dst |= *src.
bool | sse2_or_arr_unal (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src, const __m128i *BMRESTRICT src_end) BMNOEXCEPT
| OR array elements against another array (unaligned) dst |= *src.
bool | sse2_or_block_2way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| OR 2 blocks anc copy result to the destination dst = *src1 | src2.
bool | sse2_or_block_3way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| OR array elements against another 2 arrays dst |= *src1 | src2.
bool | sse2_or_block_5way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2, const __m128i *BMRESTRICT src3, const __m128i *BMRESTRICT src4) BMNOEXCEPT
| OR array elements against another 2 arrays dst |= *src1 | src2 | src3 | src4.
unsigned | sse2_xor_block (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| XOR block against another dst ^= *src.
unsigned | sse2_xor_block_2way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| 3 operand XOR dst = *src1 ^ src2
unsigned | sse2_sub_block (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| AND-NOT (SUB) array elements against another array dst &= ~*src.
void | sse2_set_block (__m128i *BMRESTRICT dst, bm::word_t value) BMNOEXCEPT
| SSE2 block memset dst = value.
void | sse2_copy_block (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| SSE2 block copy dst = *src.
void | sse2_copy_block_unalign (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| SSE2 block copy (unaligned SRC) dst = *src.
void | sse2_stream_block (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| SSE2 block copy dst = *src.
void | sse2_stream_block_unalign (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| SSE2 block copy (unaligned src) dst = *src.
void | sse2_invert_block (__m128i *BMRESTRICT dst) BMNOEXCEPT
| Invert bit block dst = ~*dst or dst ^= *dst.
BMFORCEINLINE __m128i | sse2_and (__m128i a, __m128i b) BMNOEXCEPT
BMFORCEINLINE __m128i | sse2_or (__m128i a, __m128i b) BMNOEXCEPT
BMFORCEINLINE __m128i | sse2_xor (__m128i a, __m128i b) BMNOEXCEPT
BMFORCEINLINE __m128i | sse2_sub (__m128i a, __m128i b) BMNOEXCEPT
const bm::gap_word_t * | sse2_gap_sum_arr (const bm::gap_word_t *BMRESTRICT pbuf, unsigned sse_vect_waves, unsigned *sum) BMNOEXCEPT
| Gap block population count (array sum) utility.
unsigned | sse2_lower_bound_scan_u32 (const unsigned *BMRESTRICT arr, unsigned target, unsigned from, unsigned to) BMNOEXCEPT
| lower bound (great or equal) linear scan in ascending order sorted array
bm::id_t | avx2_bit_count (const __m256i *BMRESTRICT block, const __m256i *BMRESTRICT block_end)
| AVX2 Harley-Seal popcount The algorithm is based on the paper "Faster Population Counts using AVX2 Instructions" by Daniel Lemire, Nathan Kurz and Wojciech Mula (23 Nov 2016).
bm::id_t | avx2_bit_block_count (const bm::word_t *const block, bm::id64_t digest)
| Calculate population count based on digest.
bm::id_t | avx2_bit_count_and (const __m256i *BMRESTRICT block, const __m256i *BMRESTRICT block_end, const __m256i *BMRESTRICT mask_block)
| AND bit count for two aligned bit-blocks.
bm::id_t | avx2_bit_count_or (const __m256i *BMRESTRICT block, const __m256i *BMRESTRICT block_end, const __m256i *BMRESTRICT mask_block)
bm::id_t | avx2_bit_count_xor (const __m256i *BMRESTRICT block, const __m256i *BMRESTRICT block_end, const __m256i *BMRESTRICT mask_block)
| XOR bit count for two aligned bit-blocks.
bm::id_t | avx2_bit_count_sub (const __m256i *BMRESTRICT block, const __m256i *BMRESTRICT block_end, const __m256i *BMRESTRICT mask_block)
| AND NOT bit count for two aligned bit-blocks.
void | avx2_xor_arr_2_mask (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src, const __m256i *BMRESTRICT src_end, bm::word_t mask)
| XOR array elements to specified mask dst = *src ^ mask.
void | avx2_andnot_arr_2_mask (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src, const __m256i *BMRESTRICT src_end, bm::word_t mask)
| Inverts array elements and NOT them to specified mask dst = ~*src & mask.
unsigned | avx2_and_block (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| AND array elements against another array dst &= *src.
bool | avx2_and_digest (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| AND block digest stride dst &= *src.
bool | avx2_and_digest_2way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2)
| AND block digest stride 2 way dst = *src1 & *src2.
bool | avx2_and_or_digest_2way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2)
| AND-OR block digest stride 2 way dst |= *src1 & *src2.
bool | avx2_and_digest_5way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2, const __m256i *BMRESTRICT src3, const __m256i *BMRESTRICT src4)
| AND block digest stride.
bool | avx2_and_digest_3way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2)
| AND block digest stride.
unsigned | avx2_and_arr_unal (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src, const __m256i *BMRESTRICT src_end)
| AND array elements against another array (unaligned) dst &= *src.
bool | avx2_or_block (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| OR array elements against another array dst |= *src.
bool | avx2_or_arr_unal (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src, const __m256i *BMRESTRICT src_end)
| OR array elements against another unaligned array dst |= *src.
bool | avx2_or_block_2way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2)
| OR 2 arrays and copy to the destination dst = *src1 | src2.
bool | avx2_or_block_3way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2)
| OR array elements against another 2 arrays dst |= *src1 | src2.
bool | avx2_or_block_5way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2, const __m256i *BMRESTRICT src3, const __m256i *BMRESTRICT src4)
| OR array elements against another 4 arrays dst |= *src1 | src2.
unsigned | avx2_xor_block (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| XOR block against another dst ^= *src.
unsigned | avx2_xor_block_2way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2)
| 3 operand XOR dst = *src1 ^ src2
unsigned | avx2_sub_block (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| AND-NOT (SUB) array elements against another array dst &= ~*src.
bool | avx2_sub_digest (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| SUB (AND NOT) block digest stride dst &= ~*src.
bool | avx2_sub_digest_2way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2)
| 2-operand SUB (AND NOT) block digest stride dst = *src1 & ~*src2
bool | avx2_sub_digest_5way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2, const __m256i *BMRESTRICT src3, const __m256i *BMRESTRICT src4)
| SUB block digest stride.
bool | avx2_sub_digest_3way (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src1, const __m256i *BMRESTRICT src2)
| SUB block digest stride.
BMFORCEINLINE void | avx2_set_block (__m256i *BMRESTRICT dst, bm::word_t value)
| AVX2 block memset dst = value.
void | avx2_copy_block (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| AVX2 block copy dst = *src.
void | avx2_copy_block_unalign (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| AVX2 block copy (unaligned SRC) dst = *src.
void | avx2_stream_block (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| AVX2 block copy dst = *src.
void | avx2_stream_block_unalign (__m256i *BMRESTRICT dst, const __m256i *BMRESTRICT src)
| AVX2 block copy (unaligned SRC) dst = *src.
void | avx2_invert_block (__m256i *BMRESTRICT dst)
| Invert bit-block dst = ~*dst or dst ^= *dst.
bool | avx2_is_all_zero (const __m256i *BMRESTRICT block)
| check if block is all zero bits
bool | avx2_is_digest_zero (const __m256i *BMRESTRICT block)
| check if digest stride is all zero bits
void | avx2_block_set_digest (__m256i *dst, unsigned value)
| set digest stride to 0xFF.. or 0x0 value
bool | avx2_is_all_one (const __m256i *BMRESTRICT block)
| check if block is all one bits
BMFORCEINLINE bool | avx2_test_all_one_wave (const void *ptr)
| check if wave of pointers is all 0xFFF
BMFORCEINLINE bool | avx2_test_all_zero_wave (const void *ptr)
| check if wave of pointers is all NULL
BMFORCEINLINE bool | avx2_test_all_zero_wave2 (const void *ptr0, const void *ptr1)
| check if 2 wave of pointers are all NULL
BMFORCEINLINE bool | avx2_test_all_eq_wave2 (const void *ptr0, const void *ptr1)
| check if 2 wave of pointers are all the same (NULL or FULL)
bool | avx2_shift_l1 (__m256i *block, bm::word_t *empty_acc, unsigned co1)
| block shift left by 1
bool | avx2_shift_r1 (__m256i *block, bm::word_t *empty_acc, unsigned co1)
| block shift right by 1
bool | avx2_shift_r1_and (__m256i *BMRESTRICT block, bm::word_t co1, const __m256i *BMRESTRICT mask_block, bm::id64_t *BMRESTRICT digest)
| fused block shift right by 1 plus AND
unsigned | avx2_bit_block_calc_change (const __m256i *BMRESTRICT block, unsigned size)
void | avx2_bit_block_calc_xor_change (const __m256i *BMRESTRICT block, const __m256i *BMRESTRICT xor_block, unsigned size, unsigned *BMRESTRICT gcount, unsigned *BMRESTRICT bcount)
void | avx2_bit_block_calc_change_bc (const __m256i *BMRESTRICT block, unsigned *gcount, unsigned *bcount)
bool | avx2_bit_find_first_diff (const __m256i *BMRESTRICT block1, const __m256i *BMRESTRICT block2, unsigned *pos)
| Find first bit which is different between two bit-blocks.
bool | avx2_bit_find_first (const __m256i *BMRESTRICT block, unsigned off, unsigned *pos)
| Find first bit set.
const bm::gap_word_t * | avx2_gap_sum_arr (const bm::gap_word_t *pbuf, unsigned avx_vect_waves, unsigned *sum)
unsigned | avx2_idx_arr_block_lookup (const unsigned *idx, unsigned size, unsigned nb, unsigned start)
void | avx2_set_block_bits (bm::word_t *BMRESTRICT block, const unsigned *BMRESTRICT idx, unsigned start, unsigned stop)
BMFORCEINLINE __m256i | avx2_setbit_256 (__m256i target, __m256i source)
| Set a bits in an AVX target, by indexes (int4) from the source.
void | avx2_set_block_bits2 (bm::word_t *BMRESTRICT block, const unsigned *BMRESTRICT idx, unsigned start, unsigned stop)
| Experimental code to set bits via AVX strides.
void | avx2_set_block_bits3 (bm::word_t *BMRESTRICT block, const unsigned *BMRESTRICT idx, unsigned start, unsigned stop)
| Experimental code to set bits via AVX strides.
__m256i | avx2_setbit_to256 (unsigned i)
| Experiemntal.
int | avx2_cmpge_u32 (__m256i vect8, unsigned value)
| Experimental (test) function to do SIMD vector search (lower bound) in sorted, growing array.
int | avx2_cmpge_u16 (__m256i vect16, unsigned short value)
| Experimental (test) function to do SIMD vector search in sorted, growing array.
template<bool RET_TEST = false>
unsigned | avx2_gap_bfind (const unsigned short *BMRESTRICT buf, unsigned pos, unsigned *BMRESTRICT is_set)
| Hybrid binary search, starts as binary, then switches to scan.
unsigned | avx2_gap_test (const unsigned short *BMRESTRICT buf, unsigned pos)
| Hybrid binary search, starts as binary, then switches to scan.
unsigned | avx2_lower_bound_scan_u32 (const unsigned *BMRESTRICT arr, unsigned target, unsigned from, unsigned to)
| lower bound (great or equal) linear scan in ascending order sorted array
void | avx2_bit_block_gather_scatter (unsigned *BMRESTRICT arr, const unsigned *BMRESTRICT blk, const unsigned *BMRESTRICT idx, unsigned size, unsigned start, unsigned bit_idx)
unsigned | avx2_bit_to_gap (gap_word_t *BMRESTRICT dest, const unsigned *BMRESTRICT block, unsigned dest_len)
| Convert bit block to GAP block.
void | avx2_bit_block_xor (bm::word_t *target_block, const bm::word_t *block, const bm::word_t *xor_block, bm::id64_t digest)
| Build partial XOR product of 2 bit-blocks using digest mask.
void | avx2_bit_block_xor_2way (bm::word_t *target_block, const bm::word_t *xor_block, bm::id64_t digest) BMNOEXCEPT
| Build partial XOR product of 2 bit-blocks using digest mask.
bm::id_t | sse4_bit_count (const __m128i *block, const __m128i *block_end) BMNOEXCEPT
bm::id_t | sse42_bit_count_digest (const bm::word_t *BMRESTRICT block, bm::id64_t digest) BMNOEXCEPT
BMFORCEINLINE unsigned | op_xor (unsigned a, unsigned b) BMNOEXCEPT
BMFORCEINLINE unsigned | op_or (unsigned a, unsigned b) BMNOEXCEPT
BMFORCEINLINE unsigned | op_and (unsigned a, unsigned b) BMNOEXCEPT
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) BMNOEXCEPT
bool | sse4_is_all_zero (const __m128i *BMRESTRICT block) BMNOEXCEPT
| check if block is all zero bits
BMFORCEINLINE bool | sse4_is_digest_zero (const __m128i *BMRESTRICT block) BMNOEXCEPT
| check if digest stride is all zero bits
BMFORCEINLINE void | sse4_block_set_digest (__m128i *dst, unsigned value) BMNOEXCEPT
| set digest stride to 0xFF.. or 0x0 value
unsigned | sse4_and_block (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| AND blocks2 dst &= *src.
BMFORCEINLINE bool | sse4_and_digest (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| AND block digest stride dst &= *src.
BMFORCEINLINE bool | sse4_and_digest_2way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| AND block digest stride dst = *src1 & src2.
bool | sse4_and_or_digest_2way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| AND-OR block digest stride dst |= *src1 & src2.
bool | sse4_and_digest_3way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| AND block digest stride.
bool | sse4_and_digest_5way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2, const __m128i *BMRESTRICT src3, const __m128i *BMRESTRICT src4) BMNOEXCEPT
| AND block digest stride.
BMFORCEINLINE bool | sse4_sub_digest (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| SUB (AND NOT) block digest stride dst &= ~*src.
BMFORCEINLINE bool | sse4_sub_digest_2way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| 2-operand SUB (AND NOT) block digest stride dst = src1 & ~*src2
bool | sse4_sub_digest_5way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2, const __m128i *BMRESTRICT src3, const __m128i *BMRESTRICT src4) BMNOEXCEPT
| SUB block digest stride.
bool | sse4_sub_digest_3way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| SUB block digest stride.
bool | sse4_is_all_one (const __m128i *BMRESTRICT block) BMNOEXCEPT
| check if block is all ONE bits
BMFORCEINLINE bool | sse42_test_all_one_wave (const void *ptr) BMNOEXCEPT
| check if SSE wave is all oxFFFF...FFF
BMFORCEINLINE bool | sse42_test_all_zero_wave (const void *ptr) BMNOEXCEPT
| check if wave of pointers is all NULL
BMFORCEINLINE bool | sse42_test_all_zero_wave2 (const void *ptr0, const void *ptr1) BMNOEXCEPT
| check if 2 waves of pointers are all NULL
BMFORCEINLINE bool | sse42_test_all_eq_wave2 (const void *ptr0, const void *ptr1) BMNOEXCEPT
| check if wave of 2 pointers are the same (null or FULL)
unsigned | sse42_bit_block_calc_change (const __m128i *BMRESTRICT block, unsigned size) BMNOEXCEPT
void | sse42_bit_block_calc_xor_change (const __m128i *BMRESTRICT block, const __m128i *BMRESTRICT xor_block, unsigned size, unsigned *BMRESTRICT gc, unsigned *BMRESTRICT bc) BMNOEXCEPT
void | sse42_bit_block_calc_change_bc (const __m128i *BMRESTRICT block, unsigned *gc, unsigned *bc) BMNOEXCEPT
bool | sse42_bit_find_first_diff (const __m128i *BMRESTRICT block1, const __m128i *BMRESTRICT block2, unsigned *pos) BMNOEXCEPT
| Find first bit which is different between two bit-blocks.
bool | sse42_bit_find_first (const __m128i *BMRESTRICT block, unsigned off, unsigned *pos) BMNOEXCEPT
| Find first non-zero bit.
unsigned | sse4_gap_find (const bm::gap_word_t *BMRESTRICT pbuf, const bm::gap_word_t pos, const unsigned size) BMNOEXCEPT
unsigned | sse42_gap_bfind (const unsigned short *BMRESTRICT buf, unsigned pos, unsigned *BMRESTRICT is_set) BMNOEXCEPT
| Hybrid binary search, starts as binary, then switches to linear scan.
unsigned | sse42_gap_test (const unsigned short *BMRESTRICT buf, unsigned pos) BMNOEXCEPT
| Hybrid binary search to test GAP value, starts as binary, then switches to scan.
int | sse42_cmpge_u32 (__m128i vect4, unsigned value) BMNOEXCEPT
| Experimental (test) function to do SIMD vector search (lower bound) in sorted, growing array.
unsigned | sse42_idx_arr_block_lookup (const unsigned *idx, unsigned size, unsigned nb, unsigned start) BMNOEXCEPT
void | sse42_set_block_bits (bm::word_t *BMRESTRICT block, const unsigned *BMRESTRICT idx, unsigned start, unsigned stop) BMNOEXCEPT
void | sse4_bit_block_gather_scatter (unsigned *BMRESTRICT arr, const unsigned *BMRESTRICT blk, const unsigned *BMRESTRICT idx, unsigned size, unsigned start, unsigned bit_idx) BMNOEXCEPT
bool | sse42_shift_l1 (__m128i *block, unsigned *empty_acc, unsigned co1) BMNOEXCEPT
| block shift left by 1
bool | sse42_shift_r1 (__m128i *block, unsigned *empty_acc, unsigned co1) BMNOEXCEPT
| block shift right by 1
bool | sse42_shift_r1_and (__m128i *block, bm::word_t co1, const __m128i *BMRESTRICT mask_block, bm::id64_t *digest) BMNOEXCEPT
| block shift right by 1 plus AND
void | sse42_bit_block_xor (bm::word_t *target_block, const bm::word_t *block, const bm::word_t *xor_block, bm::id64_t digest) BMNOEXCEPT
| Build partial XOR product of 2 bit-blocks using digest mask.
void | sse42_bit_block_xor_2way (bm::word_t *target_block, const bm::word_t *xor_block, bm::id64_t digest) BMNOEXCEPT
| Build partial XOR product of 2 bit-blocks using digest mask.
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)
bool | sse2_is_all_zero (const __m128i *BMRESTRICT block) BMNOEXCEPT
| check if block is all zero bits
bool | sse2_is_all_one (const __m128i *BMRESTRICT block) BMNOEXCEPT
| check if block is all ONE bits
BMFORCEINLINE bool | sse2_is_digest_zero (const __m128i *BMRESTRICT block) BMNOEXCEPT
| check if digest stride is all zero bits
BMFORCEINLINE void | sse2_block_set_digest (__m128i *dst, unsigned value) BMNOEXCEPT
| set digest stride to 0xFF.. or 0x0 value
void | sse2_bit_block_xor (bm::word_t *target_block, const bm::word_t *block, const bm::word_t *xor_block, bm::id64_t digest) BMNOEXCEPT
| Build partial XOR product of 2 bit-blocks using digest mask.
void | sse2_bit_block_xor_2way (bm::word_t *target_block, const bm::word_t *xor_block, bm::id64_t digest) BMNOEXCEPT
| Build partial XOR product of 2 bit-blocks using digest mask.
BMFORCEINLINE bool | sse2_and_digest (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| AND block digest stride dst &= *src.
BMFORCEINLINE bool | sse2_and_or_digest_2way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| AND-OR block digest stride dst |= *src1 & src2.
bool | sse2_and_digest_5way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2, const __m128i *BMRESTRICT src3, const __m128i *BMRESTRICT src4) BMNOEXCEPT
| AND block digest stride.
bool | sse2_and_digest_3way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| AND block digest stride.
BMFORCEINLINE bool | sse2_and_digest_2way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| AND block digest stride dst = *src1 & src2.
BMFORCEINLINE bool | sse2_sub_digest (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src) BMNOEXCEPT
| SUB (AND NOT) block digest stride dst &= ~*src.
BMFORCEINLINE bool | sse2_sub_digest_2way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| 2-operand SUB (AND NOT) block digest stride dst = src1 & ~*src2
bool | sse2_sub_digest_5way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2, const __m128i *BMRESTRICT src3, const __m128i *BMRESTRICT src4) BMNOEXCEPT
| SUB block digest stride.
bool | sse2_sub_digest_3way (__m128i *BMRESTRICT dst, const __m128i *BMRESTRICT src1, const __m128i *BMRESTRICT src2) BMNOEXCEPT
| SUB block digest stride.
bool | sse2_bit_find_first (const __m128i *BMRESTRICT block, unsigned off, unsigned *pos) BMNOEXCEPT
| Find first non-zero bit.
bool | sse2_bit_find_first_diff (const __m128i *BMRESTRICT block1, const __m128i *BMRESTRICT block2, unsigned *pos) BMNOEXCEPT
| Find first bit which is different between two bit-blocks.
bool | sse2_shift_r1 (__m128i *block, unsigned *empty_acc, unsigned co1) BMNOEXCEPT
| block shift right by 1
bool | sse2_shift_l1 (__m128i *block, unsigned *empty_acc, unsigned co1) BMNOEXCEPT
| block shift left by 1
bm::id_t | sse2_bit_block_calc_count_change (const __m128i *BMRESTRICT block, const __m128i *BMRESTRICT block_end, unsigned *BMRESTRICT bit_count)
unsigned | sse2_gap_find (const bm::gap_word_t *BMRESTRICT pbuf, const bm::gap_word_t pos, unsigned size)
unsigned | sse2_gap_bfind (const unsigned short *BMRESTRICT buf, unsigned pos, unsigned *BMRESTRICT is_set)
| Hybrid binary search, starts as binary, then switches to linear scan.
unsigned | sse2_gap_test (const unsigned short *BMRESTRICT buf, unsigned pos)
| Hybrid binary search, starts as binary, then switches to scan.
template<class BV>
BV::size_type | count_and (const BV &bv1, const BV &bv2) BMNOEXCEPT
| Computes bitcount of AND operation of two bitsets.
template<class BV>
BV::size_type | any_and (const BV &bv1, const BV &bv2) BMNOEXCEPT
| Computes if there is any bit in AND operation of two bitsets.
template<class BV>
bm::distance_metric_descriptor::size_type | count_xor (const BV &bv1, const BV &bv2) BMNOEXCEPT
| Computes bitcount of XOR operation of two bitsets.
template<class BV>
BV::size_type | any_xor (const BV &bv1, const BV &bv2) BMNOEXCEPT
| Computes if there is any bit in XOR operation of two bitsets.
template<class BV>
BV::size_type | count_sub (const BV &bv1, const BV &bv2) BMNOEXCEPT
| Computes bitcount of SUB operation of two bitsets.
template<class BV>
BV::size_type | any_sub (const BV &bv1, const BV &bv2) BMNOEXCEPT
| Computes if there is any bit in SUB operation of two bitsets.
template<class BV>
BV::size_type | count_or (const BV &bv1, const BV &bv2) BMNOEXCEPT
| Computes bitcount of OR operation of two bitsets.
template<class BV>
BV::size_type | any_or (const BV &bv1, const BV &bv2) BMNOEXCEPT
| Computes if there is any bit in OR operation of two bitsets.
template<class BV, class Func>
int | for_each_bit (const BV &bv, Func &bit_functor)
| bit-vector visitor scanner to traverse each 1 bit using C++ visitor
template<class BV, class Func>
int | for_each_bit_range (const BV &bv, typename BV::size_type left, typename BV::size_type right, Func &bit_functor)
| bit-vector range visitor to traverse each 1 bit
template<class BV>
int | visit_each_bit (const BV &bv, void *handle_ptr, bit_visitor_callback_type callback_ptr)
| bvector visitor scanner to traverse each 1 bit using C callback
template<class BV>
int | visit_each_bit_range (const BV &bv, typename BV::size_type left, typename BV::size_type right, void *handle_ptr, bit_visitor_callback_type callback_ptr)
| bvector visitor scanner to traverse each bits in range (C callback)
template<typename BV, typename PairVect>
void | rank_range_split (const BV &bv, typename BV::size_type rank, PairVect &target_v)
| Algorithm to identify bit-vector ranges (splits) for the rank.
distance_metric | operation2metric (set_operation op) BMNOEXCEPT
| 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) BMNOEXCEPT
| Internal function computes different distance metrics.
unsigned | combine_count_and_operation_with_block (const bm::word_t *blk, const bm::word_t *arg_blk) BMNOEXCEPT
| Internal function computes AND distance.
void | combine_any_operation_with_block (const bm::word_t *blk, unsigned gap, const bm::word_t *arg_blk, unsigned arg_gap, distance_metric_descriptor *dmit, distance_metric_descriptor *dmit_end) BMNOEXCEPT
| 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) BMNOEXCEPT
bm::distance_metric_descriptor::size_type | combine_any_operation_with_block (const bm::word_t *blk, unsigned gap, const bm::word_t *arg_blk, unsigned arg_gap, distance_metric metric) BMNOEXCEPT
void | distance_stage (const distance_metric_descriptor *dmit, const distance_metric_descriptor *dmit_end, bool *is_all_and) BMNOEXCEPT
| 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) BMNOEXCEPT
| Distance computing template function.
template<class BV>
BV::size_type | distance_and_operation (const BV &bv1, const BV &bv2) BMNOEXCEPT
| 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) BMNOEXCEPT
| Distance screening template function.
template<typename It, typename SIZE_TYPE>
It | block_range_scan (It first, It last, SIZE_TYPE nblock, SIZE_TYPE *max_id) BMNOEXCEPT
| 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>
BV::size_type | count_intervals (const BV &bv)
| Compute number of bit intervals (GAPs) in the bitvector.
template<typename 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 Func, typename SIZE_TYPE>
int | for_each_bit_blk (const bm::word_t *block, SIZE_TYPE offset, Func &bit_functor)
| for-each visitor, calls a visitor functor for each 1 bit group
template<typename Func, typename SIZE_TYPE>
int | for_each_bit_blk (const bm::word_t *block, SIZE_TYPE offset, unsigned left, unsigned right, Func &bit_functor)
| for-each range visitor, calls a visitor functor for each 1 bit group
template<typename T, typename Func, typename SIZE_TYPE>
int | for_each_gap_blk (const T *buf, SIZE_TYPE offset, Func &bit_functor)
| for-each visitor, calls a special visitor functor for each 1 bit range
template<typename T, typename Func, typename SIZE_TYPE>
int | for_each_gap_blk_range (const T *BMRESTRICT buf, SIZE_TYPE offset, unsigned left, unsigned right, Func &bit_functor)
| for-each visitor, calls a special visitor functor for each 1 bit range
template<typename T, typename N, typename F>
int | for_each_bit_block_range (T ***root, N top_size, N nb_from, N nb_to, F &f)
template<class BV, class Func>
int | for_each_bit_range_no_check (const BV &bv, typename BV::size_type left, typename BV::size_type right, Func &bit_functor)
| Implementation of for_each_bit_range without boilerplave checks.
template<typename BV, typename VECT>
void | convert_sub_to_arr (const BV &bv, unsigned sb, VECT &vect)
| convert sub-blocks to an array of set 1s (32-bit)
template<class SIMBATCH, class SV>
void | build_jaccard_similarity_batch (SIMBATCH &sbatch, const SV &sv)
| Utility function to build jaccard similarity batch for sparse_vector<>.
template<class BV>
bool | is_interval (const BV &bv, typename BV::size_type left, typename BV::size_type right) BMNOEXCEPT
| Returns true if range is all 1s flanked with 0s Function performs the test on a closed range [left, right] true interval is all 1s AND test(left-1)==false AND test(right+1)==false Examples: 01110 [1,3] - true 11110 [0,3] - true 11110 [1,3] - false.
template<class BV>
bool | find_interval_start (const BV &bv, typename BV::size_type from, typename BV::size_type &pos) BMNOEXCEPT
| Reverse find index of first 1 bit gap (01110) starting from position Reverse scan for the first 1 in a block of continious 1s. Method employs closed interval semantics: 0[pos..from].
template<typename BV>
bool | find_interval_end (const BV &bv, typename BV::size_type from, typename BV::size_type &pos) BMNOEXCEPT
| Reverse find index of first 1 bit gap (01110) starting from position Reverse scan for the first 1 in a block of continious 1s. Method employs closed interval semantics: 0[pos..from].
template<class BV>
void | init_kleene (BV &bv_value, const BV &bv_null)
| Initialized the value bit-vector so that it always returns 0 (false) for the unknown.
template<class BV>
int | get_value_kleene (const BV &bv_value, const BV &bv_null, typename BV::size_type idx) BMNOEXCEPT
| Return Kleene logic value based on value and known vectors.
template<class BV>
void | set_value_kleene (BV &bv_value, BV &bv_null, typename BV::size_type idx, int val)
| Set Kleene logic value based on value and known vectors.
template<class BV>
void | invert_kleene (BV &bv_value, const BV &bv_null)
| Kleene NEG operation.
template<class BV>
void | or_kleene (BV &bv_value1, BV &bv_null1, const BV &bv_value2, const BV &bv_null2)
| Kleene OR(vect1, vect2) (vect1 |= vect2) 1 OR Unk = 1 (known).
template<class BV>
void | or_kleene (BV &bv_value_target, BV &bv_null_target, const BV &bv_value1, const BV &bv_null1, const BV &bv_value2, const BV &bv_null2)
| 3-way Kleene OR: target := OR(vect1, vect2) (target := vect1 | vect2) 1 OR Unk = 1 (known)
template<class BV>
void | and_kleene (BV &bv_value1, BV &bv_null1, const BV &bv_value2, const BV &bv_null2)
| Kleene AND(vect1, vect2) (vect1 &= vect2) 0 AND Unk = 0 (known).
template<class BV>
void | and_kleene (BV &bv_value_target, BV &bv_null_target, const BV &bv_value1, const BV &bv_null1, const BV &bv_value2, const BV &bv_null2)
| 3-way Kleene target:=AND(vect1, vect2) (target:= vect1 & vect2) 0 AND Unk = 0 (known)
int | and_values_kleene (int a, int b) BMNOEXCEPT
| Reference function for Kleene logic AND (for verification and testing).
int | or_values_kleene (int a, int b) BMNOEXCEPT
| Reference function for Kleene logic OR (for verification and testing).
template<class BV>
void | bit_import_u32 (BV &bv, const unsigned int *BMRESTRICT bit_arr, typename BV::size_type bit_arr_size, bool optimize)
| Import native stream of bits (represented as 32-bit unsigned ints).
void | run_task_batch (task_batch_base &tasks)
| Run task batch sequentially.
template<typename TCont>
void | join_multiple_threads (TCont &tcont)
| Wait for multiple threads to exit.
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 plane count BPS - bit plane 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 plane count BPS - bit plane 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 planes(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_plane_cnt][bm::set_block_plane_size], const unsigned char *BMRESTRICT pc_vector, const unsigned char *BMRESTRICT pc_vector_end, unsigned tmatrix_out[bm::set_block_plane_cnt][bm::set_block_plane_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, typename BT>
void | gap_2_bitblock (const GT *BMRESTRICT gap_buf, BT *BMRESTRICT block, unsigned block_size)
| Copy GAP block body to bit block with DGap transformation.
template<typename TM>
unsigned | find_effective_columns (const TM &tmatrix)
| Compute effective right column border of the t-matrix.
template<typename T>
BMFORCEINLINE T | min_value (T v1, T v2) BMNOEXCEPT
| Get minimum of 2 values.
template<typename T>
BMFORCEINLINE T | ilog2 (T x) BMNOEXCEPT
| Fast loop-less function to find LOG2.
template<>
BMFORCEINLINE bm::gap_word_t | ilog2 (gap_word_t x) BMNOEXCEPT
BMFORCEINLINE unsigned | count_leading_zeros (unsigned x) BMNOEXCEPT
| Portable LZCNT with (uses minimal LUT).
BMFORCEINLINE unsigned | count_trailing_zeros (unsigned v) BMNOEXCEPT
| Portable TZCNT with (uses 37-LUT).
template<typename T>
BMFORCEINLINE T | ilog2_LUT (T x) BMNOEXCEPT
| Lookup table based integer LOG2.
template<>
BMFORCEINLINE bm::gap_word_t | ilog2_LUT< bm::gap_word_t > (bm::gap_word_t x) BMNOEXCEPT
| Lookup table based short integer LOG2.
template<typename T>
BMFORCEINLINE T | bit_scan_fwd (T v) BMNOEXCEPT
BMFORCEINLINE unsigned | bit_scan_reverse32 (unsigned w) BMNOEXCEPT
BMFORCEINLINE unsigned | bit_scan_forward32 (unsigned w) BMNOEXCEPT
BMFORCEINLINE unsigned long long | bmi_bslr_u64 (unsigned long long w) BMNOEXCEPT
BMFORCEINLINE unsigned long long | bmi_blsi_u64 (unsigned long long w)
unsigned | count_leading_zeros_u32 (unsigned w) BMNOEXCEPT
| 32-bit bit-scan reverse
unsigned | count_leading_zeros_u64 (bm::id64_t w) BMNOEXCEPT
| 64-bit bit-scan reverse
unsigned | count_trailing_zeros_u32 (unsigned w) BMNOEXCEPT
| 32-bit bit-scan fwd
unsigned | count_trailing_zeros_u64 (bm::id64_t w) BMNOEXCEPT
| 64-bit bit-scan fwd
template<class T>
unsigned | bit_scan_reverse (T value) BMNOEXCEPT
BMFORCEINLINE unsigned | mask_r_u32 (unsigned nbit) BMNOEXCEPT
BMFORCEINLINE unsigned | mask_l_u32 (unsigned nbit) BMNOEXCEPT
template<typename W>
BMFORCEINLINE void | xor_swap (W &x, W &y) BMNOEXCEPT
| XOR swap two variables.
unsigned | compute_h64_mask (unsigned long long w) BMNOEXCEPT
| Сompute mask of bytes presense in 64-bit word.
BMFORCEINLINE bool | has_zero_byte_u64 (bm::id64_t v) BMNOEXCEPT
| Returns true if INT64 contains 0 octet.
BMFORCEINLINE bm::id_t | word_bitcount (bm::id_t w) BMNOEXCEPT
BMFORCEINLINE unsigned | word_bitcount64 (bm::id64_t x) BMNOEXCEPT
template<typename T>
bool | is_aligned (T *p) BMNOEXCEPT
| Check pointer alignment.
template<class BV>
size_t | serialize (const BV &bv, unsigned char *buf, bm::word_t *temp_block=0, unsigned serialization_flags=0)
| Saves bitvector into memory.
template<class BV>
size_t | serialize (BV &bv, unsigned char *buf, unsigned serialization_flags=0)
| Saves bitvector into memory. Allocates temporary memory block for bvector.
template<class BV>
size_t | deserialize (BV &bv, const unsigned char *buf, bm::word_t *temp_block=0, const bm::bv_ref_vector< BV > *ref_vect=0)
| Bitvector deserialization from a memory BLOB.
template<class BV>
void | deserialize_range (BV &bv, const unsigned char *buf, typename BV::size_type from, typename BV::size_type to, const bm::bv_ref_vector< BV > *ref_vect=0)
| Bitvector range deserialization from a memory BLOB.
template<class BV>
BV::size_type | process_operation (BV &bv, BV &bv_tmp, bm::set_operation op)
| Utility function to process operation using temp vector.
void * | aligned_new_malloc (size_t size)
| Aligned malloc (unlike classic malloc it throws bad_alloc exception).
void | aligned_free (void *ptr) BMNOEXCEPT
| Aligned free.
template<typename SV>
void | dynamic_range_clip_high (SV &svect, unsigned high_bit)
| Clip dynamic range for signal higher than specified.
template<typename SV>
void | dynamic_range_clip_low (SV &svect, unsigned low_bit)
| Clip dynamic range for signal lower than specified (boost).
template<typename SV>
bool | sparse_vector_find_first_mismatch (const SV &sv1, const SV &sv2, typename SV::size_type &midx, bm::null_support null_proc=bm::use_null)
| Find first mismatch (element which is different) between two sparse vectors (uses linear scan in bit-vector planes).
template<typename SV1, typename SV2>
void | sparse_vector_find_mismatch (typename SV1::bvector_type &bv, const SV1 &sv1, const SV2 &sv2, bm::null_support null_proc)
| Find mismatch vector, indicating positions of mismatch between two sparse vectors (uses linear scan in bit-vector planes).
template<class SV>
void | sparse_vector_serialize (const SV &sv, sparse_vector_serial_layout< SV > &sv_layout, bm::word_t *temp_block=0)
| Serialize sparse vector into a memory buffer(s) structure.
template<class SV>
int | sparse_vector_deserialize (SV &sv, const unsigned char *buf, bm::word_t *temp_block=0)
| Deserialize sparse vector.

## Variables

template<bool T>
all_set< T >::all_set_block | all_set< T >::_block
template<bool T>
gap_operation_to_bitset_func_type | operation_functions< T >::gap2bit_table_ [bm::set_END]
template<bool T>
gap_operation_func_type | operation_functions< T >::gapop_table_ [bm::set_END]
template<bool T>
bit_operation_count_func_type | operation_functions< T >::bit_op_count_table_ [bm::set_END]
const unsigned short | set_bitscan_wave_size = 4
| Size of bit decode wave in words.
const unsigned | id_max32 = 0xFFFFFFFFu
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_alloc_size = bm::set_block_size * unsigned(sizeof(bm::word_t))
const unsigned | set_block_plane_size = bm::set_block_size / 32u
const unsigned | set_block_plane_cnt = (unsigned)(sizeof(bm::word_t) * 8u)
const unsigned | block_waves = 64
const unsigned | set_block_digest_wave_size = bm::set_block_size / bm::block_waves
const unsigned | set_block_digest_pos_shift = 10
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_max_bits_cmrz = bm::gap_max_bits / 2
const unsigned | gap_levels = 4
const unsigned | gap_max_level = bm::gap_levels - 1
const unsigned | bie_cut_off = 16384
const unsigned | set_array_size32 = 256u
const unsigned | set_sub_array_size = set_array_size32
const unsigned | set_array_shift = 8u
const unsigned | set_array_mask = 0xFFu
const unsigned | set_total_blocks32 = (bm::set_array_size32 * bm::set_array_size32)
const unsigned | set_sub_total_bits = bm::set_sub_array_size * bm::gap_max_bits
const unsigned | id_max = bm::id_max32
const unsigned | set_top_array_size = bm::set_array_size32
const unsigned | set_total_blocks = bm::set_total_blocks32
const unsigned | bits_in_block = bm::set_block_size * unsigned((sizeof(bm::word_t) * 8))
const unsigned | bits_in_array = bm::bits_in_block * bm::set_array_size32
const unsigned | rs3_border0 = 21824
const unsigned | rs3_border1 = (rs3_border0 * 2)
const unsigned | rs3_half_span = rs3_border0 / 2
const unsigned | rs3_border0_1 = rs3_border0 + rs3_half_span
const unsigned | rs3_border1_1 = rs3_border1 + rs3_half_span
const id64_t | all_bits_mask = 0xffffffffffffffffULL
const unsigned | set_block_size_op = bm::set_block_size / 2
template<bool T>
const char | _copyright< T >::_p []
template<bool T>
const unsigned | _copyright< T >::_v [3]
template<bool T>
const unsigned | DeBruijn_bit_position< T >::_multiply [32]
template<bool T>
const signed char | first_bit_table< T >::_idx [256]
template<bool T>
const unsigned char | bit_count_table< T >::_count [256]
template<bool T>
const unsigned char | lzcnt_table< T >::_lut [16]
template<bool T>
const unsigned char | tzcnt_table< T >::_lut [37]
template<bool T>
const unsigned | block_set_table< T >::_left [32]
template<bool T>
const unsigned | block_set_table< T >::_right [32]
template<bool T>
const gap_word_t | gap_len_table< T >::_len [bm::gap_levels]
template<bool T>
const gap_word_t | gap_len_table_min< T >::_len [bm::gap_levels]
template<bool T>
const gap_word_t | gap_len_table_nl< T >::_len [bm::gap_levels]
template<bool T>
globals< T >::bo | globals< T >::_bo
const unsigned char | ibpc_uncompr = 0
const unsigned char | ibpc_all_zero = 1
| !< plane uncompressed
const unsigned char | ibpc_all_one = 2
| !< plane ALL ZERO
const unsigned char | ibpc_equiv = 3
| !< plane ALL ONE
const unsigned char | ibpc_close = 4
| !< plane is equal to plane M
const unsigned char | ibpc_end = 8
| !< plane is close to plane M
const unsigned | set_compression_max = 6
| Maximum supported compression level.
const unsigned | set_compression_default = 6
| Default compression level.
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).
const unsigned char | set_block_64zero = 25
| lots of zero blocks
const unsigned char | set_block_64one = 26
| lots of all-set blocks
const unsigned char | set_block_gap_bienc = 27
| Interpolated GAP block (legacy).
const unsigned char | set_block_arrgap_bienc = 28
| Interpolated GAP array.
const unsigned char | set_block_arrgap_bienc_inv = 29
| Interpolated GAP array (inverted).
const unsigned char | set_block_arrbit_inv = 30
| List of bits OFF.
const unsigned char | set_block_arr_bienc = 31
| Interpolated block as int array.
const unsigned char | set_block_arr_bienc_inv = 32
| Interpolated inverted block int array.
const unsigned char | set_block_bitgap_bienc = 33
| Interpolated bit-block as GAPs.
const unsigned char | set_block_bit_digest0 = 34
| H-compression with digest mask.
const unsigned char | set_block_ref_eq = 35
| block is a copy of a reference block
const unsigned char | set_block_xor_ref8 = 36
| block is masked XOR of a reference block (8-bit)
const unsigned char | set_block_xor_ref16 = 37
| block is masked XOR of a reference block (16-bit)
const unsigned char | set_block_xor_ref32 = 38
| ..... 32-bit (should never happen)
const unsigned char | set_block_xor_gap_ref8 = 39
| ..... 8-bit
const unsigned char | set_block_xor_gap_ref16 = 40
| ..... 16-bit
const unsigned char | set_block_xor_gap_ref32 = 41
| ..... 32-bit (should never happen)
const unsigned char | set_block_xor_chain = 42
| XOR chain (composit of sub-blocks).
const unsigned char | set_block_gap_bienc_v2 = 43
| Interpolated GAP block (v2).
const unsigned char | set_block_arrgap_bienc_v2 = 44
| //!< Interpolated GAP array (v2)
const unsigned char | set_block_arrgap_bienc_inv_v2 = 45
| Interpolated GAP array (inverted).
const unsigned char | set_block_bitgap_bienc_v2 = 46
| Interpolated bit-block as GAPs (v2 - reseved).
const unsigned char | set_nb_bookmark16 = 47
| jump ahead mark (16-bit)
const unsigned char | set_nb_bookmark24 = 48
| jump ahead mark (24-bit)
const unsigned char | set_nb_bookmark32 = 49
| jump ahead mark (32-bit)
const unsigned char | set_nb_sync_mark8 = 50
| bookmark sync point (8-bits)
const unsigned char | set_nb_sync_mark16 = 51
const unsigned char | set_nb_sync_mark24 = 52
const unsigned char | set_nb_sync_mark32 = 53
const unsigned char | set_nb_sync_mark48 = 54
const unsigned char | set_nb_sync_mark64 = 55
| ..... 64-bit (should never happen)
const unsigned char | set_sblock_bienc = 56
| super-block interpolated list
const unsigned char | set_block_arr_bienc_8bh = 57
| BIC block 8bit header.
const unsigned char | set_block_xor_ref8_um = 58
| block is un-masked XOR of a reference block (8-bit)
const unsigned char | set_block_xor_ref16_um = 59
| block is un-masked XOR of a reference block (16-bit)
const unsigned char | set_block_xor_ref32_um = 60
| ..... 32-bit (should never happen)
const unsigned | sparse_max_l5 = 48
const unsigned | sparse_max_l6 = 256
const unsigned | sblock_flag_sb16 = (1u << 0)
| 16-bit SB index (8-bit by default)
const unsigned | sblock_flag_sb32 = (1u << 1)
| 32-bit SB index
const unsigned | sblock_flag_min16 = (1u << 2)
| 16-bit minv
const unsigned | sblock_flag_min24 = (1u << 3)
| 24-bit minv
const unsigned | sblock_flag_min32 = bm::sblock_flag_min16 | bm::sblock_flag_min24
const unsigned | sblock_flag_len16 = (1u << 4)
| 16-bit len (8-bit by default)
const unsigned | sblock_flag_max16 = (1u << 5)
const unsigned | sblock_flag_max24 = (1u << 6)
const unsigned | sblock_flag_max32 = bm::sblock_flag_max16 | bm::sblock_flag_max24

## Aggregator traits and control constants

typedef bm::agg_run_options< agg_disable_result_bvectors, agg_disable_counts > | agg_opt_disable_bvects_and_counts
| Pre-defined aggregator options to disable both intermediate results and counts.
typedef bm::agg_run_options< agg_disable_result_bvectors, agg_compute_counts > | agg_opt_only_counts
| Pre-defined aggregator options for counts-only (results dropped) operation.
typedef bm::agg_run_options< agg_produce_result_bvectors, agg_compute_counts > | agg_opt_bvect_and_counts
| Pre-defined aggregator options for results plus counts operation.
const bool | agg_produce_result_bvectors = true
const bool | agg_disable_result_bvectors = false
const bool | agg_compute_counts = true
const bool | agg_disable_counts = false
const bool | agg_disable_search_masks = false
template<typename Agg, typename It>
void | aggregator_pipeline_execute (It first, It last)
| Experimental method ro run multiple aggregators in sync.

## Typedef Documentation

## bit_operation_count_func_type

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

Definition at line 9547 of file bmfunc.h.

## bvector_size_type

typedef bm::id_t bm::bvector_size_type

Definition at line 103 of file bm.h.

## gap_operation_func_type

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

## gap_operation_to_bitset_func_type

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

Definition at line 9537 of file bmfunc.h.

## gap_word_t

typedef unsigned short bm::gap_word_t

Examples
  xsample01.cpp.

Definition at line 78 of file bmconst.h.

## id64_t

typedef unsigned long long int bm::id64_t

Examples
  bvsample01_64.cpp, inv_list.cpp, xsample07.cpp, and xsample07a.cpp.

Definition at line 35 of file bmconst.h.

## id_t

typedef unsigned int bm::id_t

Examples
  inv_list.cpp, sample12.cpp, sample25.cpp, svsample05.cpp, and svsample06.cpp.

Definition at line 38 of file bmconst.h.

## short_t

typedef unsigned short bm::short_t

Definition at line 40 of file bmconst.h.

## word_t

typedef unsigned int bm::word_t

Examples
  sample6.cpp.

Definition at line 39 of file bmconst.h.

## wordop_t

typedef id64_t bm::wordop_t

Definition at line 131 of file bmconst.h.

## Enumeration Type Documentation

## bit_representation

enum bm::bit_representation

Possible representations for bit sets.

Enumerator
e_bit_GAP | GAPs.
e_bit_INT | Int list.
e_bit_IINT | Inverted int list.
e_bit_1 | all 1s
e_bit_0 | all 0s (empty block)
e_bit_bit | uncompressed bit-block
e_bit_end |

Definition at line 10169 of file bmfunc.h.

## ByteOrder

enum bm::ByteOrder

Byte orders recognized by the library.

Enumerator
BigEndian |
LittleEndian |

Definition at line 451 of file bmconst.h.

## remap_setup

enum class bm::remap_setup

strong

Enumerator
COPY_RTABLES | copy remap tables only (without data)

Definition at line 48 of file bmstrsparsevec.h.

## serialization_header_mask

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
BM_HM_64_BIT | 64-bit vector
BM_HM_HXOR | horizontal XOR compression turned ON
BM_HM_SPARSE | very sparse vector

Definition at line 1077 of file bmserial.h.

## set_representation

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 216 of file bmconst.h.

## simd_codes

enum bm::simd_codes

codes for supported SIMD optimizations

Enumerator
simd_none |
simd_sse2 | !< No SIMD or any other optimization
simd_sse42 | !< Intel SSE2
simd_avx2 | !< Intel SSE4.2
simd_avx512 | !< Intel AVX2
simd_wasm128 | !< Intel AVX512
simd_neon | ! WASM SIMD 128

Definition at line 435 of file bmconst.h.

## xor_complement_match

enum bm::xor_complement_match

XOR complementarity type between 2 blocks.

Enumerator
e_no_xor_match |
e_xor_match_GC |
e_xor_match_BC |
e_xor_match_iBC |
e_xor_match_EQ |

Definition at line 80 of file bmxor.h.

## Function Documentation

## aligned_free()

void bm::aligned_free | ( | void * | ptr | ) |

inline

Aligned free.

Definition at line 464 of file bmalloc.h.

References BMNOEXCEPT.

Referenced by bm::aggregator< bvector_type >::free_arena(), bm::aggregator< bvector_type >::free_arg_group(), bm::bvps_addr_resolver< BV >::free_rs_index(), bm::aggregator< BV >::~aggregator(), and bm::aggregator< BV >::pipeline< Opt >::~pipeline().

## aligned_new_malloc()

void * bm::aligned_new_malloc | ( | size_t | size | ) |

inline

Aligned malloc (unlike classic malloc it throws bad_alloc exception).

To allocate temp bit-block use: bm::aligned_new_malloc(bm::set_block_alloc_size);

Definition at line 436 of file bmalloc.h.

References BM_ALLOC_ALIGN.

Referenced by bm::aggregator< BV >::aggregator(), bm::aggregator< BV >::cache_gap_block(), bm::aggregator< bvector_type >::construct_arena(), bm::aggregator< bvector_type >::construct_arg_group(), and bm::bvps_addr_resolver< BV >::construct_rs_index().

## avx2_bit_block_gather_scatter()

void bm::avx2_bit_block_gather_scatter | ( | unsigned *BMRESTRICT | arr,
|  | const unsigned *BMRESTRICT | blk,
|  | const unsigned *BMRESTRICT | idx,
|  | unsigned | size,
|  | unsigned | start,
|  | unsigned | bit_idx )

inline

AVX2 bit block gather-scatter

Parameters

  arr | - destination array to set bits
  blk | - source bit-block
  idx | - gather index array
  size | - gather array size
  start | - gaher start index
  bit_idx | - bit to set in the target array

Definition at line 3141 of file bmavx2.h.

References BM_ALIGN32, BM_ALIGN32ATTR, BMRESTRICT, set_block_mask, set_word_mask, and set_word_shift.

Referenced by bit_block_gather_scatter().

## avx2_bit_count_or()

bm::id_t bm::avx2_bit_count_or | ( | const __m256i *BMRESTRICT | block,
|  | const __m256i *BMRESTRICT | block_end,
|  | const __m256i *BMRESTRICT | mask_block )

inline

Definition at line 337 of file bmavx2.h.

References BM_AVX2_BIT_COUNT, BM_AVX2_POPCNT_PROLOG, and BMRESTRICT.

## avx2_gap_sum_arr()

const bm::gap_word_t * bm::avx2_gap_sum_arr | ( | const bm::gap_word_t * | pbuf,
|  | unsigned | avx_vect_waves,
|  | unsigned * | sum )

inline

Definition at line 2453 of file bmavx2.h.

Referenced by gap_bit_count_unr().

## avx2_idx_arr_block_lookup()

unsigned bm::avx2_idx_arr_block_lookup | ( | const unsigned * | idx,
|  | unsigned | size,
|  | unsigned | nb,
|  | unsigned | start )

inline

AVX2 index lookup to check what belongs to the same block (8 elements)

Definition at line 2492 of file bmavx2.h.

References set_block_shift.

## avx2_set_block_bits()

void bm::avx2_set_block_bits | ( | bm::word_t *BMRESTRICT | block,
|  | const unsigned *BMRESTRICT | idx,
|  | unsigned | start,
|  | unsigned | stop )

inline

SSE4.2 bulk bit set

Definition at line 2533 of file bmavx2.h.

References BM_ALIGN32, BM_ALIGN32ATTR, BMRESTRICT, set_block_mask, set_word_mask, and set_word_shift.

## avx2_set_block_bits2()

void bm::avx2_set_block_bits2 | ( | bm::word_t *BMRESTRICT | block,
|  | const unsigned *BMRESTRICT | idx,
|  | unsigned | start,
|  | unsigned | stop )

inline

Experimental code to set bits via AVX strides.

Definition at line 2709 of file bmavx2.h.

References BMRESTRICT, and set_block_mask.

## avx2_set_block_bits3()

void bm::avx2_set_block_bits3 | ( | bm::word_t *BMRESTRICT | block,
|  | const unsigned *BMRESTRICT | idx,
|  | unsigned | start,
|  | unsigned | stop )

inline

Experimental code to set bits via AVX strides.

Definition at line 2748 of file bmavx2.h.

References avx2_setbit_256(), BM_ALIGN32, BM_ALIGN32ATTR, BMRESTRICT, set_block_mask, set_word_mask, and set_word_shift.

## avx2_setbit_256()

BMFORCEINLINE __m256i bm::avx2_setbit_256 | ( | __m256i | target,
|  | __m256i | source )

Set a bits in an AVX target, by indexes (int4) from the source.

Definition at line 2662 of file bmavx2.h.

Referenced by avx2_set_block_bits3().

## avx2_setbit_to256()

__m256i bm::avx2_setbit_to256 | ( | unsigned | i | ) |

inline

Experiemntal.

Set number of bits in AVX register from 0 to i [ 000000 00000 0000000 00011 11111 ] - i = 7

Definition at line 2841 of file bmavx2.h.

## best_representation()

bm::bit_representation bm::best_representation | ( | unsigned | gc,
|  | unsigned | bc,
|  | unsigned | max_bits,
|  | float | bie_bits_per_int,
|  | unsigned * | best_metric )

inline

Detect best representation for serialization for a block or sub-block.

Parameters

  gc | - gap count
  bc | - bit count
  max_bits | - total number of bits in block
  bie_bits_per_int | - number of bits per int in the compression scheme
  best_metric | - [out] - best metric (number of bits or gaps)

Returns
  representation metric

Definition at line 10191 of file bmfunc.h.

References BMNOEXCEPT, e_bit_0, e_bit_1, e_bit_bit, e_bit_GAP, e_bit_IINT, and e_bit_INT.

## bit_block_any_range()

bm::id_t bm::bit_block_any_range | ( | const bm::word_t * | block,
|  | bm::word_t | left,
|  | bm::word_t | right )

inline

References BMNOEXCEPT.

Referenced by block_any_range(), gap_bitset_and_any(), gap_bitset_sub_any(), and gap_bitset_xor_any().

## bit_block_change32()

unsigned bm::bit_block_change32 | ( | const bm::word_t *BMRESTRICT | block,
|  | unsigned | size )

inline

Function calculates number of times when bit value changed

Definition at line 5161 of file bmfunc.h.

References BMNOEXCEPT, BMRESTRICT, and word_bitcount().

Referenced by bit_block_calc_change(), bit_block_change_bc(), and compute_s_block_descr().

## bit_block_change64()

unsigned bm::bit_block_change64 | ( | const bm::word_t *BMRESTRICT | in_block,
|  | unsigned | size )

inline

Function calculates number of times when bit value changed

Definition at line 5203 of file bmfunc.h.

References BMNOEXCEPT, BMRESTRICT, and word_bitcount64().

Referenced by bit_block_calc_change(), bit_block_change_bc(), and compute_s_block_descr().

## bit_block_change_bc()

void bm::bit_block_change_bc | ( | const bm::word_t *BMRESTRICT | block,
|  | unsigned *BMRESTRICT | gc,
|  | unsigned *BMRESTRICT | bc )

inline

Function calculates basic bit-block statistics number of times when bit value changed (GAPS) and population count

Parameters

  block | - bit-block pointer
  gc | - [output] gap_count
  bc | - [output] bit count

Definition at line 5252 of file bmfunc.h.

References bit_block_change32(), bit_block_change64(), bit_block_count(), BM_ASSERT, BMNOEXCEPT, BMRESTRICT, set_block_size, and VECT_BLOCK_CHANGE_BC.

Referenced by bm::xor_scanner< BV >::compute_sim_model(), bm::serializer< BV >::find_bit_best_encoding(), bm::serializer< BV >::find_bit_best_encoding_l5(), and bm::xor_scanner< BV >::search_best_xor_mask().

## bit_block_xor() [1/2]

void bm::bit_block_xor | ( | bm::word_t * | target_block,
|  | const bm::word_t * | block,
|  | const bm::word_t * | xor_block,
|  | bm::id64_t | digest )

inline

Build partial XOR product of 2 bit-blocks using digest mask.

Parameters

  target_block | - target := block ^ xor_block
  block | - arg1
  xor_block | - arg2
  digest | - mask for each block wave to XOR (1) or just copy (0)

Definition at line 483 of file bmxor.h.

References block_waves, BM_ASSERT, BMNOEXCEPT, set_block_digest_wave_size, and VECT_BIT_BLOCK_XOR.

## bit_block_xor() [2/2]

void bm::bit_block_xor | ( | bm::word_t * | target_block,
|  | const bm::word_t * | xor_block,
|  | bm::id64_t | digest )

inline

Build partial XOR product of 2 bit-blocks using digest mask.

Parameters

  target_block | - target := target ^ xor_block
  xor_block | - arg
  digest | - mask for each block wave to XOR (1)

Definition at line 569 of file bmxor.h.

References BM_ASSERT, bmi_blsi_u64(), bmi_bslr_u64(), BMNOEXCEPT, set_block_digest_wave_size, VECT_BIT_BLOCK_XOR_2WAY, and word_bitcount64().

## bit_block_xor_change()

void bm::bit_block_xor_change | ( | const bm::word_t *BMRESTRICT | block,
|  | const bm::word_t *BMRESTRICT | xor_block,
|  | unsigned | size,
|  | unsigned *BMRESTRICT | gc,
|  | unsigned *BMRESTRICT | bc )

inline

Function calculates number of times when bit value changed

Definition at line 207 of file bmxor.h.

References bit_block_xor_change32(), bit_block_xor_change64(), BMNOEXCEPT, BMRESTRICT, and VECT_BLOCK_XOR_CHANGE.

Referenced by bm::xor_scanner< BV >::compute_xor_complexity_descr().

## bit_iblock_pcv_stat()

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 441 of file bmtrans.h.

References BM_ASSERT, and BMRESTRICT.

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

## bit_iblock_reduce()

void bm::bit_iblock_reduce | ( | const unsigned | tmatrix[bm::set_block_plane_cnt][bm::set_block_plane_size],
|  | const unsigned char *BMRESTRICT | pc_vector,
|  | const unsigned char *BMRESTRICT | pc_vector_end,
|  | unsigned | tmatrix_out[bm::set_block_plane_cnt][bm::set_block_plane_size] )

inline

Matrix reduction based on transformation pc vector.

Definition at line 461 of file bmtrans.h.

References BM_ASSERT, BMRESTRICT, ibpc_all_one, ibpc_all_zero, ibpc_close, ibpc_equiv, ibpc_uncompr, set_block_plane_cnt, and set_block_plane_size.

## bit_recomb()

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 )

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

Definition at line 9439 of file bmfunc.h.

References BMNOEXCEPT, and set_block_size.

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

## bit_scan_forward32()

BMFORCEINLINE unsigned bm::bit_scan_forward32 | ( | unsigned | w | ) |

Definition at line 319 of file bmutil.h.

References bit_scan_fwd(), BM_ASSERT, and BMNOEXCEPT.

Referenced by bit_block_find(), bit_block_find_interval_end(), bit_block_to_gap(), bit_find_first(), bit_find_first(), bit_find_first_diff(), bit_find_first_if_1(), count_trailing_zeros_u32(), count_trailing_zeros_u64(), sse2_bit_find_first(), sse2_bit_find_first_diff(), and sse2_lower_bound_scan_u32().

## bit_scan_fwd()

template<typename T>

BMFORCEINLINE T bm::bit_scan_fwd | ( | T | v | ) |

Definition at line 297 of file bmutil.h.

References bm::DeBruijn_bit_position< T >::_multiply, BMFORCEINLINE, and BMNOEXCEPT.

Referenced by bit_scan_forward32(), bm::bit_in< TDecoder >::gamma(), and sse2_gap_find().

## bit_scan_reverse32()

BMFORCEINLINE unsigned bm::bit_scan_reverse32 | ( | unsigned | w | ) |

Definition at line 304 of file bmutil.h.

References BM_ASSERT, BMNOEXCEPT, and ilog2_LUT().

Referenced by bm::bit_in< TDecoder >::bic_decode_u16_cm(), bm::bit_in< TDecoder >::bic_decode_u16_cm_bitset(), bm::bit_in< TDecoder >::bic_decode_u16_cm_dry(), bm::bit_in< TDecoder >::bic_decode_u16_rg(), bm::bit_in< TDecoder >::bic_decode_u16_rg_bitset(), bm::bit_in< TDecoder >::bic_decode_u16_rg_dry(), bm::bit_in< TDecoder >::bic_decode_u32_cm(), bm::bit_out< TEncoder >::bic_encode_u16_cm(), bm::bit_out< TEncoder >::bic_encode_u16_rg(), bm::bit_out< TEncoder >::bic_encode_u32_cm(), bit_block_find_interval_start(), bit_block_find_prev(), bit_scan_reverse(), count_leading_zeros_u64(), and bm::bit_out< TEncoder >::gamma().

## bit_to_gap()

unsigned bm::bit_to_gap | ( | gap_word_t *BMRESTRICT | dest,
|  | const unsigned *BMRESTRICT | block,
|  | unsigned | dest_len )

inline

Convert bit block to GAP representation.

Definition at line 4870 of file bmfunc.h.

References bit_block_to_gap(), BMNOEXCEPT, BMRESTRICT, and VECT_BIT_TO_GAP.

Referenced by bm::serializer< BV >::bienc_gap_bit_block(), bm::serializer< BV >::gamma_gap_bit_block(), bm::interval_enumerator< BV >::go_to_impl(), and bm::serializer< BV >::interpolated_gap_bit_block().

## bitscan_bsf()

template<typename B, typename OT>

unsigned short bm::bitscan_bsf | ( | unsigned | w,
|  | B * | bits,
|  | OT | offs )

Definition at line 709 of file bmfunc.h.

References BMNOEXCEPT, and count_trailing_zeros_u32().

## bitscan_nibble()

unsigned bm::bitscan_nibble | ( | unsigned | w,
|  | unsigned * | bits )

inline

portable, switch based bitscan

Definition at line 382 of file bmfunc.h.

References BMNOEXCEPT.

## block_any()

bool bm::block_any | ( | const bm::word_t *const BMRESTRICT | block | ) |

inline

Returns "true" if one bit is set in the block Function check for block varieties.

Definition at line 6482 of file bmfunc.h.

References bit_is_all_zero(), BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, BMRESTRICT, gap_is_all_zero(), and IS_FULL_BLOCK.

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

## block_any_range()

bool bm::block_any_range | ( | const bm::word_t *const BMRESTRICT | block,
|  | unsigned | left,
|  | unsigned | right )

inline

Returns "true" if one bit is set in the block [left, right] Function check for block varieties.

Definition at line 6461 of file bmfunc.h.

References bit_block_any_range(), BM_ASSERT, BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, BMRESTRICT, gap_any_range(), gap_max_bits, and IS_FULL_BLOCK.

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

## block_find_first_diff()

bool bm::block_find_first_diff | ( | const bm::word_t *BMRESTRICT | blk,
|  | const bm::word_t *BMRESTRICT | arg_blk,
|  | unsigned *BMRESTRICT | pos )

inline

Find first bit which is different between two blocks (GAP or bit).

Parameters

  blk | - block 1
  arg_blk | - block 2
  pos | - out - position of difference (undefined if blocks are equal)

Returns
  true if difference was found

Definition at line 9268 of file bmfunc.h.

References bit_find_first(), bit_find_first_diff(), BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, BMRESTRICT, gap_convert_to_bitset(), gap_find_first(), and gap_find_first_diff().

Referenced by bm::bvector< Alloc >::find_first_mismatch(), and bm::xor_scanner< BV >::search_best_xor_mask().

## block_find_interval_end()

unsigned bm::block_find_interval_end | ( | const bm::word_t *BMRESTRICT | block,
|  | unsigned | nbit_from,
|  | unsigned *BMRESTRICT | found_nbit )

inline

Find end of the current 111 interval.

Returns
  search result code 0 - not found, 1 found, 2 - found at the end

Definition at line 6232 of file bmfunc.h.

References bit_block_find_interval_end(), BM_ASSERT, BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, BMRESTRICT, gap_find_interval_end(), gap_max_bits, and IS_FULL_BLOCK.

Referenced by find_interval_end().

## block_find_interval_start()

unsigned bm::block_find_interval_start | ( | const bm::word_t *BMRESTRICT | block,
|  | unsigned | nbit_from,
|  | unsigned *BMRESTRICT | found_nbit )

inline

Find start of the current 111 interval.

Returns
  search result code 0 - not found, 1 found, 2 - found at the start

Definition at line 6396 of file bmfunc.h.

References bit_block_find_interval_start(), BM_ASSERT, BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, BMRESTRICT, gap_find_interval_start(), gap_max_bits, and IS_FULL_BLOCK.

Referenced by find_interval_start().

## block_find_rank()

template<typename SIZE_TYPE>

SIZE_TYPE bm::block_find_rank | ( | const bm::word_t *const | block,
|  | SIZE_TYPE | rank,
|  | unsigned | nbit_from,
|  | unsigned & | nbit_pos )

Find rank in block (GAP or BIT).

Parameters

  block | - bit block buffer pointer
  rank | - rank to find (must be > 0)
  nbit_from | - start bit position in block
  nbit_pos | - found position

Returns
  0 if position with rank was found, or the remaining rank (rank - population count)

Definition at line 8997 of file bmfunc.h.

References bit_find_rank(), BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, and gap_find_rank().

Referenced by bm::bvector< Alloc >::find_rank(), bm::bvector< Alloc >::find_rank(), and bm::bvector< Alloc >::select().

## block_find_reverse()

bool bm::block_find_reverse | ( | const bm::word_t *BMRESTRICT | block,
|  | unsigned | nbit_from,
|  | unsigned *BMRESTRICT | found_nbit )

inline

Reverse find 1.

Returns
  search result code 0 - not found, 1 found

Definition at line 6431 of file bmfunc.h.

References bit_block_find_prev(), BM_ASSERT, BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, BMRESTRICT, gap_find_prev(), gap_max_bits, and IS_FULL_BLOCK.

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

## block_is_all_one_range()

bool bm::block_is_all_one_range | ( | const bm::word_t *const BMRESTRICT | block,
|  | unsigned | left,
|  | unsigned | right )

inline

Returns "true" if all bits are 1 in the block [left, right] Function check for block varieties.

Definition at line 6107 of file bmfunc.h.

References bit_block_is_all_one_range(), BM_ASSERT, BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, BMRESTRICT, FULL_BLOCK_FAKE_ADDR, gap_is_all_one_range(), and gap_max_bits.

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

## block_is_interval()

bool bm::block_is_interval | ( | const bm::word_t *const BMRESTRICT | block,
|  | unsigned | left,
|  | unsigned | right )

inline

Returns "true" if all bits are 1 in the block [left, right] and border bits are 0.

Definition at line 6128 of file bmfunc.h.

References bit_block_is_all_one_range(), BM_ASSERT, BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, BMRESTRICT, FULL_BLOCK_FAKE_ADDR, gap_is_interval(), gap_max_bits, set_word_mask, and set_word_shift.

Referenced by is_interval().

## block_ptr_array_range()

bool bm::block_ptr_array_range | ( | bm::word_t ** | arr,
|  | unsigned & | left,
|  | unsigned & | right )

inline

array range detector

Definition at line 9872 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, and set_sub_array_size.

## block_range_scan()

template<typename It, typename SIZE_TYPE>

It bm::block_range_scan | ( | It | first,
|  | It | last,
|  | SIZE_TYPE | nblock,
|  | SIZE_TYPE * | max_id )

Internal algorithms scans the input for the block range limit.

Definition at line 1047 of file bmalgo_impl.h.

References BM_ASSERT, BMNOEXCEPT, id_max, and set_block_shift.

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

## block_to_global_index()

bm::id_t bm::block_to_global_index | ( | unsigned | i,
|  | unsigned | j,
|  | unsigned | block_idx )

inline

calculate bvector<> global bit-index from block-local coords

Returns
  bit index in linear bit-vector coordinates

Definition at line 10054 of file bmfunc.h.

References BMNOEXCEPT, gap_max_bits, and set_sub_array_size.

Referenced by bm::aggregator< BV >::find_first_and_sub().

## bmfor_each()

template<class T, class F>

F bm::bmfor_each | ( | T | first,
|  | T | last,
|  | F | f )

Special BM optimized analog of STL for_each

Definition at line 2208 of file bmfunc.h.

## bmi_blsi_u64()

BMFORCEINLINE unsigned long long bm::bmi_blsi_u64 | ( | unsigned long long | w | ) |

Definition at line 345 of file bmutil.h.

Referenced by avx2_bit_block_count(), avx2_bit_block_xor_2way(), bit_block_and(), bit_block_and_2way(), bit_block_and_3way(), bit_block_and_5way(), bit_block_and_or_2way(), bit_block_convert_to_arr(), bit_block_count(), bit_block_sub(), bit_block_sub_2way(), bit_block_sub_3way(), bit_block_sub_5way(), bit_block_xor(), bit_find_first(), bit_find_first_if_1(), bitscan_popcnt64(), bitscan_popcnt64(), block_compact_by_digest(), bm::serializer< BV >::encode_bit_digest(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_digest0_block(), sse2_bit_block_xor_2way(), sse42_bit_block_xor_2way(), sse42_bit_count_digest(), and update_block_digest0().

## bmi_bslr_u64()

BMFORCEINLINE unsigned long long bm::bmi_bslr_u64 | ( | unsigned long long | w | ) |

Definition at line 335 of file bmutil.h.

References BMNOEXCEPT.

Referenced by avx2_bit_block_count(), avx2_bit_block_xor_2way(), bit_block_and(), bit_block_and_2way(), bit_block_and_3way(), bit_block_and_5way(), bit_block_and_or_2way(), bit_block_convert_to_arr(), bit_block_count(), bit_block_sub(), bit_block_sub_2way(), bit_block_sub_3way(), bit_block_sub_5way(), bit_block_xor(), bitscan_popcnt64(), bitscan_popcnt64(), block_compact_by_digest(), bm::serializer< BV >::encode_bit_digest(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_digest0_block(), sse2_bit_block_xor_2way(), sse42_bit_block_xor_2way(), sse42_bit_count_digest(), and update_block_digest0().

## build_jaccard_similarity_batch()

template<class SIMBATCH, class SV>

void bm::build_jaccard_similarity_batch | ( | SIMBATCH & | sbatch,
|  | const SV & | sv )

Utility function to build jaccard similarity batch for sparse_vector<>.

Definition at line 190 of file bmalgo_similarity.h.

References COUNT_AND, COUNT_OR, and bm::distance_metric_descriptor::metric.

## check_any_fullb()

bool bm::check_any_fullb | ( | const bm::word_t * | blka[8],
|  | const bm::word_t * | FBADDR )

inline

Definition at line 1279 of file bmbmatrix.h.

Referenced by bm::basic_bmatrix< BV >::get_octet().

## check_block_one()

bool bm::check_block_one | ( | const bm::word_t * | blk,
|  | bool | deep_scan )

inline

Checks if block has only 1 bits.

Parameters

  blk | - Block's pointer
  deep_scan | - flag to do full bit block verification (scan) when deep scan is not requested result can be approximate

Returns
  true if block consists of 1 bits.

Definition at line 9120 of file bmfunc.h.

References BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, gap_is_all_one(), is_bits_one(), and IS_FULL_BLOCK.

Referenced by bm::bvector< Alloc >::is_all_one_range(), and bm::serializer< BV >::serialize().

## check_block_zero()

bool bm::check_block_zero | ( | const bm::word_t * | blk,
|  | bool | deep_scan )

inline

Checks all conditions and returns true if block consists of only 0 bits.

Parameters

  blk | - Blocks's pointer
  deep_scan | - flag to do full bit block verification (scan) when deep scan is not requested result can be approximate

Returns
  true if all bits are in the block are 0

Definition at line 9096 of file bmfunc.h.

References bit_is_all_zero(), BM_IS_GAP, BMGAP_PTR, BMNOEXCEPT, gap_is_all_zero(), and IS_FULL_BLOCK.

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

## check_pair_vect_vbr()

template<typename BMChain, typename RVect>

unsigned char bm::check_pair_vect_vbr | ( | const BMChain & | mchain,
|  | const RVect & | ref_vect )

Check effective bit-rate for the XOR encode vector.

Returns
  1 - < 256 (8bit), 2 - < 65536 (16-bit) or 0 - 32-bit

Definition at line 404 of file bmxor.h.

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

## combine_any_operation_with_block() [1/2]

bm::distance_metric_descriptor::size_type bm::combine_any_operation_with_block | ( | const bm::word_t * | blk,
|  | unsigned | gap,
|  | const bm::word_t * | arg_blk,
|  | unsigned | arg_gap,
|  | distance_metric | metric )

inline

Convenience internal function to compute combine any for one metric

Definition at line 712 of file bmalgo_impl.h.

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

## combine_any_operation_with_block() [2/2]

void bm::combine_any_operation_with_block | ( | const bm::word_t * | blk,
|  | unsigned | gap,
|  | const bm::word_t * | arg_blk,
|  | unsigned | arg_gap,
|  | distance_metric_descriptor * | dmit,
|  | distance_metric_descriptor * | dmit_end )

inline

Internal function computes different existense of distance metric.

Definition at line 443 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_ASSERT, BM_VECT_ALIGN, BM_VECT_ALIGN_ATTR, BMGAP_PTR, BMNOEXCEPT, combine_any_operation_with_block(), 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_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(), combine_any_operation_with_block(), and distance_operation_any().

## combine_count_and_operation_with_block()

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 406 of file bmalgo_impl.h.

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

Referenced by distance_and_operation().

## combine_count_operation_with_block() [1/2]

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 693 of file bmalgo_impl.h.

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

## combine_count_operation_with_block() [2/2]

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 189 of file bmalgo_impl.h.

References bit_block_count(), bm::operation_functions< T >::bit_operation_count(), bit_operation_sub_count(), BM_ASSERT, BM_IS_GAP, BM_VECT_ALIGN, BM_VECT_ALIGN_ATTR, BMGAP_PTR, BMNOEXCEPT, combine_count_operation_with_block(), COUNT_A, COUNT_AND, COUNT_B, COUNT_OR, COUNT_SUB_AB, COUNT_SUB_BA, COUNT_XOR, gap_bit_count_unr(), 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(), combine_count_operation_with_block(), bm::iterator_deserializer< BV, SerialIterator >::deserialize(), and distance_operation().

## compute_h64_mask()

unsigned bm::compute_h64_mask | ( | unsigned long long | w | ) |

inline

Сompute mask of bytes presense in 64-bit word.

Parameters

  w | - [in] input 64-bit word

Returns
  mask with 8 bits

Definition at line 556 of file bmutil.h.

References BMNOEXCEPT.

Referenced by bm::encoder::put_h64().

## compute_s_block_descr()

void bm::compute_s_block_descr | ( | const bm::word_t *BMRESTRICT | block,
|  | block_waves_xor_descr &BMRESTRICT | x_descr,
|  | unsigned *BMRESTRICT | s_gc,
|  | unsigned *BMRESTRICT | s_bc )

inline

Compute reference (non-XOR) 64-dim complexity descriptor for the s-block.

Phase 1 of the XOR filtering process is to establish the base metric

Definition at line 430 of file bmxor.h.

References bit_block_change32(), bit_block_change64(), bit_count_min_unroll(), block_waves, BM_ASSERT, BMNOEXCEPT, BMRESTRICT, set_block_digest_wave_size, and VECT_BLOCK_CHANGE.

Referenced by bm::xor_scanner< BV >::compute_s_block_stats(), bm::xor_scanner< BV >::deoptimize_gap_blocks(), and bm::serializer< BV >::find_bit_best_encoding().

## convert_sub_to_arr()

template<typename BV, typename VECT>

void bm::convert_sub_to_arr | ( | const BV & | bv,
|  | unsigned | sb,
|  | VECT & | vect )

convert sub-blocks to an array of set 1s (32-bit)

Definition at line 2016 of file bmalgo_impl.h.

References gap_max_bits, id_max, and set_sub_array_size.

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

## count_leading_zeros_u32()

unsigned bm::count_leading_zeros_u32 | ( | unsigned | w | ) |

inline

32-bit bit-scan reverse

Definition at line 356 of file bmutil.h.

References BM_ASSERT, BMNOEXCEPT, and count_leading_zeros().

## count_leading_zeros_u64()

unsigned bm::count_leading_zeros_u64 | ( | bm::id64_t | w | ) |

inline

64-bit bit-scan reverse

Definition at line 373 of file bmutil.h.

References bit_scan_reverse32(), BM_ASSERT, and BMNOEXCEPT.

Referenced by gap_and_to_bitset(), and gap_sub_to_bitset().

## count_nz()

template<typename VT, typename SZ>

SZ bm::count_nz | ( | const VT * | arr,
|  | SZ | arr_size )

Find count of non-zero elements in the array.

Definition at line 10154 of file bmfunc.h.

References BMNOEXCEPT.

Referenced by bm::sparse_vector_serializer< SV >::encode_remap_matrix().

## count_trailing_zeros_u32()

unsigned bm::count_trailing_zeros_u32 | ( | unsigned | w | ) |

inline

32-bit bit-scan fwd

Definition at line 401 of file bmutil.h.

References bit_scan_forward32(), BM_ASSERT, and BMNOEXCEPT.

Referenced by bitscan_bsf(), bitscan_bsf(), and word_select32_bitscan_tz().

## count_trailing_zeros_u64()

unsigned bm::count_trailing_zeros_u64 | ( | bm::id64_t | w | ) |

inline

64-bit bit-scan fwd

Definition at line 419 of file bmutil.h.

References bit_scan_forward32(), BM_ASSERT, and BMNOEXCEPT.

Referenced by bit_find_first_diff(), bitscan_bsf64(), gap_and_to_bitset(), gap_sub_to_bitset(), and word_select64_bitscan_tz().

## dgap_2_gap()

template<typename T>

void bm::dgap_2_gap | ( | const T *BMRESTRICT | dgap_buf,
|  | T *BMRESTRICT | gap_buf,
|  | T | gap_header = 0 )

Convert D-GAP buffer into GAP buffer.

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

Parameters

  dgap_buf | - Delta-GAP buffer
  gap_header | - GAP header word
  gap_buf | - GAP buffer

Definition at line 2806 of file bmfunc.h.

References BMNOEXCEPT, and BMRESTRICT.

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

## distance_stage()

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 733 of file bmalgo_impl.h.

References BMNOEXCEPT, and COUNT_AND.

Referenced by distance_operation(), and distance_operation_any().

## dm_control()

bm::id64_t bm::dm_control | ( | unsigned | from,
|  | unsigned | to )

inline

digest mask control generation (for debug and test only)

Definition at line 1007 of file bmfunc.h.

References BMNOEXCEPT.

## find_effective_columns()

template<typename TM>

unsigned bm::find_effective_columns | ( | const TM & | tmatrix | ) |

Compute effective right column border of the t-matrix.

Definition at line 712 of file bmtrans.h.

References bm::tmatrix< T, ROWS, COLS >::cols(), and bm::tmatrix< T, ROWS, COLS >::rows().

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

## find_first_nz()

template<typename VT, typename SZ>

bool bm::find_first_nz | ( | const VT * | arr,
|  | SZ | arr_size,
|  | SZ * | found_idx )

Find max non-zero value in an array.

Definition at line 10135 of file bmfunc.h.

References BMNOEXCEPT.

Referenced by bm::str_sparse_vector< CharType, BV, STR_SIZE >::build_octet_remap().

## find_max_nz()

template<typename VT, typename SZ>

bool bm::find_max_nz | ( | const VT * | arr,
|  | SZ | arr_size,
|  | SZ * | found_idx )

Find max non-zero value in an array.

Definition at line 10114 of file bmfunc.h.

References BMNOEXCEPT.

Referenced by bm::str_sparse_vector< CharType, BV, STR_SIZE >::build_octet_remap().

## find_not_null_ptr()

template<typename N>

bool bm::find_not_null_ptr | ( | const bm::word_t *const *const * | arr,
|  | N | start,
|  | N | size,
|  | N * | pos )

Fini not NULL position

Returns
  index of not NULL pointer

Definition at line 1427 of file bmfunc.h.

References avx2_test_all_zero_wave(), BM_ASSERT, and BMNOEXCEPT.

Referenced by bm::bvector< Alloc >::calc_stat(), bm::bvector< Alloc >::count(), and bm::bvector< Alloc >::erase().

## find_ptr()

bool bm::find_ptr | ( | const void *const * | p_arr,
|  | size_t | arr_size,
|  | const void * | ptr,
|  | size_t * | idx )

inline

Scan search for pointer value in unordered array.

Returns
  found flag and index

Definition at line 10025 of file bmfunc.h.

References BMNOEXCEPT.

## for_each_bit_block_range()

template<typename T, typename N, typename F>

int bm::for_each_bit_block_range | ( | T *** | root,
|  | N | top_size,
|  | N | nb_from,
|  | N | nb_to,
|  | F & | f )

For each non-zero block in [from, to] executes supplied functor

Definition at line 1844 of file bmalgo_impl.h.

References BM_ASSERT, BM_IS_GAP, BMGAP_PTR, for_each_bit_blk(), for_each_gap_blk(), FULL_BLOCK_FAKE_ADDR, gap_max_bits, get_block_start(), get_super_block_start(), set_array_mask, set_array_shift, set_sub_array_size, and set_sub_total_bits.

Referenced by for_each_bit_range_no_check().

## for_each_bit_range_no_check()

template<class BV, class Func>

int bm::for_each_bit_range_no_check | ( | const BV & | bv,
|  | typename BV::size_type | left,
|  | typename BV::size_type | right,
|  | Func & | bit_functor )

Implementation of for_each_bit_range without boilerplave checks.

Definition at line 1925 of file bmalgo_impl.h.

References bits_in_block, BM_IS_GAP, BMGAP_PTR, for_each_bit_blk(), for_each_bit_block_range(), for_each_gap_blk_range(), get_block_coord(), bm::bvector< Alloc >::get_blocks_manager(), set_block_mask, and set_block_shift.

Referenced by bm::str_sparse_vector< char, bm::bvector<>, 64 >::decode_substr(), bm::sparse_vector< Val, BV >::extract(), and for_each_bit_range().

## for_each_block()

template<class T, class F, typename BLOCK_IDX>

void bm::for_each_block | ( | T *** | root,
|  | unsigned | size1,
|  | F & | f,
|  | BLOCK_IDX | start )

For each block executes supplied function.

Definition at line 2173 of file bmfunc.h.

References FULL_BLOCK_FAKE_ADDR, and set_sub_array_size.

Referenced by count_intervals().

## for_each_dgap()

template<class T, class Func>

void bm::for_each_dgap | ( | const T * | gap_buf,
|  | Func & | func )

D-GAP block for_each algorithm

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

Parameters

  gap_buf | - GAP buffer
  func | - functor object

Definition at line 2739 of file bmfunc.h.

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

## for_each_nzblock()

template<class T, class F>

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

For each non-zero block executes supplied function.

Definition at line 1908 of file bmfunc.h.

References avx2_test_all_zero_wave(), FULL_BLOCK_FAKE_ADDR, set_sub_array_size, and sse42_test_all_zero_wave().

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

## for_each_nzblock2()

template<class T, class F>

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

For each non-zero block executes supplied function.

Definition at line 2017 of file bmfunc.h.

References FULL_BLOCK_FAKE_ADDR, and set_sub_array_size.

## for_each_nzblock_if()

template<typename T, typename BI, typename F>

bool bm::for_each_nzblock_if | ( | T *** | root,
|  | BI | size1,
|  | F & | f )

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

Definition at line 2139 of file bmfunc.h.

References BMNOEXCEPT, FULL_BLOCK_FAKE_ADDR, and set_sub_array_size.

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

## for_each_nzblock_range()

template<typename T, typename N, typename F>

void bm::for_each_nzblock_range | ( | T *** | root,
|  | N | top_size,
|  | N | nb_from,
|  | N | nb_to,
|  | F & | f )

For each non-zero block in [from, to] executes supplied functor

Definition at line 1851 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, FULL_BLOCK_FAKE_ADDR, gap_max_bits, set_array_mask, set_array_shift, set_sub_array_size, and set_sub_total_bits.

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

## gap_2_bitblock()

template<typename GT, typename BT>

void bm::gap_2_bitblock | ( | const GT *BMRESTRICT | gap_buf,
|  | BT *BMRESTRICT | block,
|  | unsigned | block_size )

Copy GAP block body to bit block with DGap transformation.

Definition at line 625 of file bmtrans.h.

References BMRESTRICT, and gap_2_dgap().

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

## gap_2_dgap()

template<typename T>

T * bm::gap_2_dgap | ( | const T *BMRESTRICT | gap_buf,
|  | T *BMRESTRICT | dgap_buf,
|  | bool | copy_head = true )

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

References BMNOEXCEPT, BMRESTRICT, bm::d_copy_func< T >::dgap_buf_, and for_each_dgap().

Referenced by gap_2_bitblock().

## gap_bfind()

template<typename T>

unsigned bm::gap_bfind | ( | const T *BMRESTRICT | buf,
|  | unsigned | pos,
|  | unsigned *BMRESTRICT | is_set )

Definition at line 1725 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, BMRESTRICT, gap_max_bits, and VECT_GAP_BFIND.

Referenced by bm::bvector< Alloc >::build_rs_index(), for_each_gap_blk_range(), gap_and_to_bitset(), gap_any_range(), gap_bit_count_range(), gap_bit_count_range_hint(), gap_block_find(), gap_find_interval_end(), gap_find_interval_start(), gap_find_prev(), gap_find_rank(), gap_insert(), gap_is_all_one_range(), gap_is_interval(), gap_set_value(), gap_set_value(), gap_sub_to_bitset(), bm::sparse_vector< Val, BV >::gather(), bm::bvector< Alloc >::enumerator::go_to(), bm::interval_enumerator< BV >::go_to_impl(), and bm::bvector< Alloc >::swap().

## gap_bit_count_to()

template<typename T, bool TCORRECT = false>

unsigned bm::gap_bit_count_to | ( | const T *const | buf,
|  | T | right )

Definition at line 2696 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, and gap_max_bits.

Referenced by bm::bvector< Alloc >::build_rs_index(), bm::bvector< Alloc >::count_range_no_check(), bm::bvector< Alloc >::count_to_test(), and bm::bvector< Alloc >::rank_corrected().

## gap_buff_op()

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,
|  | unsigned & | dlen )

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
  dlen | - destination length after the operation

Note
  Internal function.

Definition at line 2944 of file bmfunc.h.

References BMNOEXCEPT2, BMRESTRICT, and gap_max_bits.

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

## get_block_coord()

template<typename BI_TYPE>

BMFORCEINLINE void bm::get_block_coord | ( | BI_TYPE | nb,
|  | unsigned & | i,
|  | unsigned & | j )

Recalc linear bvector block index into 2D matrix coordinates.

Definition at line 180 of file bmfunc.h.

References BMNOEXCEPT, set_array_mask, and set_array_shift.

Referenced by bm::bvector< Alloc >::any_range(), bit_import_u32(), bm::bvector< Alloc >::build_rs_index(), bm::bvector< Alloc >::check_or_next(), bm::bvector< Alloc >::clear_range_no_check(), bm::aggregator< BV >::combine_and_sub(), bm::bvector< Alloc >::combine_operation_with_block(), bm::xor_scanner< BV >::compute_sim_model(), bm::bvector< Alloc >::count_range_no_check(), bm::bvector< Alloc >::count_to(), bm::bvector< Alloc >::count_to_test(), bm::xor_scanner< BV >::deoptimize_gap_blocks(), bm::deserializer< BV, DEC >::deserialize(), bm::iterator_deserializer< BV, SerialIterator >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::bvector< Alloc >::erase(), bm::sparse_vector< Val, BV >::extract_range(), bm::bvector< Alloc >::find_first_mismatch(), find_interval_end(), find_interval_start(), bm::bvector< Alloc >::find_reverse(), for_each_bit_range_no_check(), bm::sparse_vector< Val, BV >::gather(), bm::bvector< Alloc >::get_bit(), bm::basic_bmatrix< BV >::get_half_octet(), bm::basic_bmatrix< BV >::get_octet(), bm::bvector< Alloc >::enumerator::go_to(), bm::interval_enumerator< BV >::go_to_impl(), bm::bvector< Alloc >::import(), bm::bvector< Alloc >::import_block(), bm::bvector< Alloc >::import_sorted(), bm::bvector< Alloc >::insert(), bm::bvector< Alloc >::is_all_one_range(), is_interval(), bm::basic_bmatrix< BV >::optimize_block(), bm::bvector< Alloc >::optimize_range(), bm::bvector< Alloc >::rank_corrected(), bm::bvector< Alloc >::select(), bm::serializer< BV >::serialize(), bm::bvector< Alloc >::set_range_no_check(), bm::sparse_vector< Val, BV >::set_value_no_null(), bm::bvector< Alloc >::swap(), bm::deserializer< BV, DEC >::xor_decode(), and bm::deserializer< BV, DEC >::xor_decode_chain().

## get_block_start()

template<typename RTYPE>

BMFORCEINLINE RTYPE bm::get_block_start | ( | unsigned | i,
|  | unsigned | j )

Compute bit address of the first bit in a block.

Definition at line 201 of file bmfunc.h.

References BMFORCEINLINE, BMNOEXCEPT, gap_max_bits, and get_super_block_start().

Referenced by find_interval_start(), bm::bvector< Alloc >::find_reverse(), and for_each_bit_block_range().

## get_nibble()

unsigned char bm::get_nibble | ( | const unsigned char * | arr,
|  | unsigned | idx )

inline

get nibble from the array

Parameters

  arr | - base array of characters
  idx | - nibble index

Returns
  value

Definition at line 10280 of file bmfunc.h.

References BM_ASSERT, and BMNOEXCEPT.

## get_super_block_start()

template<typename RTYPE>

BMFORCEINLINE RTYPE bm::get_super_block_start | ( | unsigned | i | ) |

Compute bit address of the first bit in a superblock.

Definition at line 191 of file bmfunc.h.

References BMFORCEINLINE, BMNOEXCEPT, and set_sub_total_bits.

Referenced by find_interval_start(), for_each_bit_block_range(), and get_block_start().

## greedy_refine_match_vector()

template<typename PVT, typename VT>

VT::size_type bm::greedy_refine_match_vector | ( | PVT & | match_pairs_vect,
|  | VT & | match_vect,
|  | typename VT::size_type | best_ref_idx,
|  | bm::id64_t | d64,
|  | bm::xor_complement_match | match_type )

Greedy algorithm to find additional matches improving the inital best match block on its match type.

Parameters

  match_pairs_vect | - [out] target vector of best match pairs
  match_vect | - [in/out] vector of all found match descriptors

Returns
  number of new finds (if any)

Definition at line 327 of file bmxor.h.

References bm::block_xor_match_descr::bc_d64, bm::block_xor_match_descr::bc_gain, BM_ASSERT, e_no_xor_match, e_xor_match_BC, e_xor_match_GC, e_xor_match_iBC, bm::block_xor_match_descr::gc_d64, bm::block_xor_match_descr::gc_gain, bm::block_xor_match_descr::ibc_d64, bm::block_xor_match_descr::ibc_gain, bm::block_xor_match_descr::match_type, bm::block_xor_match_descr::ref_idx, and bm::block_xor_match_descr::xor_d64.

Referenced by bm::xor_scanner< BV >::refine_match_chain().

## has_zero_byte_u64()

BMFORCEINLINE bool bm::has_zero_byte_u64 | ( | bm::id64_t | v | ) |

Returns true if INT64 contains 0 octet.

Definition at line 571 of file bmutil.h.

References BMNOEXCEPT.

Referenced by bm::sv_sample_index< SV >::common_prefix_length(), and bm::str_sparse_vector< CharType, BV, STR_SIZE >::compare_str().

## idx_arr_block_lookup_u32()

unsigned bm::idx_arr_block_lookup_u32 | ( | const unsigned * | idx,
|  | unsigned | size,
|  | unsigned | nb,
|  | unsigned | start )

inline

block boundaries look ahead U32

Parameters

  idx | - array to look into
  size | - array size
  nb | - block number to look ahead
  start | - start offset in idx

Returns
  block boundary offset end (no more match at the returned offset)

Definition at line 9781 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, set_block_shift, and VECT_ARR_BLOCK_LOOKUP.

Referenced by bm::sparse_vector< Val, BV >::gather(), bm::bvector< Alloc >::import(), and bm::bvector< Alloc >::import_sorted().

## idx_arr_block_lookup_u64()

bm::id64_t bm::idx_arr_block_lookup_u64 | ( | const bm::id64_t * | idx,
|  | bm::id64_t | size,
|  | bm::id64_t | nb,
|  | bm::id64_t | start )

inline

block boundaries look ahead U32

Parameters

  idx | - array to look into
  size | - array size
  nb | - block number to look ahead
  start | - start offset in idx

Returns
  block boundary offset end (no more match at the returned offset)

Definition at line 9755 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, and set_block_shift.

Referenced by bm::sparse_vector< Val, BV >::gather(), bm::bvector< Alloc >::import(), and bm::bvector< Alloc >::import_sorted().

## ilog2() [1/2]

template<>

BMFORCEINLINE bm::gap_word_t bm::ilog2 | ( | gap_word_t | x | ) |

Definition at line 140 of file bmutil.h.

References BMNOEXCEPT.

## ilog2() [2/2]

template<typename T>

BMFORCEINLINE T bm::ilog2 | ( | T | x | ) |

Fast loop-less function to find LOG2.

Definition at line 126 of file bmutil.h.

References BMFORCEINLINE, and BMNOEXCEPT.

## ilog2_LUT()

template<typename T>

BMFORCEINLINE T bm::ilog2_LUT | ( | T | x | ) |

Lookup table based integer LOG2.

Definition at line 199 of file bmutil.h.

References bm::first_bit_table< T >::_idx, BMFORCEINLINE, and BMNOEXCEPT.

Referenced by bit_scan_reverse32().

## ilog2_LUT< bm::gap_word_t >()

template<>

BMFORCEINLINE bm::gap_word_t bm::ilog2_LUT< bm::gap_word_t > | ( | bm::gap_word_t | x | ) |

Lookup table based short integer LOG2.

Definition at line 218 of file bmutil.h.

References bm::first_bit_table< T >::_idx, BMFORCEINLINE, and BMNOEXCEPT.

## is_aligned()

template<typename T>

bool bm::is_aligned | ( | T * | p | ) |

Check pointer alignment.

Definition at line 637 of file bmutil.h.

References BM_ALLOC_ALIGN, and BMNOEXCEPT.

## is_const_set_operation()

bool bm::is_const_set_operation | ( | set_operation | op | ) |

inline

Returns true if set operation is constant (bitcount).

Definition at line 1330 of file bmfunc.h.

References BMNOEXCEPT, and set_COUNT.

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

## is_digest_one_range()

bool bm::is_digest_one_range | ( | bm::id64_t | digest | ) |

inline

Is one range of 1s ( 0000110000 - one range, 000011000010 - more than one).

Returns
  true

Definition at line 1067 of file bmfunc.h.

References BM_ASSERT, and BMNOEXCEPT.

## join_multiple_threads()

template<typename TCont>

void bm::join_multiple_threads | ( | TCont & | tcont | ) |

Wait for multiple threads to exit.

Definition at line 108 of file bmthreadpool.h.

Referenced by bm::thread_pool< QValue, Lock >::join().

## lower_bound_linear_u32()

unsigned bm::lower_bound_linear_u32 | ( | const unsigned * | arr,
|  | unsigned | target,
|  | unsigned | from,
|  | unsigned | to )

inline

Linear lower bound search in unsigned array.

Definition at line 9905 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, and VECT_LOWER_BOUND_SCAN_U32.

Referenced by lower_bound_u32().

## lower_bound_linear_u64()

unsigned bm::lower_bound_linear_u64 | ( | const unsigned long long * | arr,
|  | unsigned long long | target,
|  | unsigned | from,
|  | unsigned | to )

inline

Linear lower bound search in unsigned LONG array.

Definition at line 9928 of file bmfunc.h.

References BM_ASSERT, and BMNOEXCEPT.

Referenced by lower_bound_u64().

## lower_bound_u32()

unsigned bm::lower_bound_u32 | ( | const unsigned * | arr,
|  | unsigned | target,
|  | unsigned | from,
|  | unsigned | to )

inline

Hybrid, binary-linear lower bound search in unsigned array.

Definition at line 9953 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, and lower_bound_linear_u32().

## lower_bound_u64()

unsigned bm::lower_bound_u64 | ( | const unsigned long long * | arr,
|  | unsigned long long | target,
|  | unsigned | from,
|  | unsigned | to )

inline

Hybrid, binary-linear lower bound search in unsigned LONG array.

Definition at line 9988 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, and lower_bound_linear_u64().

## mask_l_u32()

BMFORCEINLINE unsigned bm::mask_l_u32 | ( | unsigned | nbit | ) |

Definition at line 522 of file bmutil.h.

References bm::block_set_table< T >::_left, BM_ASSERT, and BMNOEXCEPT.

Referenced by bit_block_any_range(), bit_block_calc_count_range(), bit_block_calc_count_to(), bit_block_find_interval_start(), bit_block_find_prev(), bit_block_is_all_one_range(), for_each_bit_blk(), and xor_bit_block().

## mask_r_u32()

BMFORCEINLINE unsigned bm::mask_r_u32 | ( | unsigned | nbit | ) |

Definition at line 513 of file bmutil.h.

References bm::block_set_table< T >::_right, BM_ASSERT, and BMNOEXCEPT.

Referenced by bit_block_any_range(), bit_block_calc_count_range(), bit_block_erase(), bit_block_insert(), bit_block_is_all_one_range(), for_each_bit_blk(), and xor_bit_block().

## min_delta_apply()

void bm::min_delta_apply | ( | unsigned * | arr,
|  | size_t | arr_size,
|  | unsigned | delta )

inline

Recalculate the array to decrement delta as arr[i] = arr[i] - delta + 1 so that array remains monotonically growing (fit for interpolative compression).

Definition at line 10097 of file bmfunc.h.

References BM_ASSERT, and BMNOEXCEPT.

## min_delta_u32()

unsigned bm::min_delta_u32 | ( | const unsigned * | arr,
|  | size_t | arr_size )

inline

Calculate minimal delta between elements of sorted array.

Definition at line 10068 of file bmfunc.h.

References BM_ASSERT.

## min_value()

template<typename T>

BMFORCEINLINE T bm::min_value | ( | T | v1,
|  | T | v2 )

Get minimum of 2 values.

Definition at line 103 of file bmutil.h.

References BMFORCEINLINE, and BMNOEXCEPT.

Referenced by distance_and_operation().

## op_and()

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

Definition at line 182 of file bmsse4.h.

References BMNOEXCEPT.

## op_or()

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

Definition at line 173 of file bmsse4.h.

References BMNOEXCEPT.

## op_xor()

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

Definition at line 163 of file bmsse4.h.

References BMNOEXCEPT.

## operator&()

template<class Alloc>

bvector< Alloc > bm::operator& | ( | const bvector< Alloc > & | bv1,
|  | const bvector< Alloc > & | bv2 )

inline

Definition at line 2235 of file bm.h.

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

## operator-()

template<class Alloc>

bvector< Alloc > bm::operator- | ( | const bvector< Alloc > & | bv1,
|  | const bvector< Alloc > & | bv2 )

inline

Definition at line 2268 of file bm.h.

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

## operator^()

template<class Alloc>

bvector< Alloc > bm::operator^ | ( | const bvector< Alloc > & | bv1,
|  | const bvector< Alloc > & | bv2 )

inline

Definition at line 2257 of file bm.h.

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

## operator|()

template<class Alloc>

bvector< Alloc > bm::operator| | ( | const bvector< Alloc > & | bv1,
|  | const bvector< Alloc > & | bv2 )

inline

Definition at line 2246 of file bm.h.

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

## parallel_popcnt_32()

int bm::parallel_popcnt_32 | ( | unsigned int | n | ) |

inline

32-bit paralle, bitcount

Definition at line 232 of file bmfunc.h.

References BMNOEXCEPT.

## process_operation()

template<class BV>

BV::size_type bm::process_operation | ( | BV & | bv,
|  | BV & | bv_tmp,
|  | bm::set_operation | op )

Utility function to process operation using temp vector.

Definition at line 6394 of file bmserial.h.

References BM_ASSERT, count_and(), count_or(), count_sub(), count_xor(), set_AND, set_ASSIGN, set_COUNT, set_COUNT_A, set_COUNT_AND, set_COUNT_B, set_COUNT_OR, set_COUNT_SUB_AB, set_COUNT_SUB_BA, set_COUNT_XOR, set_END, set_OR, set_SUB, and set_XOR.

Referenced by bm::operation_deserializer< BV >::deserialize().

## ptrp_test()

bm::id64_t bm::ptrp_test | ( | ptr_payload_t | ptr,
|  | bm::gap_word_t | v )

inline

Test presense of value in payload pointer

Definition at line 10310 of file bmfunc.h.

References BMNOEXCEPT.

## set_block_bits_u32()

void bm::set_block_bits_u32 | ( | bm::word_t *BMRESTRICT | block,
|  | const unsigned *BMRESTRICT | idx,
|  | unsigned | start,
|  | unsigned | stop )

inline

set bits in a bit-block using global index

Parameters

  idx | - array to look into
  block | - block pointer to set bits
  start | - index array start
  stop | - index array stop in a range [start..stop)

Returns
  block boundary offset end (no more match at the returned offset)

Definition at line 9844 of file bmfunc.h.

References BM_ASSERT, BMNOEXCEPT, BMRESTRICT, set_block_mask, set_word_mask, set_word_shift, and VECT_SET_BLOCK_BITS.

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

## set_block_bits_u64()

void bm::set_block_bits_u64 | ( | bm::word_t *BMRESTRICT | block,
|  | const bm::id64_t *BMRESTRICT | idx,
|  | bm::id64_t | start,
|  | bm::id64_t | stop )

inline

set bits in a bit-block using global index

Parameters

  idx | - array to look into
  block | - block pointer to set bits
  start | - index array start
  stop | - index array stop in a range [start..stop)

Returns
  block boundary offset end (no more match at the returned offset)

Definition at line 9814 of file bmfunc.h.

References BMNOEXCEPT, BMRESTRICT, set_block_mask, set_word_mask, and set_word_shift.

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

## set_nibble()

void bm::set_nibble | ( | unsigned char * | arr,
|  | unsigned | idx,
|  | unsigned char | v )

inline

set nibble in the array

Parameters

  arr | - base array of characters
  idx | - nibble index
  v | - value to set

Definition at line 10251 of file bmfunc.h.

References BM_ASSERT, and BMNOEXCEPT.

## setop2op()

bm::operation bm::setop2op | ( | bm::set_operation | op | ) |

inline

Convert set operation to operation.

Definition at line 1339 of file bmfunc.h.

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

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

## sse2_and()

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

Definition at line 1035 of file bmsse_util.h.

References BMNOEXCEPT.

## sse2_and_block()

unsigned bm::sse2_and_block | ( | __m128i *BMRESTRICT | dst,
|  | const __m128i *BMRESTRICT | src,
|  | const __m128i *BMRESTRICT | src_end )

inline

Definition at line 312 of file bmsse_util.h.

References BM_ALIGN16, BM_ALIGN16ATTR, BMNOEXCEPT, and BMRESTRICT.

## sse2_bit_block_calc_count_change()

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 1221 of file bmsse2.h.

References BM_ALIGN16, BM_ALIGN16ATTR, BMRESTRICT, and word_bitcount().

## sse2_bit_count()

bm::id_t bm::sse2_bit_count | ( | const __m128i * | block,
|  | const __m128i * | block_end )

inline

    SSE2 optimized bitcounting function implements parallel bitcounting
    algorithm for SSE2 instruction set.

    unsigned CalcBitCount32(unsigned b)
    {
        b = (b & 0x55555555) + (b >> 1 & 0x55555555);
        b = (b & 0x33333333) + (b >> 2 & 0x33333333);
        b = (b + (b >> 4)) & 0x0F0F0F0F;
        b = b + (b >> 8);
        b = (b + (b >> 16)) & 0x0000003F;
        return b;
    }

    @ingroup SSE2

Definition at line 66 of file bmsse2.h.

References BM_ALIGN16, and BM_ALIGN16ATTR.

## sse2_bit_count_op()

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 )

Definition at line 127 of file bmsse2.h.

References BM_ALIGN16, BM_ALIGN16ATTR, and BMRESTRICT.

## sse2_gap_find()

unsigned bm::sse2_gap_find | ( | const bm::gap_word_t *BMRESTRICT | pbuf,
|  | const bm::gap_word_t | pos,
|  | unsigned | size )

inline

SSE4.2 check for one to two (variable len) 128 bit SSE lines for gap search results (8 elements)

Definition at line 1379 of file bmsse2.h.

References bit_scan_fwd(), BM_ASSERT, and BMRESTRICT.

Referenced by sse2_gap_bfind().

## sse2_gap_sum_arr()

const bm::gap_word_t * bm::sse2_gap_sum_arr | ( | const bm::gap_word_t *BMRESTRICT | pbuf,
|  | unsigned | sse_vect_waves,
|  | unsigned * | sum )

inline

Gap block population count (array sum) utility.

Parameters

  pbuf | - unrolled, aligned to 1-start GAP buffer
  sse_vect_waves | - number of SSE vector lines to process
  sum | - result acumulator

Returns
  tail pointer

Definition at line 1071 of file bmsse_util.h.

References BMNOEXCEPT, and BMRESTRICT.

Referenced by gap_bit_count_unr().

## sse2_or()

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

Definition at line 1041 of file bmsse_util.h.

References BMNOEXCEPT.

## sse2_sub()

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

Definition at line 1054 of file bmsse_util.h.

References BMNOEXCEPT.

## sse2_xor()

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

Definition at line 1048 of file bmsse_util.h.

References BMNOEXCEPT.

## sse42_idx_arr_block_lookup()

unsigned bm::sse42_idx_arr_block_lookup | ( | const unsigned * | idx,
|  | unsigned | size,
|  | unsigned | nb,
|  | unsigned | start )

inline

SSE4.2 index lookup to check what belongs to the same block (8 elements)

Definition at line 1558 of file bmsse4.h.

References BMNOEXCEPT, and set_block_shift.

## sse42_set_block_bits()

void bm::sse42_set_block_bits | ( | bm::word_t *BMRESTRICT | block,
|  | const unsigned *BMRESTRICT | idx,
|  | unsigned | start,
|  | unsigned | stop )

inline

SSE4.2 bulk bit set

Definition at line 1595 of file bmsse4.h.

References BM_ALIGN16, BM_ALIGN16ATTR, BMNOEXCEPT, BMRESTRICT, set_block_mask, set_word_mask, and set_word_shift.

## sse4_bit_block_gather_scatter()

void bm::sse4_bit_block_gather_scatter | ( | unsigned *BMRESTRICT | arr,
|  | const unsigned *BMRESTRICT | blk,
|  | const unsigned *BMRESTRICT | idx,
|  | unsigned | size,
|  | unsigned | start,
|  | unsigned | bit_idx )

inline

SSE4.2 bit block gather-scatter

Parameters

  arr | - destination array to set bits
  blk | - source bit-block
  idx | - gather index array
  size | - gather array size
  start | - gaher start index
  bit_idx | - bit to set in the target array

Definition at line 1679 of file bmsse4.h.

References BM_ALIGN16, BM_ALIGN16ATTR, BMNOEXCEPT, BMRESTRICT, set_block_mask, set_word_mask, and set_word_shift.

Referenced by bit_block_gather_scatter().

## sse4_bit_count_op()

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 )

Definition at line 189 of file bmsse4.h.

References BM_ALIGN16, BM_ALIGN16ATTR, BMNOEXCEPT, and BMRESTRICT.

## sum_arr()

template<typename T>

bm::id64_t bm::sum_arr | ( | const T * | first,
|  | const T * | last )

Computes SUM of all elements of the sequence

Definition at line 2221 of file bmfunc.h.

References BMNOEXCEPT.

## test_4bits()

bool bm::test_4bits | ( | const bm::word_t * | p0,
|  | const bm::word_t * | p1,
|  | const bm::word_t * | p2,
|  | const bm::word_t * | p3 )

inline

Test 4 pointers are not NULL and not marked as FULLBLOCK.

Definition at line 1472 of file bmbmatrix.h.

References BMNOEXCEPT, and FULL_BLOCK_FAKE_ADDR.

Referenced by bm::basic_bmatrix< BV >::get_half_octet().

## test_4gaps()

bool bm::test_4gaps | ( | const bm::word_t * | p0,
|  | const bm::word_t * | p1,
|  | const bm::word_t * | p2,
|  | const bm::word_t * | p3 )

inline

Test 4 pointers are all marked as GAPs.

Definition at line 1460 of file bmbmatrix.h.

References BMNOEXCEPT.

Referenced by bm::basic_bmatrix< BV >::get_half_octet().

## tmatrix_reduce()

template<class TMatrix>

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

Transposed Matrix reduction based on transformation pc vector.

Definition at line 516 of file bmtrans.h.

References BM_ASSERT, bm::tmatrix< T, ROWS, COLS >::cols(), ibpc_all_one, ibpc_all_zero, ibpc_close, ibpc_equiv, ibpc_uncompr, bm::tmatrix< T, ROWS, COLS >::row(), and bm::tmatrix< T, ROWS, COLS >::rows().

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

## tmatrix_restore()

template<class TMatrix>

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

Transposed Matrix restore based on transformation pc vector.

Definition at line 563 of file bmtrans.h.

References BM_ASSERT, bm::tmatrix< T, ROWS, COLS >::cols(), ibpc_all_one, ibpc_all_zero, ibpc_close, ibpc_equiv, ibpc_uncompr, bm::tmatrix< T, ROWS, COLS >::row(), and bm::tmatrix< T, ROWS, COLS >::rows().

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

## vect_bit_transpose()

template<typename T, unsigned BPC, unsigned BPS>

void bm::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 plane count BPS - bit plane size.

Parameters

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

Definition at line 257 of file bmtrans.h.

References BM_ASSERT, and bm::bit_grabber< T, BPC >::get().

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

## vect_bit_trestore()

template<typename T, unsigned BPC, unsigned BPS>

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

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

Parameters

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

Definition at line 290 of file bmtrans.h.

References bm::bit_trans_grabber< T, BPC, BPS >::get().

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

## xor_swap()

template<typename W>

BMFORCEINLINE void bm::xor_swap | ( | W & | x,
|  | W & | y )

XOR swap two variables.

Definition at line 534 of file bmutil.h.

References BM_ASSERT, BMFORCEINLINE, and BMNOEXCEPT.

Referenced by bm::bvector< Alloc >::any_range(), bm::bvector< dbg_alloc >::bvector(), bm::bvector< Alloc >::copy_range(), bm::rsc_sparse_vector< Val, SV >::copy_range(), bm::sparse_vector< Val, BV >::copy_range(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::copy_range(), bm::bvector< Alloc >::count_range(), bm::bvector< Alloc >::count_range(), bm::rsc_sparse_vector< Val, SV >::count_range_notnull(), bm::sparse_vector_scanner< SV, S_FACTOR >::find_range(), for_each_bit_range(), bm::bvector< Alloc >::is_all_one_range(), is_interval(), bm::bvector< Alloc >::keep_range(), bm::sparse_vector< Val, BV >::keep_range(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::keep_range(), sparse_vector_find_mismatch(), bm::base_sparse_vector< Val, BV, MAX_SIZE >::swap(), bm::basic_bmatrix< BV >::swap(), bm::bvector< Alloc >::swap(), bm::interval_enumerator< BV >::swap(), and bm::str_sparse_vector< CharType, BV, STR_SIZE >::swap().

## Variable Documentation

## _copyright< T >::_p

template<bool T>

const char bm::_copyright< T >::_p[]

Initial value:
=
"BitMagic Library. v.7.13.4 (c) 2002-2022 Anatoliy Kuznetsov."

Definition at line 249 of file bmconst.h.

Referenced by bm::all_set< T >::all_set_block::all_set_block().

## _copyright< T >::_v

template<bool T>

const unsigned bm::_copyright< T >::_v[3]

Initial value:
=
{ BM_VERSION_MAJOR, BM_VERSION_MINOR, BM_VERSION_PATCH }
BM_VERSION_PATCH
#define BM_VERSION_PATCH
Definition bmconst.h:247
BM_VERSION_MINOR
#define BM_VERSION_MINOR
Definition bmconst.h:246
BM_VERSION_MAJOR
#define BM_VERSION_MAJOR
Definition bmconst.h:245

Definition at line 251 of file bmconst.h.

## all_bits_mask

const id64_t bm::all_bits_mask = 0xffffffffffffffffULL

Definition at line 132 of file bmconst.h.

Referenced by bit_andnot_arr_ffmask(), bm::bvector< Alloc >::combine_operation_with_block(), and is_bits_one().

## all_set< T >::_block

template<bool T>

all_set<T>::all_set_block bm::all_set< T >::_block

Definition at line 1418 of file bmfunc.h.

## bie_cut_off

const unsigned bm::bie_cut_off = 16384

Definition at line 88 of file bmconst.h.

## bit_count_table< T >::_count

template<bool T>

const unsigned char bm::bit_count_table< T >::_count[256]

Initial value:
= {
0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
}

Definition at line 314 of file bmconst.h.

## bits_in_array

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

Definition at line 115 of file bmconst.h.

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

## bits_in_block

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

Definition at line 114 of file bmconst.h.

Referenced by bm::bvector< Alloc >::clear_range_no_check(), bm::aggregator< BV >::combine_and_sub(), bm::bvector< Alloc >::count_range_no_check(), bm::deserializer< BV, DEC >::deserialize(), bm::iterator_deserializer< BV, SerialIterator >::deserialize(), for_each_bit_blk(), for_each_bit_range_no_check(), for_each_gap_blk_range(), gap_init_range_block(), bm::bvector< Alloc >::enumerator::go_first(), and bm::bvector< Alloc >::set_range_no_check().

## block_set_table< T >::_left

template<bool T>

const unsigned bm::block_set_table< T >::_left[32]

Initial value:
= {
0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff, 0x7ff,
0xfff, 0x1fff, 0x3fff, 0x7fff, 0xffff, 0x1ffff, 0x3ffff, 0x7ffff,
0xfffff, 0x1fffff, 0x3fffff, 0x7fffff, 0xffffff, 0x1ffffff, 0x3ffffff,
0x7ffffff, 0xfffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff
}

Definition at line 370 of file bmconst.h.

## block_set_table< T >::_right

template<bool T>

const unsigned bm::block_set_table< T >::_right[32]

Initial value:
= {
0xffffffff, 0xfffffffe, 0xfffffffc, 0xfffffff8, 0xfffffff0,
0xffffffe0, 0xffffffc0, 0xffffff80, 0xffffff00, 0xfffffe00,
0xfffffc00, 0xfffff800, 0xfffff000, 0xffffe000, 0xffffc000,
0xffff8000, 0xffff0000, 0xfffe0000, 0xfffc0000, 0xfff80000,
0xfff00000, 0xffe00000, 0xffc00000, 0xff800000, 0xff000000,
0xfe000000, 0xfc000000, 0xf8000000, 0xf0000000, 0xe0000000,
0xc0000000, 0x80000000
}

Definition at line 378 of file bmconst.h.

## block_waves

const unsigned bm::block_waves = 64

Definition at line 66 of file bmconst.h.

Referenced by avx2_bit_block_xor(), bit_block_xor(), block_compact_by_digest(), block_expand_by_digest(), compute_s_block_descr(), bm::xor_scanner< BV >::compute_xor_complexity_descr(), bm::serializer< BV >::find_bit_best_encoding(), sse2_bit_block_xor(), sse42_bit_block_xor(), and bm::buffer< bvector_type >::xor_tmp_product().

## DeBruijn_bit_position< T >::_multiply

template<bool T>

const unsigned bm::DeBruijn_bit_position< T >::_multiply[32]

Initial value:
= {
0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
}

Definition at line 267 of file bmconst.h.

## first_bit_table< T >::_idx

template<bool T>

const signed char bm::first_bit_table< T >::_idx[256]

Initial value:
= {
-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
}

Definition at line 282 of file bmconst.h.

## gap_equiv_len

const unsigned bm::gap_equiv_len

Initial value:
= (unsigned)
((sizeof(bm::word_t) * bm::set_block_size) / sizeof(bm::gap_word_t))
bm::word_t
unsigned int word_t
Definition bmconst.h:39
bm::set_block_size
const unsigned set_block_size
Definition bmconst.h:55
bm::gap_word_t
unsigned short gap_word_t
Definition bmconst.h:78

Definition at line 82 of file bmconst.h.

Referenced by bm::bvector< Alloc >::combine_operation_block_and(), bm::bvector< Alloc >::combine_operation_block_and(), bm::bvector< Alloc >::combine_operation_block_and_or(), bm::bvector< Alloc >::combine_operation_block_or(), bm::bvector< Alloc >::combine_operation_block_or(), bm::bvector< Alloc >::combine_operation_block_sub(), bm::bvector< Alloc >::combine_operation_block_sub(), bm::bvector< Alloc >::combine_operation_block_xor(), bm::bvector< Alloc >::combine_operation_block_xor(), bm::bvector< Alloc >::combine_operation_with_block(), bm::iterator_deserializer< BV, SerialIterator >::deserialize(), bm::serializer< BV >::encode_gap_block(), bm::serializer< BV >::find_bit_best_encoding(), and bm::serializer< BV >::gamma_gap_bit_block().

## gap_len_table< T >::_len

template<bool T>

const gap_word_t bm::gap_len_table< T >::_len[bm::gap_levels]

Initial value:
=
{ 128, 256, 512, bm::gap_max_buff_len }
bm::gap_max_buff_len
const unsigned gap_max_buff_len
Definition bmconst.h:80

Definition at line 401 of file bmconst.h.

Referenced by bm::bvector< dbg_alloc >::bvector().

## gap_len_table_min< T >::_len

template<bool T>

const gap_word_t bm::gap_len_table_min< T >::_len[bm::gap_levels]

Initial value:
=
{ 32, 96, 128, 512 }

Definition at line 416 of file bmconst.h.

## gap_len_table_nl< T >::_len

template<bool T>

const gap_word_t bm::gap_len_table_nl< T >::_len[bm::gap_levels]

Initial value:
=
{ 32, 128, 512, bm::gap_max_buff_len }

Definition at line 429 of file bmconst.h.

## gap_levels

const unsigned bm::gap_levels = 4

Examples
  xsample01.cpp.

Definition at line 85 of file bmconst.h.

Referenced by bm::bv_statistics::add_gap_block(), bm::mem_alloc< block_allocator, ptr_allocator, standard_alloc_pool >::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::bv_statistics::reset(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::serial_stream_iterator(), and set_gap_level().

## gap_max_bits

const unsigned bm::gap_max_bits = 65536

Definition at line 81 of file bmconst.h.

Referenced by bm::interval_enumerator< BV >::advance(), bm::bvector< Alloc >::any_range(), avx2_gap_bfind(), bm::xor_scanner< BV >::best_metric(), bm::sparse_vector_scanner< SV, S_FACTOR >::bfind_eq_str_impl(), bm::serializer< BV >::bienc_gap_bit_block(), bit_block_calc_count_range(), bit_block_convert_to_arr(), bit_block_find_interval_end(), bit_block_is_all_one_range(), bit_operation_or_count(), bit_operation_sub_count(), bit_operation_xor_count(), block_any_range(), block_find_interval_end(), block_find_interval_start(), block_find_reverse(), block_is_all_one_range(), block_is_interval(), block_to_global_index(), bm::bvector< Alloc >::build_rs_index(), bm::bvector< Alloc >::check_or_next(), bm::aggregator< BV >::combine_and_sub(), bm::bvector< Alloc >::combine_operation_block_sub(), bm::bvector< Alloc >::combine_operation_with_block(), bm::xor_scanner< BV >::compute_sim_model(), bm::xor_scanner< BV >::compute_xor_complexity_descr(), bm::sv_sample_index< SV >::construct(), convert_sub_to_arr(), bm::bvector< Alloc >::copy_range_no_check(), bm::bvector< Alloc >::count(), bm::deserializer< BV, DEC >::decode_arr_sblock(), bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::deserializer< BV, DEC >::deserializer(), digest_mask(), bm::bvector< Alloc >::erase(), bm::bvector< Alloc >::find(), bm::serializer< BV >::find_bit_best_encoding(), bm::serializer< BV >::find_bit_best_encoding_l5(), bm::bvector< Alloc >::find_first_mismatch(), bm::serializer< BV >::find_gap_best_encoding(), find_interval_end(), find_interval_start(), bm::bvector< Alloc >::find_rank(), bm::bvector< Alloc >::find_reverse(), bm::bvector< Alloc >::find_reverse(), for_each_bit_blk(), for_each_bit_block_range(), for_each_nzblock_range(), gap_add_value(), gap_any_range(), gap_bfind(), gap_bit_count_range(), gap_bit_count_range_hint(), gap_bit_count_to(), gap_block_find(), gap_buff_any_op(), gap_buff_count_op(), gap_buff_op(), gap_find_first(), gap_find_interval_end(), gap_find_interval_start(), gap_find_last(), gap_find_prev(), gap_insert(), gap_is_all_one(), gap_is_all_one_range(), gap_is_all_zero(), gap_is_interval(), gap_set_array(), gap_set_value(), gap_set_value(), gap_set_value_cpos(), gap_shift_l1(), gap_shift_r1(), gap_test(), gap_test_unr(), get_block_start(), bm::interval_enumerator< BV >::go_to_impl(), bm::bvector< Alloc >::enumerator::go_up(), bm::bvector< Alloc >::insert(), bm::serializer< BV >::interpolated_gap_bit_block(), bm::bvector< Alloc >::is_all_one_range(), is_interval(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_gap_block(), bm::sv_sample_index< SV >::recalc_range(), bm::xor_scanner< BV >::search_best_xor_mask(), bm::bvector< Alloc >::select(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::serial_stream_iterator(), bm::serializer< BV >::serializer(), bm::serializer< BV >::serializer(), bm::bvector< Alloc >::enumerator::skip(), and bm::xor_sim_params::xor_sim_params().

## gap_max_bits_cmrz

const unsigned bm::gap_max_bits_cmrz = bm::gap_max_bits / 2

Definition at line 84 of file bmconst.h.

## gap_max_buff_len

const unsigned bm::gap_max_buff_len = 1280

Definition at line 80 of file bmconst.h.

Referenced by combine_any_operation_with_block(), bm::serializer< BV >::find_bit_best_encoding(), bm::serializer< BV >::find_bit_best_encoding_l5(), and improve_gap_levels().

## gap_max_level

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

Definition at line 86 of file bmconst.h.

## globals< T >::_bo

template<bool T>

globals<T>::bo bm::globals< T >::_bo

Definition at line 489 of file bmconst.h.

## ibpc_all_one

const unsigned char bm::ibpc_all_one = 2

!< plane ALL ZERO

Definition at line 351 of file bmtrans.h.

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

## ibpc_all_zero

const unsigned char bm::ibpc_all_zero = 1

!< plane uncompressed

Definition at line 350 of file bmtrans.h.

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

## ibpc_close

const unsigned char bm::ibpc_close = 4

!< plane is equal to plane M

Definition at line 353 of file bmtrans.h.

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

## ibpc_end

const unsigned char bm::ibpc_end = 8

!< plane is close to plane M

Definition at line 355 of file bmtrans.h.

## ibpc_equiv

const unsigned char bm::ibpc_equiv = 3

!< plane ALL ONE

Definition at line 352 of file bmtrans.h.

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

## ibpc_uncompr

const unsigned char bm::ibpc_uncompr = 0

Definition at line 349 of file bmtrans.h.

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

## id_max

const unsigned bm::id_max = bm::id_max32

Examples
  bvsample01_64.cpp, rscsample06.cpp, sample24.cpp, sample25.cpp, and svsample07a.cpp.

Definition at line 109 of file bmconst.h.

Referenced by bm::rsc_sparse_vector< Val, SV >::back_insert_iterator::add(), bm::rsc_sparse_vector< Val, SV >::back_insert_iterator::add_null(), bm::interval_enumerator< BV >::advance(), bm::rsc_sparse_vector< Val, SV >::const_iterator::advance(), bm::sparse_vector< Val, BV >::const_iterator::advance(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::const_iterator::advance(), bm::bvector< Alloc >::any_range(), bm::base_sparse_vector< Val, BV, MAX_SIZE >::base_sparse_vector(), bm::base_sparse_vector< Val, BV, 1 >::base_sparse_vector(), block_range_scan(), bm::bvector< dbg_alloc >::bvector(), bm::bvector< dbg_alloc >::bvector(), bm::bvector< Alloc >::clear_bit_no_check(), combine_or(), combine_sub(), combine_xor(), bm::rsc_sparse_vector< Val, SV >::const_iterator::const_iterator(), bm::sparse_vector< Val, BV >::const_iterator::const_iterator(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::const_iterator::const_iterator(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::const_iterator::const_iterator(), convert_sub_to_arr(), bm::bvector< Alloc >::copy_range_no_check(), count_intervals(), bm::bvector< Alloc >::count_range(), bm::bvector< Alloc >::count_range(), bm::bvector< Alloc >::count_to(), bm::bvector< Alloc >::count_to_test(), bm::rsc_sparse_vector< Val, SV >::decode(), bm::rsc_sparse_vector< Val, SV >::decode_buf(), bm::deserializer< BV, DEC >::deserialize(), bm::serializer< BV >::encode_header(), bm::rsc_sparse_vector< unsigned, sparse_vector_u32 >::end(), bm::sparse_vector< unsigned, bm::bvector<> >::end(), bm::str_sparse_vector< char, bm::bvector<>, 64 >::end(), bm::bvector< Alloc >::erase(), bm::bvector< dbg_alloc >::extract_next(), bm::bvector< Alloc >::find(), bm::bvector< dbg_alloc >::find_first_mismatch(), find_interval_end(), bm::bvector< Alloc >::find_rank(), bm::bvector< Alloc >::find_rank(), bm::sparse_vector_scanner< SV, S_FACTOR >::find_zero(), for_each_bit_range(), bm::rsc_sparse_vector< Val, SV >::gather(), bm::sparse_vector< Val, BV >::gather(), bm::bvector< dbg_alloc >::get_next(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::const_iterator::get_string_view(), bm::sparse_vector< Val, BV >::get_unsigned(), bm::sparse_vector< Val, BV >::get_unsigned_bits(), bm::rsc_sparse_vector< Val, SV >::const_iterator::go_to(), bm::sparse_vector< Val, BV >::const_iterator::go_to(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::const_iterator::go_to(), bm::interval_enumerator< BV >::go_to_impl(), bm::bvector< Alloc >::import_sorted(), bm::bvector< Alloc >::insert(), bm::interval_enumerator< bm::bvector<> >::interval_enumerator(), bm::interval_enumerator< bm::bvector<> >::interval_enumerator(), bm::interval_enumerator< bm::bvector<> >::interval_enumerator(), bm::interval_enumerator< bm::bvector<> >::interval_enumerator(), bm::interval_enumerator< bm::bvector<> >::interval_enumerator(), bm::bvector< Alloc >::iterator_base::invalidate(), bm::interval_enumerator< BV >::invalidate(), bm::rsc_sparse_vector< Val, SV >::const_iterator::invalidate(), bm::sparse_vector< Val, BV >::const_iterator::invalidate(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::const_iterator::invalidate(), bm::bvector< Alloc >::invert(), bm::bvector< Alloc >::is_all_one_range(), is_interval(), bm::bvector< Alloc >::iterator_base::iterator_base(), main(), bm::bvector< Alloc >::bulk_insert_iterator::operator=(), bm::bvector< Alloc >::insert_iterator::operator=(), bm::bvector< dbg_alloc >::operator[](), bm::rsc_sparse_vector< Val, SV >::push_back_null(), bm::sparse_vector< Val, BV >::push_back_null(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::push_back_null(), bm::bvector< Alloc >::rank_corrected(), bm::aggregator< BV >::reset_range_hint(), bm::rsc_sparse_vector< Val, SV >::resize(), bm::rsc_sparse_vector< Val, SV >::resolve_sync(), bm::rsc_sparse_vector< unsigned, sparse_vector_u32 >::rsc_sparse_vector(), bm::bvector< Alloc >::set_bit(), bm::bvector< Alloc >::set_bit_conditional(), bm::bvector< Alloc >::set_bit_no_check(), bm::bvector< Alloc >::set_bit_no_check(), bm::bvector< Alloc >::set_range(), bm::rsc_sparse_vector< Val, SV >::const_iterator::skip_zero_values(), bm::sparse_vector< Val, BV >::const_iterator::skip_zero_values(), bm::sparse_vector< unsigned, bm::bvector<> >::sparse_vector(), sparse_vector_find_first_mismatch(), bm::sparse_vector_scanner< SV, S_FACTOR >::sparse_vector_scanner(), sse42_shift_r1_and(), bm::str_sparse_vector< char, bm::bvector<>, 64 >::str_sparse_vector(), bm::bvector< Alloc >::swap(), bm::bvector< Alloc >::sync_size(), bm::bvector< Alloc >::iterator_base::valid(), bm::interval_enumerator< BV >::valid(), bm::rsc_sparse_vector< Val, SV >::const_iterator::valid(), bm::sparse_vector< Val, BV >::const_iterator::valid(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::const_iterator::valid(), and bm::str_sparse_vector< CharType, BV, STR_SIZE >::const_iterator::value().

## id_max32

const unsigned bm::id_max32 = 0xFFFFFFFFu

Definition at line 50 of file bmconst.h.

Referenced by bm::sparse_vector_serializer< SV >::serialize().

## lzcnt_table< T >::_lut

template<bool T>

const unsigned char bm::lzcnt_table< T >::_lut[16]

Initial value:
=
{
32U, 31U, 30U, 30U, 29U, 29U, 29U, 29U,
28U, 28U, 28U, 28U, 28U, 28U, 28U, 28U
}

Definition at line 336 of file bmconst.h.

## operation_functions< T >::bit_op_count_table_

template<bool T>

bit_operation_count_func_type bm::operation_functions< T >::bit_op_count_table_[bm::set_END]

Initial value:
= {
0,
0,
0,
0,
0,
0,
&bit_operation_and_count,
&bit_operation_xor_count,
&bit_operation_or_count,
&bit_operation_sub_count,
&bit_operation_sub_count_inv,
0,
0,
}
bm::bit_operation_sub_count_inv
bm::id_t bit_operation_sub_count_inv(const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
Performs inverted bitblock SUB operation and calculates bitcount of the result.
Definition bmfunc.h:7712
bm::bit_operation_or_count
bm::id_t bit_operation_or_count(const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
Performs bitblock OR operation and calculates bitcount of the result.
Definition bmfunc.h:7765
bm::bit_operation_xor_count
bm::id_t bit_operation_xor_count(const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
Performs bitblock XOR operation and calculates bitcount of the result.
Definition bmfunc.h:8543
bm::bit_operation_and_count
bm::id_t bit_operation_and_count(const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
Performs bitblock AND operation and calculates bitcount of the result.
Definition bmfunc.h:7626
bm::bit_operation_sub_count
bm::id_t bit_operation_sub_count(const bm::word_t *BMRESTRICT src1, const bm::word_t *BMRESTRICT src2) BMNOEXCEPT
Performs bitblock SUB operation and calculates bitcount of the result.
Definition bmfunc.h:7675

Definition at line 9603 of file bmfunc.h.

## operation_functions< T >::gap2bit_table_

template<bool T>

gap_operation_to_bitset_func_type bm::operation_functions< T >::gap2bit_table_[bm::set_END]

Initial value:
= {
&gap_and_to_bitset<bm::gap_word_t>,
&gap_add_to_bitset<bm::gap_word_t>,
&gap_sub_to_bitset<bm::gap_word_t>,
&gap_xor_to_bitset<bm::gap_word_t>,
0
}
bm::gap_and_to_bitset
void gap_and_to_bitset(unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr) BMNOEXCEPT
ANDs GAP block to bitblock.
Definition bmfunc.h:4090
bm::gap_xor_to_bitset
void gap_xor_to_bitset(unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr) BMNOEXCEPT
XOR GAP block to bitblock.
Definition bmfunc.h:4011
bm::gap_sub_to_bitset
void gap_sub_to_bitset(unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr) BMNOEXCEPT
SUB (AND NOT) GAP block to bitblock.
Definition bmfunc.h:3912
bm::gap_add_to_bitset
void gap_add_to_bitset(unsigned *BMRESTRICT dest, const T *BMRESTRICT pcurr, unsigned len) BMNOEXCEPT
Adds(OR) GAP block to bitblock.
Definition bmfunc.h:4039

Definition at line 9582 of file bmfunc.h.

## operation_functions< T >::gapop_table_

template<bool T>

gap_operation_func_type bm::operation_functions< T >::gapop_table_[bm::set_END]

Initial value:
= {
&gap_operation_and,
&gap_operation_or,
&gap_operation_sub,
&gap_operation_xor,
0
}
bm::gap_operation_or
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) BMNOEXCEPT
GAP OR operation.
Definition bmfunc.h:6666
bm::gap_operation_xor
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) BMNOEXCEPT
GAP XOR operation.
Definition bmfunc.h:6585
bm::gap_operation_and
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) BMNOEXCEPT
GAP AND operation.
Definition bmfunc.h:6518
bm::gap_operation_sub
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) BMNOEXCEPT
GAP SUB (AND NOT) operation.
Definition bmfunc.h:6712

Definition at line 9592 of file bmfunc.h.

## rs3_border0

const unsigned bm::rs3_border0 = 21824

Definition at line 119 of file bmconst.h.

Referenced by bm::bvector< Alloc >::build_rs_index(), and bm::rsc_sparse_vector< Val, SV >::count_range_notnull().

## rs3_border0_1

const unsigned bm::rs3_border0_1 = rs3_border0 + rs3_half_span

Definition at line 122 of file bmconst.h.

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

## rs3_border1

const unsigned bm::rs3_border1 = (rs3_border0 * 2)

Definition at line 120 of file bmconst.h.

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

## rs3_border1_1

const unsigned bm::rs3_border1_1 = rs3_border1 + rs3_half_span

Definition at line 123 of file bmconst.h.

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

## rs3_half_span

const unsigned bm::rs3_half_span = rs3_border0 / 2

Definition at line 121 of file bmconst.h.

## sblock_flag_len16

const unsigned bm::sblock_flag_len16 = (1u << 4)

16-bit len (8-bit by default)

Definition at line 2405 of file bmserial.h.

Referenced by bm::serializer< BV >::bienc_arr_sblock(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_bic_sb_arr().

## sblock_flag_max16

const unsigned bm::sblock_flag_max16 = (1u << 5)

Definition at line 2406 of file bmserial.h.

Referenced by bm::serializer< BV >::bienc_arr_sblock(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_bic_sb_arr().

## sblock_flag_max24

const unsigned bm::sblock_flag_max24 = (1u << 6)

Definition at line 2407 of file bmserial.h.

Referenced by bm::serializer< BV >::bienc_arr_sblock(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_bic_sb_arr().

## sblock_flag_max32

const unsigned bm::sblock_flag_max32 = bm::sblock_flag_max16 | bm::sblock_flag_max24

Definition at line 2408 of file bmserial.h.

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

## sblock_flag_min16

const unsigned bm::sblock_flag_min16 = (1u << 2)

16-bit minv

Definition at line 2401 of file bmserial.h.

Referenced by bm::serializer< BV >::bienc_arr_sblock(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_bic_sb_arr().

## sblock_flag_min24

const unsigned bm::sblock_flag_min24 = (1u << 3)

24-bit minv

Definition at line 2402 of file bmserial.h.

Referenced by bm::serializer< BV >::bienc_arr_sblock(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_bic_sb_arr().

## sblock_flag_min32

const unsigned bm::sblock_flag_min32 = bm::sblock_flag_min16 | bm::sblock_flag_min24

Definition at line 2403 of file bmserial.h.

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

## sblock_flag_sb16

const unsigned bm::sblock_flag_sb16 = (1u << 0)

16-bit SB index (8-bit by default)

Definition at line 2398 of file bmserial.h.

Referenced by bm::serializer< BV >::bienc_arr_sblock(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_bic_sb_arr().

## sblock_flag_sb32

const unsigned bm::sblock_flag_sb32 = (1u << 1)

32-bit SB index

Definition at line 2399 of file bmserial.h.

Referenced by bm::serializer< BV >::bienc_arr_sblock(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_bic_sb_arr().

## set_array_mask

const unsigned bm::set_array_mask = 0xFFu

Definition at line 97 of file bmconst.h.

Referenced by bm::aggregator< BV >::find_first_and_sub(), for_each_bit_block_range(), for_each_nzblock_range(), and get_block_coord().

## set_array_shift

const unsigned bm::set_array_shift = 8u

Definition at line 96 of file bmconst.h.

Referenced by bm::aggregator< BV >::find_first_and_sub(), for_each_bit_block_range(), for_each_nzblock_range(), and get_block_coord().

## set_array_size32

const unsigned bm::set_array_size32 = 256u

Definition at line 94 of file bmconst.h.

## set_bitscan_wave_size

const unsigned short bm::set_bitscan_wave_size = 4

Size of bit decode wave in words.

Definition at line 9623 of file bmfunc.h.

Referenced by for_each_bit_blk(), for_each_bit_blk(), bm::bvector< Alloc >::enumerator::go_to(), bm::bvector< Alloc >::enumerator::go_up(), and bm::bvector< Alloc >::enumerator::skip().

## set_blkblk_mask

const unsigned bm::set_blkblk_mask = 0xFFFFFFu

Definition at line 58 of file bmconst.h.

## set_block_16one

const unsigned char bm::set_block_16one = 6

UP to 65536 all-set blocks.

Definition at line 1099 of file bmserial.h.

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

## set_block_16zero

const unsigned char bm::set_block_16zero = 5

Up to 65536 zero blocks.

Definition at line 1098 of file bmserial.h.

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

## set_block_1one

const unsigned char bm::set_block_1one = 2

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

Definition at line 1095 of file bmserial.h.

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

## set_block_1zero

const unsigned char bm::set_block_1zero = 1

One all-zero block.

Definition at line 1094 of file bmserial.h.

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

## set_block_32one

const unsigned char bm::set_block_32one = 8

UP to 4G all-set blocks.

Definition at line 1101 of file bmserial.h.

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

## set_block_32zero

const unsigned char bm::set_block_32zero = 7

Up to 4G zero blocks.

Definition at line 1100 of file bmserial.h.

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

## set_block_64one

const unsigned char bm::set_block_64one = 26

lots of all-set blocks

Definition at line 1119 of file bmserial.h.

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

## set_block_64zero

const unsigned char bm::set_block_64zero = 25

lots of zero blocks

Definition at line 1118 of file bmserial.h.

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

## set_block_8one

const unsigned char bm::set_block_8one = 4

Up to 256 all-set blocks.

Definition at line 1097 of file bmserial.h.

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

## set_block_8zero

const unsigned char bm::set_block_8zero = 3

Up to 256 zero blocks.

Definition at line 1096 of file bmserial.h.

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

## set_block_alloc_size

const unsigned bm::set_block_alloc_size = bm::set_block_size * unsigned(sizeof(bm::word_t))

Definition at line 61 of file bmconst.h.

## set_block_aone

const unsigned char bm::set_block_aone = 10

All other blocks one.

Definition at line 1103 of file bmserial.h.

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

## set_block_arr_bienc

const unsigned char bm::set_block_arr_bienc = 31

Interpolated block as int array.

Definition at line 1125 of file bmserial.h.

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

## set_block_arr_bienc_8bh

const unsigned char bm::set_block_arr_bienc_8bh = 57

BIC block 8bit header.

Definition at line 1155 of file bmserial.h.

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

## set_block_arr_bienc_inv

const unsigned char bm::set_block_arr_bienc_inv = 32

Interpolated inverted block int array.

Definition at line 1126 of file bmserial.h.

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

## set_block_arrbit

const unsigned char bm::set_block_arrbit = 16

List of bits ON.

Definition at line 1109 of file bmserial.h.

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

## set_block_arrbit_inv

const unsigned char bm::set_block_arrbit_inv = 30

List of bits OFF.

Definition at line 1124 of file bmserial.h.

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

## set_block_arrgap

const unsigned char bm::set_block_arrgap = 18

List of bits ON (GAP block).

Definition at line 1111 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::encode_gap_block(), bm::serializer< BV >::find_bit_best_encoding_l5(), bm::serializer< BV >::find_gap_best_encoding(), bm::serializer< BV >::gamma_gap_array(), bm::serializer< BV >::interpolated_gap_array(), bm::serializer< BV >::interpolated_gap_array_v0(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_gap_block(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_id_list().

## set_block_arrgap_bienc

const unsigned char bm::set_block_arrgap_bienc = 28

Interpolated GAP array.

Definition at line 1122 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::encode_gap_block(), bm::serializer< BV >::find_bit_best_encoding_l5(), bm::serializer< BV >::find_gap_best_encoding(), bm::serializer< BV >::interpolated_gap_array_v0(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_gap_block(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_id_list(), and bm::serializer< BV >::serialize().

## set_block_arrgap_bienc_inv

const unsigned char bm::set_block_arrgap_bienc_inv = 29

Interpolated GAP array (inverted).

Definition at line 1123 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::encode_gap_block(), bm::serializer< BV >::find_bit_best_encoding_l5(), bm::serializer< BV >::find_gap_best_encoding(), bm::serializer< BV >::interpolated_gap_array_v0(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_gap_block(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_id_list(), and bm::serializer< BV >::serialize().

## set_block_arrgap_bienc_inv_v2

const unsigned char bm::set_block_arrgap_bienc_inv_v2 = 45

Interpolated GAP array (inverted).

Definition at line 1141 of file bmserial.h.

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

## set_block_arrgap_bienc_v2

const unsigned char bm::set_block_arrgap_bienc_v2 = 44

//!< Interpolated GAP array (v2)

Definition at line 1140 of file bmserial.h.

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

## set_block_arrgap_egamma

const unsigned char bm::set_block_arrgap_egamma = 21

Gamma compressed delta GAP array.

Definition at line 1114 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::encode_gap_block(), bm::serializer< BV >::find_bit_best_encoding(), bm::serializer< BV >::find_bit_best_encoding_l5(), bm::serializer< BV >::find_gap_best_encoding(), bm::serializer< BV >::gamma_gap_array(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_gap_block(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_id_list(), and bm::serializer< BV >::serialize().

## set_block_arrgap_egamma_inv

const unsigned char bm::set_block_arrgap_egamma_inv = 23

Gamma compressed inverted delta GAP array.

Definition at line 1116 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::encode_gap_block(), bm::serializer< BV >::find_bit_best_encoding(), bm::serializer< BV >::find_bit_best_encoding_l5(), bm::serializer< BV >::find_gap_best_encoding(), bm::serializer< BV >::gamma_gap_array(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_gap_block(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_id_list(), and bm::serializer< BV >::serialize().

## set_block_arrgap_inv

const unsigned char bm::set_block_arrgap_inv = 24

List of bits OFF (GAP block).

Definition at line 1117 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::encode_gap_block(), bm::serializer< BV >::find_bit_best_encoding_l5(), bm::serializer< BV >::find_gap_best_encoding(), bm::serializer< BV >::gamma_gap_array(), bm::serializer< BV >::interpolated_gap_array(), bm::serializer< BV >::interpolated_gap_array_v0(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_gap_block(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_id_list().

## set_block_azero

const unsigned char bm::set_block_azero = 9

All other blocks zero.

Definition at line 1102 of file bmserial.h.

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

## set_block_bit

const unsigned char bm::set_block_bit = 11

Plain bit block.

Definition at line 1104 of file bmserial.h.

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

## set_block_bit_0runs

const unsigned char bm::set_block_bit_0runs = 22

Bit block with encoded zero intervals.

Definition at line 1115 of file bmserial.h.

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

## set_block_bit_1bit

const unsigned char bm::set_block_bit_1bit = 19

Bit block with 1 bit ON.

Definition at line 1112 of file bmserial.h.

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

## set_block_bit_digest0

const unsigned char bm::set_block_bit_digest0 = 34

H-compression with digest mask.

Definition at line 1128 of file bmserial.h.

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

## set_block_bit_interval

const unsigned char bm::set_block_bit_interval = 17

Interval block.

Definition at line 1110 of file bmserial.h.

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

## set_block_bitgap_bienc

const unsigned char bm::set_block_bitgap_bienc = 33

Interpolated bit-block as GAPs.

Definition at line 1127 of file bmserial.h.

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

## set_block_bitgap_bienc_v2

const unsigned char bm::set_block_bitgap_bienc_v2 = 46

Interpolated bit-block as GAPs (v2 - reseved).

Definition at line 1142 of file bmserial.h.

## set_block_digest_pos_shift

const unsigned bm::set_block_digest_pos_shift = 10

Definition at line 68 of file bmconst.h.

Referenced by digest_mask(), gap_and_to_bitset(), and gap_sub_to_bitset().

## set_block_digest_wave_size

const unsigned bm::set_block_digest_wave_size = bm::set_block_size / bm::block_waves

Definition at line 67 of file bmconst.h.

Referenced by avx2_bit_block_count(), avx2_bit_block_xor(), avx2_bit_block_xor_2way(), avx2_shift_r1_and(), bit_block_and(), bit_block_and_2way(), bit_block_and_3way(), bit_block_and_5way(), bit_block_and_or_2way(), bit_block_count(), bit_block_init_and_2way(), bit_block_shift_r1_and(), bit_block_sub(), bit_block_sub_2way(), bit_block_sub_3way(), bit_block_sub_5way(), bit_block_xor(), bit_block_xor(), bit_find_first(), bit_find_first_if_1(), block_compact_by_digest(), block_expand_by_digest(), block_init_digest0(), calc_block_digest0(), compute_s_block_descr(), bm::xor_scanner< BV >::compute_xor_complexity_descr(), bm::serializer< BV >::encode_bit_digest(), bm::serializer< BV >::find_bit_best_encoding(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_digest0_block(), sse2_bit_block_xor(), sse2_bit_block_xor_2way(), sse42_bit_block_xor(), sse42_bit_block_xor_2way(), sse42_bit_count_digest(), sse42_shift_r1_and(), update_block_digest0(), and widx_to_digest_mask().

## set_block_end

const unsigned char bm::set_block_end = 0

End of serialization.

Definition at line 1093 of file bmserial.h.

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

## set_block_gap

const unsigned char bm::set_block_gap = 14

Plain GAP block.

Definition at line 1107 of file bmserial.h.

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

## set_block_gap_bienc

const unsigned char bm::set_block_gap_bienc = 27

Interpolated GAP block (legacy).

Definition at line 1121 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::deserializer< BV, DEC >::deserialize_gap(), bm::serializer< BV >::encode_gap_block(), bm::serializer< BV >::find_bit_best_encoding_l5(), bm::serializer< BV >::find_gap_best_encoding(), bm::serializer< BV >::interpolated_encode_gap_block(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_gap_block(), and bm::serializer< BV >::serialize().

## set_block_gap_bienc_v2

const unsigned char bm::set_block_gap_bienc_v2 = 43

Interpolated GAP block (v2).

Definition at line 1139 of file bmserial.h.

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

## set_block_gap_egamma

const unsigned char bm::set_block_gap_egamma = 20

Gamma compressed GAP block.

Definition at line 1113 of file bmserial.h.

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

## set_block_gapbit

const unsigned char bm::set_block_gapbit = 15

GAP compressed bitblock.

Definition at line 1108 of file bmserial.h.

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

## set_block_mask

const unsigned bm::set_block_mask = 0xFFFFu

Definition at line 57 of file bmconst.h.

Referenced by bm::bvector< Alloc >::and_bit_no_check(), bm::bvector< Alloc >::any_range(), avx2_bit_block_gather_scatter(), avx2_set_block_bits(), avx2_set_block_bits2(), avx2_set_block_bits3(), bit_block_erase(), bit_block_gather_scatter(), bit_block_insert(), bm::bvector< Alloc >::check_or_next(), clear_bit(), bm::bvector< Alloc >::clear_bit_no_check(), bm::bvector< Alloc >::clear_range_no_check(), combine_or(), combine_sub(), combine_xor(), bm::sparse_vector_scanner< SV, S_FACTOR >::compare_str(), bm::bvector< Alloc >::count_range_no_check(), bm::bvector< Alloc >::count_to(), bm::bvector< Alloc >::count_to_test(), bm::bvector< Alloc >::erase(), bm::sparse_vector< Val, BV >::extract_range(), find_interval_end(), find_interval_start(), bm::bvector< Alloc >::find_rank(), bm::bvector< Alloc >::find_rank(), bm::bvector< Alloc >::find_reverse(), for_each_bit_range_no_check(), bm::sparse_vector< Val, BV >::gather(), bm::bvector< Alloc >::get_bit(), bm::basic_bmatrix< BV >::get_half_octet(), bm::basic_bmatrix< BV >::get_octet(), bm::bvector< Alloc >::enumerator::go_to(), bm::interval_enumerator< BV >::go_to_impl(), bm::bvector< Alloc >::import_block(), bm::bvector< Alloc >::import_sorted(), bm::bvector< Alloc >::inc(), bm::bvector< Alloc >::insert(), bm::bvector< Alloc >::is_all_one_range(), is_interval(), bm::aggregator< BV >::process_bit_blocks_and(), bm::bvector< Alloc >::rank_corrected(), set_bit(), bm::bvector< Alloc >::set_bit_conditional_impl(), bm::bvector< Alloc >::set_bit_no_check(), bm::bvector< Alloc >::set_bit_no_check(), set_block_bits_u32(), set_block_bits_u64(), bm::aggregator< BV >::set_range_hint(), bm::bvector< Alloc >::set_range_no_check(), sse42_set_block_bits(), sse4_bit_block_gather_scatter(), bm::bvector< Alloc >::swap(), test_bit(), and xor_bit_block().

## set_block_plane_cnt

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

Definition at line 64 of file bmconst.h.

Referenced by bit_iblock_reduce().

## set_block_plane_size

const unsigned bm::set_block_plane_size = bm::set_block_size / 32u

Definition at line 63 of file bmconst.h.

Referenced by bit_iblock_reduce().

## set_block_ref_eq

const unsigned char bm::set_block_ref_eq = 35

block is a copy of a reference block

Definition at line 1130 of file bmserial.h.

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

## set_block_sgapbit

const unsigned char bm::set_block_sgapbit = 12

SGAP compressed bitblock.

Definition at line 1105 of file bmserial.h.

## set_block_sgapgap

const unsigned char bm::set_block_sgapgap = 13

SGAP compressed GAP block.

Definition at line 1106 of file bmserial.h.

## set_block_shift

const unsigned bm::set_block_shift = 16u

Definition at line 56 of file bmconst.h.

Referenced by bm::interval_enumerator< BV >::advance(), bm::bvector< Alloc >::and_bit_no_check(), bm::bvector< Alloc >::any_range(), avx2_idx_arr_block_lookup(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::back_insert_iterator::back_insert_iterator(), bm::sparse_vector_scanner< SV, S_FACTOR >::bfind_eq_str_impl(), block_range_scan(), bm::bvector< Alloc >::build_rs_index(), bm::bvector< Alloc >::check_or_next(), bm::bvector< Alloc >::clear_bit_no_check(), bm::bvector< Alloc >::clear_range_no_check(), bm::aggregator< BV >::combine_and_sub(), combine_or(), combine_sub(), combine_xor(), bm::sparse_vector_scanner< SV, S_FACTOR >::compare_str(), bm::bvector< Alloc >::copy_range_no_check(), bm::bvector< Alloc >::count_range_no_check(), bm::bvector< Alloc >::count_to(), bm::bvector< Alloc >::count_to_test(), bm::deserializer< BV, DEC >::deserialize(), bm::iterator_deserializer< BV, SerialIterator >::deserialize(), bm::bvector< Alloc >::erase(), bm::sparse_vector< Val, BV >::extract_range(), bm::aggregator< BV >::find_first_and_sub(), bm::bvector< Alloc >::find_first_mismatch(), find_interval_end(), find_interval_start(), bm::bvector< Alloc >::find_rank(), bm::bvector< Alloc >::find_rank(), bm::bvector< Alloc >::find_reverse(), bm::sparse_vector< Val, BV >::back_insert_iterator::flush(), bm::str_sparse_vector< CharType, BV, STR_SIZE >::back_insert_iterator::flush_impl(), for_each_bit_range_no_check(), bm::sparse_vector< Val, BV >::gather(), bm::bvector< Alloc >::get_bit(), bm::basic_bmatrix< BV >::get_half_octet(), bm::basic_bmatrix< BV >::get_octet(), bm::bvector< Alloc >::enumerator::go_to(), bm::interval_enumerator< BV >::go_to_impl(), idx_arr_block_lookup_u32(), idx_arr_block_lookup_u64(), bm::bvector< Alloc >::import(), bm::bvector< Alloc >::import_sorted(), bm::bvector< Alloc >::inc(), bm::bvector< Alloc >::insert(), bm::bvector< Alloc >::is_all_one_range(), is_interval(), bm::bvector< Alloc >::optimize_range(), bm::aggregator< BV >::process_bit_blocks_and(), bm::bvector< Alloc >::rank_corrected(), bm::set2set_11_transform< SV >::remap(), bm::bvector< Alloc >::set_bit_conditional_impl(), bm::bvector< Alloc >::set_bit_no_check(), bm::bvector< Alloc >::set_bit_no_check(), bm::iterator_deserializer< BV, SerialIterator >::set_range(), bm::aggregator< BV >::set_range_hint(), bm::bvector< Alloc >::set_range_no_check(), bm::sparse_vector< Val, BV >::set_value_no_null(), sse42_idx_arr_block_lookup(), bm::bvector< Alloc >::swap(), and bm::deserializer< BV, DEC >::xor_decode().

## set_block_size

const unsigned bm::set_block_size = 2048u

Definition at line 55 of file bmconst.h.

Referenced by bm::bv_statistics::add_bit_block(), bm::alloc_pool< block_allocator, ptr_allocator >::alloc_bit_block(), bm::mem_alloc< block_allocator, ptr_allocator, standard_alloc_pool >::alloc_bit_block(), avx2_and_block(), avx2_bit_block_calc_change_bc(), avx2_bit_find_first(), avx2_bit_find_first_diff(), avx2_bit_to_gap(), avx2_copy_block(), avx2_copy_block_unalign(), avx2_invert_block(), avx2_is_all_one(), avx2_is_all_zero(), avx2_or_block(), avx2_or_block_2way(), avx2_or_block_3way(), avx2_or_block_5way(), avx2_set_block(), avx2_shift_l1(), avx2_shift_r1(), avx2_stream_block(), avx2_stream_block_unalign(), avx2_sub_block(), avx2_xor_block(), avx2_xor_block_2way(), bm::serializer< BV >::bienc_gap_bit_block(), bit_andnot_arr_ffmask(), bit_block_and(), bit_block_and_any(), bit_block_and_count(), bit_block_calc_change(), bit_block_change_bc(), bit_block_copy(), bit_block_copy_unalign(), bit_block_count(), bit_block_erase(), bit_block_find(), bit_block_find_interval_end(), bit_block_insert(), bit_block_or(), bit_block_or_2way(), bit_block_or_3way(), bit_block_or_5way(), bit_block_or_any(), bit_block_or_count(), bit_block_rotate_left_1(), bit_block_rotate_left_1_unr(), bit_block_set(), bit_block_shift_l1(), bit_block_shift_l1_unr_min(), bit_block_shift_r1(), bit_block_shift_r1_and(), bit_block_shift_r1_unr_min(), bit_block_stream(), bit_block_stream_unalign(), bit_block_sub(), bit_block_sub_any(), bit_block_sub_count(), bit_block_to_gap(), bit_block_xor(), bit_block_xor_2way(), bit_block_xor_any(), bit_block_xor_count(), bit_find_first(), bit_find_first(), bit_find_first_diff(), bit_find_last(), bit_find_rank(), bit_import_u32(), bit_invert(), bit_is_all_zero(), bit_operation_or(), bit_recomb(), bm::bvector< Alloc >::bulk_insert_iterator::buf_size_max(), bm::aggregator< BV >::cache_gap_block(), bm::bvector< Alloc >::calc_stat(), combine_any_operation_with_block(), combine_count_operation_with_block(), bm::bvector< Alloc >::combine_operation_with_block(), bm::aggregator< BV >::pipeline< Opt >::compute_run_batch(), bm::deserializer< BV, DEC >::decode_block_bit(), bm::deserializer< BV, DEC >::decode_block_bit_interval(), bm::serializer< BV >::encode_bit_digest(), bm::serializer< BV >::encode_bit_interval(), bm::bit_block_t::end(), bm::bit_block_t::end(), bm::bvector< Alloc >::erase(), export_array(), bm::serializer< BV >::find_bit_best_encoding(), bm::serializer< BV >::find_bit_best_encoding_l5(), bm::bvector< Alloc >::find_rank(), bm::bvector< Alloc >::find_rank(), for_each_bit_blk(), bm::alloc_pool< block_allocator, ptr_allocator >::free_bit_block(), bm::mem_alloc< block_allocator, ptr_allocator, standard_alloc_pool >::free_bit_block(), bm::alloc_pool< block_allocator, ptr_allocator >::free_pools(), bm::serializer< BV >::gamma_arr_bit_block(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_AND(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_ASSIGN(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_COUNT(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_COUNT_A(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_COUNT_AND(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_COUNT_OR(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_COUNT_SUB_AB(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_COUNT_SUB_BA(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_COUNT_XOR(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_OR(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_SUB(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::get_bit_block_XOR(), bm::bvector< Alloc >::enumerator::go_to(), bm::bvector< Alloc >::import_block(), bm::bvector< Alloc >::insert(), bm::serializer< BV >::interpolated_arr_bit_block(), is_bits_one(), bm::aggregator< BV >::process_shift_right_and(), bm::random_subset< BV >::random_subset(), bm::deseriaizer_base< DEC, BLOCK_IDX >::read_0runs_block(), bm::bvector< Alloc >::select(), bm::serializer< BV >::serialize(), bm::serializer< BV >::set_ref_vectors(), sse2_and_block(), sse2_bit_find_first(), sse2_bit_find_first_diff(), sse2_copy_block(), sse2_copy_block_unalign(), sse2_invert_block(), sse2_is_all_one(), sse2_is_all_zero(), sse2_or_block(), sse2_or_block_2way(), sse2_or_block_3way(), sse2_or_block_5way(), sse2_set_block(), sse2_shift_l1(), sse2_shift_r1(), sse2_stream_block(), sse2_stream_block_unalign(), sse2_sub_block(), sse2_xor_block(), sse2_xor_block_2way(), sse42_bit_block_calc_change_bc(), sse42_bit_find_first(), sse42_bit_find_first_diff(), sse42_shift_l1(), sse42_shift_r1(), sse4_and_block(), sse4_is_all_one(), and sse4_is_all_zero().

## set_block_size_op

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

Definition at line 133 of file bmconst.h.

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

## set_block_xor_chain

const unsigned char bm::set_block_xor_chain = 42

XOR chain (composit of sub-blocks).

Definition at line 1137 of file bmserial.h.

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

## set_block_xor_gap_ref16

const unsigned char bm::set_block_xor_gap_ref16 = 40

..... 16-bit

Definition at line 1135 of file bmserial.h.

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

## set_block_xor_gap_ref32

const unsigned char bm::set_block_xor_gap_ref32 = 41

..... 32-bit (should never happen)

Definition at line 1136 of file bmserial.h.

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

## set_block_xor_gap_ref8

const unsigned char bm::set_block_xor_gap_ref8 = 39

..... 8-bit

Definition at line 1134 of file bmserial.h.

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

## set_block_xor_ref16

const unsigned char bm::set_block_xor_ref16 = 37

block is masked XOR of a reference block (16-bit)

Definition at line 1132 of file bmserial.h.

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

## set_block_xor_ref16_um

const unsigned char bm::set_block_xor_ref16_um = 59

block is un-masked XOR of a reference block (16-bit)

Definition at line 1158 of file bmserial.h.

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

## set_block_xor_ref32

const unsigned char bm::set_block_xor_ref32 = 38

..... 32-bit (should never happen)

Definition at line 1133 of file bmserial.h.

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

## set_block_xor_ref32_um

const unsigned char bm::set_block_xor_ref32_um = 60

..... 32-bit (should never happen)

Definition at line 1159 of file bmserial.h.

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

## set_block_xor_ref8

const unsigned char bm::set_block_xor_ref8 = 36

block is masked XOR of a reference block (8-bit)

Definition at line 1131 of file bmserial.h.

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

## set_block_xor_ref8_um

const unsigned char bm::set_block_xor_ref8_um = 58

block is un-masked XOR of a reference block (8-bit)

Definition at line 1157 of file bmserial.h.

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

## set_compression_default

const unsigned bm::set_compression_default = 6

Default compression level.

Examples
  inv_list.cpp.

Definition at line 60 of file bmserial.h.

Referenced by bm::sv_serialization_plan_builder< SV >::serialization_params::serialization_params(), bm::serializer< BV >::serializer(), and bm::serializer< BV >::serializer().

## set_compression_max

const unsigned bm::set_compression_max = 6

Maximum supported compression level.

Definition at line 59 of file bmserial.h.

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

## set_nb_bookmark16

const unsigned char bm::set_nb_bookmark16 = 47

jump ahead mark (16-bit)

Definition at line 1144 of file bmserial.h.

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

## set_nb_bookmark24

const unsigned char bm::set_nb_bookmark24 = 48

jump ahead mark (24-bit)

Definition at line 1145 of file bmserial.h.

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

## set_nb_bookmark32

const unsigned char bm::set_nb_bookmark32 = 49

jump ahead mark (32-bit)

Definition at line 1146 of file bmserial.h.

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

## set_nb_sync_mark16

const unsigned char bm::set_nb_sync_mark16 = 51

Definition at line 1148 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::serializer< BV >::process_bookmark(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::try_skip().

## set_nb_sync_mark24

const unsigned char bm::set_nb_sync_mark24 = 52

Definition at line 1149 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::serializer< BV >::process_bookmark(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::try_skip().

## set_nb_sync_mark32

const unsigned char bm::set_nb_sync_mark32 = 53

Definition at line 1150 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::serializer< BV >::process_bookmark(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::try_skip().

## set_nb_sync_mark48

const unsigned char bm::set_nb_sync_mark48 = 54

Definition at line 1151 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::serializer< BV >::process_bookmark(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::try_skip().

## set_nb_sync_mark64

const unsigned char bm::set_nb_sync_mark64 = 55

..... 64-bit (should never happen)

Definition at line 1152 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::serializer< BV >::process_bookmark(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::try_skip().

## set_nb_sync_mark8

const unsigned char bm::set_nb_sync_mark8 = 50

bookmark sync point (8-bits)

Definition at line 1147 of file bmserial.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), bm::serializer< BV >::process_bookmark(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::try_skip().

## set_sblock_bienc

const unsigned char bm::set_sblock_bienc = 56

super-block interpolated list

Definition at line 1154 of file bmserial.h.

Referenced by bm::serializer< BV >::bienc_arr_sblock(), bm::deserializer< BV, DEC >::deserialize(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_bic_sb_arr().

## set_sub_array_size

const unsigned bm::set_sub_array_size = set_array_size32

Definition at line 95 of file bmconst.h.

Referenced by aggregator_pipeline_execute(), bm::all_set< T >::all_set_block::all_set_block(), bm::bvector< Alloc >::any_range(), bm::bvector< Alloc >::bit_and(), bit_import_u32(), bm::bvector< Alloc >::bit_or(), bm::bvector< Alloc >::bit_or_and(), bm::bvector< Alloc >::bit_sub(), bm::bvector< Alloc >::bit_xor(), block_ptr_array_range(), block_to_global_index(), bm::bvector< Alloc >::build_rs_index(), bm::bvector< Alloc >::calc_stat(), bm::bvector< Alloc >::check_or_next(), bm::aggregator< BV >::combine_and(), bm::aggregator< BV >::combine_and_sub(), bm::aggregator< BV >::combine_and_sub(), bm::aggregator< BV >::combine_and_sub(), bm::bvector< Alloc >::combine_operation(), bm::bvector< Alloc >::combine_operation_and(), bm::bvector< Alloc >::combine_operation_or(), bm::bvector< Alloc >::combine_operation_sub(), bm::bvector< Alloc >::combine_operation_xor(), bm::aggregator< BV >::combine_or(), bm::aggregator< BV >::combine_shift_right_and(), bm::bvector< Alloc >::compare(), convert_sub_to_arr(), bm::bvector< Alloc >::count(), bm::deserializer< BV, DEC >::decode_arr_sblock(), bm::deserializer< BV, DEC >::deserialize(), distance_and_operation(), distance_operation(), distance_operation_any(), bm::bvector< Alloc >::erase(), bm::bvector< Alloc >::fill_alloc_digest(), bm::bvector< Alloc >::find(), bm::aggregator< BV >::find_effective_sub_block_size(), bm::aggregator< BV >::find_first_and_sub(), bm::bvector< Alloc >::find_first_mismatch(), find_interval_end(), bm::bvector< Alloc >::find_reverse(), bm::bvector< Alloc >::find_reverse(), for_each_bit(), for_each_bit_block_range(), for_each_block(), for_each_nzblock(), for_each_nzblock2(), for_each_nzblock_if(), for_each_nzblock_range(), bm::bvector< Alloc >::enumerator::go_first(), bm::bvector< Alloc >::insert(), bm::bvector< Alloc >::invert(), bm::bvector< Alloc >::is_all_one_range(), bm::bvector< Alloc >::merge(), bm::aggregator< BV >::run_step(), and bm::serializer< BV >::serialize().

## set_sub_total_bits

const unsigned bm::set_sub_total_bits = bm::set_sub_array_size * bm::gap_max_bits

Definition at line 100 of file bmconst.h.

Referenced by bm::serializer< BV >::bienc_arr_sblock(), for_each_bit_block_range(), for_each_nzblock_range(), get_super_block_start(), and bm::deseriaizer_base< DEC, BLOCK_IDX >::read_bic_sb_arr().

## set_top_array_size

const unsigned bm::set_top_array_size = bm::set_array_size32

Definition at line 110 of file bmconst.h.

Referenced by bm::aggregator< BV >::combine_shift_right_and(), bm::bvector< Alloc >::erase(), bm::bvector< Alloc >::insert(), and bm::bvector< Alloc >::invert().

## set_total_blocks

const unsigned bm::set_total_blocks = bm::set_total_blocks32

Definition at line 111 of file bmconst.h.

Referenced by bm::deserializer< BV, DEC >::deserialize(), export_array(), bm::bvector< Alloc >::find_rank(), bm::bvector< Alloc >::import_block(), bm::bvector< Alloc >::insert(), bm::serial_stream_iterator< DEC, BLOCK_IDX >::next(), and bm::serializer< BV >::serialize().

## set_total_blocks32

const unsigned bm::set_total_blocks32 = (bm::set_array_size32 * bm::set_array_size32)

Definition at line 99 of file bmconst.h.

## set_word_mask

const unsigned bm::set_word_mask = 0x1Fu

Definition at line 73 of file bmconst.h.

Referenced by bm::bvector< Alloc >::and_bit_no_check(), avx2_bit_block_gather_scatter(), avx2_set_block_bits(), avx2_set_block_bits3(), bm::bit_in< TDecoder >::bic_decode_u16_cm_bitset(), bm::bit_in< TDecoder >::bic_decode_u16_rg_bitset(), bit_block_any_range(), bit_block_calc_count_range(), bit_block_erase(), bit_block_find(), bit_block_find_interval_end(), bit_block_find_interval_start(), bit_block_find_prev(), bit_block_gather_scatter(), bit_block_insert(), bit_block_is_all_one_range(), bit_find_rank(), block_is_interval(), clear_bit(), bm::bvector< Alloc >::clear_bit_no_check(), combine_or(), combine_sub(), combine_xor(), bm::bvector< Alloc >::count_to_test(), bm::sparse_vector< Val, BV >::extract_range(), for_each_bit_blk(), bm::bvector< Alloc >::get_bit(), bm::basic_bmatrix< BV >::get_half_octet(), bm::basic_bmatrix< BV >::get_octet(), bm::bvector< Alloc >::enumerator::go_to(), bm::bvector< Alloc >::inc(), or_bit_block(), bm::aggregator< BV >::process_bit_blocks_and(), bm::aggregator< BV >::process_bit_blocks_sub(), bm::bvector< Alloc >::rank_corrected(), bm::bvmini< N >::set(), bm::miniset< A, N >::set(), set_bit(), bm::bvector< Alloc >::set_bit_conditional_impl(), bm::bvector< Alloc >::set_bit_no_check(), bm::bvector< Alloc >::set_bit_no_check(), set_block_bits_u32(), set_block_bits_u64(), sse42_set_block_bits(), sse4_bit_block_gather_scatter(), sub_bit_block(), bm::bvector< Alloc >::swap(), bm::bvmini< N >::test(), bm::miniset< A, N >::test(), test_bit(), and xor_bit_block().

## set_word_shift

const unsigned bm::set_word_shift = 5u

Definition at line 72 of file bmconst.h.

Referenced by bm::bvector< Alloc >::and_bit_no_check(), avx2_bit_block_gather_scatter(), avx2_set_block_bits(), avx2_set_block_bits3(), bm::bit_in< TDecoder >::bic_decode_u16_cm_bitset(), bm::bit_in< TDecoder >::bic_decode_u16_rg_bitset(), bit_block_any_range(), bit_block_calc_count_range(), bit_block_erase(), bit_block_find(), bit_block_find_interval_end(), bit_block_find_interval_start(), bit_block_find_prev(), bit_block_gather_scatter(), bit_block_insert(), bit_block_is_all_one_range(), bit_find_rank(), block_is_interval(), clear_bit(), bm::bvector< Alloc >::clear_bit_no_check(), combine_or(), combine_sub(), combine_xor(), bm::bvector< Alloc >::count_to_test(), bm::sparse_vector< Val, BV >::extract_range(), for_each_bit_blk(), bm::bvector< Alloc >::get_bit(), bm::basic_bmatrix< BV >::get_half_octet(), bm::basic_bmatrix< BV >::get_octet(), bm::bvector< Alloc >::enumerator::go_to(), bm::bvector< Alloc >::inc(), or_bit_block(), bm::aggregator< BV >::process_bit_blocks_and(), bm::aggregator< BV >::process_bit_blocks_sub(), bm::bvector< Alloc >::rank_corrected(), bm::bvmini< N >::set(), bm::miniset< A, N >::set(), set_bit(), bm::bvector< Alloc >::set_bit_conditional_impl(), bm::bvector< Alloc >::set_bit_no_check(), bm::bvector< Alloc >::set_bit_no_check(), set_block_bits_u32(), set_block_bits_u64(), sse42_set_block_bits(), sse4_bit_block_gather_scatter(), sub_bit_block(), bm::bvector< Alloc >::swap(), bm::bvmini< N >::test(), bm::miniset< A, N >::test(), test_bit(), and xor_bit_block().

## sparse_max_l5

const unsigned bm::sparse_max_l5 = 48

Definition at line 1163 of file bmserial.h.

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

## sparse_max_l6

const unsigned bm::sparse_max_l6 = 256

Definition at line 1164 of file bmserial.h.

Referenced by bm::serializer< BV >::serializer(), bm::serializer< BV >::serializer(), bm::serializer< BV >::set_compression_level(), and bm::serializer< BV >::set_sparse_cutoff().

## tzcnt_table< T >::_lut

template<bool T>

const unsigned char bm::tzcnt_table< T >::_lut[37]

Initial value:
=
{
32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11,
0, 13, 4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0,
21, 14, 9, 5, 20, 8, 19, 18
}

Definition at line 351 of file bmconst.h.