Fixes + reduce std::vector usage for better target("avx2") support

Author: adamant-pwn

cp-algo/geometry/closest_pair.hpp

@@ -1,14 +1,14 @@
 #ifndef CP_ALGO_GEOMETRY_CLOSEST_PAIR_HPP
 #define CP_ALGO_GEOMETRY_CLOSEST_PAIR_HPP
 #include "../random/rng.hpp"
+#include "../util/big_alloc.hpp"
 #include "point.hpp"
 #include <vector>
 #include <map>
 namespace cp_algo::geometry {
     // Rabin & Lipton
-    template<typename ftype>
-    auto closest_pair(std::vector<point_t<ftype>> const& r) {
-        using point = point_t<ftype>;
+    auto closest_pair(auto const& r) {
+        using point = std::decay_t<decltype(r[0])>;
         size_t n = size(r);
         int64_t md = 1e18;
         for(size_t i = 0; i < n / 100; i++) {
@@ -21,7 +21,7 @@ namespace cp_algo::geometry {
                 }
             }
         }
-        std::map<point, std::vector<size_t>> neigs;
+        std::map<point, big_vector<size_t>> neigs;
         md = (int64_t)ceil(sqrt((double)md));
         for(size_t i = 0; i < n; i++) {
             neigs[r[i] / md].push_back(i);

cp-algo/geometry/convex_hull.hpp

@@ -1,19 +1,19 @@
 #ifndef CP_ALGO_GEOMETRY_CONVEX_HULL_HPP
 #define CP_ALGO_GEOMETRY_CONVEX_HULL_HPP
 #include "point.hpp"
+#include "../util/big_alloc.hpp"
 #include <algorithm>
 #include <utility>
 #include <vector>
 #include <ranges>
 namespace cp_algo::geometry {
-    template<typename ftype>
-    std::vector<point_t<ftype>> convex_hull(std::vector<point_t<ftype>> r) {
-        using point = point_t<ftype>;
+    auto convex_hull(auto r) {
+        using point = std::decay_t<decltype(r[0])>;
         std::ranges::sort(r);
         if(size(r) <= 1 || r[0] == r.back()) {
-            return empty(r) ? r : std::vector{r[0]};
+            return empty(r) ? big_vector<point>{} : big_vector{r[0]};
         }
-        std::vector<point> hull = {r[0]};
+        big_vector<point> hull = {r[0]};
         for(int half: {0, 1}) {
             size_t base = size(hull);
             for(auto it: std::views::drop(r, 1)) {

cp-algo/graph/euler.hpp

@@ -1,6 +1,7 @@
 #ifndef CP_ALGO_GRAPH_EULER_HPP
 #define CP_ALGO_GRAPH_EULER_HPP
 #include "base.hpp"
+#include "../util/big_alloc.hpp"
 #include <algorithm>
 #include <iostream>
 #include <optional>
@@ -10,7 +11,7 @@
 namespace cp_algo::graph {
     template<graph_type graph>
     std::optional<node_index> euler_start(graph const& g) {
-        std::vector<int> deg(g.n());
+        big_vector<int> deg(g.n());
         std::optional<node_index> default_start = 0;
         for(auto v: g.nodes()) {
             for(auto e: g.outgoing(v)) {
@@ -47,7 +48,7 @@ namespace cp_algo::graph {
     std::deque<edge_index> try_euler_trail(graph const& g, node_index v0) {
         std::deque<edge_index> trail;
         enum state { unvisited, visited };
-        std::vector<state> state(g.m());
+        big_vector<state> state(g.m());
         auto const& adj = g.incidence_lists();
         auto head = adj.head;
 

cp-algo/graph/mst.hpp

@@ -6,12 +6,12 @@
 #include <algorithm>
 namespace cp_algo::graph {
     template<weighted_undirected_graph_type graph>
-    std::pair<int64_t, std::vector<edge_index>> mst(graph const& g) {
+    std::pair<int64_t, big_vector<edge_index>> mst(graph const& g) {
         struct edge {
             edge_index idx;
             node_index v;
         };
-        std::vector<edge> edges;
+        big_vector<edge> edges;
         for(auto v: g.nodes()) {
             for(auto e: g.outgoing(v)) {
                 if (v < g.edge(e).traverse(v)) {
@@ -24,7 +24,7 @@ namespace cp_algo::graph {
         });
         structures::dsu me(g.n());
         int64_t total = 0;
-        std::vector<edge_index> mst;
+        big_vector<edge_index> mst;
         for(auto [idx, v]: edges) {
             if(me.uni(v, g.edge(idx).traverse(v))) {
                 total += g.edge(idx).w;

cp-algo/graph/shortest_path.hpp

@@ -5,8 +5,8 @@
 #include <queue>
 namespace cp_algo::graph {
     struct shortest_path_context {
-        std::vector<int64_t> dist;
-        std::vector<edge_index> pre;
+        big_vector<int64_t> dist;
+        big_vector<edge_index> pre;
         static constexpr int64_t inf = 1e18;
         shortest_path_context(int n)
             : dist(n, inf), pre(n) {}
@@ -42,7 +42,7 @@ namespace cp_algo::graph {
 
     struct spfa_context: shortest_path_context {
         std::queue<node_index> que;
-        std::vector<char> flags;
+        big_vector<char> flags;
         static constexpr char in_queue = 1;
         static constexpr char invalidated = 2;
 
@@ -73,7 +73,7 @@ namespace cp_algo::graph {
             edge_index e;
             node_index v;
         };
-        std::vector<std::basic_string<traverse_edge>> dependents;
+        big_vector<std::basic_string<traverse_edge>> dependents;
 
         deep_spfa_context(int n) : spfa_context(n), dependents(n) {}
 
@@ -85,7 +85,7 @@ namespace cp_algo::graph {
         }
 
         void invalidate_subtree(node_index v) {
-            std::vector<node_index> to_invalidate = {v};
+            big_vector<node_index> to_invalidate = {v};
             while (!empty(to_invalidate)) {
                 node_index u = to_invalidate.back();
                 to_invalidate.pop_back();
@@ -144,8 +144,8 @@ namespace cp_algo::graph {
         return negative_edges ? deep_spfa(g, s) : dijkstra(g, s);
     }
 
-    std::vector<edge_index> recover_path(auto const& g, auto const& pre, node_index s, node_index t) {
-        std::vector<edge_index> path;
+    big_vector<edge_index> recover_path(auto const& g, auto const& pre, node_index s, node_index t) {
+        big_vector<edge_index> path;
         node_index v = t;
         while(v != s) {
             path.push_back(pre[v]);
@@ -156,7 +156,7 @@ namespace cp_algo::graph {
     }
 
     template<weighted_graph_type graph>
-    std::optional<std::pair<int64_t, std::vector<edge_index>>> shortest_path(graph const& g, node_index s, node_index t) {
+    std::optional<std::pair<int64_t, big_vector<edge_index>>> shortest_path(graph const& g, node_index s, node_index t) {
         auto [dist, pre] = single_source_shortest_path(g, s);
         if (dist[t] == shortest_path_context::inf) {
             return std::nullopt;

cp-algo/linalg/frobenius.hpp

@@ -16,8 +16,8 @@ namespace cp_algo::linalg {
         using polyn = math::poly_t<base>;
         assert(A.n() == A.m());
         size_t n = A.n();
-        std::vector<polyn> charps;
-        std::vector<vec_t> basis, basis_init;
+        big_vector<polyn> charps;
+        big_vector<vec_t> basis, basis_init;
         while(size(basis) < n) {
             size_t start = size(basis);
             auto generate_block = [&](auto x) {
@@ -78,7 +78,7 @@ namespace cp_algo::linalg {
     template<typename base>
     auto with_frobenius(matrix<base> const& A, auto &&callback) {
         auto [T, Tinv, charps] = frobenius_form<full>(A);
-        std::vector<matrix<base>> blocks;
+        big_vector<matrix<base>> blocks;
         for(auto charp: charps) {
             matrix<base> block(charp.deg());
             auto xk = callback(charp);

cp-algo/linalg/matrix.hpp

@@ -15,10 +15,10 @@ namespace cp_algo::linalg {
         math::modint_type<base_t>,
         modint_vec<base_t>,
         vec<base_t>>>
-    struct matrix: std::vector<_vec_t> {
+    struct matrix: big_vector<_vec_t> {
         using vec_t = _vec_t;
         using base = base_t;
-        using Base = std::vector<vec_t>;
+        using Base = big_vector<vec_t>;
         using Base::Base;
 
         matrix(size_t n): Base(n, vec_t(n)) {}
@@ -90,7 +90,7 @@ namespace cp_algo::linalg {
             }
         }
 
-        static matrix block_diagonal(std::vector<matrix> const& blocks) {
+        static matrix block_diagonal(big_vector<matrix> const& blocks) {
             size_t n = 0;
             for(auto &it: blocks) {
                 assert(it.n() == it.m());
@@ -283,7 +283,7 @@ namespace cp_algo::linalg {
         // variables into pivots and free
         auto sort_classify(size_t lim) {
             size_t rk = 0;
-            std::vector<size_t> free, pivots;
+            big_vector<size_t> free, pivots;
             for(size_t j = 0; j < lim; j++) {
                 for(size_t i = rk + 1; i < n() && row(rk)[j] == base(0); i++) {
                     if(row(i)[j] != base(0)) {

cp-algo/math/combinatorics.hpp

@@ -1,14 +1,15 @@
 #ifndef CP_ALGO_MATH_COMBINATORICS_HPP
 #define CP_ALGO_MATH_COMBINATORICS_HPP
 #include "../math/common.hpp"
+#include "../util/big_alloc.hpp"
 #include <cassert>
 #include <ranges>
 namespace cp_algo::math {
     // fact/rfact/small_inv are caching
     // Beware of usage with dynamic mod
     template<typename T>
     T fact(auto n) {
-        static std::vector<T> F(maxn);
+        static big_vector<T> F(maxn);
         static bool init = false;
         if(!init) {
             F[0] = T(1);
@@ -22,7 +23,7 @@ namespace cp_algo::math {
     // Only works for modint types
     template<typename T>
     T rfact(auto n) {
-        static std::vector<T> F(maxn);
+        static big_vector<T> F(maxn);
         static bool init = false;
         if(!init) {
             int t = (int)std::min<int64_t>(T::mod(), maxn) - 1;
@@ -36,8 +37,8 @@ namespace cp_algo::math {
     }
     template<typename T, int base>
     T pow_fixed(int n) {
-        static std::vector<T> prec_low(1 << 16);
-        static std::vector<T> prec_high(1 << 16);
+        static big_vector<T> prec_low(1 << 16);
+        static big_vector<T> prec_high(1 << 16);
         static bool init = false;
         if(!init) {
             init = true;
@@ -52,8 +53,8 @@ namespace cp_algo::math {
         return prec_low[n & 0xFFFF] * prec_high[n >> 16];
     }
     template<typename T>
-    std::vector<T> bulk_invs(auto const& args) {
-        std::vector<T> res(std::size(args), args[0]);
+    big_vector<T> bulk_invs(auto const& args) {
+        big_vector<T> res(std::size(args), args[0]);
         for(size_t i = 1; i < std::size(args); i++) {
             res[i] = res[i - 1] * args[i];
         }

cp-algo/math/cvector.hpp

@@ -20,7 +20,7 @@ namespace cp_algo::math::fft {
     }
 
     struct cvector {
-        std::vector<vpoint, big_alloc<vpoint>> r;
+        big_vector<vpoint> r;
         cvector(size_t n) {
             n = std::max(flen, std::bit_ceil(n));
             r.resize(n / flen);

cp-algo/math/factorials.hpp

@@ -9,7 +9,7 @@
 
 namespace cp_algo::math {
     template<bool use_bump_alloc = false, int maxn = -1>
-    auto facts(auto const& args) {
+    [[gnu::target("avx2")]] auto facts(auto const& args) {
         static_assert(!use_bump_alloc || maxn > 0, "maxn must be set if use_bump_alloc is true");
         constexpr int max_mod = 1'000'000'000;
         constexpr int accum = 4;
@@ -27,7 +27,7 @@ namespace cp_algo::math {
         constexpr int limit_reg = max_mod / 64;
         int limit_odd = 0;
 
-        std::vector<base, big_alloc<base>> res(size(args), 1);
+        big_vector<base> res(size(args), 1);
         const int mod = base::mod();
         const int imod = -math::inv2(mod);
         for(auto [i, xy]: std::views::zip(args, res) | std::views::enumerate) {
@@ -56,13 +56,10 @@ namespace cp_algo::math {
                 static std::array<u32x8, subblock> prods[accum];
                 for(int z = 0; z < accum; z++) {
                     for(int j = 0; j < simd_size; j++) {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
                         cur[z][j] = uint32_t(b + z * block + j * subblock);
                         cur[z][j] = proj(cur[z][j]);
                         prods[z][0][j] = cur[z][j] + !cur[z][j];
                         prods[z][0][j] = uint32_t(uint64_t(prods[z][0][j]) * bi2x32.getr() % mod);
-#pragma GCC diagnostic pop
                     }
                 }
                 for(int i = 1; i < block / simd_size; i++) {