Storm 1.10.0.1
A Modern Probabilistic Model Checker
Loading...
Searching...
No Matches
BitVectorTest.cpp
Go to the documentation of this file.
1#include "storm/exceptions/InvalidArgumentException.h"
2#include "storm/exceptions/OutOfRangeException.h"
3#include "storm/storage/BitVector.h"
4#include "test/storm_gtest.h"
5
6TEST(BitVectorTest, InitToZero) {
7 storm::storage::BitVector vector(32);
8
9 for (uint64_t i = 0; i < 32; ++i) {
10 ASSERT_FALSE(vector.get(i));
11 }
12
13 ASSERT_TRUE(vector.empty());
14 ASSERT_FALSE(vector.full());
15}
16
17TEST(BitVectorTest, InitToOne) {
18 storm::storage::BitVector vector(32, true);
19
20 for (uint64_t i = 0; i < 32; ++i) {
21 ASSERT_TRUE(vector.get(i));
22 }
23 ASSERT_FALSE(vector.empty());
24 ASSERT_TRUE(vector.full());
25}
26
27TEST(BitVectorTest, InitFromIterator) {
28 std::vector<uint64_t> valueVector = {0, 4, 10};
29 storm::storage::BitVector vector(32, valueVector.begin(), valueVector.end());
30
31 ASSERT_EQ(32ul, vector.size());
32
33 for (uint64_t i = 0; i < 32; ++i) {
34 if (i == 0 || i == 4 || i == 10) {
35 ASSERT_TRUE(vector.get(i));
36 } else {
37 ASSERT_FALSE(vector.get(i));
38 }
39 }
40}
41
42TEST(BitVectorTest, InitFromIntVector) {
43 std::vector<uint64_t> valueVector = {0, 4, 10};
44 storm::storage::BitVector vector(32, valueVector);
45
46 ASSERT_EQ(32ul, vector.size());
47
48 for (uint64_t i = 0; i < 32; ++i) {
49 if (i == 0 || i == 4 || i == 10) {
50 ASSERT_TRUE(vector.get(i));
51 } else {
52 ASSERT_FALSE(vector.get(i));
53 }
54 }
55}
56
57TEST(BitVectorTest, GetSet) {
58 storm::storage::BitVector vector(32);
59
60 for (uint64_t i = 0; i < 32; ++i) {
61 vector.set(i, i % 2 == 0);
62 }
63
64 for (uint64_t i = 0; i < 32; ++i) {
65 ASSERT_EQ(i % 2 == 0, vector.get(i));
66 }
67}
68
69TEST(BitVectorTest, GetAsInt) {
70 storm::storage::BitVector vector(77);
71
72 vector.set(62);
73 vector.set(63);
74 vector.set(64);
75 vector.set(65);
76
77 EXPECT_EQ(3ul, vector.getAsInt(0, 64));
78 EXPECT_EQ(1ul, vector.getAsInt(62, 1));
79 EXPECT_EQ(3ul, vector.getAsInt(62, 2));
80 EXPECT_EQ(7ul, vector.getAsInt(62, 3));
81 EXPECT_EQ(15ul, vector.getAsInt(62, 4));
82
83 vector.set(64, false);
84
85 EXPECT_EQ(1ul, vector.getAsInt(62, 1));
86 EXPECT_EQ(3ul, vector.getAsInt(62, 2));
87 EXPECT_EQ(6ul, vector.getAsInt(62, 3));
88 EXPECT_EQ(13ul, vector.getAsInt(62, 4));
89
90 vector.set(61);
91 vector.set(62, false);
92 EXPECT_EQ(2ul, vector.getAsInt(61, 2));
93}
94
95TEST(BitVectorTest, SetFromInt) {
96 storm::storage::BitVector vector(77);
97
98 vector.setFromInt(62, 1, 1);
99
100 EXPECT_TRUE(vector.get(62));
101 EXPECT_FALSE(vector.get(63));
102 EXPECT_FALSE(vector.get(64));
103 EXPECT_FALSE(vector.get(65));
104
105 vector.setFromInt(61, 2, 2);
106
107 EXPECT_TRUE(vector.get(61));
108 EXPECT_FALSE(vector.get(62));
109 EXPECT_FALSE(vector.get(63));
110
111 vector.setFromInt(61, 3, 5);
112
113 EXPECT_TRUE(vector.get(61));
114 EXPECT_FALSE(vector.get(62));
115 EXPECT_TRUE(vector.get(63));
116
117 vector = storm::storage::BitVector(77);
118 vector.setFromInt(62, 4, 15);
119
120 EXPECT_TRUE(vector.get(62));
121 EXPECT_TRUE(vector.get(63));
122 EXPECT_TRUE(vector.get(64));
123 EXPECT_TRUE(vector.get(65));
124
125 vector.setFromInt(62, 5, 17);
126}
127
128TEST(BitVectorTest, GetSetInt) {
129 storm::storage::BitVector vector(77);
130
131 vector.setFromInt(63, 3, 2);
132 EXPECT_EQ(2ul, vector.getAsInt(63, 3));
133}
134
135TEST(BitVectorDeathTest, GetSetAssertion) {
136 storm::storage::BitVector vector(32);
137
138#ifndef NDEBUG
139 EXPECT_DEATH_IF_SUPPORTED(vector.get(32), "");
140 EXPECT_DEATH_IF_SUPPORTED(vector.set(32), "");
141#else
142 std::cerr << "WARNING: Not testing GetSetAssertions, as they are disabled in release mode.\n";
143 SUCCEED();
144#endif
145}
146
147TEST(BitVectorTest, Resize) {
148 storm::storage::BitVector vector(32);
149
150 for (uint64_t i = 0; i < 32; ++i) {
151 vector.set(i);
152 }
153
154 vector.resize(70);
155
156 ASSERT_EQ(70ul, vector.size());
157 ASSERT_EQ(32ul, vector.getNumberOfSetBits());
158
159 for (uint64_t i = 0; i < 32; ++i) {
160 ASSERT_TRUE(vector.get(i));
161 }
162 bool result;
163 for (uint64_t i = 32; i < 70; ++i) {
164 result = true;
165 ASSERT_NO_THROW(result = vector.get(i));
166 ASSERT_FALSE(result);
167 }
168
169 vector.resize(72, true);
170
171 std::cout << vector << std::endl;
172 ASSERT_EQ(72ul, vector.size());
173 ASSERT_EQ(34ul, vector.getNumberOfSetBits());
174
175 for (uint64_t i = 0; i < 32; ++i) {
176 ASSERT_TRUE(vector.get(i));
177 }
178 for (uint64_t i = 32; i < 70; ++i) {
179 result = true;
180 ASSERT_NO_THROW(result = vector.get(i));
181 ASSERT_FALSE(result);
182 }
183 for (uint64_t i = 70; i < 72; ++i) {
184 ASSERT_TRUE(vector.get(i));
185 }
186
187 vector.resize(16, 0);
188 ASSERT_EQ(16ul, vector.size());
189 ASSERT_EQ(16ul, vector.getNumberOfSetBits());
190
191 for (uint64_t i = 0; i < 16; ++i) {
192 ASSERT_TRUE(vector.get(i));
193 }
194
195 vector.resize(65, 1);
196 ASSERT_EQ(65ul, vector.size());
197 ASSERT_TRUE(vector.full());
198}
199
200TEST(BitVectorTest, OperatorAnd) {
201 storm::storage::BitVector vector1(32);
202 storm::storage::BitVector vector2(32);
203
204 for (int i = 0; i < 32; ++i) {
205 vector1.set(i, i % 2 == 0);
206 vector2.set(i, i % 2 == 1);
207 }
208 vector1.set(31);
209 vector2.set(31);
210
211 storm::storage::BitVector andResult = vector1 & vector2;
212 for (uint64_t i = 0; i < 31; ++i) {
213 ASSERT_FALSE(andResult.get(i));
214 }
215 ASSERT_TRUE(andResult.get(31));
216}
217
218TEST(BitVectorTest, OperatorAndEqual) {
219 storm::storage::BitVector vector1(32);
220 storm::storage::BitVector vector2(32);
221
222 for (int i = 0; i < 32; ++i) {
223 vector1.set(i, i % 2 == 0);
224 vector2.set(i, i % 2 == 1);
225 }
226 vector1.set(31);
227 vector2.set(31);
228
229 vector1 &= vector2;
230
231 for (uint64_t i = 0; i < 31; ++i) {
232 ASSERT_FALSE(vector1.get(i));
233 }
234 ASSERT_TRUE(vector1.get(31));
235}
236
237TEST(BitVectorTest, OperatorOr) {
238 storm::storage::BitVector vector1(32);
239 storm::storage::BitVector vector2(32);
240
241 for (uint64_t i = 0; i < 32; ++i) {
242 vector1.set(i, i % 2 == 0);
243 vector2.set(i, i % 2 == 1);
244 }
245 vector1.set(31, false);
246 vector2.set(31, false);
247
248 storm::storage::BitVector orResult = vector1 | vector2;
249
250 for (uint64_t i = 0; i < 31; ++i) {
251 ASSERT_TRUE(orResult.get(i));
252 }
253 ASSERT_FALSE(orResult.get(31));
254}
255
256TEST(BitVectorTest, OperatorOrEqual) {
257 storm::storage::BitVector vector1(32);
258 storm::storage::BitVector vector2(32);
259
260 for (uint64_t i = 0; i < 32; ++i) {
261 vector1.set(i, i % 2 == 0);
262 vector2.set(i, i % 2 == 1);
263 }
264 vector1.set(31, false);
265 vector2.set(31, false);
266
267 vector1 |= vector2;
268
269 for (uint64_t i = 0; i < 31; ++i) {
270 ASSERT_TRUE(vector1.get(i));
271 }
272 ASSERT_FALSE(vector1.get(31));
273}
274
275TEST(BitVectorTest, OperatorXor) {
276 storm::storage::BitVector vector1(32);
277 storm::storage::BitVector vector2(32);
278
279 for (uint64_t i = 0; i < 32; ++i) {
280 vector1.set(i);
281 vector2.set(i, i % 2 == 1);
282 }
283
284 storm::storage::BitVector vector3 = vector1 ^ vector2;
285 storm::storage::BitVector vector4 = ~vector2;
286 storm::storage::BitVector vector5 = vector1 ^ vector1;
287
288 for (uint64_t i = 0; i < 32; ++i) {
289 ASSERT_EQ(vector3.get(i), vector4.get(i));
290 ASSERT_FALSE(vector5.get(i));
291 }
292}
293
294TEST(BitVectorTest, OperatorModulo) {
295 storm::storage::BitVector vector1(32);
296 storm::storage::BitVector vector2(32);
297
298 for (uint64_t i = 0; i < 15; ++i) {
299 vector2.set(i, i % 2 == 0);
300 }
301
302 vector1.set(2);
303 vector1.set(5);
304 vector1.set(6);
305
306 storm::storage::BitVector moduloResult = vector1 % vector2;
307
308 ASSERT_EQ(8ul, moduloResult.size());
309 ASSERT_EQ(2ul, moduloResult.getNumberOfSetBits());
310
311 for (uint64_t i = 0; i < 8; ++i) {
312 if (i == 1 || i == 3) {
313 ASSERT_TRUE(moduloResult.get(i));
314 } else {
315 ASSERT_FALSE(moduloResult.get(i));
316 }
317 }
318}
319
320TEST(BitVectorTest, OperatorNot) {
321 storm::storage::BitVector vector1(32);
322 storm::storage::BitVector vector2(32);
323
324 for (uint64_t i = 0; i < 32; ++i) {
325 vector1.set(i, i % 2 == 0);
326 vector2.set(i, i % 2 == 1);
327 }
328
329 storm::storage::BitVector notResult = ~vector2;
330
331 for (uint64_t i = 0; i < 32; ++i) {
332 ASSERT_EQ(vector1.get(i), notResult.get(i));
333 }
334}
335
336TEST(BitVectorTest, Complement) {
337 storm::storage::BitVector vector1(32);
338 storm::storage::BitVector vector2(32);
339
340 for (uint64_t i = 0; i < 32; ++i) {
341 vector1.set(i, i % 2 == 0);
342 vector2.set(i, i % 2 == 1);
343 }
344
345 vector2.complement();
346
347 for (uint64_t i = 0; i < 32; ++i) {
348 ASSERT_EQ(vector1.get(i), vector2.get(i));
349 }
350}
351
352TEST(BitVectorTest, Increment) {
353 storm::storage::BitVector vector1(130, false);
354 storm::storage::BitVector vector2(130, false);
355
356 vector1.increment();
357 EXPECT_EQ(1ull, vector1.getNumberOfSetBits());
358 vector2.set(0, true);
359 EXPECT_EQ(vector1, vector2);
360
361 vector1.increment();
362 EXPECT_EQ(1ull, vector1.getNumberOfSetBits());
363 vector2.clear();
364 vector2.set(1, true);
365 EXPECT_EQ(vector1, vector2);
366
367 vector1.increment();
368 EXPECT_EQ(2ull, vector1.getNumberOfSetBits());
369 vector2.set(0, true);
370 EXPECT_EQ(vector1, vector2);
371
372 vector1.clear();
373 for (uint64_t i = 0; i < 66; ++i) {
374 vector1.set(i, true);
375 }
376 vector1.increment();
377 EXPECT_EQ(1ull, vector1.getNumberOfSetBits());
378 vector2.clear();
379 vector2.set(66, true);
380 EXPECT_EQ(vector1, vector2);
381
382 vector1.increment();
383 EXPECT_EQ(2ull, vector1.getNumberOfSetBits());
384 vector2.set(0, true);
385 EXPECT_EQ(vector1, vector2);
386
387 vector1.clear();
388 vector1.complement();
389 EXPECT_TRUE(vector1.full());
390 vector1.increment();
391 EXPECT_TRUE(vector1.empty());
392}
393
394TEST(BitVectorTest, permute) {
395 storm::storage::BitVector vector1(9, {3, 5});
396 std::vector<uint64_t> inversePermutation = {0, 1, 3, 2, 4, 6, 5, 8, 7};
397 storm::storage::BitVector vector2 = vector1.permute(inversePermutation);
398 EXPECT_EQ(vector1.getNumberOfSetBits(), vector2.getNumberOfSetBits());
399 EXPECT_TRUE(vector2.get(2));
400 EXPECT_TRUE(vector2.get(6));
401}
402
403TEST(BitVectorTest, permuteGrouped) {
404 storm::storage::BitVector vector1(6, {0, 2, 5});
405 std::vector<uint64_t> inversePermutation = {1, 0, 2};
406 std::vector<uint64_t> groupIndices = {0, 3, 5, 6};
407 storm::storage::BitVector permuted = vector1.permuteGroupedVector(inversePermutation, groupIndices);
408 storm::storage::BitVector expected(6, {2, 4, 5});
409 EXPECT_EQ(expected, permuted);
410}
411
412TEST(BitVectorTest, Implies) {
413 storm::storage::BitVector vector1(32);
414 storm::storage::BitVector vector2(32, true);
415
416 for (uint64_t i = 0; i < 32; ++i) {
417 vector1.set(i, i % 2 == 0);
418 }
419 vector2.set(31, false);
420 vector2.set(30, false);
421
422 storm::storage::BitVector impliesResult = vector1.implies(vector2);
423
424 for (uint64_t i = 0; i < 30; ++i) {
425 ASSERT_TRUE(impliesResult.get(i));
426 }
427 ASSERT_FALSE(impliesResult.get(30));
428 ASSERT_TRUE(impliesResult.get(31));
429}
430
431TEST(BitVectorTest, Subset) {
432 storm::storage::BitVector vector1(32);
433 storm::storage::BitVector vector2(32, true);
434
435 for (uint64_t i = 0; i < 32; ++i) {
436 vector1.set(i, i % 2 == 0);
437 }
438
439 ASSERT_TRUE(vector1.isSubsetOf(vector2));
440
441 vector2.set(16, false);
442
443 ASSERT_FALSE(vector1.isSubsetOf(vector2));
444}
445
446TEST(BitVectorTest, Disjoint) {
447 storm::storage::BitVector vector1(32);
448 storm::storage::BitVector vector2(32);
449
450 for (uint64_t i = 0; i < 32; ++i) {
451 vector1.set(i, i % 2 == 0);
452 vector2.set(i, i % 2 == 1);
453 }
454
455 ASSERT_TRUE(vector1.isDisjointFrom(vector2));
456
457 vector2.set(16, true);
458
459 ASSERT_FALSE(vector1.isDisjointFrom(vector2));
460}
461
462TEST(BitVectorTest, Empty) {
463 storm::storage::BitVector vector(32);
464
465 ASSERT_TRUE(vector.empty());
466
467 vector.set(17, true);
468
469 ASSERT_FALSE(vector.empty());
470
471 vector.set(17, false);
472 vector.set(18, false);
473
474 ASSERT_TRUE(vector.empty());
475}
476
477TEST(BitVectorTest, Full) {
478 storm::storage::BitVector vector(32, true);
479
480 ASSERT_TRUE(vector.full());
481
482 vector.set(17, false);
483
484 ASSERT_FALSE(vector.full());
485
486 vector.set(17, true);
487 vector.set(18, true);
488
489 ASSERT_TRUE(vector.full());
490}
491
492TEST(BitVectorTest, NumberOfSetBits) {
493 storm::storage::BitVector vector(32);
494
495 for (uint64_t i = 0; i < 32; ++i) {
496 vector.set(i, i % 2 == 0);
497 }
498
499 ASSERT_EQ(16ul, vector.getNumberOfSetBits());
500}
501
502TEST(BitVectorTest, NumberOfSetBitsBeforeIndex) {
503 storm::storage::BitVector vector(32);
504
505 for (uint64_t i = 0; i < 32; ++i) {
506 vector.set(i, i % 2 == 0);
507 }
508
509 ASSERT_EQ(7ul, vector.getNumberOfSetBitsBeforeIndex(14));
510}
511
512TEST(BitVectorTest, BeginEnd) {
513 storm::storage::BitVector vector(32);
514
515 ASSERT_TRUE(vector.begin() == vector.end());
516
517 vector.set(17);
518
519 ASSERT_FALSE(vector.begin() == vector.end());
520
521 vector.set(17, false);
522
523 ASSERT_TRUE(vector.begin() == vector.end());
524}
525
526TEST(BitVectorTest, NextSetIndex) {
527 storm::storage::BitVector vector(32);
528
529 vector.set(14);
530 vector.set(17);
531
532 ASSERT_EQ(14ul, vector.getNextSetIndex(14));
533 ASSERT_EQ(17ul, vector.getNextSetIndex(15));
534 ASSERT_EQ(17ul, vector.getNextSetIndex(16));
535 ASSERT_EQ(17ul, vector.getNextSetIndex(17));
536 ASSERT_EQ(vector.size(), vector.getNextSetIndex(18));
537}
538
539TEST(BitVectorTest, NextUnsetIndex) {
540 storm::storage::BitVector vector(32);
541
542 vector.set(14);
543 vector.set(17);
544
545 vector.complement();
546
547 ASSERT_EQ(14ul, vector.getNextUnsetIndex(14));
548 ASSERT_EQ(17ul, vector.getNextUnsetIndex(15));
549 ASSERT_EQ(17ul, vector.getNextUnsetIndex(16));
550 ASSERT_EQ(17ul, vector.getNextUnsetIndex(17));
551 ASSERT_EQ(vector.size(), vector.getNextUnsetIndex(18));
552}
553
554TEST(BitVectorTest, SequenceBefore) {
555 storm::storage::BitVector vector(65);
556
557 vector.set(14);
558 vector.set(17);
559 vector.set(64);
560
561 auto vector_compl = ~vector;
562
563 for (uint64_t i = 0; i <= 65; ++i) {
564 uint64_t expected;
565 if (i <= 14) {
566 expected = 0ul;
567 } else if (i <= 17) {
568 expected = 15ul;
569 } else if (i <= 64) {
570 expected = 18ul;
571 } else {
572 expected = 65ul;
573 }
574 ASSERT_EQ(expected, vector.getStartOfZeroSequenceBefore(i)) << " input index is i=" << i;
575 ASSERT_EQ(expected, vector_compl.getStartOfOneSequenceBefore(i)) << " input index is i=" << i;
576 }
577}
578
579TEST(BitVectorTest, Iterator) {
580 storm::storage::BitVector vector(32);
581
582 for (uint64_t i = 0; i < 32; ++i) {
583 vector.set(i, i % 2 == 0);
584 }
585
586 uint64_t i = 0;
587 for (auto bit : vector) {
588 ASSERT_EQ(i, bit);
589 i += 2;
590 }
591 ASSERT_EQ(i, 32ull);
592}
593
594TEST(BitVectorTest, ReverseIterator) {
595 storm::storage::BitVector vector(547490);
596
597 uint64_t i = 2;
598 for (; i < vector.size(); i += 3) {
599 vector.set(i, true);
600 }
601
602 for (auto bitIt = vector.rbegin(); bitIt != vector.rend(); ++bitIt) {
603 i -= 3;
604 ASSERT_EQ(i, *bitIt);
605 }
606 ASSERT_EQ(i, 2ull);
607}
608
609TEST(BitVectorTest, CompareAndSwap) {
610 storm::storage::BitVector vector(140);
611 vector.setFromInt(0, 64, 2377830234574424100);
612 vector.setFromInt(64, 64, 1152921504607379586);
613 vector.setFromInt(128, 12, 2080);
614
615 bool result = vector.compareAndSwap(0, 68, 68);
616 ASSERT_FALSE(result);
617
618 result = vector.compareAndSwap(68, 0, 68);
619 ASSERT_TRUE(result);
620}
621
622TEST(BitVectorTest, Concat) {
623 storm::storage::BitVector vector1(64, {3, 5});
624 storm::storage::BitVector vector2(65, {10, 12});
625
626 vector1.concat(vector2);
627 ASSERT_EQ(129ul, vector1.size());
628 ASSERT_TRUE(vector1.get(3));
629 ASSERT_TRUE(vector1.get(5));
630 ASSERT_TRUE(vector1.get(10 + 64));
631 ASSERT_TRUE(vector1.get(12 + 64));
632 ASSERT_EQ(4ul, vector1.getNumberOfSetBits());
633}
634
635TEST(BitVectorTest, Expand) {
636 storm::storage::BitVector vector1(64, {3, 5});
637 vector1.expandSize();
638 ASSERT_EQ(64ul, vector1.size());
639 ASSERT_EQ(2ul, vector1.getNumberOfSetBits());
640 storm::storage::BitVector vector2(65, {10, 12});
641 vector2.expandSize();
642 ASSERT_EQ(128ul, vector2.size());
643 ASSERT_EQ(2ul, vector2.getNumberOfSetBits());
644}
645
646TEST(BitVectorTest, Assignment) {
647 storm::storage::BitVector v1(10), v2(100000);
648 v1 = v2;
649 v1.set(9999);
650 ASSERT_TRUE(v1.get(9999));
651}
652
653TEST(BitVectorTest, ZeroSized) {
654 storm::storage::BitVector v(0);
655 EXPECT_EQ(0, v.size());
656 EXPECT_TRUE(v.empty());
657 EXPECT_TRUE(v.full());
658 EXPECT_EQ(0, v.getNumberOfSetBits());
659 EXPECT_EQ(0, v.getAsInt(0, 0));
660 EXPECT_EQ(0, v.getNextSetIndex(0));
661 EXPECT_EQ(v, v);
662 EXPECT_EQ(v, ~v);
663 for (auto const& entry : v) {
664 FAIL() << "Should not iterate over an empty bit vector.";
665 }
666}
TEST
TEST(BitVectorTest, InitToZero)
Definition BitVectorTest.cpp:6
Iterator
PositionIteratorType Iterator
Definition SpiritParserDefinitions.h:23
storm::storage::BitVector
A bit vector that is internally represented as a vector of 64-bit values.
Definition BitVector.h:16
storm::storage::BitVector::complement
void complement()
Negates all bits in the bit vector.
Definition BitVector.cpp:424
storm::storage::BitVector::rbegin
const_reverse_iterator rbegin() const
Returns a reverse iterator to the indices of the set bits in the bit vector.
Definition BitVector.cpp:751
storm::storage::BitVector::getNextSetIndex
uint64_t getNextSetIndex(uint64_t startingIndex) const
Retrieves the index of the bit that is the next bit set to true in the bit vector.
Definition BitVector.cpp:762
storm::storage::BitVector::isDisjointFrom
bool isDisjointFrom(BitVector const &other) const
Checks whether none of the bits that are set in the current bit vector are also set in the given bit ...
Definition BitVector.cpp:480
storm::storage::BitVector::full
bool full() const
Retrieves whether all bits are set in this bit vector.
Definition BitVector.cpp:660
storm::storage::BitVector::rend
const_reverse_iterator rend() const
Returns a reverse iterator pointing at the element past the front of the bit vector.
Definition BitVector.cpp:758
storm::storage::BitVector::end
const_iterator end() const
Returns an iterator pointing at the element past the back of the bit vector.
Definition BitVector.cpp:747
storm::storage::BitVector::empty
bool empty() const
Retrieves whether no bits are set to true in this bit vector.
Definition BitVector.cpp:654
storm::storage::BitVector::clear
void clear()
Removes all set bits from the bit vector.
Definition BitVector.cpp:680
storm::storage::BitVector::isSubsetOf
bool isSubsetOf(BitVector const &other) const
Checks whether all bits that are set in the current bit vector are also set in the given bit vector.
Definition BitVector.cpp:465
storm::storage::BitVector::implies
BitVector implies(BitVector const &other) const
Performs a logical "implies" with the given bit vector.
Definition BitVector.cpp:455
storm::storage::BitVector::getNumberOfSetBits
uint64_t getNumberOfSetBits() const
Returns the number of bits that are set to true in this bit vector.
Definition BitVector.cpp:689
storm::storage::BitVector::getNextUnsetIndex
uint64_t getNextUnsetIndex(uint64_t startingIndex) const
Retrieves the index of the bit that is the next bit set to false in the bit vector.
Definition BitVector.cpp:766
storm::storage::BitVector::compareAndSwap
bool compareAndSwap(uint64_t start1, uint64_t start2, uint64_t length)
Compare two intervals [start1, start1+length] and [start2, start2+length] and swap them if the second...
Definition BitVector.cpp:1051
storm::storage::BitVector::setFromInt
void setFromInt(uint64_t bitIndex, uint64_t numberOfBits, uint64_t value)
Sets the selected number of lowermost bits of the provided value at the given bit index.
Definition BitVector.cpp:616
storm::storage::BitVector::permute
BitVector permute(std::vector< uint64_t > const &inversePermutation) const
Apply a permutation of entries.
Definition BitVector.cpp:514
storm::storage::BitVector::set
void set(uint64_t index, bool value=true)
Sets the given truth value at the given index.
Definition BitVector.cpp:242
storm::storage::BitVector::increment
void increment()
Increments the (unsigned) number represented by this BitVector by one.
Definition BitVector.cpp:429
storm::storage::BitVector::begin
const_iterator begin() const
Returns an iterator to the indices of the set bits in the bit vector.
Definition BitVector.cpp:739
storm::storage::BitVector::getStartOfZeroSequenceBefore
uint64_t getStartOfZeroSequenceBefore(uint64_t endIndex) const
Retrieves the smallest index i such that all bits in the range [i,endIndex) are 0.
Definition BitVector.cpp:774
storm::storage::BitVector::getAsInt
uint64_t getAsInt(uint64_t bitIndex, uint64_t numberOfBits) const
Retrieves the content of the current bit vector at the given index for the given number of bits as an...
Definition BitVector.cpp:574
storm::storage::BitVector::size
size_t size() const
Retrieves the number of bits this bit vector can store.
Definition BitVector.cpp:731
storm::storage::BitVector::resize
void resize(uint64_t newLength, bool init=false)
Resizes the bit vector to hold the given new number of bits.
Definition BitVector.cpp:272
storm::storage::BitVector::expandSize
void expandSize(bool init=false)
Definition BitVector.cpp:330
storm::storage::BitVector::get
bool get(uint64_t index) const
Retrieves the truth value of the bit at the given index and performs a bound check.
Definition BitVector.cpp:267
storm::storage::BitVector::getNumberOfSetBitsBeforeIndex
uint64_t getNumberOfSetBitsBeforeIndex(uint64_t index) const
Retrieves the number of bits set in this bit vector with an index strictly smaller than the given one...
Definition BitVector.cpp:693
storm::storage::BitVector::permuteGroupedVector
BitVector permuteGroupedVector(std::vector< uint64_t > const &inversePermutation, std::vector< uint64_t > const &rowGroupIndices) const
Apply a permutation of entries assuming a grouped vector.
Definition BitVector.cpp:524
storm::storage::BitVector::concat
void concat(BitVector const &extension)
Concatenate this bitvector with another bitvector.
Definition BitVector.cpp:321
storm_gtest.h