Put bit.hpp and bump_alloc.hpp in /util

Author: adamant-pwn

cp-algo/math/fft.hpp

@@ -290,10 +290,9 @@ namespace cp_algo::math::fft {
         }
         return std::max(flen, std::bit_ceil(as + bs - 1) / 2);
     }
-    static const int naive_threshold = 64;
     void mul_truncate(auto &a, auto const& b, size_t k) {
         using base = std::decay_t<decltype(a[0])>;
-        if(std::min({k, size(a), size(b)}) < naive_threshold) {
+        if(std::min({k, size(a), size(b)}) < magic) {
             mul_slow(a, b, k);
             return;
         }

cp-algo/bit.hpp renamed to cp-algo/structures/bit_array.hpp

@@ -1,23 +1,7 @@
-#ifndef CP_ALGO_BIT_HPP
-#define CP_ALGO_BIT_HPP
-#include <immintrin.h>
-#include <cstdint>
-#include <array>
-#include <bit>
-namespace cp_algo {
-    template<typename Uint>
-    constexpr size_t bit_width = sizeof(Uint) * 8;
-    template<size_t maxc, typename Uint = uint64_t>
-    using popcount_array = std::array<int, maxc / bit_width<Uint> + 1>;
-
-    size_t order_of_bit(auto x, size_t k) {
-        return k ? std::popcount(x << (bit_width<decltype(x)> - k)) : 0;
-    }
-    // Requires GCC target("popcnt,bmi2")
-    size_t kth_set_bit(uint64_t x, size_t k) {
-        return std::countr_zero(_pdep_u64(1ULL << k, x));
-    }
-
+#ifndef CP_ALGO_STRUCTURES_BIT_ARRAY_HPP
+#define CP_ALGO_STRUCTURES_BIT_ARRAY_HPP
+#include "cp-algo/util/bit.hpp"
+namespace cp_algo::structures {
     template<size_t N, typename Uint = uint64_t>
     struct bit_array {
         static constexpr size_t width = bit_width<Uint>;
@@ -41,4 +25,4 @@ namespace cp_algo {
         }
     };
 }
-#endif // CP_ALGO_BIT_HPP
+#endif // CP_ALGO_STRUCTURES_BIT_ARRAY_HPP

cp-algo/structures/bitpack.hpp

@@ -1,7 +1,7 @@
 
 #ifndef CP_ALGO_STRUCTURES_BITPACK_HPP
 #define CP_ALGO_STRUCTURES_BITPACK_HPP
-#include "cp-algo/bit.hpp"
+#include "bit_array.hpp"
 #include <cstdint>
 #include <cstddef>
 #include <string>

cp-algo/structures/eertree.hpp

@@ -5,7 +5,7 @@
 #include <iostream>
 #include <vector>
 #include <string>
-#include "../bump_alloc.hpp"
+#include "../util/bump_alloc.hpp"
 namespace cp_algo::structures {
     template<int sigma = 26, char mch = 'a'>
     struct eertree {

cp-algo/structures/fenwick_set.hpp

@@ -1,8 +1,10 @@
 #ifndef CP_ALGO_STRUCTURES_FENWICK_SET_HPP
 #define CP_ALGO_STRUCTURES_FENWICK_SET_HPP
 #include "fenwick.hpp"
-#include "cp-algo/bit.hpp"
+#include "bit_array.hpp"
 namespace cp_algo::structures {
+    template<size_t maxc, typename Uint = uint64_t>
+    using popcount_array = std::array<int, maxc / bit_width<Uint> + 1>;
     // fenwick-based set for [0, maxc)
     template<size_t maxc, typename Uint = uint64_t>
     struct fenwick_set: fenwick<int, popcount_array<maxc, Uint>> {
@@ -24,15 +26,15 @@ namespace cp_algo::structures {
         }
         void insert(size_t x) {
             if(bits.test(x)) return;
+            Base::add(x / word, 1);
             bits.flip(x);
             sz++;
-            Base::add(x / word, 1);
         }
         void erase(size_t x) {
             if(!bits.test(x)) return;
+            Base::add(x / word, -1);
             bits.flip(x);
             sz--;
-            Base::add(x / word, -1);
         }
         size_t order_of_key(size_t x) const {
             return Base::prefix_sum(x / word) + order_of_bit(bits.word(x / word), x % word);

cp-algo/util/bit.hpp

@@ -0,0 +1,19 @@
+#ifndef CP_ALGO_UTIL_BIT_HPP
+#define CP_ALGO_UTIL_BIT_HPP
+#include <immintrin.h>
+#include <cstdint>
+#include <array>
+#include <bit>
+namespace cp_algo {
+    template<typename Uint>
+    constexpr size_t bit_width = sizeof(Uint) * 8;
+
+    size_t order_of_bit(auto x, size_t k) {
+        return k ? std::popcount(x << (bit_width<decltype(x)> - k)) : 0;
+    }
+    // Requires GCC target("popcnt,bmi2")
+    size_t kth_set_bit(uint64_t x, size_t k) {
+        return std::countr_zero(_pdep_u64(1ULL << k, x));
+    }
+}
+#endif // CP_ALGO_UTIL_BIT_HPP

cp-algo/bump_alloc.hpp renamed to cp-algo/util/bump_alloc.hpp

@@ -1,5 +1,5 @@
-#ifndef CP_ALGO_BUMP_ALLOC_HPP
-#define CP_ALGO_BUMP_ALLOC_HPP
+#ifndef CP_ALGO_UTIL_BUMP_ALLOC_HPP
+#define CP_ALGO_UTIL_BUMP_ALLOC_HPP
 #include <cstddef>
 namespace cp_algo {
     char buf[450 << 20] alignas(32);
@@ -16,4 +16,4 @@ namespace cp_algo {
         void deallocate(T*, size_t) {}
     };
 }
-#endif // CP_ALGO_BUMP_ALLOC_HPP
+#endif // CP_ALGO_UTIL_BUMP_ALLOC_HPP