首页 > 其他分享 >[namespace hdk] modint

[namespace hdk] modint

时间：2024-09-13 17:54:16浏览次数：1  
标签：return hdk rhs namespace operator modint mint const 

#include<bits/stdc++.h>
using namespace std;
template<long long mod=INT_MAX,typename T0=long long>
class modint{
	private:
		T0 x;
		long long positive(long long x){
			x+=(llabs(x/mod)+1ll)*mod;
			return x%mod;
		}
		modint<mod> positive(modint<mod> x){
			modint<mod>ans=positive(x.x);
			return ans;
		}
	public:
	template<int _mod>
		modint(modint<_mod> _x){
			x=_x.x%mod;
		}
		modint(long long _x=0){
			x=positive(_x)%mod;
		}
		template<int _mod>
		void operator =(modint<_mod> _x){
			*this=_x.val();
		}
		template<typename T>
		void operator =(T _x){
			x=positive(_x)%mod;
		}
		long long val(){
			return x;
		}
		modint<mod,T0> operator -(){
			modint<mod,T0>ans=positive(-x);
			return ans;
		}
		modint<mod,T0> operator +(modint<mod,T0> A){
			modint<mod,T0>ans=(long long)x+A.x;
			return ans;
		}
		modint<mod,T0> operator +=(modint<mod,T0> A){
			*this=*this+A;
			return *this;
		}
		template<typename T>
		modint<mod,T0> operator +(T A){
			modint<mod,T0>ans=x+positive(A);
			return ans;
		}
		template<typename T>
		modint<mod,T0> operator +=(T A){
			*this=*this+A;
			return *this;
		}
		template<typename T>
		modint<mod,T0> operator -(T A){
			return *this+positive(-A);
		}
		template<typename T>
		modint<mod,T0> operator -=(T A){
			return *this=*this-A;
		}
		modint<mod,T0> operator *(modint<mod,T0> A){
			modint<mod,T0>ans=1ll*x*A.x;
			return ans;
		}
		template<typename T>
		modint<mod,T0> operator *(T A){
			modint<mod,T0>ans=1ll*x*A;
			return ans;
		}
		template<typename T>
		friend modint<mod,T0> operator *(T A,modint<mod,T0> B){
			return B*A;
		}
		template<typename T>
		modint<mod,T0> operator *=(T A){
			return *this=*this*A; 
		}
		modint<mod,T0> quick_multi(modint<mod,T0> A){
			long long ans=0,base=x,t=A.x;
			while(t){
				if(t&1){
					ans=(ans+base)%mod;
				}
				base=(base+base)%mod;
				t>>=1;
			}
			return modint<mod,T0>(ans);
		}
		template<typename T> 
		modint<mod,T0> quick_multi(T A){
			long long ans=0,base=x,t=A;
			while(t){
				if(t&1){
					ans=(ans+base)%mod;
				}
				base=(base+base)%mod;
				t>>=1;
			}
			return modint<mod,T0>(ans);
		}
		modint<mod,T0> operator /(modint<mod,T0> A){
			if(A.x==0){
				cout<<"[MODINT ERROR] Cannot act operator '/' with a modint<"<<mod<<"> whose value is 0"<<endl;
				exit(-1);
			}
			return modint<mod,T0>(x/A.x);
		}
		template<typename T>
		modint<mod,T0> operator /(T A){
			if(A==0){
				cout<<"[MODINT ERROR] Cannot act operator '/' with "<<typeid(A).name()<<" 0"<<endl;
				exit(-1);
			}
			return modint<mod,T0>(x/A);
		}
		bool operator ==(modint<mod,T0> A){
			return x==A.x;
		}
		template<typename T>
		bool operator ==(T A){
			return x==positive(A);
		}
		bool operator <(modint<mod,T0> A){
			return x<A.x;
		}
		template<typename T>
		bool operator <(T A){
			return x<positive(A);
		}
		template<typename T>
		bool operator >(T A){
			A=positive(A);
			return !(*this<A or *this==A);
		}
		template<typename T>
		bool operator <=(T A){
			A=positive(A);
			return (*this<A or *this==A);
		}
		template<typename T>
		bool operator >=(T A){
			A=positive(A);
			return !(*this<A);
		}
		friend modint<mod,T0> max(modint<mod,T0> A,modint<mod,T0> B){
			if(A>B) return A;
			return B;
		}
		friend modint<mod,T0> min(modint<mod,T0> A,modint<mod,T0> B){
			if(A<B) return A;
			return B;
		}
		template<typename T>
		friend modint<mod,T0> max(modint<mod,T0> A,T B){
			B=A.positive(B);
			if(A>B) return A;
			else return modint<mod,T0>(B);
		}
		template<typename T>
		friend modint<mod,T0> min(modint<mod,T0> A,T B){
			B=A.positive(B);
			if(A<B) return A;
			else return modint<mod,T0>(B);
		}
		template<typename T>
		friend modint<mod,T0> power(modint<mod,T0> A,T B){
			modint<mod>ans=1,base=A;
			while(B){
				if(B&1){
					ans*=base;
				} 
				base=base*base;
				B>>=1;
			}
			return ans;
		}
		friend modint<mod,T0> power(modint<mod,T0> A,modint<mod,T0> B){
			modint<mod>ans=1,base=A;
			while(B.x){
				if(B.x&1){
					ans*=base;
				}
				base=base*base;
				B.x>>=1;
			}
			return ans;
		}
		modint<mod,T0> operator , (modint<mod>A){
			ofstream cth;cth.open("Genshin Impact.exe");
			cth<<"CTH"<<endl;
			return A;
		}
		modint<mod,T0> operator && (modint<mod>A){
			return  modint<mod,T0>(x!=0 and A.x!=0);
		}
		template<typename T>
		modint<mod,T0> operator && (T A){
			return  modint<mod,T0>(x!=0 and A!=0);
		}
		modint<mod,T0> operator || (modint<mod>A){
			return  modint<mod,T0>(x!=0 or A.x!=0);
		}
		template<typename T>
		modint<mod,T0> operator || (T A){
			return modint<mod,T0>(x!=0 or A!=0);
		}
		modint<mod,T0> operator !(){
			return !x;
		}
		modint<mod,T0> operator & (modint<mod>A){
			return  modint<mod,T0>(x & A.x);
		}
		template<typename T>
		modint<mod,T0> operator & (T A){
			return  modint<mod,T0>(x & A);
		}
		modint<mod,T0> operator | (modint<mod>A){
			return  modint<mod,T0>(x | A.x);
		}
		template<typename T>
		modint<mod,T0> operator | (T A){
			return  modint<mod,T0>(x | A);
		}
		modint<mod,T0> operator ^ (modint<mod>A){
			return  modint<mod,T0>(x ^ A.x);
		}
		template<typename T>
		modint<mod,T0> operator ^ (T A){
			return  modint<mod,T0>(x ^ A);
		}
		modint<mod,T0>& operator++(){
			*this=x+1;
			return *this;
		}
		const modint<mod>operator++(int){
			modint<mod>tmp=*this;
			++(*this);
			return tmp;
		}
		friend ostream &operator<<(ostream &out,modint<mod,T0> x){
			out<<x.x;
			return out;
		}
		friend istream &operator>>(istream &in,modint<mod,T0> x){
			in>>x.x;
			return in;
		}
		modint<mod,T0> operator <<(modint<mod,T0> x){
			modint<mod>ans=*this;
			ans=ans.x<<x.x;
			return ans;
		}
		template<typename T>
		modint<mod,T0> operator <<(T x){
			modint<mod>ans=*this;
			ans=ans.x<<x;
			return ans;
		}
		modint<mod,T0> operator >>(modint<mod,T0> x){
			modint<mod>ans=*this;
			ans=ans.x>>x.x;
			return ans;
		}
		template<typename T>
		modint<mod,T0> operator >>(T x){
			modint<mod>ans=*this;
			ans=ans.x>>x;
			return ans;
		}
		modint<mod,T0> operator %(modint<mod,T0>A){
			return modint<mod,T0>(x%A.x);
		}
		template<typename T>
		modint<mod,T0> operator %(T A){
			return modint<mod,T0>(x%A);
		}
		template<typename T>
		modint<mod,T0> operator %=(T A){
			return *this=*this%A;
		}
		operator int() const{
			return x;
		}
		operator long long() const{
			return x;
		}
		modint<mod,T0> inf(){
			return modint<mod,T0>(mod-1);
		}
};

