feat: update modint

Author: ttamx

modular-arithmetic/dynamic-modint.hpp

@@ -0,0 +1,98 @@
+#pragma once
+
+/**
+ * Author: Teetat T.
+ * Date: 2026-04-15
+ * Description: modular arithmetic operations
+ */
+
+struct Barrett{
+    u32 _m;
+    u64 im;
+
+    explicit Barrett(u32 m):_m(m),im((u64)(-1)/m+1){}
+
+    u32 umod()const{return _m;}
+    u32 mul(u32 a,u32 b)const{
+        u64 z=a;
+        z*=b;
+        u64 x=(u64)(((unsigned __int128)(z)*im)>>64);
+        u64 y=x*_m;
+        return (u32)(z-y+(z<y?_m:0));
+    }
+};
+
+template<int id>
+struct DynamicModInt{
+    using mint = DynamicModInt;
+
+    u32 x;
+    static Barrett bt;
+
+    constexpr DynamicModInt():x(0){}
+    constexpr DynamicModInt(ll x):x((x%=get_mod())<0?x+get_mod():x){}
+    explicit operator int()const{return (int)x;}
+    constexpr static u32 umod(){return bt.umod();}
+    constexpr static int get_mod(){return (int)bt.umod();}
+    static void set_mod(u32 m){
+        assert(m>=1);
+        bt=Barrett(m);
+    }
+    
+    mint operator-()const{
+        mint res;
+        res.val=x?umod()-x:0;
+        return res;
+    }
+    mint operator+()const{return *this;}
+
+    mint inv()const{
+        int a=x,b=get_mod(),u=1,v=0,q=0;
+        while(b>0){
+            q=a/b;
+            swap(a-=q*b,b);
+            swap(u-=q*v,v);
+        }
+        return mint(u);
+    }
+    mint pow(ll n)const{
+        mint res=1,a=*this;
+        for(;n>0;a*=a,n>>=1)if(n&1)res*=a;
+        return res;
+    }
+    mint &operator+=(const mint &o){
+        if((x+=o.x)>=umod())x-=umod();
+        return *this;
+    }
+    mint &operator-=(const mint &o){
+        if((x-=o.x)>=umod())x+=umod();
+        return *this;
+    }
+    mint &operator*=(const mint &o){
+        x=bt.mul(x,o.x);
+        return *this;
+    }
+    mint &operator/=(const mint &o){
+        return *this*=o.inv();
+    }
+
+    mint operator+(const mint &o)const{return mint(*this)+=o;}
+    mint operator-(const mint &o)const{return mint(*this)-=o;}
+    mint operator*(const mint &o)const{return mint(*this)*=o;}
+    mint operator/(const mint &o)const{return mint(*this)/=o;}
+
+    mint &operator++(){return *this+=mint(1);}
+    mint &operator--(){return *this-=mint(1);}
+    mint operator++(int){mint res=*this;*this+=mint(1);return res;}
+    mint operator--(int){mint res=*this;*this-=mint(1);return res;}
+    
+    bool operator==(const mint &o)const{return x==o.x;}
+    bool operator!=(const mint &o)const{return x!=o.x;}
+    bool operator<(const mint &o)const{return x<o.x;}
+    
+    friend istream &operator>>(istream &is,mint &o){ll x{};is>>x;o=mint(x);return is;}
+    friend ostream &operator<<(ostream &os,const mint &o){return os<<o.x;}
+};
+template<int id>
+Barrett DynamicModInt<id>::bt=Barrett(998244353);
+using dmint = DynamicModInt<0>;

modular-arithmetic/modint.hpp

@@ -2,55 +2,77 @@
 
 /**
  * Author: Teetat T.
- * Date: 2024-03-17
+ * Date: 2026-04-15
  * Description: modular arithmetic operations
  */
 
