Remove bitpack, add util functions on bit_array instead

Author: adamant-pwn

cp-algo/min/structures/bitpack.hpp

@@ -1,14 +1,17 @@
 #ifndef CP_ALGO_STRUCTURES_BIT_ARRAY_HPP
 #define CP_ALGO_STRUCTURES_BIT_ARRAY_HPP
 #include "../util/bit.hpp"
+#include "../util/big_alloc.hpp"
 #include <cassert>
+CP_ALGO_BIT_PRAGMA_PUSH
 namespace cp_algo::structures {
     template<typename C>
     concept Resizable = requires(C& c, std::size_t n) { c.resize(n); };
 
     template<class Cont>
     struct _bit_array {
-        static constexpr size_t width = bit_width<uint64_t>;
+        using word_t = typename Cont::value_type;
+        static constexpr size_t width = bit_width<word_t>;
         size_t words, n;
         alignas(32) Cont data;
 
@@ -22,18 +25,24 @@ namespace cp_algo::structures {
             }
         }
 
-        constexpr _bit_array(): n(0), words(0), data() {}
+        constexpr _bit_array(): data() {
+            if constexpr (!Resizable<Cont>) {
+                resize(std::size(data) * width);
+            } else {
+                resize(0);
+            }
+        }
         constexpr _bit_array(size_t N): data() {
             resize(N);
         }
 
-        constexpr uint64_t& word(size_t x) {
+        constexpr word_t& word(size_t x) {
             return data[x];
         }
-        constexpr uint64_t word(size_t x) const {
+        constexpr word_t word(size_t x) const {
             return data[x];
         }
-        constexpr void set_all(uint64_t val = -1) {
+        constexpr void set_all(word_t val = -1) {
             for(auto& w: data) {w = val;}
         }
         constexpr void reset() {
@@ -57,21 +66,26 @@ namespace cp_algo::structures {
         constexpr size_t size() const {
             return n;
         }
-    };
-
-    template<size_t N>
-    struct bit_array: _bit_array<std::array<uint64_t, (N + 63) / 64>> {
-        using Base = _bit_array<std::array<uint64_t, (N + 63) / 64>>;
-        using Base::Base, Base::words, Base::data;
-        constexpr bit_array(): Base(N) {}
-    };
-    struct dynamic_bit_array: _bit_array<std::vector<uint64_t>> {
-        using Base = _bit_array<std::vector<uint64_t>>;
-        using Base::Base, Base::words;
-        constexpr dynamic_bit_array(size_t N): Base(N) {
-            data.resize(words);
+        
+        auto operator <=> (_bit_array const& t) const = default;
+        
+        constexpr _bit_array& xor_hint(_bit_array const& t, size_t hint) {
+            for(size_t i = hint / width; i < std::size(data); i++) {
+                data[i] ^= t.data[i];
+            }
+            return *this;
+        }
+        constexpr _bit_array& operator ^= (_bit_array const& t) {
+            return xor_hint(t, 0);
+        }
+        constexpr _bit_array operator ^ (_bit_array const& t) const {
+            return _bit_array(*this) ^= t;
         }
     };
 
+    template<size_t N>
+    using bit_array = _bit_array<std::array<uint64_t, (N + 63) / 64>>;
+    using dynamic_bit_array = _bit_array<big_vector<uint64_t>>;
 }
+#pragma GCC pop_options
 #endif // CP_ALGO_STRUCTURES_BIT_ARRAY_HPP

cp-algo/structures/bit_array.hpp

@@ -0,0 +1,69 @@
+#ifndef CP_ALGO_STRUCTURES_BIT_ARRAY_UTIL_HPP
+#define CP_ALGO_STRUCTURES_BIT_ARRAY_UTIL_HPP
+#include "../structures/bit_array.hpp"
+#include "../util/bit.hpp"
+#include <cstdint>
+#include <cstddef>
+#include <string>
+#include <array>
+#include <span>
+CP_ALGO_BIT_PRAGMA_PUSH
+namespace cp_algo::structures {
+    template<typename BitArray>
+    constexpr void from_string(BitArray& arr, std::span<char> bits) {
+        arr.resize(std::size(bits));
+        int64_t i = 0;
+        constexpr int width = BitArray::width;
+        for(; i + width <= (int64_t)std::size(bits); i += width) {
+            arr.word(i / width) = read_bits64(bits.data() + i);
+        }
+        for(; i < (int64_t)std::size(bits); i++) {
+            if(bits[i] & 1) {
+                arr.set(i);
+            }
+        }
+    }
+
+    template<typename BitArray>
+    constexpr big_string to_string(BitArray const& arr) {
+        big_string res(arr.words * BitArray::width, '0');
+        for(size_t i = 0; i < arr.words; i++) {
+            write_bits64(res.data() + i * BitArray::width, arr.word(i));
+        }
+        res.resize(arr.n);
+        return res;
+    }
+
+    template<typename BitArray>
+    constexpr size_t count(BitArray const& arr, size_t n) {
+        size_t res = 0;
+        for(size_t i = 0; i < n / BitArray::width; i++) {
+            res += std::popcount(arr.word(i));
+        }
+        if (n % BitArray::width) {
+            res += std::popcount(arr.word(n / BitArray::width) & mask(n % BitArray::width));
+        }
+        return res;
+    }
+    
+    template<typename BitArray>
+    constexpr size_t count(BitArray const& arr) {
+        return count(arr, arr.n);
+    }
+    
+    template<typename BitArray>
+    constexpr size_t ctz(BitArray const& arr) {
+        size_t res = 0;
+        size_t i = 0;
+        while(i < arr.words && arr.word(i) == 0) {
+            res += BitArray::width;
+            i++;
+        }
+        if(i < arr.words) {
+            res += std::countr_zero(arr.word(i));
+        }
+        return std::min(res, arr.n);
+    }
+}
+#pragma GCC pop_options
+#endif // CP_ALGO_STRUCTURES_BIT_ARRAY_UTIL_HPP

cp-algo/structures/bit_array_util.hpp

@@ -2,9 +2,21 @@
 #define CP_ALGO_UTIL_BIT_HPP
 #include "../util/simd.hpp"
 #include <cstdint>
+#include <cstddef>
 #include <array>
 #include <bit>
-CP_ALGO_SIMD_PRAGMA_PUSH
+
+#if defined(__x86_64__) && !defined(CP_ALGO_DISABLE_AVX2)
+#define CP_ALGO_BIT_OPS_TARGET _Pragma("GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")")
+#else
+#define CP_ALGO_BIT_OPS_TARGET _Pragma("GCC target(\"bmi,bmi2,lzcnt,popcnt\")")
+#endif
+
+#define CP_ALGO_BIT_PRAGMA_PUSH \
+    _Pragma("GCC push_options") \
+    CP_ALGO_BIT_OPS_TARGET
+
+CP_ALGO_BIT_PRAGMA_PUSH
 namespace cp_algo {
     template<typename Uint>
     constexpr size_t bit_width = sizeof(Uint) * 8;
@@ -16,7 +28,7 @@ namespace cp_algo {
     size_t order_of_bit(auto x, size_t k) {
         return k ? std::popcount(x << (bit_width<decltype(x)> - k)) : 0;
     }
-    [[gnu::target("bmi2")]] inline size_t kth_set_bit(uint64_t x, size_t k) {
+    inline size_t kth_set_bit(uint64_t x, size_t k) {
         return std::countr_zero(_pdep_u64(1ULL << k, x));
     }
     template<int fl = 0>

cp-algo/structures/bitpack.hpp

@@ -4,6 +4,7 @@
 #include <cstdint>
 #include <cstddef>
 #include <memory>
+
 #if defined(__x86_64__) && !defined(CP_ALGO_DISABLE_AVX2)
 #define CP_ALGO_SIMD_AVX2_TARGET _Pragma("GCC target(\"avx2\")")
 #else
@@ -13,6 +14,7 @@
 #define CP_ALGO_SIMD_PRAGMA_PUSH \
     _Pragma("GCC push_options") \
     CP_ALGO_SIMD_AVX2_TARGET
+
 CP_ALGO_SIMD_PRAGMA_PUSH
 namespace cp_algo {
     template<typename T, size_t len>

cp-algo/util/bit.hpp

@@ -2,14 +2,14 @@
 // @brief Determinant of Matrix (Mod 2)
 #define PROBLEM "https://judge.yosupo.jp/problem/matrix_det_mod_2"
 #pragma GCC optimize("O3,unroll-loops")
-#include "cp-algo/structures/bitpack.hpp"
+#include "cp-algo/structures/bit_array_util.hpp"
 #include <bits/stdc++.h>
 
 using namespace std;
-using cp_algo::structures::bitpack;
+using cp_algo::structures::bit_array;
 
 const int maxn = 1 << 12;
-bitpack<maxn> a[maxn];
+bit_array<maxn> a[maxn];
 
 void solve() {
     size_t n;
@@ -18,13 +18,13 @@ void solve() {
     vector<size_t> lead(n);
     for(size_t i = 0; i < n; i++) {
         cin >> row;
-        a[i] = row;
+        from_string(a[i], row);
         for(size_t j = 0; j < i; j++) {
             if(a[i][lead[j]]) {
                 a[i].xor_hint(a[j], lead[j]);
             }
         }
-        lead[i] = a[i].ctz();
+        lead[i] = ctz(a[i]);
         if(lead[i] == n) {
             cout << 0 << "\n";
             return;

cp-algo/util/simd.hpp

@@ -1,14 +1,14 @@
 // @brief Inverse Matrix (Mod 2)
 #define PROBLEM "https://judge.yosupo.jp/problem/inverse_matrix_mod_2"
 #pragma GCC optimize("O3,unroll-loops")
-#include "cp-algo/structures/bitpack.hpp"
+#include "cp-algo/structures/bit_array_util.hpp"
 #include <bits/stdc++.h>
 
 using namespace std;
 using namespace cp_algo::structures;
 
 const int maxn = 1 << 12;
-bitpack<2 * maxn> a[maxn];
+bit_array<2 * maxn> a[maxn];
 
 void solve() {
     size_t n;
@@ -17,15 +17,15 @@ void solve() {
     vector<size_t> lead(n);
     for(size_t i = 0; i < n; i++) {
         cin >> row;
-        a[i] = row;
+        from_string(a[i], row);
         a[i].resize(2 * n);
         a[i].set(n + i);
         for(size_t j = 0; j < i; j++) {
             if(a[i][lead[j]]) {
                 a[i].xor_hint(a[j], lead[j]);
             }
         }
-        lead[i] = a[i].ctz();
+        lead[i] = ctz(a[i]);
         if(lead[i] >= n) {
             cout << -1 << "\n";
             return;
@@ -41,7 +41,7 @@ void solve() {
             swap(a[i], a[lead[i]]);
             swap(lead[i], lead[lead[i]]);
         }
-        cout << a[i].to_string().substr(n, n) << "\n";
+        cout << to_string(a[i]).substr(n, n) << "\n";
     }
 }