BitMagic-C++
bvsetalgebra.cpp
Go to the documentation of this file.
1 /*
2 Copyright(c) 2002-2017 Anatoliy Kuznetsov(anatoliy_kuznetsov at yahoo.com)
3 
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7 
8  http://www.apache.org/licenses/LICENSE-2.0
9 
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 
16 For more information please visit: http://bitmagic.io
17 */
18 
19 /** \example bvsetalgebra.cpp
20  Example demonstrates variety of algebra of sets operations.
21  http://bitmagic.io/set-algebra.html
22 
23  <a href="http://bitmagic.io/set-algebra.html">Algebra Of Sets</a>
24 
25  \sa bvector
26 
27  \sa bvector<>::bit_or
28  \sa bvector<>::bit_and
29  \sa bvector<>::bit_xor
30  \sa bvector<>::bit_sub
31 
32  \sa bm::aggregator
33  \sa bm::operation_deserializer
34 
35  \sa bm::combine_and
36  \sa bm::combine_and_sorted
37  \sa bm::combine_sub
38  \sa bm::combine_or
39  \sa bm::combine_xor
40 
41  \sa sample7.cpp
42 
43 */
44 
45 /*! \file bvsetalgebra.cpp
46  \brief Example: algebra of sets operations
47 */
48 
49 
50 #include <iostream>
51 #include <vector>
52 
53 
54 #include "bm.h"
55 #include "bmalgo.h"
56 #include "bmserial.h"
57 #include "bmaggregator.h"
58 
59 
60 using namespace std;
61 
62 // utility function to print a set
63 static
65 {
68  for (; en.valid() && cnt < 10; ++en, ++cnt)
69  cout << *en << ", ";
70  if (cnt == 10)
71  cout << " ...";
72  cout << "(size = "<< bv.size() << ")" << endl;
73 }
74 
75 // utility function to create serialized bit-vector BLOB
76 static
77 void make_BLOB(vector<unsigned char>& target_buf, bm::bvector<>& bv)
78 {
81  bvs.set_compression_level(4);
82 
83  bv.optimize(tb, bm::bvector<>::opt_compress); // memory compression
84 
85  bm::serializer<bm::bvector<> >::buffer sbuf;
86  bvs.serialize(bv, sbuf, 0);
87  target_buf.resize(sbuf.size());
88  ::memcpy(target_buf.data(), sbuf.buf(), sbuf.size());
89 }
90 
91 
92 // -------------------------------------------------------------
93 // Demo for Set Union (OR) operations
94 //
95 static
96 void DemoOR()
97 {
98  typedef bm::bvector<>::size_type size_type;
100 
101  // bit-vector set union operation: bv_A |= bv_B
102  {
103  bm::bvector<> bv_A { 1, 2, 3 };
104  bm::bvector<> bv_B { 1, 2, 4 };
105  bv_A.bit_or(bv_B);
106 
107  print_bvector(bv_A); // 1, 2, 3, 4
108  }
109  // same, but sizes are set, observe size gets extended up
110  {
111  bm::bvector<> bv_A { 1, 2, 3 };
112  bm::bvector<> bv_B { 1, 2, 4 };
113  bv_A.resize(5);
114  bv_B.resize(10);
115 
116  bv_A.bit_or(bv_B);
117 
118  print_bvector(bv_A); // 1, 2, 3, 4 (size = 10)
119  }
120  // 3-operand OR: bv_T = bv_A | bv_B
121  {
122  bm::bvector<> bv_T;
123  bm::bvector<> bv_A { 1, 2, 3 };
124  bm::bvector<> bv_B { 1, 2, 4 };
125 
126  bv_T.bit_or(bv_A, bv_B, bm::bvector<>::opt_compress);
127 
128  print_bvector(bv_T); // 1, 2, 3, 4 (size = 10)
129  }
130 
131 
132  // merge operation is a logical equivalent of OR
133  // except it can destroy the source vector to borrow memory blocks from it
134  // (this is faster, especially in multi-threaded cases)
135  {
136  bm::bvector<> bv_A { 1, 2, 3 };
137  bm::bvector<> bv_B { 1, 2, 4 };
138  bv_A.merge(bv_B);
139 
140  print_bvector(bv_A); // 1, 2, 3, 4 (size = 10)
141  }
142 
143  // bit-vector set union operation (opcode interpeter mode)
144  // maybe useful for building query interpetors
145  {
146  bm::bvector<> bv_A { 1, 2, 3 };
147  bm::bvector<> bv_B { 1, 2, 4 };
148  bv_A.combine_operation(bv_B, bm::BM_OR);
149 
150  print_bvector(bv_A); // 1, 2, 3, 4
151  }
152 
153  // Set union between bit-vector and STL container
154  {
155  bm::bvector<> bv_A { 1, 2, 3 };
156  vector<size_type> vect_B { 1, 2, 4 };
157 
158  bm::combine_or(bv_A, vect_B.begin(), vect_B.end());
159  print_bvector(bv_A); // 1, 2, 3, 4
160  }
161 
162  // Set union between bit-vector and C-array.
163  // This tends to be faster then "combine_or()" especially on sorted vectors
164  // and in SIMD enabled configurations
165  {
166  bm::bvector<> bv_A { 1, 2, 3 };
167  vector<size_type> vect_B { 1, 2, 4 };
168 
169  const size_type* arr = &vect_B[0];
170  bv_A.set(arr, unsigned(vect_B.size()), bm::BM_SORTED); // sorted - fastest
171  print_bvector(bv_A); // 1, 2, 3, 4
172  }
173 
174  // Set union between bit-vector and a serialized bit-vector BLOB
175  // (created on the fly)
176  {
177  bm::bvector<> bv_A { 1, 2, 3 };
178  vector<unsigned char> blob;
179  {
180  bm::bvector<> bv_B { 1, 2, 4 };
181  make_BLOB(blob, bv_B);
182  }
183  od.deserialize(bv_A, blob.data(), bm::set_OR);
184  print_bvector(bv_A); // 1, 2, 3, 4
185  }
186 
187  // Union of many sets with bm::aggegator<>
188  // target := A OR B OR C
189  //
190  // This method is best when we have multiple vectors at hands, aggregator
191  // is capable of doing it faster, than pair by pair OR
192  {
193  bm::bvector<> bv_T; // target vector
194 
195  bm::bvector<> bv_A { 1, 2 };
196  bm::bvector<> bv_B { 2, 3 };
197  bm::bvector<> bv_C { 3, 4 };
198 
200  agg.set_optimization(); // perform on-the-fly optimization of result
201 
202  // attach vectors to group 0 for OR operation
203  agg.add(&bv_A);
204  agg.add(&bv_B);
205  agg.add(&bv_C);
206 
207  agg.combine_or(bv_T);
208 
209  agg.reset(); // reset the aggregator parameters
210 
211  print_bvector(bv_T); // 1, 2, 3, 4
212  }
213 
214 }
215 
216 
217 // -------------------------------------------------------------
218 // Demo for Set Intersect (AND) operations
219 //
220 static
221 void DemoAND()
222 {
223  typedef bm::bvector<>::size_type size_type;
225 
226  // bit-vector set intersect operation: bv_A &= bv_B
227  {
228  bm::bvector<> bv_A { 1, 2, 3 };
229  bm::bvector<> bv_B { 1, 2, 4 };
230  bv_A.bit_and(bv_B);
231 
232  print_bvector(bv_A); // 1, 2
233  }
234  // same, but sizes are set, observe size gets extended up
235  {
236  bm::bvector<> bv_A { 1, 2, 3 };
237  bm::bvector<> bv_B { 1, 2, 4 };
238  bv_A.resize(5);
239  bv_B.resize(10);
240 
241  bv_A.bit_and(bv_B);
242 
243  print_bvector(bv_A); // 1, 2 (size = 10)
244  }
245  // 3-operand AND: bv_T = bv_A & bv_B
246  {
247  bm::bvector<> bv_T;
248  bm::bvector<> bv_A { 1, 2, 3 };
249  bm::bvector<> bv_B { 1, 2, 4 };
250  bv_T.bit_and(bv_A, bv_B, bm::bvector<>::opt_compress);
251 
252  print_bvector(bv_T); // 1, 2
253  }
254 
255  // bit-vector set union operation (opcode interpeter mode)
256  // maybe useful for building query interpetors
257  {
258  bm::bvector<> bv_A { 1, 2, 3 };
259  bm::bvector<> bv_B { 1, 2, 4 };
260  bv_A.combine_operation(bv_B, bm::BM_AND);
261 
262  print_bvector(bv_A); // 1, 2
263  }
264 
265  // Set Intersect between bit-vector and STL container
266  {
267  bm::bvector<> bv_A { 1, 2, 3 };
268  vector<unsigned> vect_B { 1, 2, 4 };
269 
270  bm::combine_and(bv_A, vect_B.begin(), vect_B.end());
271  print_bvector(bv_A); // 1, 2
272  }
273 
274  // Set Intersect between bit-vector and C-array.
275  // This may be faster then "combine_and()" especially on sorted vectors
276  {
277  bm::bvector<> bv_A { 1, 2, 3 };
278  vector<size_type> vect_B { 1, 2, 4 };
279 
280  const size_type* arr = &vect_B[0];
281  bv_A.keep(arr, size_type(vect_B.size()), bm::BM_SORTED); // sorted - fastest
282  print_bvector(bv_A); // 1, 2
283  }
284 
285  // Set Intersect between bit-vector and a serialized bit-vector BLOB
286  //
287  {
288  bm::bvector<> bv_A { 1, 2, 3 };
289  vector<unsigned char> blob;
290  {
291  bm::bvector<> bv_B { 1, 2, 4 };
292  make_BLOB(blob, bv_B);
293  }
294  od.deserialize(bv_A, blob.data(), bm::set_AND);
295  print_bvector(bv_A); // 1, 2
296  }
297 
298  // Intersection of many sets with bm::aggegator<> (find common subset)
299  // target := A AND B AND C
300  //
301  // This method is best when we have multiple vectors at hands, aggregator
302  // is capable of doing it faster, than pair by pair AND
303  {
304  bm::bvector<> bv_T; // target vector
305 
306  bm::bvector<> bv_A { 1, 2 };
307  bm::bvector<> bv_B { 1, 2, 3 };
308  bm::bvector<> bv_C { 1, 2, 3, 4 };
309 
311  agg.set_optimization(); // perform on-the-fly optimization of result
312 
313  // attach vectors to group 0 for OR operation
314  agg.add(&bv_A);
315  agg.add(&bv_B);
316  agg.add(&bv_C);
317 
318  agg.combine_and(bv_T);
319 
320  agg.reset(); // reset the aggregator parameters
321 
322  print_bvector(bv_T); // 1, 2
323  }
324 }
325 
326 // -------------------------------------------------------------
327 // Demo for XOR operations
328 //
329 static
330 void DemoXOR()
331 {
333 
334  // bit-vector xor operation: bv_A ^= bv_B
335  {
336  bm::bvector<> bv_A { 1, 2, 3 };
337  bm::bvector<> bv_B { 1, 2, 4 };
338  bv_A.bit_xor(bv_B);
339 
340  print_bvector(bv_A); // 3, 4
341  }
342  // same, but sizes are set, observe size gets extended up
343  {
344  bm::bvector<> bv_A { 1, 2, 3 };
345  bm::bvector<> bv_B { 1, 2, 4 };
346  bv_A.resize(5);
347  bv_B.resize(10);
348 
349  bv_A.bit_xor(bv_B);
350 
351  print_bvector(bv_A); // 3, 4 (size = 10)
352  }
353  // 3-operand XOR: bv_T = bv_A ^ bv_B
354  {
355  bm::bvector<> bv_T;
356  bm::bvector<> bv_A { 1, 2, 3 };
357  bm::bvector<> bv_B { 1, 2, 4 };
358  bv_T.bit_xor(bv_A, bv_B, bm::bvector<>::opt_compress);
359 
360  print_bvector(bv_T); // 3, 4
361  }
362 
363  // bit-vector xor operation (opcode interpeter mode)
364  // maybe useful for building query interpetors
365  {
366  bm::bvector<> bv_A { 1, 2, 3 };
367  bm::bvector<> bv_B { 1, 2, 4 };
368  bv_A.combine_operation(bv_B, bm::BM_XOR);
369 
370  print_bvector(bv_A); // 3, 4
371  }
372 
373  // xor between bit-vector and STL container
374  {
375  bm::bvector<> bv_A { 1, 2, 3 };
376  vector<unsigned> vect_B { 1, 2, 4 };
377 
378  bm::combine_xor(bv_A, vect_B.begin(), vect_B.end());
379  print_bvector(bv_A); // 3, 4
380  }
381 
382  // xor between bit-vector and a serialized bit-vector BLOB
383  //
384  {
385  bm::bvector<> bv_A { 1, 2, 3 };
386  vector<unsigned char> blob;
387  {
388  bm::bvector<> bv_B { 1, 2, 4 };
389  make_BLOB(blob, bv_B);
390  }
391  od.deserialize(bv_A, blob.data(), bm::set_XOR);
392  print_bvector(bv_A); // 3, 4
393  }
394 }
395 
396 
397 // -------------------------------------------------------------
398 // Demo for Set Substract (AND NOT) operations
399 //
400 static
401 void DemoSUB()
402 {
403  typedef bm::bvector<>::size_type size_type;
405 
406  // bit-vector set union operation: bv_A -= bv_B
407  {
408  bm::bvector<> bv_A { 1, 2, 3 };
409  bm::bvector<> bv_B { 1, 2, 4 };
410  bv_A.bit_sub(bv_B);
411 
412  print_bvector(bv_A); // 3
413  }
414  // same, but sizes are set, observe size gets extended up
415  {
416  bm::bvector<> bv_A { 1, 2, 3 };
417  bm::bvector<> bv_B { 1, 2, 4 };
418  bv_A.resize(5);
419  bv_B.resize(10);
420 
421  bv_A.bit_sub(bv_B);
422 
423  print_bvector(bv_A); // 3 (size = 10)
424  }
425 
426  // 3-operand SUB: bv_T = bv_A - bv_B
427  {
428  bm::bvector<> bv_T;
429  bm::bvector<> bv_A { 1, 2, 3 };
430  bm::bvector<> bv_B { 1, 2, 4 };
431  bv_T.bit_sub(bv_A, bv_B, bm::bvector<>::opt_compress);
432 
433  print_bvector(bv_T); // 3
434  }
435 
436  // bit-vector minus operation (opcode interpeter mode)
437  // maybe useful for building query interpetors
438  {
439  bm::bvector<> bv_A { 1, 2, 3 };
440  bm::bvector<> bv_B { 1, 2, 4 };
441  bv_A.combine_operation(bv_B, bm::BM_SUB);
442 
443  print_bvector(bv_A); // 3
444  }
445 
446  // and not between bit-vector and STL container
447  {
448  bm::bvector<> bv_A { 1, 2, 3 };
449  vector<size_type> vect_B { 1, 2, 4 };
450 
451  bm::combine_sub(bv_A, vect_B.begin(), vect_B.end());
452  print_bvector(bv_A); // 3
453  }
454 
455  // Set Intersect between bit-vector and C-array.
456  // This may be faster then "combine_and()" especially on sorted vectors
457  {
458  bm::bvector<> bv_A { 1, 2, 3 };
459  vector<size_type> vect_B { 1, 2, 4 };
460 
461  const size_type* arr = &vect_B[0];
462  bv_A.clear(arr, unsigned(vect_B.size()), bm::BM_SORTED); // sorted - fastest
463  print_bvector(bv_A); // 3
464  }
465 
466  // Set union between bit-vector and a serialized bit-vector BLOB
467  //
468  {
469  bm::bvector<> bv_A { 1, 2, 3 };
470  vector<unsigned char> blob;
471  {
472  bm::bvector<> bv_B { 1, 2, 4 };
473  make_BLOB(blob, bv_B);
474  }
475  od.deserialize(bv_A, blob.data(), bm::set_SUB);
476  print_bvector(bv_A); // 3
477  }
478 
479  // Subtraction of many sets with bm::aggegator<>
480  // target := (target SUB A) OR (target SUB B) OR (target SUB C)
481  //
482  {
483  bm::bvector<> bv_T; // target vector
484 
485  bm::bvector<> bv_A { 1, 2, 3, 4 };
486  bm::bvector<> bv_B { 1, 2 };
487  bm::bvector<> bv_C { 1, 2, 4 };
488 
490  agg.set_optimization(); // perform on-the-fly optimization of result
491 
492  // here we are really using AND SUB operation
493  // where group 0 is all ANDed and group 1 SUBtracted from the result
494  // group 1 is only 1 vector, so AND part will be no-op
495  //
496  agg.add(&bv_A, 0); // add to group 0 (subtraction source)
497 
498  agg.add(&bv_B, 1); // add to group 1 (subtraction arguments)
499  agg.add(&bv_C, 1);
500 
501  agg.combine_and_sub(bv_T);
502 
503  agg.reset(); // reset the aggregator parameters
504 
505  print_bvector(bv_T); // 3
506  }
507 }
508 
509 // -------------------------------------------------------------
510 // Demo for Set Invert (NOT)
511 //
512 static
513 void DemoINV()
514 {
515  // bit-vector invert operation
516  // by default it inverts the whole 32-bit space
517  {
518  bm::bvector<> bv_A { 4, 5, 6 };
519  bv_A.invert();
520 
521  print_bvector(bv_A); // 0, 1, 2, 3, 7 ...
522  }
523 
524  // bit-vector invert operation
525  // it is size bound, inverts within set limits
526  {
527  bm::bvector<> bv_A { 4, 5, 6 };
528  bv_A.resize(7);
529  bv_A.invert();
530 
531  print_bvector(bv_A); // 0, 1, 2, 3, size = 7
532  }
533 }
534 
535 
536 // -------------------------------------------------------------
537 // Demo for AND-SUB
538 // AND-SUB implements a search pattern "all this but not that"
539 //
540 static
542 {
543  // Operation on two groups of vectors using aggregator
544  // 1. Group 0 - find common subset (Set Intersect / AND)
545  // 2. Group 1 - find union (OR) of the group and SUBtract it from #1
546  //
547  // target := (A AND D AND ...) AND NOT (B OR C OR ...)
548  //
549  {
550  bm::bvector<> bv_T; // target vector
551 
552  bm::bvector<> bv_A { 1, 2, 3, 4 };
553  bm::bvector<> bv_B { 1, 2 };
554  bm::bvector<> bv_C { 1, 2, 4 };
555  bm::bvector<> bv_D { 0, 2, 3, 4, 5 };
556 
558  agg.set_optimization(); // perform on-the-fly optimization of result
559 
560  // here we are really using AND SUB operation
561  // where group 0 is all ANDed and group 1 SUBtracted from the result
562  //
563  agg.add(&bv_A, 0); // add to group 0 for AND
564  agg.add(&bv_D, 0); //
565 
566  agg.add(&bv_B, 1); // add to group 1 SUB tract from group 0 result
567  agg.add(&bv_C, 1);
568 
569  agg.combine_and_sub(bv_T);
570 
571  agg.reset(); // reset the aggregator parameters
572 
573  print_bvector(bv_T); // 3
574  }
575 }
576 
577 
578 
579 int main(void)
580 {
581  try
582  {
583  cout << endl << "Set Union (OR) demo" << endl << endl;
584  DemoOR();
585 
586  cout << endl << "Set Intersect (AND) demo" << endl << endl;
587  DemoAND();
588 
589  cout << endl << "XOR demo" << endl << endl;
590  DemoXOR();
591 
592  cout << endl << "Set Minus (SUB/AND-NOT) demo" << endl << endl;
593  DemoSUB();
594 
595  cout << endl << "Set Invert (NOT) demo" << endl << endl;
596  DemoINV();
597 
598  cout << endl << "Set AND-SUB demo" << endl << endl;
599  DemoAND_SUB();
600  }
601  catch(std::exception& ex)
602  {
603  std::cerr << ex.what() << std::endl;
604  }
605 
606  return 0;
607 }
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:622
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:1272
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:4823
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:5031
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:630
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:638
DemoAND
static void DemoAND()
Definition: bvsetalgebra.cpp:221
bm::serializer::set_compression_level
void set_compression_level(unsigned clevel) BMNOEXCEPT
Set compression level.
Definition: bmserial.h:1119
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:3595
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:5125
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:3532
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:106
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:3560
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:2270
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:589
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:3001
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:4920
main
int main(void)
Definition: bvsetalgebra.cpp:579
bm::aggregator::reset
void reset() BMNOEXCEPT
Reset aggregate groups, forget all attached vectors.
Definition: bmaggregator.h:554
bm::bvector::merge
void merge(bm::bvector< Alloc > &bvect)
Merge/move content from another vector.
Definition: bm.h:4738
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:5543
bm::bvector::first
enumerator first() const
Returns enumerator pointing on the first non-zero bit.
Definition: bm.h:1784
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:3085
bm::combine_sub
void combine_sub(BV &bv, It first, It last)
SUB Combine bitvector and the iterable sequence.
Definition: bmalgo_impl.h:1184