Repo created

3party/succinct/test_bit_vector.cpp

@@ -0,0 +1,196 @@
+#define BOOST_TEST_MODULE bit_vector
+#include "test_common.hpp"
+#include "test_rank_select_common.hpp"
+
+#include <cstdlib>
+#include <boost/foreach.hpp>
+
+#include "mapper.hpp"
+#include "bit_vector.hpp"
+
+BOOST_AUTO_TEST_CASE(bit_vector)
+{
+    srand(42);
+
+    std::vector<bool> v = random_bit_vector();
+
+    {
+        succinct::bit_vector_builder bvb;
+        for (size_t i = 0; i < v.size(); ++i) {
+            bvb.push_back(v[i]);
+        }
+
+        succinct::bit_vector bitmap(&bvb);
+        test_equal_bits(v, bitmap, "Random bits (push_back)");
+    }
+
+    {
+        succinct::bit_vector_builder bvb(v.size());
+        for (size_t i = 0; i < v.size(); ++i) {
+            bvb.set(i, v[i]);
+        }
+        bvb.push_back(0);
+        v.push_back(0);
+        bvb.push_back(1);
+        v.push_back(1);
+
+        succinct::bit_vector bitmap(&bvb);
+        test_equal_bits(v, bitmap, "Random bits (set)");
+    }
+
+    uint64_t ints[] = {uint64_t(-1), uint64_t(1) << 63, 1, 1, 1, 3, 5, 7, 0xFFF, 0xF0F, 1, 0xFFFFFF, 0x123456, uint64_t(1) << 63, uint64_t(-1)};
+    {
+        succinct::bit_vector_builder bvb;
+        BOOST_FOREACH(uint64_t i, ints) {
+            uint64_t len = succinct::broadword::msb(i) + 1;
+            bvb.append_bits(i, len);
+        }
+        succinct::bit_vector bitmap(&bvb);
+        uint64_t pos = 0;
+        BOOST_FOREACH(uint64_t i, ints) {
+            uint64_t len = succinct::broadword::msb(i) + 1;
+            BOOST_REQUIRE_EQUAL(i, bitmap.get_bits(pos, len));
+            pos += len;
+        }
+    }
+
+    {
+        using succinct::broadword::msb;
+        std::vector<size_t> positions(1);
+        BOOST_FOREACH(uint64_t i, ints) {
+            positions.push_back(positions.back() + msb(i) + 1);
+        }
+
+        succinct::bit_vector_builder bvb(positions.back());
+
+        for (size_t i = 0; i < positions.size() - 1; ++i) {
+            uint64_t v = ints[i];
+            uint64_t len = positions[i + 1] - positions[i];
+            bvb.set_bits(positions[i], v, len);
+        }
+
+        succinct::bit_vector bitmap(&bvb);
+        for (size_t i = 0; i < positions.size() - 1; ++i) {
+            uint64_t v = ints[i];
+            uint64_t len = positions[i + 1] - positions[i];
+            BOOST_REQUIRE_EQUAL(v, bitmap.get_bits(positions[i], len));
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(bit_vector_enumerator)
+{
+    srand(42);
+    std::vector<bool> v = random_bit_vector();
+    succinct::bit_vector bitmap(v);
+
+    size_t i = 0;
+    size_t pos = 0;
+
+    succinct::bit_vector::enumerator e(bitmap, pos);
+    while (pos < bitmap.size()) {
+        bool next = e.next();
+        MY_REQUIRE_EQUAL(next, v[pos], "pos = " << pos << " i = " << i);
+        pos += 1;
+
+        pos += size_t(rand()) % (bitmap.size() - pos + 1);
+        e = succinct::bit_vector::enumerator(bitmap, pos);
+        i += 1;
+    }
+}
+
+BOOST_AUTO_TEST_CASE(bit_vector_unary_enumerator)
+{
+    srand(42);
+    uint64_t n = 20000;
+    std::vector<bool> v = random_bit_vector(n);
+
+    // punch some long gaps in v
+    for (size_t g = 0; g < n / 1000; ++g) {
+        ssize_t l = std::min(ssize_t(rand() % 256), ssize_t(v.size() - g));
+        std::fill(v.begin(), v.begin() + l, 0);
+    }
+
+    succinct::bit_vector bitmap(v);
+
+    std::vector<size_t> ones;
+    for (size_t i = 0; i < v.size(); ++i) {
+        if (bitmap[i]) {
+            ones.push_back(i);
+        }
+    }
+
+    {
+        succinct::bit_vector::unary_enumerator e(bitmap, 0);
+
+        for (size_t r = 0; r < ones.size(); ++r) {
+            uint64_t pos = e.next();
+            MY_REQUIRE_EQUAL(ones[r], pos,
+                             "r = " << r);
+        }
+    }
+
+    {
+        succinct::bit_vector::unary_enumerator e(bitmap, 0);
+
+        for (size_t r = 0; r < ones.size(); ++r) {
+            for (size_t k = 0; k < std::min(size_t(256), size_t(ones.size() - r)); ++k) {
+                succinct::bit_vector::unary_enumerator ee(e);
+                ee.skip(k);
+                uint64_t pos = ee.next();
+                MY_REQUIRE_EQUAL(ones[r + k], pos,
+                                 "r = " << r << " k = " << k);
+            }
+            e.next();
+        }
+    }
+
+    {
+        succinct::bit_vector::unary_enumerator e(bitmap, 0);
+
+        for (size_t pos = 0; pos < v.size(); ++pos) {
+            uint64_t skip = 0;
+            for (size_t d = 0; d < std::min(size_t(256), size_t(v.size() - pos)); ++d) {
+                if (v[pos + d] == 0) {
+                    succinct::bit_vector::unary_enumerator ee(bitmap, pos);
+                    ee.skip0(skip);
+
+                    uint64_t expected_pos = pos + d;
+                    for (; !v[expected_pos] && expected_pos < v.size(); ++expected_pos);
+                    if (!v[expected_pos]) break;
+                    uint64_t pos = ee.next();
+                    MY_REQUIRE_EQUAL(expected_pos, pos,
+                                     "pos = " << pos << " skip = " << skip);
+
+                    skip += 1;
+                }
+            }
+        }
+    }
+}
+
+void test_bvb_reverse(size_t n)
+{
+    std::vector<bool> v = random_bit_vector(n);
+    succinct::bit_vector_builder bvb;
+    for (size_t i = 0; i < v.size(); ++i) {
+        bvb.push_back(v[i]);
+    }
+
+    std::reverse(v.begin(), v.end());
+    bvb.reverse();
+
+    succinct::bit_vector bitmap(&bvb);
+    test_equal_bits(v, bitmap, "In-place reverse");
+}
+
+BOOST_AUTO_TEST_CASE(bvb_reverse)
+{
+    srand(42);
+
+    test_bvb_reverse(0);
+    test_bvb_reverse(63);
+    test_bvb_reverse(64);
+    test_bvb_reverse(1000);
+    test_bvb_reverse(1024);
+}