BitMagic-C++: bvsetalgebra.cpp

BitMagic-C++

bvsetalgebra.cpp

Example demonstrates variety of algebra of sets operations. http://bitmagic.io/set-algebra.html

Algebra Of Sets

See also
  bvector<> container
  bvector<>::bit_or
  bvector<>::bit_and
  bvector<>::bit_xor
  bvector<>::bit_sub
  bm::aggregator
  bm::operation_deserializer
  bm::combine_and
  bm::combine_and_sorted
  bm::combine_sub
  bm::combine_or
  bm::combine_xor
  sample7.cpp

/*
Copyright(c) 2002-2017 Anatoliy Kuznetsov(anatoliy_kuznetsov at yahoo.com)
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
For more information please visit: http://bitmagic.io
*/
/** \example bvsetalgebra.cpp
Example demonstrates variety of algebra of sets operations.
http://bitmagic.io/set-algebra.html
<a href="http://bitmagic.io/set-algebra.html">Algebra Of Sets</a>
\sa bvector
\sa bvector<>::bit_or
\sa bvector<>::bit_and
\sa bvector<>::bit_xor
\sa bvector<>::bit_sub
\sa bm::aggregator
\sa bm::operation_deserializer
\sa bm::combine_and
\sa bm::combine_and_sorted
\sa bm::combine_sub
\sa bm::combine_or
\sa bm::combine_xor
\sa sample7.cpp
*/
/*! \file bvsetalgebra.cpp
\brief Example: algebra of sets operations
*/
#include <iostream>
#include <vector>
#include "bm.h"
#include "bmalgo.h"
#include "bmserial.h"
#include "bmaggregator.h"
using namespace std;
// utility function to print a set
static
void print_bvector(const bm::bvector<>& bv)
{
bm::bvector<>::size_type cnt = 0;
bm::bvector<>::enumerator en = bv. first();
for (; en. valid() && cnt < 10; ++en, ++cnt)
cout << *en << ", ";
if (cnt == 10)
cout << " ...";
cout << "(size = "<< bv. size() << ")" << endl;
}
// utility function to create serialized bit-vector BLOB
static
void make_BLOB(vector<unsigned char>& target_buf, bm::bvector<>& bv)
{
BM_DECLARE_TEMP_BLOCK(tb)
bm::serializer<bm::bvector<> > bvs(tb);
bvs.set_compression_level(4);
bv. optimize(tb, bm::bvector<>::opt_compress); // memory compression
bm::serializer<bm::bvector<> >::buffer sbuf;
bvs. serialize(bv, sbuf, 0);
target_buf.resize(sbuf.size());
::memcpy(target_buf.data(), sbuf.buf(), sbuf.size());
}
// -------------------------------------------------------------
// Demo for Set Union (OR) operations
//
static
void DemoOR()
{
typedef bm::bvector<>::size_type size_type;
bm::operation_deserializer<bm::bvector<> > od;
// bit-vector set union operation: bv_A |= bv_B
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A. bit_or(bv_B);
print_bvector(bv_A); // 1, 2, 3, 4
}
// same, but sizes are set, observe size gets extended up
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A. resize(5);
bv_B.resize(10);
bv_A.bit_or(bv_B);
print_bvector(bv_A); // 1, 2, 3, 4 (size = 10)
}
// 3-operand OR: bv_T = bv_A | bv_B
{
bm::bvector<> bv_T;
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_T.bit_or(bv_A, bv_B, bm::bvector<>::opt_compress);
print_bvector(bv_T); // 1, 2, 3, 4 (size = 10)
}
// merge operation is a logical equivalent of OR
// except it can destroy the source vector to borrow memory blocks from it
// (this is faster, especially in multi-threaded cases)
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A. merge(bv_B);
print_bvector(bv_A); // 1, 2, 3, 4 (size = 10)
}
// bit-vector set union operation (opcode interpeter mode)
// maybe useful for building query interpetors
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A. combine_operation(bv_B, bm::BM_OR);
print_bvector(bv_A); // 1, 2, 3, 4
}
// Set union between bit-vector and STL container
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<size_type> vect_B { 1, 2, 4 };
bm::combine_or(bv_A, vect_B.begin(), vect_B.end());
print_bvector(bv_A); // 1, 2, 3, 4
}
// Set union between bit-vector and C-array.
// This tends to be faster then "combine_or()" especially on sorted vectors
// and in SIMD enabled configurations
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<size_type> vect_B { 1, 2, 4 };
const size_type* arr = &vect_B[0];
bv_A. set(arr, unsigned(vect_B.size()), bm::BM_SORTED); // sorted - fastest
print_bvector(bv_A); // 1, 2, 3, 4
}
// Set union between bit-vector and a serialized bit-vector BLOB
// (created on the fly)
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<unsigned char> blob;
{
bm::bvector<> bv_B { 1, 2, 4 };
make_BLOB(blob, bv_B);
}
od. deserialize(bv_A, blob.data(), bm::set_OR);
print_bvector(bv_A); // 1, 2, 3, 4
}
// Union of many sets with bm::aggegator<>
// target := A OR B OR C
//
// This method is best when we have multiple vectors at hands, aggregator
// is capable of doing it faster, than pair by pair OR
{
bm::bvector<> bv_T; // target vector
bm::bvector<> bv_A { 1, 2 };
bm::bvector<> bv_B { 2, 3 };
bm::bvector<> bv_C { 3, 4 };
bm::aggregator<bm::bvector<> > agg;
agg. set_optimization(); // perform on-the-fly optimization of result
// attach vectors to group 0 for OR operation
agg. add(&bv_A);
agg.add(&bv_B);
agg.add(&bv_C);
agg. combine_or(bv_T);
agg. reset(); // reset the aggregator parameters
print_bvector(bv_T); // 1, 2, 3, 4
}
}
// -------------------------------------------------------------
// Demo for Set Intersect (AND) operations
//
static
void DemoAND()
{
typedef bm::bvector<>::size_type size_type;
bm::operation_deserializer<bm::bvector<> > od;
// bit-vector set intersect operation: bv_A &= bv_B
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A. bit_and(bv_B);
print_bvector(bv_A); // 1, 2
}
// same, but sizes are set, observe size gets extended up
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A.resize(5);
bv_B.resize(10);
bv_A.bit_and(bv_B);
print_bvector(bv_A); // 1, 2 (size = 10)
}
// 3-operand AND: bv_T = bv_A & bv_B
{
bm::bvector<> bv_T;
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_T.bit_and(bv_A, bv_B, bm::bvector<>::opt_compress);
print_bvector(bv_T); // 1, 2
}
// bit-vector set union operation (opcode interpeter mode)
// maybe useful for building query interpetors
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A.combine_operation(bv_B, bm::BM_AND);
print_bvector(bv_A); // 1, 2
}
// Set Intersect between bit-vector and STL container
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<unsigned> vect_B { 1, 2, 4 };
bm::combine_and(bv_A, vect_B.begin(), vect_B.end());
print_bvector(bv_A); // 1, 2
}
// Set Intersect between bit-vector and C-array.
// This may be faster then "combine_and()" especially on sorted vectors
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<size_type> vect_B { 1, 2, 4 };
const size_type* arr = &vect_B[0];
bv_A. keep(arr, size_type(vect_B.size()), bm::BM_SORTED); // sorted - fastest
print_bvector(bv_A); // 1, 2
}
// Set Intersect between bit-vector and a serialized bit-vector BLOB
//
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<unsigned char> blob;
{
bm::bvector<> bv_B { 1, 2, 4 };
make_BLOB(blob, bv_B);
}
od.deserialize(bv_A, blob.data(), bm::set_AND);
print_bvector(bv_A); // 1, 2
}
// Intersection of many sets with bm::aggegator<> (find common subset)
// target := A AND B AND C
//
// This method is best when we have multiple vectors at hands, aggregator
// is capable of doing it faster, than pair by pair AND
{
bm::bvector<> bv_T; // target vector
bm::bvector<> bv_A { 1, 2 };
bm::bvector<> bv_B { 1, 2, 3 };
bm::bvector<> bv_C { 1, 2, 3, 4 };
bm::aggregator<bm::bvector<> > agg;
agg.set_optimization(); // perform on-the-fly optimization of result
// attach vectors to group 0 for OR operation
agg.add(&bv_A);
agg.add(&bv_B);
agg.add(&bv_C);
agg. combine_and(bv_T);
agg.reset(); // reset the aggregator parameters
print_bvector(bv_T); // 1, 2
}
}
// -------------------------------------------------------------
// Demo for XOR operations
//
static
void DemoXOR()
{
bm::operation_deserializer<bm::bvector<> > od;
// bit-vector xor operation: bv_A ^= bv_B
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A. bit_xor(bv_B);
print_bvector(bv_A); // 3, 4
}
// same, but sizes are set, observe size gets extended up
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A.resize(5);
bv_B.resize(10);
bv_A.bit_xor(bv_B);
print_bvector(bv_A); // 3, 4 (size = 10)
}
// 3-operand XOR: bv_T = bv_A ^ bv_B
{
bm::bvector<> bv_T;
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_T.bit_xor(bv_A, bv_B, bm::bvector<>::opt_compress);
print_bvector(bv_T); // 3, 4
}
// bit-vector xor operation (opcode interpeter mode)
// maybe useful for building query interpetors
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A.combine_operation(bv_B, bm::BM_XOR);
print_bvector(bv_A); // 3, 4
}
// xor between bit-vector and STL container
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<unsigned> vect_B { 1, 2, 4 };
bm::combine_xor(bv_A, vect_B.begin(), vect_B.end());
print_bvector(bv_A); // 3, 4
}
// xor between bit-vector and a serialized bit-vector BLOB
//
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<unsigned char> blob;
{
bm::bvector<> bv_B { 1, 2, 4 };
make_BLOB(blob, bv_B);
}
od.deserialize(bv_A, blob.data(), bm::set_XOR);
print_bvector(bv_A); // 3, 4
}
}
// -------------------------------------------------------------
// Demo for Set Substract (AND NOT) operations
//
static
void DemoSUB()
{
typedef bm::bvector<>::size_type size_type;
bm::operation_deserializer<bm::bvector<> > od;
// bit-vector set union operation: bv_A -= bv_B
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A. bit_sub(bv_B);
print_bvector(bv_A); // 3
}
// same, but sizes are set, observe size gets extended up
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A.resize(5);
bv_B.resize(10);
bv_A.bit_sub(bv_B);
print_bvector(bv_A); // 3 (size = 10)
}
// 3-operand SUB: bv_T = bv_A - bv_B
{
bm::bvector<> bv_T;
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_T.bit_sub(bv_A, bv_B, bm::bvector<>::opt_compress);
print_bvector(bv_T); // 3
}
// bit-vector minus operation (opcode interpeter mode)
// maybe useful for building query interpetors
{
bm::bvector<> bv_A { 1, 2, 3 };
bm::bvector<> bv_B { 1, 2, 4 };
bv_A.combine_operation(bv_B, bm::BM_SUB);
print_bvector(bv_A); // 3
}
// and not between bit-vector and STL container
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<size_type> vect_B { 1, 2, 4 };
bm::combine_sub(bv_A, vect_B.begin(), vect_B.end());
print_bvector(bv_A); // 3
}
// Set Intersect between bit-vector and C-array.
// This may be faster then "combine_and()" especially on sorted vectors
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<size_type> vect_B { 1, 2, 4 };
const size_type* arr = &vect_B[0];
bv_A. clear(arr, unsigned(vect_B.size()), bm::BM_SORTED); // sorted - fastest
print_bvector(bv_A); // 3
}
// Set union between bit-vector and a serialized bit-vector BLOB
//
{
bm::bvector<> bv_A { 1, 2, 3 };
vector<unsigned char> blob;
{
bm::bvector<> bv_B { 1, 2, 4 };
make_BLOB(blob, bv_B);
}
od.deserialize(bv_A, blob.data(), bm::set_SUB);
print_bvector(bv_A); // 3
}
// Subtraction of many sets with bm::aggegator<>
// target := (target SUB A) OR (target SUB B) OR (target SUB C)
//
{
bm::bvector<> bv_T; // target vector
bm::bvector<> bv_A { 1, 2, 3, 4 };
bm::bvector<> bv_B { 1, 2 };
bm::bvector<> bv_C { 1, 2, 4 };
bm::aggregator<bm::bvector<> > agg;
agg.set_optimization(); // perform on-the-fly optimization of result
// here we are really using AND SUB operation
// where group 0 is all ANDed and group 1 SUBtracted from the result
// group 1 is only 1 vector, so AND part will be no-op
//
agg.add(&bv_A, 0); // add to group 0 (subtraction source)
agg.add(&bv_B, 1); // add to group 1 (subtraction arguments)
agg.add(&bv_C, 1);
agg. combine_and_sub(bv_T);
agg.reset(); // reset the aggregator parameters
print_bvector(bv_T); // 3
}
}
// -------------------------------------------------------------
// Demo for Set Invert (NOT)
//
static
void DemoINV()
{
// bit-vector invert operation
// by default it inverts the whole 32-bit space
{
bm::bvector<> bv_A { 4, 5, 6 };
bv_A. invert();
print_bvector(bv_A); // 0, 1, 2, 3, 7 ...
}
// bit-vector invert operation
// it is size bound, inverts within set limits
{
bm::bvector<> bv_A { 4, 5, 6 };
bv_A.resize(7);
bv_A.invert();
print_bvector(bv_A); // 0, 1, 2, 3, size = 7
}
}
// -------------------------------------------------------------
// Demo for AND-SUB
// AND-SUB implements a search pattern "all this but not that"
//
static
void DemoAND_SUB()
{
// Operation on two groups of vectors using aggregator
// 1. Group 0 - find common subset (Set Intersect / AND)
// 2. Group 1 - find union (OR) of the group and SUBtract it from #1
//
// target := (A AND D AND ...) AND NOT (B OR C OR ...)
//
{
bm::bvector<> bv_T; // target vector
bm::bvector<> bv_A { 1, 2, 3, 4 };
bm::bvector<> bv_B { 1, 2 };
bm::bvector<> bv_C { 1, 2, 4 };
bm::bvector<> bv_D { 0, 2, 3, 4, 5 };
bm::aggregator<bm::bvector<> > agg;
agg.set_optimization(); // perform on-the-fly optimization of result
// here we are really using AND SUB operation
// where group 0 is all ANDed and group 1 SUBtracted from the result
//
agg.add(&bv_A, 0); // add to group 0 for AND
agg.add(&bv_D, 0); //
agg.add(&bv_B, 1); // add to group 1 SUB tract from group 0 result
agg.add(&bv_C, 1);
agg.combine_and_sub(bv_T);
agg.reset(); // reset the aggregator parameters
print_bvector(bv_T); // 3
}
}
int main(void)
{
try
{
cout << endl << "Set Union (OR) demo" << endl << endl;
DemoOR();
cout << endl << "Set Intersect (AND) demo" << endl << endl;
DemoAND();
cout << endl << "XOR demo" << endl << endl;
DemoXOR();
cout << endl << "Set Minus (SUB/AND-NOT) demo" << endl << endl;
DemoSUB();
cout << endl << "Set Invert (NOT) demo" << endl << endl;
DemoINV();
cout << endl << "Set AND-SUB demo" << endl << endl;
DemoAND_SUB();
}
catch(std::exception& ex)
{
std::cerr << ex.what() << std::endl;
}
return 0;
}
bmaggregator.h
Algorithms for fast aggregation of N bvectors.
bm::aggregator::combine_or
void combine_or(bvector_type &bv_target)
Aggregate added group of vectors using logical OR Operation does NOT perform an explicit reset of arg...
Definition: bmaggregator.h:609
bm::combine_and
void combine_and(BV &bv, It first, It last)
AND Combine bitvector and the iterable sequence.
Definition: bmalgo_impl.h:1301
bm::BM_AND
@ BM_AND
Definition: bmconst.h:177
print_bvector
static void print_bvector(const bm::bvector<> &bv)
Definition: bvsetalgebra.cpp:64
bm::set_AND
@ set_AND
Definition: bmconst.h:154
bm::bvector::size
size_type size() const BMNOEXCEPT
Returns bvector's capacity (number of bits it can store)
Definition: bm.h:1258
bm::set_SUB
@ set_SUB
Definition: bmconst.h:156
bm::bvector::bit_or
bm::bvector< Alloc > & bit_or(const bm::bvector< Alloc > &bv1, const bm::bvector< Alloc > &bv2, typename bm::bvector< Alloc >::optmode opt_mode)
3-operand OR : this := bv1 OR bv2
Definition: bm.h:4809
BM_DECLARE_TEMP_BLOCK
#define BM_DECLARE_TEMP_BLOCK(x)
Definition: bm.h:47
bm::bvector::bit_and
bm::bvector< Alloc > & bit_and(const bm::bvector< Alloc > &bv1, const bm::bvector< Alloc > &bv2, typename bm::bvector< Alloc >::optmode opt_mode)
3-operand AND : this := bv1 AND bv2
Definition: bm.h:5017
DemoXOR
static void DemoXOR()
Definition: bvsetalgebra.cpp:330
DemoINV
static void DemoINV()
Definition: bvsetalgebra.cpp:513
bm::aggregator::combine_and
void combine_and(bvector_type &bv_target)
Aggregate added group of vectors using logical AND Operation does NOT perform an explicit reset of ar...
Definition: bmaggregator.h:617
bm::BM_SORTED
@ BM_SORTED
input set is sorted (ascending order)
Definition: bmconst.h:191
bm::serializer::serialize
size_type serialize(const BV &bv, unsigned char *buf, size_t buf_size)
Bitvector serialization into memory block.
Definition: bmserial.h:2264
bm::aggregator
Algorithms for fast aggregation of a group of bit-vectors.
Definition: bmaggregator.h:58
bm::bvector::enumerator
Constant iterator designed to enumerate "ON" bits.
Definition: bm.h:599
bmalgo.h
Algorithms for bvector<> (main include)
bm::aggregator::combine_and_sub
bool combine_and_sub(bvector_type &bv_target)
Aggregate added group of vectors using fused logical AND-SUB Operation does NOT perform an explicit r...
Definition: bmaggregator.h:625
DemoAND
static void DemoAND()
Definition: bvsetalgebra.cpp:221
DemoAND_SUB
static void DemoAND_SUB()
Definition: bvsetalgebra.cpp:541
bm::bvector<>
bm::set_OR
@ set_OR
Definition: bmconst.h:155
bm::bvector::set
bvector< Alloc > & set(size_type n, bool val=true)
Sets bit n if val is true, clears bit n if val is false.
Definition: bm.h:3581
bm::bvector::iterator_base::valid
bool valid() const BMNOEXCEPT
Checks if iterator is still valid. Analog of != 0 comparison for pointers.
Definition: bm.h:280
bm::bvector::bit_sub
bm::bvector< Alloc > & bit_sub(const bm::bvector< Alloc > &bv1, const bm::bvector< Alloc > &bv2, typename bm::bvector< Alloc >::optmode opt_mode)
3-operand SUB : this := bv1 MINUS bv2 SUBtraction is also known as AND NOT
Definition: bm.h:5111
bm::bvector::keep
void keep(const size_type *ids, size_type ids_size, bm::sort_order so=bm::BM_UNKNOWN)
Keep list of bits in this bitset, others are cleared.
Definition: bm.h:3518
make_BLOB
static void make_BLOB(vector< unsigned char > &target_buf, bm::bvector<> &bv)
Definition: bvsetalgebra.cpp:77
bm::aggregator::set_optimization
void set_optimization(typename bvector_type::optmode opt=bvector_type::opt_compress)
set on-the-fly bit-block compression By default aggregator does not try to optimize result,...
Definition: bmaggregator.h:105
DemoOR
static void DemoOR()
Definition: bvsetalgebra.cpp:96
bm::set_XOR
@ set_XOR
Definition: bmconst.h:157
bm::operation_deserializer
Deserializer, performs logical operations between bit-vector and serialized bit-vector.
Definition: bmserial.h:824
bm::bvector::clear
void clear(const size_type *ids, size_type ids_size, bm::sort_order so=bm::BM_UNKNOWN)
clear list of bits in this bitset
Definition: bm.h:3546
bm::serializer
Bit-vector serialization class.
Definition: bmserial.h:75
bm::bvector::resize
void resize(size_type new_size)
Change size of the bvector.
Definition: bm.h:2256
bm::aggregator::add
unsigned add(const bvector_type *bv, unsigned agr_group=0) BMNOEXCEPT
Attach source bit-vector to a argument group (0 or 1).
Definition: bmaggregator.h:576
bm::BM_OR
@ BM_OR
Definition: bmconst.h:178
bm::bvector::invert
bvector< Alloc > & invert()
Invert/NEG all bits It should be noted, invert is affected by size() if size is set - it only inverts...
Definition: bm.h:2987
bm::combine_or
void combine_or(BV &bv, It first, It last)
OR Combine bitvector and the iterable sequence.
Definition: bmalgo_impl.h:1016
bm::operation_deserializer::deserialize
size_type deserialize(bvector_type &bv, const unsigned char *buf, set_operation op, bool exit_on_one=false)
Deserialize bvector using buffer as set operation argument.
Definition: bmserial.h:5772
DemoSUB
static void DemoSUB()
Definition: bvsetalgebra.cpp:401
bmserial.h
Serialization / compression of bvector<>. Set theoretical operations on compressed BLOBs.
bm::bvector::bit_xor
bm::bvector< Alloc > & bit_xor(const bm::bvector< Alloc > &bv1, const bm::bvector< Alloc > &bv2, typename bm::bvector< Alloc >::optmode opt_mode)
3-operand XOR : this := bv1 XOR bv2
Definition: bm.h:4906
main
int main(void)
Definition: bvsetalgebra.cpp:579
bm::aggregator::reset
void reset() BMNOEXCEPT
Reset aggregate groups, forget all attached vectors.
Definition: bmaggregator.h:542
bm::bvector::merge
void merge(bm::bvector< Alloc > &bvect)
Merge/move content from another vector.
Definition: bm.h:4724
bm::bvector::combine_operation
void combine_operation(const bm::bvector< Alloc > &bvect, bm::operation opcode)
perform a set-algebra operation by operation code
Definition: bm.h:5529
bm::bvector::first
enumerator first() const
Returns enumerator pointing on the first non-zero bit.
Definition: bm.h:1770
bm::BM_XOR
@ BM_XOR
Definition: bmconst.h:180
bm::combine_xor
void combine_xor(BV &bv, It first, It last)
XOR Combine bitvector and the iterable sequence.
Definition: bmalgo_impl.h:1097
bm::bvector::size_type
bm::id_t size_type
Definition: bm.h:117
bm::BM_SUB
@ BM_SUB
Definition: bmconst.h:179
bm.h
Compressed bit-vector bvector<> container, set algebraic methods, traversal iterators.
bm::bvector::optimize
void optimize(bm::word_t *temp_block=0, optmode opt_mode=opt_compress, statistics *stat=0)
Optimize memory bitvector's memory allocation.
Definition: bm.h:3071
bm::combine_sub
void combine_sub(BV &bv, It first, It last)
SUB Combine bitvector and the iterable sequence.
Definition: bmalgo_impl.h:1184