Improve fft-mod init

Author: adamant-pwn

cp-algo/math/fft.hpp

@@ -25,8 +25,8 @@ namespace cp_algo::math::fft {
             base step = bpow(factor, n);
             cvector::exec_on_roots(2 * n, std::min(n, size(a)), [&](size_t i, auto rt) {
                 auto splt = [&](size_t i, auto mul) {
-                    auto ai = ftype(i < size(a) ? (a[i] * mul).rem() : 0);
-                    auto rem = std::remainder(ai, split);
+                    auto ai = i < size(a) ? (a[i] * mul).rem_direct() : 0;
+                    auto rem = ai % split;
                     auto quo = (ai - rem) / split;
                     return std::pair{rem, quo};
                 };
@@ -94,13 +94,13 @@ namespace cp_algo::math::fft {
                 int64_t A0 = llround(real(Ai));
                 int64_t A1 = llround(real(Ci));
                 int64_t A2 = llround(real(Bi));
-                res[i] = A0 + A1 * split + A2 * splitsplit;
+                res[i].setr_direct(base::m_reduce(A0 + A1 * split + A2 * splitsplit));
                 res[i] *= cur;
                 if(n + i < k) {
                     int64_t B0 = llround(imag(Ai));
                     int64_t B1 = llround(imag(Ci));
                     int64_t B2 = llround(imag(Bi));
-                    res[n + i] = B0 + B1 * split + B2 * splitsplit;
+                    res[n + i].setr_direct(base::m_reduce(B0 + B1 * split + B2 * splitsplit));
                     res[n + i] *= cur * step;
                 }
                 cur *= ifactor;

cp-algo/number_theory/modint.hpp

@@ -37,6 +37,9 @@ namespace cp_algo::math {
                 return UInt((ab + m * mod()) >> bits);
             }
         }
+        static UInt m_reduce(Int2 ab) {
+            return m_reduce(UInt2(ab + UInt2(ab < 0) * mod() * mod()));
+        }
         static UInt m_transform(UInt a) {
             if(mod() % 2 == 0) [[unlikely]] {
                 return a;
@@ -89,7 +92,7 @@ namespace cp_algo::math {
         }
 
         // Only use if you really know what you're doing!
-        UInt modmod() const {return (UInt)8 * mod() * mod();};
+        static UInt modmod() {return (UInt)8 * mod() * mod();};
         void add_unsafe(UInt t) {r += t;}
         void pseudonormalize() {r = std::min(r, r - modmod());}
         modint const& normalize() {
@@ -100,11 +103,15 @@ namespace cp_algo::math {
         }
         void setr(UInt rr) {r = m_transform(rr);}
         UInt getr() const {
-            UInt res = m_reduce(r);
+            UInt res = m_reduce(UInt2(r));
             return std::min(res, res - mod());
         }
         void setr_direct(UInt rr) {r = rr;}
         UInt getr_direct() const {return r;}
+        Int rem_direct() const {
+            UInt R = std::min(r, r - mod());
+            return 2 * R > (UInt)mod() ? R - mod() : R;
+        }
     private:
         UInt r;
         modint& to_modint() {return static_cast<modint&>(*this);}