Use shared static variable for dynamic_modint

Author: adamant-pwn

cp-algo/algebra/modint.hpp

@@ -1,55 +1,40 @@
 #ifndef CP_ALGO_ALGEBRA_MODINT_HPP
 #define CP_ALGO_ALGEBRA_MODINT_HPP
-#include "../random/rng.hpp"
-#include "affine.hpp"
 #include "common.hpp"
-#include <algorithm>
 #include <iostream>
-#include <optional>
 namespace cp_algo::algebra {
     template<typename modint>
     struct modint_base {
-        // Would make it virtual, but it affects avx...
-        int mod() const {
-            if constexpr(modint::static_mod) {
-                return modint::static_mod;
-            } else {
-                return static_cast<modint*>(this)->mod();
-            }
+        static int mod() {
+            return modint::mod();
         }
         modint_base(): r(0) {}
         modint_base(int64_t rr): r(rr % mod()) {
             r = std::min(r, r + mod());
         }
         modint inv() const {
-            return bpow(static_cast<modint const&>(*this), mod() - 2);
+            return bpow(to_modint(), mod() - 2);
         }
         modint operator - () const {return std::min(-r, mod() - r);}
-        modint& operator /= (const modint &t) {return *this *= t.inv();}
+        modint& operator /= (const modint &t) {
+            return to_modint() *= t.inv();
+        }
         modint& operator *= (const modint &t) {
-            r *= t.r; r %= mod();
-            return static_cast<modint&>(*this);
+            r *= t.r; if(mod()) {r %= mod();}
+            return to_modint();
         }
         modint& operator += (const modint &t) {
             r += t.r; r = std::min(r, r - mod());
-            return static_cast<modint&>(*this);
+            return to_modint();
         }
         modint& operator -= (const modint &t) {
             r -= t.r; r = std::min(r, r + mod());
-            return static_cast<modint&>(*this);
-        }
-        modint operator + (const modint &t) const {
-            return modint(static_cast<modint const&>(*this)) += t;
-        }
-        modint operator - (const modint &t) const {
-            return modint(static_cast<modint const&>(*this)) -= t;
-        }
-        modint operator * (const modint &t) const {
-            return modint(static_cast<modint const&>(*this)) *= t;
-        }
-        modint operator / (const modint &t) const {
-            return modint(static_cast<modint const&>(*this)) /= t;
+            return to_modint();
         }
+        modint operator + (const modint &t) const {return modint(to_modint()) += t;}
+        modint operator - (const modint &t) const {return modint(to_modint()) -= t;}
+        modint operator * (const modint &t) const {return modint(to_modint()) *= t;}
+        modint operator / (const modint &t) const {return modint(to_modint()) /= t;}
         auto operator <=> (const modint_base &t) const = default;
         explicit operator int() const {return r;}
         int64_t rem() const {return 2 * r > (uint64_t)mod() ? r - mod() : r;}
@@ -62,12 +47,14 @@ namespace cp_algo::algebra {
             if(r >= (uint64_t)mod()) {
                 r %= mod();
             }
-            return static_cast<modint&>(*this);
+            return to_modint();
         }
         uint64_t& setr() {return r;}
         uint64_t getr() const {return r;}
     private:
         uint64_t r;
+        modint& to_modint() {return static_cast<modint&>(*this);}
+        modint const& to_modint() const {return static_cast<modint const&>(*this);}
     };
     template<typename modint>
     std::istream& operator >> (std::istream &in, modint_base<modint> &x) {
@@ -81,28 +68,19 @@ namespace cp_algo::algebra {
 
     template<int m>
     struct modint: modint_base<modint<m>> {
-        constexpr static int static_mod = m;
+        static constexpr int mod() {return m;}
         using Base = modint_base<modint<m>>;
         using Base::Base;
-        constexpr static uint64_t static_modmod = 8LL*m*m;
     };
 
     struct dynamic_modint: modint_base<dynamic_modint> {
-        constexpr static int static_mod = 0;
+        static int mod() {return m;}
+        static void switch_mod(int nm) {m = nm;}
         using Base = modint_base<dynamic_modint>;
-        int mod() const {return m;}
-        dynamic_modint(dynamic_modint const& t): Base(t), m(t.m) {}
-        dynamic_modint(int m, int64_t r): m(m) {
-            setr() = r % m;
-            setr() = std::min(setr(), setr() + mod());
-        }
-        static auto GF(int mod) {
-            return [mod](int64_t r) {
-                return dynamic_modint(mod, r);
-            };
-        }
+        using Base::Base;
     private:
-        int m;
+        static int m;
     };
+    int dynamic_modint::m = 0;
 }
 #endif // CP_ALGO_ALGEBRA_MODINT_HPP

cp-algo/algebra/number_theory.hpp

@@ -3,8 +3,6 @@
 #include "../random/rng.hpp"
 #include "affine.hpp"
 #include "modint.hpp"
-#include <algorithm>
-#include <iostream>
 #include <optional>
 namespace cp_algo::algebra {
     // https://en.wikipedia.org/wiki/Berlekamp-Rabin_algorithm

cp-algo/linalg/vector.hpp

@@ -7,6 +7,7 @@
 #include <valarray>
 #include <iostream>
 #include <iterator>
+#include <cassert>
 namespace cp_algo::linalg {
     template<class vec, typename base>
     struct valarray_base: std::valarray<base> {

verify/number_theory/modsqrt.test.cpp

@@ -0,0 +1,33 @@
+// @brief Sqrt Mod
+#define PROBLEM "https://judge.yosupo.jp/problem/sqrt_mod"
+#pragma GCC optimize("Ofast,unroll-loops")
+#pragma GCC target("avx2,tune=native")
+#include "cp-algo/algebra/number_theory.hpp"
+#include <bits/stdc++.h>
+
+using namespace std;
+using namespace cp_algo::algebra;
+using base = dynamic_modint;
+
+void solve() {
+    int y, p;
+    cin >> y >> p;
+    base::switch_mod(p);
+    auto res = sqrt(base(y));
+    if(res) {
+        cout << *res << "\n";
+    } else {
+        cout << -1 << "\n";
+    }
+}
+
+signed main() {
+    //freopen("input.txt", "r", stdin);
+    ios::sync_with_stdio(0);
+    cin.tie(0);
+    int t = 1;
+    cin >> t;
+    while(t--) {
+        solve();
+    }
+}