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 )

◆ 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 )

◆ bmi_bslr_u64()

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

◆ 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 )

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

◆ 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:

=

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.

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

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

◆ 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,                            
}

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
}

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
}

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.

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

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

◆ set_block_arrbit

const unsigned char bm::set_block_arrbit = 16

List of bits ON.

Definition at line 1109 of file bmserial.h.

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

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

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

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

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

◆ set_block_bit_interval

const unsigned char bm::set_block_bit_interval = 17

Interval block.

Definition at line 1110 of file bmserial.h.

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

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

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

◆ set_block_size

const unsigned bm::set_block_size = 2048u

Definition at line 55 of file bmconst.h.

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

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

◆ set_word_shift

const unsigned bm::set_word_shift = 5u

Definition at line 72 of file bmconst.h.

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

Data Structures

Typedefs

Enumerations

Functions

Variables

Aggregator traits and control constants

Typedef Documentation

◆ bit_operation_count_func_type

◆ bvector_size_type

◆ gap_operation_func_type

◆ gap_operation_to_bitset_func_type

◆ gap_word_t

◆ id64_t

◆ id_t

◆ short_t

◆ word_t

◆ wordop_t

Enumeration Type Documentation

◆ bit_representation

◆ ByteOrder

◆ remap_setup

◆ serialization_header_mask

◆ set_representation

◆ simd_codes

◆ xor_complement_match

Function Documentation

◆ aligned_free()

◆ aligned_new_malloc()

◆ avx2_bit_block_gather_scatter()

◆ avx2_bit_count_or()

◆ avx2_gap_sum_arr()

◆ avx2_idx_arr_block_lookup()

◆ avx2_set_block_bits()

◆ avx2_set_block_bits2()

◆ avx2_set_block_bits3()

◆ avx2_setbit_256()

◆ avx2_setbit_to256()

◆ best_representation()

◆ bit_block_any_range()

◆ bit_block_change32()

◆ bit_block_change64()

◆ bit_block_change_bc()

◆ bit_block_xor() [1/2]

◆ bit_block_xor() [2/2]

◆ bit_block_xor_change()

◆ bit_iblock_pcv_stat()

◆ bit_iblock_reduce()

◆ bit_recomb()

◆ bit_scan_forward32()

◆ bit_scan_fwd()

◆ bit_scan_reverse32()

◆ bit_to_gap()

◆ bitscan_bsf()

◆ bitscan_nibble()

◆ block_any()

◆ block_any_range()

◆ block_find_first_diff()

◆ block_find_interval_end()

◆ block_find_interval_start()

◆ block_find_rank()

◆ block_find_reverse()

◆ block_is_all_one_range()

◆ block_is_interval()

◆ block_ptr_array_range()

◆ block_range_scan()

◆ block_to_global_index()

◆ bmfor_each()

◆ bmi_blsi_u64()

◆ bmi_bslr_u64()

◆ build_jaccard_similarity_batch()

◆ check_any_fullb()

◆ check_block_one()

◆ check_block_zero()

◆ check_pair_vect_vbr()

◆ combine_any_operation_with_block() [1/2]

◆ combine_any_operation_with_block() [2/2]

◆ combine_count_and_operation_with_block()

◆ combine_count_operation_with_block() [1/2]

◆ combine_count_operation_with_block() [2/2]

◆ compute_h64_mask()