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