Update

Author: adamant-pwn

cp-algo/math/cvector.hpp

@@ -4,10 +4,12 @@
 #include "../util/checkpoint.hpp"
 #include <experimental/simd>
 #include <ranges>
+
+namespace stdx = std::experimental;
 namespace cp_algo::math::fft {
     using ftype = double;
     using point = complex<ftype>;
-    using vftype = std::experimental::native_simd<ftype>;
+    using vftype = stdx::native_simd<ftype>;
     using vpoint = complex<vftype>;
     static constexpr size_t flen = vftype::size();
 
@@ -57,15 +59,15 @@ namespace cp_algo::math::fft {
             auto [Ax, Ay] = A.vget(k);
             alignas(32) ftype Bx[2 * flen];
             alignas(32) ftype By[2 * flen];
-            Bvx.copy_to(Bx + flen, std::experimental::vector_aligned);
-            Bvy.copy_to(By + flen, std::experimental::vector_aligned);
-            Brvx.copy_to(Bx, std::experimental::vector_aligned);
-            Brvy.copy_to(By, std::experimental::vector_aligned);
+            Bvx.copy_to(Bx + flen, stdx::vector_aligned);
+            Bvy.copy_to(By + flen, stdx::vector_aligned);
+            Brvx.copy_to(Bx, stdx::vector_aligned);
+            Brvy.copy_to(By, stdx::vector_aligned);
             vpoint res = {0, 0};
             for(size_t i = 0; i < flen; i++) {
                 vftype Bsx, Bsy;
-                Bsx.copy_from(Bx + flen - i, std::experimental::element_aligned);
-                Bsy.copy_from(By + flen - i, std::experimental::element_aligned);
+                Bsx.copy_from(Bx + flen - i, stdx::element_aligned);
+                Bsy.copy_from(By + flen - i, stdx::element_aligned);
                 res += vpoint(Ax[i], Ay[i]) * vpoint(Bsx, Bsy);
             }
             return res;

cp-algo/math/fft.hpp

@@ -13,13 +13,17 @@ namespace cp_algo::math::fft {
 
         dft(auto const& a, size_t n): A(n), B(n) {
             split = int(std::sqrt(base::mod())) + 1;
-            cvector::exec_on_roots(2 * n, size(a), [&](size_t i, point rt) {
-                size_t ti = std::min(i, i - n);
-                auto rem = std::remainder(a[i].rem(), split);
-                auto quo = (ftype(a[i].rem()) - rem) / split;
-                A.set(ti, A.get(ti) + rem * rt);
-                B.set(ti, B.get(ti) + quo * rt);
-    
+            cvector::exec_on_roots(2 * n, std::min(n, size(a)), [&](size_t i, auto rt) {
+                auto splt = [&](size_t i) {
+                    ftype ai = i < size(a) ? a[i].rem() : 0;
+                    auto rem = std::remainder(ai, split);
+                    auto quo = (ai - rem) / split;
+                    return std::pair{rem, quo};
+                };
+                auto [rai, qai] = splt(i);
+                auto [rani, qani] = splt(n + i);
+                A.set(i, point(rai, rani) * rt);
+                B.set(i, point(qai, qani) * rt);
             });
             checkpoint("dft init");
             if(n) {
@@ -154,8 +158,9 @@ namespace cp_algo::math::fft {
         auto n = std::max(flen, std::bit_ceil(
             std::min(k, size(a)) + std::min(k, size(b)) - 1
         ) / 2);
-        a.resize(k);
         auto A = dft<base>(a, n);
+        a.resize(k);
+        checkpoint("resize a");
         if(&a == &b) {
             A.mul(A, a, k);
         } else {

cp-algo/number_theory/factorize.hpp

@@ -15,7 +15,7 @@ namespace cp_algo::math {
             base x, y;
             base g = 1;
             while(g == 1) {
-                for(int i = 1; i <= 64; i++) {
+                for(int i = 0; i < 64; i++) {
                     x = f(x);
                     y = f(f(y));
                     if(x == y) [[unlikely]] {

cp-algo/util/bump_alloc.hpp

@@ -2,7 +2,7 @@
 #define CP_ALGO_UTIL_BUMP_ALLOC_HPP
 #include <cstddef>
 namespace cp_algo {
-    alignas(32) char buf[450 << 20];
+    alignas(64) char buf[450 << 20];
     size_t buf_ind = sizeof buf;
     template<class T> struct bump_alloc {
         typedef T value_type;

verify/number_theory/factorize.test.cpp

@@ -27,4 +27,3 @@ signed main() {
         solve();
     }
 }
-