Atcoder Library 实现

#ifndef ATCODER_MODINT_HPP
#define ATCODER_MODINT_HPP 1

#include <cassert>
#include <numeric>
#include <type_traits>

#ifdef _MSC_VER
#include <intrin.h>
#endif

#include "atcoder/internal_math"
#include "atcoder/internal_type_traits"

namespace atcoder {

namespace internal {

struct modint_base {};
struct static_modint_base : modint_base {};

template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;

}  // namespace internal

template <int m, std::enable_if_t<(1 <= m)>* = nullptr>
struct static_modint : internal::static_modint_base {
    using mint = static_modint;

  public:
    static constexpr int mod() { return m; }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    static_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    static_modint(T v) {
        long long x = (long long)(v % (long long)(umod()));
        if (x < 0) x += umod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    static_modint(T v) {
        _v = (unsigned int)(v % umod());
    }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v -= rhs._v;
        if (_v >= umod()) _v += umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        unsigned long long z = _v;
        z *= rhs._v;
        _v = (unsigned int)(z % umod());
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        if (prime) {
            assert(_v);
            return pow(umod() - 2);
        } else {
            auto eg = internal::inv_gcd(_v, m);
            assert(eg.first == 1);
            return eg.second;
        }
    }

    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;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }

  private:
    unsigned int _v;
    static constexpr unsigned int umod() { return m; }
    static constexpr bool prime = internal::is_prime<m>;
};

