Improve dft

Author: adamant-pwn

cp-algo/math/fft.hpp

@@ -212,7 +212,7 @@ namespace cp_algo::math::fft {
             }
         }
 
-        void mul(auto &&C, auto &&D, auto &res, size_t k) {
+        void mul(auto &&C, auto const& D, auto &res, size_t k) {
             assert(A.size() == C.size());
             size_t n = A.size();
             if(!n) {
@@ -247,17 +247,24 @@ namespace cp_algo::math::fft {
                 res[n + i] = B0 + B1 * split + B2 * splitsplit;
             });
         }
-        void mul(auto &&B, auto& res, size_t k) {
+        void mul_inplace(auto &B, auto& res, size_t k) {
             mul(B.A, B.B, res, k);
         }
-        std::vector<base> operator *= (auto &&B) {
+        void mul(auto const& B, auto& res, size_t k) {
+            mul(cvector(B.A), B.B, res, k);
+        }
+        std::vector<base> operator *= (dft &B) {
             std::vector<base> res(2 * A.size());
-            mul(B.A, B.B, res, size(res));
+            mul_inplace(B, res, size(res));
+            return res;
+        }
+        std::vector<base> operator *= (dft const& B) {
+            std::vector<base> res(2 * A.size());
+            mul(B, res, size(res));
             return res;
         }
-
         auto operator * (dft const& B) const {
-            return dft(*this) *= dft(B);
+            return dft(*this) *= B;
         }
 
         point operator [](int i) const {return A.get(i);}
@@ -296,9 +303,9 @@ namespace cp_algo::math::fft {
         a.resize(k);
         auto A = dft<base>(a, n);
         if(&a == &b) {
-            A.mul(dft<base>(A), a, k);
+            A.mul(A, a, k);
         } else {
-            A.mul(dft<base>(std::views::take(b, k), n), a, k);
+            A.mul_inplace(dft<base>(std::views::take(b, k), n), a, k);
         }
     }
     void mul(auto &a, auto const& b) {

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

@@ -89,8 +89,8 @@ namespace cp_algo::math::poly::impl {
         auto qqf = fft::dft<base>(qq.a, N);
         int M = q0.deg() + (n + 1) / 2;
         std::deque<base> A(M), B(M);
-        q0f.mul(fft::dft<base>(qqf), A, M);
-        q1f.mul(qqf, B, M);
+        q0f.mul(qqf, A, M);
+        q1f.mul_inplace(qqf, B, M);
         q.a.resize(n + 1);
         for(size_t i = 0; i < n; i += 2) {
             q.a[i] = A[q0.deg() + i / 2];
@@ -122,8 +122,8 @@ namespace cp_algo::math::poly::impl {
         auto qqf = fft::dft<base>(qq.a, N);
 
         std::deque<base> A((n + 1) / 2), B((n + 1) / 2);
-        q0f.mul(fft::dft<base>(qqf), A, (n + 1) / 2);
-        q1f.mul(qqf, B, (n + 1) / 2);
+        q0f.mul(qqf, A, (n + 1) / 2);
+        q1f.mul_inplace(qqf, B, (n + 1) / 2);
         p.a.resize(n + 1);
         for(size_t i = 0; i < n; i += 2) {
             p.a[i] = A[i / 2];