封装取模类

_nothingGG · 2025-05-24 09:01:02 · 算法·理论

template<int Mod=1000000007,typename T=int>class mint{
private:
    T x;
    static T increase(const T &num){return num>=Mod?num-Mod:num;}
    static T decrease(const T &num){return num<0?num+Mod:num;}
    static mint pow(mint a,T b){
        mint res(1);
        while(b){
            if(b&1)res*=a;
            a*=a;
            b>>=1;
        }
        return res;
    }
public:
    mint():x(0){}
    mint(T num):x(num>=0?num%Mod:(Mod-(-num)%Mod)%Mod){}
    mint inv() const{
        T a=x,u=1,v=0,k=0;
        int b=Mod;
        while(b>0){
            k=a/b;
            swap(a-=k*b,b);
            swap(u-=k*v,v);
        }
        return mint(u);
    }
    mint pow(T b)const{return pow(*this,b);}
    mint operator-() const {return mint(-x);}
    mint &operator+=(const mint &rhs){x=increase(x+rhs.x);return *this;}
    mint &operator-=(const mint &rhs){x=decrease(x-rhs.x);return *this;}
    mint &operator*=(const mint &rhs){x=1ll*x*rhs.x%Mod;return *this;}
    mint &operator/=(const mint &rhs){*this*=rhs.inverse();return *this;}
    friend mint operator+(const mint &lhs,const mint &rhs){return mint(lhs)+=rhs;}
    friend mint operator-(const mint &lhs,const mint &rhs){return mint(lhs)-=rhs;}
    friend mint operator*(const mint &lhs,const mint &rhs){return mint(lhs)*=rhs;}
    friend mint operator/(const mint &lhs,const mint &rhs){return mint(lhs)/=rhs;}
    bool operator==(const mint &rhs) const {return x==rhs.x;}
    bool operator!=(const mint &rhs) const {return x!=rhs.x;}
    bool operator>=(const mint &rhs) const {return x>=rhs.x;}
    bool operator<=(const mint &rhs) const {return x<=rhs.x;}
    bool operator>(const mint &rhs) const {return x>rhs.x;}
    bool operator<(const mint &rhs) const {return x<rhs.x;}
    T data() const {return x;}
    friend ostream &operator<<(ostream &os,const mint &num){return os<<num.x;}
    friend istream &operator>>(istream &is,mint &num){
        T input;
        is>>input;
        num=mint(input);
        return is;
    }
};