-template<int M,int root=0>
+template<int mod,int root=0>
 struct ModInt{
     using mint = ModInt;
+    
+	static_assert(mod>0,"mod must be positive");
+
     int x;
+
     constexpr ModInt():x(0){}
-    constexpr ModInt(ll x):x(norm(x%get_mod())){}
-    static int Mod;
-    static constexpr int get_mod(){return M>0?M:Mod;}
-    static constexpr void set_mod(int Mod_){Mod=Mod_;}
-    static constexpr mint get_root(){return mint(root);}
-    constexpr int norm(int x)const{if(x<0)x+=get_mod();if(x>=get_mod())x-=get_mod();return x;}
-    explicit constexpr operator int()const{return x;}
-    constexpr mint operator-()const{return mint()-mint(*this);};
-    constexpr mint operator+()const{return mint(*this);};
-    constexpr mint inv()const{
-        int a=x,b=get_mod(),u=1,v=0,q=0;
+    constexpr ModInt(ll x):x((x%=mod)<0?x+mod:x){}
+    explicit operator int()const{return x;}
+    constexpr static int get_mod(){return mod;}
+    constexpr static mint get_root(){return mint(root);}
+    
+    mint operator-()const{
+        mint res;
+        res.x=x?mod-x:0;
+        return res;
+    }
+    mint operator+()const{return *this;}
+
+    mint inv()const{
+        int a=x,b=mod,u=1,v=0,q=0;
         while(b>0){
             q=a/b;
-            a-=q*b;
-            u-=q*v;
-            swap(a,b);
-            swap(u,v);
+            swap(a-=q*b,b);
+            swap(u-=q*v,v);
         }
         return mint(u);
     }
-    constexpr int mul(int a,int b)const{return 1LL*a*b%get_mod();}
-    constexpr mint &operator+=(const mint &rhs){x=norm(x+rhs.x);return *this;}
-    constexpr mint &operator-=(const mint &rhs){x=norm(x-rhs.x);return *this;}
-    constexpr mint &operator*=(const mint &rhs){x=mul(x,rhs.x);return *this;}
-    constexpr mint &operator/=(const mint &rhs){x=mul(x,rhs.inv().x);return *this;}
-    constexpr mint &operator++(){return *this+=1;}
-    constexpr mint &operator--(){return *this-=1;}
-    constexpr mint operator++(int){mint res=*this;*this+=1;return res;}
-    constexpr mint operator--(int){mint res=*this;*this-=1;return res;}
-    friend constexpr mint operator+(mint lhs,const mint &rhs){return lhs+=rhs;}
-    friend constexpr mint operator-(mint lhs,const mint &rhs){return lhs-=rhs;}
-    friend constexpr mint operator*(mint lhs,const mint &rhs){return lhs*=rhs;}
-    friend constexpr mint operator/(mint lhs,const mint &rhs){return lhs/=rhs;}
+    mint pow(ll n)const{
+        mint res=1,a=*this;
+        for(;n>0;a*=a,n>>=1)if(n&1)res*=a;
+        return res;
+    }
+    mint &operator+=(const mint &o){
+        if((x+=o.x)>=mod)x-=mod;
+        return *this;
+    }
+    mint &operator-=(const mint &o){
+        if((x-=o.x)<0)x+=mod;
+        return *this;
+    }
+    mint &operator*=(const mint &o){
+        x=(ll(x)*o.x)%mod;
+        return *this;
+    }
+    mint &operator/=(const mint &o){
+        return *this*=o.inv();
+    }
+
+    mint operator+(const mint &o)const{return mint(*this)+=o;}
+    mint operator-(const mint &o)const{return mint(*this)-=o;}
+    mint operator*(const mint &o)const{return mint(*this)*=o;}
+    mint operator/(const mint &o)const{return mint(*this)/=o;}
+
+    mint &operator++(){return *this+=mint(1);}
+    mint &operator--(){return *this-=mint(1);}
+    mint operator++(int){mint res=*this;*this+=mint(1);return res;}
+    mint operator--(int){mint res=*this;*this-=mint(1);return res;}
+    
+    bool operator==(const mint &o)const{return x==o.x;}
+    bool operator!=(const mint &o)const{return x!=o.x;}
+    bool operator<(const mint &o)const{return x<o.x;}
+    
     friend istream &operator>>(istream &is,mint &o){ll x{};is>>x;o=mint(x);return is;}
     friend ostream &operator<<(ostream &os,const mint &o){return os<<o.x;}
-    friend constexpr bool operator==(const mint &lhs,const mint &rhs){return lhs.x==rhs.x;}
-    friend constexpr bool operator!=(const mint &lhs,const mint &rhs){return lhs.x!=rhs.x;}
-    friend constexpr bool operator<(const mint &lhs,const mint &rhs){return lhs.x<rhs.x;} // for std::map
 };
-using mint32 = ModInt<0>;
-template<>
-int mint32::Mod=int(1e9)+7;
-
+using mint998 = ModInt<998244353,3>;
+using mint107 = ModInt<1000000007>;

modular-arithmetic/modint64.hpp

@@ -108,7 +108,4 @@ struct MontgomeryModInt{
     friend ostream &operator<<(ostream &os,const mint &o){
         return os << o.val();
     }
-};
-using mint998 = MontgomeryModInt<998244353,3>;
-using mint107 = MontgomeryModInt<1000000007>;
-
+};

modular-arithmetic/montgomery-modint.hpp

@@ -1,6 +1,5 @@
 #pragma once
 #include "modular-arithmetic/binpow.hpp"
-#include "modular-arithmetic/montgomery-modint.hpp"
 
 /**
  * Author: Teetat T.

polynomial/ntt.hpp

@@ -1,6 +1,6 @@
 #define PROBLEM "https://judge.yosupo.jp/problem/bitwise_and_convolution"
 #include "template.hpp"
-#include "modular-arithmetic/montgomery-modint.hpp"
+#include "modular-arithmetic/modint.hpp"
 #include "convolution/and-convolution.hpp"
 
 using mint = mint998;

verify/yosupo/convolution/bitwise_and_convolution.test.cpp

@@ -1,6 +1,6 @@
 #define PROBLEM "https://judge.yosupo.jp/problem/bitwise_and_convolution"
 #include "template.hpp"
-#include "modular-arithmetic/montgomery-modint.hpp"
+#include "modular-arithmetic/modint.hpp"
 #include "convolution/or-convolution.hpp"
 
 using mint = mint998;

verify/yosupo/convolution/bitwise_or_convolution.test.cpp

@@ -1,6 +1,6 @@
 #define PROBLEM "https://judge.yosupo.jp/problem/bitwise_xor_convolution"
 #include "template.hpp"
-#include "modular-arithmetic/montgomery-modint.hpp"
+#include "modular-arithmetic/modint.hpp"
 #include "convolution/xor-convolution.hpp"
 
 using mint = mint998;

verify/yosupo/convolution/bitwise_xor_convolution.test.cpp

@@ -1,6 +1,6 @@
 #define PROBLEM "https://judge.yosupo.jp/problem/convolution_mod"
 #include "template.hpp"
-#include "modular-arithmetic/montgomery-modint.hpp"
+#include "modular-arithmetic/modint.hpp"
 #include "polynomial/ntt.hpp"
 
 using mint = mint998;

verify/yosupo/convolution/convolution_mod.test.cpp

@@ -1,6 +1,6 @@
 #define PROBLEM "https://judge.yosupo.jp/problem/gcd_convolution"
 #include "template.hpp"
-#include "modular-arithmetic/montgomery-modint.hpp"
+#include "modular-arithmetic/modint.hpp"
 #include "convolution/gcd-convolution.hpp"
 
 using mint = mint998;