fixes

Author: adamant-pwn

cp-algo/math/cvector.hpp

@@ -15,7 +15,9 @@ namespace cp_algo::math::fft {
     using vftype [[gnu::vector_size(bytes)]] = ftype;
     using vpoint = complex<vftype>;
     static constexpr vftype vz = {};
-    static constexpr vpoint vi = {vz, vz + 1};
+    vpoint vi(vpoint const& r) {
+        return {-imag(r), real(r)};
+    }
     vftype abs(vftype a) {
         return a < 0 ? -a : a;
     }
@@ -132,8 +134,8 @@ namespace cp_algo::math::fft {
                             auto D = at(j + 3 * i);
                             at(j) = (A + B + C + D);
                             at(j + 2 * i) = (A + B - C - D) * v2;
-                            at(j +     i) = (A - B - vi * (C - D)) * v1;
-                            at(j + 3 * i) = (A - B + vi * (C - D)) * v3;
+                            at(j +     i) = (A - B - vi(C - D)) * v1;
+                            at(j + 3 * i) = (A - B + vi(C - D)) * v3;
                         }
                     });
                     i *= 2;
@@ -171,8 +173,8 @@ namespace cp_algo::math::fft {
                             auto D = at(j + 3 * i) * v3;
                             at(j)         = (A + C) + (B + D);
                             at(j + i)     = (A + C) - (B + D);
-                            at(j + 2 * i) = (A - C) + vi * (B - D);
-                            at(j + 3 * i) = (A - C) - vi * (B - D);
+                            at(j + 2 * i) = (A - C) + vi(B - D);
+                            at(j + 3 * i) = (A - C) - vi(B - D);
                         }
                     });
                 } else { // radix-2 fallback

cp-algo/math/fft.hpp

@@ -82,7 +82,7 @@ namespace cp_algo::math::fft {
         }
 
         void recover_mod(auto &&C, auto &res, size_t k) {
-            assert(size(res) % flen == 0);
+            res.assign((k / flen + 1) * flen, base(0));
             size_t n = A.size();
             auto splitsplit = base(split * split).getr();
             base b2x32 = bpow(base(2), 32);
@@ -106,7 +106,7 @@ namespace cp_algo::math::fft {
                     Au = montgomery_mul(Au, mul, mod, imod);
                     Au = Au >= base::mod() ? Au - base::mod() : Au;
                     for(size_t j = 0; j < flen; j++) {
-                        res[i + j].setr(Au[j]);
+                        res[i + j].setr(typename base::UInt(Au[j]));
                     }
                 };
                 set_i(i, Ax, Bx, Cx, cur);
@@ -115,6 +115,7 @@ namespace cp_algo::math::fft {
                 }
                 cur = montgomery_mul(cur, step4, mod, imod);
             }
+            res.resize(k);
             checkpoint("recover mod");
         }
 
@@ -138,13 +139,13 @@ namespace cp_algo::math::fft {
             mul(cvector(B.A), B.B, res, k);
         }
         std::vector<base, big_alloc<base>> operator *= (dft &B) {
-            std::vector<base, big_alloc<base>> res(2 * A.size());
-            mul_inplace(B, res, size(res));
+            std::vector<base, big_alloc<base>> res;
+            mul_inplace(B, res, 2 * A.size());
             return res;
         }
         std::vector<base, big_alloc<base>> operator *= (dft const& B) {
-            std::vector<base, big_alloc<base>> res(2 * A.size());
-            mul(B, res, size(res));
+            std::vector<base, big_alloc<base>> res;
+            mul(B, res, 2 * A.size());
             return res;
         }
         auto operator * (dft const& B) const {
@@ -191,13 +192,11 @@ namespace cp_algo::math::fft {
             std::min(k, size(a)) + std::min(k, size(b)) - 1
         ) / 2);
         auto A = dft<base>(a | std::views::take(k), n);
-        a.assign((k / flen + 1) * flen, 0);
         if(&a == &b) {
             A.mul(A, a, k);
         } else {
             A.mul_inplace(dft<base>(b | std::views::take(k), n), a, k);
         }
-        a.resize(k);
     }
     void mul(auto &a, auto const& b) {
         size_t N = size(a) + size(b) - 1;

cp-algo/math/poly/impl/div.hpp

@@ -87,7 +87,7 @@ namespace cp_algo::math::poly::impl {
         auto q1f = fft::dft<base>(q1.a, N);
         auto qqf = fft::dft<base>(qq.a, N);
         size_t M = q0.deg() + (n + 1) / 2;
-        typename poly::Vector A(M), B(M);
+        typename poly::Vector A, B;
         q0f.mul(qqf, A, M);
         q1f.mul_inplace(qqf, B, M);
         q.a.resize(n + 1);
@@ -120,7 +120,7 @@ namespace cp_algo::math::poly::impl {
         inv_inplace(qq, (n + 1) / 2);
         auto qqf = fft::dft<base>(qq.a, N);
 
-        typename poly::Vector A((n + 1) / 2), B((n + 1) / 2);
+        typename poly::Vector A, B;
         q0f.mul(qqf, A, (n + 1) / 2);
         q1f.mul_inplace(qqf, B, (n + 1) / 2);
         p.a.resize(n + 1);