some more methods to bit_vector and compact_vector

Author: jermp

include/bit_vector.hpp

@@ -143,6 +143,8 @@ struct bit_vector  //
         }
 
         uint64_t num_bits() const { return m_num_bits; }
+
+        std::vector<uint64_t>& data() { return m_data; }
         std::vector<uint64_t> const& data() const { return m_data; }
 
     private:
@@ -192,12 +194,25 @@ struct bit_vector  //
     struct iterator {
         iterator() : m_data(nullptr), m_num_64bit_words(0), m_pos(0), m_buf(0), m_avail(0) {}
 
+        iterator(uint64_t const* data, uint64_t num_64bit_words, uint64_t pos = 0)
+            : m_data(data)                        //
+            , m_num_64bit_words(num_64bit_words)  //
+            , m_pos(pos)                          //
+        {
+            skip_to(m_pos);
+        }
+
         iterator(bit_vector const* bv, uint64_t pos = 0)
             : m_data((bv->data()).data())             //
             , m_num_64bit_words((bv->data()).size())  //
             , m_pos(pos)                              //
         {
-            assert(m_pos < bv->num_bits());
+            skip_to(m_pos);
+        }
+
+        void skip_to(uint64_t pos) {
+            assert(pos < 64 * m_num_64bit_words);
+            m_pos = pos;
             fill_buf();
         }
 

include/compact_vector.hpp

@@ -86,7 +86,7 @@ struct compact_vector  //
     struct builder {
         builder() : m_size(0), m_width(0), m_mask(0), m_back(0), m_cur_block(0), m_cur_shift(0) {}
 
-        builder(uint64_t n, uint64_t w) { resize(n, w); }
+        builder(uint64_t n, uint64_t w) : builder() { resize(n, w); }
 
         /*
             Resize the container to hold n values, each of width w.
@@ -96,6 +96,8 @@ struct compact_vector  //
             m_width = w;
             m_mask = -(w == 64) | ((uint64_t(1) << w) - 1);
             m_back = 0;
+            m_cur_block = 0;
+            m_cur_shift = 0;
             m_data.resize(
                 /* use 1 word more for safe access() */
                 essentials::words_for(m_size * m_width) + 1, 0);
@@ -109,7 +111,9 @@ struct compact_vector  //
         template <typename Iterator>
         void fill(Iterator begin, uint64_t n) {
             if (m_width == 0) throw std::runtime_error("width must be > 0");
-            for (uint64_t i = 0; i != n; ++i, ++begin) set(i, *begin);
+            for (uint64_t i = 0; i != n; ++i, ++begin) {
+                set(i, *begin);  // can just do push_back(*begin);
+            }
         }
 
         /*
@@ -134,6 +138,28 @@ struct compact_vector  //
             }
         }
 
+        void push_back(uint64_t v) {
+            assert(m_width != 0);
+            m_back = v;
+            m_data[m_cur_block] &= ~(m_mask << m_cur_shift);
+            m_data[m_cur_block] |= v << m_cur_shift;
+
+            uint64_t res_shift = 64 - m_cur_shift;
+            if (res_shift < m_width) {
+                ++m_cur_block;
+                m_data[m_cur_block] &= ~(m_mask >> res_shift);
+                m_data[m_cur_block] |= v >> res_shift;
+                m_cur_shift = -res_shift;
+            }
+
+            m_cur_shift += m_width;
+
+            if (m_cur_shift == 64) {
+                m_cur_shift = 0;
+                ++m_cur_block;
+            }
+        }
+
         void reduce_width_by(uint64_t n) {
             assert(m_width > n);
 

test/test_bit_vector.cpp

@@ -52,6 +52,35 @@ TEST_CASE("bit_vector::iterator::operator*") {
     std::cout << "EVERYTHING OK!" << std::endl;
 }
 
+TEST_CASE("bit_vector::iterator::skip_to") {
+    const uint64_t max_int = test::get_random_uint();
+    std::cout << "max_int = " << max_int << std::endl;
+    constexpr bool all_distinct = true;
+    std::vector<uint64_t> seq = test::get_sorted_sequence(sequence_length, max_int, all_distinct);
+    const uint64_t num_bits = seq.back();
+    bit_vector::builder bv_builder(num_bits + 1);
+    std::vector<bool> vec_bools(num_bits + 1, false);
+    for (auto pos : seq) {
+        bv_builder.set(pos);
+        vec_bools[pos] = true;
+    }
+    bit_vector bv;
+    bv_builder.build(bv);
+    std::cout << "checking correctness of bit_vector::iterator::skip_to..." << std::endl;
+    bit_vector::iterator it = bv.begin();
+
+    srand(essentials::get_random_seed());
+    for (int i = 0; i != 5; ++i) {
+        uint64_t pos = rand() % num_bits;
+        it.skip_to(pos);
+        for (uint64_t j = pos; j != num_bits; ++j, ++it) {
+            REQUIRE_MESSAGE(*it == vec_bools[j], "required " << vec_bools[j] << " but got " << *it);
+        }
+    }
+
+    std::cout << "EVERYTHING OK!" << std::endl;
+}
+
 TEST_CASE("bit_vector::iterator::take") {
     const uint64_t max_int = test::get_random_uint();
     std::cout << "max_int = " << max_int << std::endl;