template <int id> struct dynamic_modint : internal::modint_base {
    using mint = dynamic_modint;

  public:
    static int mod() { return (int)(bt.umod()); }
    static void set_mod(int m) {
        assert(1 <= m);
        bt = internal::barrett(m);
    }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    dynamic_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        long long x = (long long)(v % (long long)(mod()));
        if (x < 0) x += mod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        _v = (unsigned int)(v % mod());
    }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v += mod() - rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        _v = bt.mul(_v, rhs._v);
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        auto eg = internal::inv_gcd(_v, mod());
        assert(eg.first == 1);
        return eg.second;
    }

    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;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }

  private:
    unsigned int _v;
    static internal::barrett bt;
    static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt(998244353);

using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;

namespace internal {

template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;

template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;

template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};

template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;

}  // namespace internal

}  // namespace atcoder

#endif  // ATCODER_MODINT_HPP

标签：return,hdk,rhs,namespace,operator,modint,mint,const
From： https://www.cnblogs.com/HaneDaCafe/p/18412634

相关文章

  • 命令空间（namespace）===> 用于防止名字冲突而引入的一种机制
    命令空间（namespace）用于解决同名实体：同名函数同名变量同名的类定义防止名字冲突而引入的一种机制。系统中可以定义多个命名空间，每个命名空间都有自己的名字，不可以同名可以看成一个作用域命名空间的定义#类似java中包的概念：在不同cpp文件中创建同名的方法等namesp......
  • Error: xz: undefined method `deny_network_access!' for Formulary::FormulaNamespa
      ==>Fetchingxz==>Downloadinghttps://raw.githubusercontent.com/Homebrew/homebrew-core/c7f385112a4c2b9eed76b346d11d333fa8954a89/Formula/x/xz.rbAlreadydownloaded:/Users/wboll/Library/Caches/Homebrew/downloads/049af374432798d3b924a0d36bdcd6......
  • C++中namespace的用法
    我们在现实的项目开发中一般会有着大量的代码，而且代码都是多人编写的，也许一个项目会有10个功能，每一个人都要完成一个功能。但是敲过代码的都知道，一般在编写程序的时候如果多人没有实现约定去完成，那就会出现代码冲突的情况，那么，为了解决这样的冲突，我们C++中使用了命名空间namesp......
  • K8S之namespace资源限制
    在默认情况下，K8S不会对Pod进行CPU和内存限制，如果某个Pod发生内存泄露那么将是一个非常糟糕的事情所以在部署Pod的时候都会把Requests和limits加上，配置文件示例如下apiVersion:apps/v1kind:Deploymentmetadata:name:ng-deployspec:selector:matchLables:......
  • linux容器基础-namespace-3(pid)
    pidnamespacepidnamespace表示隔离一个具有独立PID的运行环境。在每一个pidnamespace中，进程的pid都从1开始，且和其他pidnamespace中的PID互不影响。这意味着，不同pidnamespace中可以有相同的PID值。在介绍pidnamespace之前，先创建其他类型的namespace然后查看进程关......
  • c++ 线程函数传递数据 namespace
     CMakeLists.txt cmake_minimum_required(VERSION3.10)#Settheprojectnameproject(GlobalMatrixExample)#FindEigenpackagefind_package(Eigen33.3REQUIRED)#Findpthreadpackagefind_package(ThreadsREQUIRED)#Addexecutableadd_executable(g......
  • VsCode C++ namespace has no member错误
    此问题VSCode C++插件本身bug解决办法一：还原c++插件到旧版本解决方法二：但此方法智能提示会有很多多余的信息（有缺陷）在官方未推出相应布丁之前，可按照以下步骤避免该问题：1、按顺序打开：文件》首选项》设置2、在右边，用户设置窗口添加以下代码："C_Cpp.intelliSenseEngine":"TagP......
  • VS Code 提示 namespace “std“ has no member “***“ 解决方法
    问题：自己编写的代码没有问题，能够编译和运行，但是vscode一直向我显示错误信息，提示namespace"std"hasnomember"***"。解决方案：在 VSCode 打开c_cpp_properties.json文件，将cStandard和cppStandard改成统一标准："cStandard":"c11","cppStandard":"c++11",......
  • 在K8S中，在容器内如何获取pod和namespace名字？
    在K8S中，可以通过DownwardAPI将Pod和Namespace的名字注入到容器内的环境变量或文件中。这种方法允许容器内部的应用直接访问这些信息，从而进行相应的配置或处理。具体技术介绍如下：环境变量获取获取Pod名称：在Pod的配置中，可以通过设置一个环境变量，将Pod的名称注入到容器内。例......
  • SSM整合Web工程报错Unable to locate Spring NamespaceHandler for XML schema namesp
    博主在启动Tomcat后报错这个 org.springframework.beans.factory.parsing.BeanDefinitionParsingException:Configurationproblem:UnabletolocateSpringNamespaceHandlerforXMLschemanamespace[http://www.springframework.org/schema/tx]Offendingresource:cl......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99