RecInt Namespace Reference

NOTE : For this common file, either basic/reduc.h or mg/reduc.h has to be pre-included. More...

Data Structures
struct	NBBITS
struct	NBBITS< 6 >
struct	NBLIMB
struct	NBLIMB< 6 >
class	rint
class	rmint
class	rmint< K, MG_ACTIVE >
class	rmint< K, MG_INACTIVE >
class	ruint
class	ruint< 0 >
class	ruint< 1 >
class	ruint< 2 >
class	ruint< 3 >
class	ruint< 4 >
class	ruint< 5 >
struct	sdiv

Typedefs
typedef uint64_t	limb
typedef uint64_t	UWtype
typedef uint64_t	UHWtype
typedef uint64_t	UDWtype
typedef uint64_t	UDItype
typedef uint32_t	USItype
typedef int64_t	DItype
typedef int32_t	SItype
using	rmint64 = rmint<6>
using	rmint128 = rmint<7>
using	rmint256 = rmint<8>
using	rmint512 = rmint<9>
using	rint64 = rint<6>
using	rint128 = rint<7>
using	rint256 = rint<8>
using	rint512 = rint<9>
using	ruint64 = ruint<6>
using	ruint128 = ruint<7>
using	ruint256 = ruint<8>
using	ruint512 = ruint<9>

Enumerations
enum	{ MG_INACTIVE , MG_ACTIVE }

Functions
template<size_t K>
rint< K > &	operator++ (rint< K > &)
template<size_t K>
rint< K >	operator++ (rint< K > &, int)
template<size_t K>
rint< K > &	operator+= (rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, rint< K > & >::type	operator+= (rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, rint< K > & >::type	operator+= (rint< K > &, const T &)
template<size_t K>
rint< K >	operator+ (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, rint< K > >::type	operator+ (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, rint< K > >::type	operator+ (const T &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, rint< K > >::type	operator+ (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, rint< K > >::type	operator+ (const T &, const rint< K > &)
template<size_t K>
void	add (bool &r, rint< K > &a, const rint< K > &b, const rint< K > &c)
template<size_t K>
void	add (bool &r, rint< K > &a, const rint< K > &c)
template<size_t K>
void	add (rint< K > &a, const rint< K > &b, const rint< K > &c)
template<size_t K>
void	add (rint< K > &a, const rint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (bool &r, rint< K > &a, const rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (bool &r, rint< K > &a, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (rint< K > &a, const rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (rint< K > &a, const T &c)
template<size_t K>
void	add_1 (bool &r, rint< K > &a, const rint< K > &b)
template<size_t K>
void	add_1 (bool &r, rint< K > &a)
template<size_t K>
void	add_1 (rint< K > &a, const rint< K > &b)
template<size_t K>
void	add_1 (rint< K > &a)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type	operator+ (const rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type	operator+ (const T &c, const rint< K > &b)
template<size_t K>
bool	operator== (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator== (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator== (const T &, const rint< K > &)
template<size_t K>
bool	operator!= (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator!= (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator!= (const T &, const rint< K > &)
template<size_t K>
bool	operator> (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator> (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator> (const T &, const rint< K > &)
template<size_t K>
bool	operator>= (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator>= (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator>= (const T &, const rint< K > &)
template<size_t K>
bool	operator< (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator< (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator< (const T &, const rint< K > &)
template<size_t K>
bool	operator<= (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator<= (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator<= (const T &, const rint< K > &)
template<size_t K>
int	cmp (const rint< K > &a, const rint< K > &b)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, int >::type	cmp (const rint< K > &a, const T &b)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, int >::type	cmp (const rint< K > &a, const T &b)
template<size_t K>
rint< K > &	mpz_to_rint (ruint< K > &, const mpz_class &)
template<size_t K>
mpz_class &	rint_to_mpz (mpz_class &, const rint< K > &)
template<size_t K>
rint< K > &	mpz_to_rint (rint< K > &a, const mpz_class &b)
template<size_t K>
mpz_ptr	rint_to_mpz_t (mpz_ptr a, const rint< K > &b)
template<size_t K>
rint< K > &	mpz_t_to_rint (rint< K > &a, mpz_srcptr b)
template<size_t K>
std::ostream &	operator<< (std::ostream &, const rint< K > &)
template<size_t K>
std::ostream &	display_dec (std::ostream &out, const rint< K > &a)
template<size_t K>
std::istream &	operator>> (std::istream &is, rint< K > &a)
template<size_t K>
rint< K > &	operator%= (rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type	operator%= (rint< K > &, const T &)
template<size_t K>
rint< K > &	operator/= (rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type	operator/= (rint< K > &, const T &)
template<size_t K>
rint< K >	operator% (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type	operator% (const rint< K > &, const T &)
template<size_t K>
rint< K >	operator/ (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type	operator/ (const rint< K > &, const T &)
template<size_t K>
rint< K > &	div_q (rint< K > &q, const rint< K > &a, const rint< K > &b)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type	div_q (rint< K > &q, const rint< K > &a, const T &b)
template<size_t K>
rint< K > &	div_r (rint< K > &r, const rint< K > &a, const rint< K > &b)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, T & >::type	div_r (T &r, const rint< K > &a, const T &b)
template<size_t K>
rint< K > &	inv_mod (rint< K > &, const rint< K > &, const rint< K > &)
template<size_t K, size_t R>
void	mod_n (rint< K > &, const rint< R > &, const rint< K > &)
template<size_t K>
void	mod_n (rint< K > &, const rint< K > &)
UWtype	__recint_umul_ppmm (UWtype *, UWtype, UWtype)
UWtype	__recint_umul_ppmm_r (UWtype, UWtype, UWtype *)
UWtype	__recint_udiv_qrnnd (UWtype *, UWtype, UWtype, UWtype)
UWtype	__recint_udiv_qrnnd_r (UWtype, UWtype, UWtype, UWtype *)
template<size_t K>
rint< K >	operator~ (const rint< K > &c)
template<size_t K>
rint< K >	operator- (const rint< K > &c)
template<size_t K>
rint< K > &	neg (rint< K > &, const rint< K > &)
template<size_t K>
rint< K > &	neg (rint< K > &)
template<size_t K>
rint< K > &	operator|= (rint< K > &b, const rint< K > &c)
template<size_t K>
rint< K > &	operator^= (rint< K > &b, const rint< K > &c)
template<size_t K>
rint< K > &	operator&= (rint< K > &b, const rint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type	operator|= (rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type	operator^= (rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type	operator&= (rint< K > &b, const T &c)
template<size_t K>
rint< K >	operator| (const rint< K > &b, const rint< K > &c)
template<size_t K>
rint< K >	operator^ (const rint< K > &b, const rint< K > &c)
template<size_t K>
rint< K >	operator& (const rint< K > &b, const rint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type	operator| (const rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type	operator^ (const rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, T >::type	operator& (const rint< K > &b, const T &c)
template<size_t K, typename T>
rint< K >	operator<< (const rint< K > &, const T &)
template<size_t K, typename T>
rint< K >	operator>> (const rint< K > &, const T &)
template<size_t K, typename T>
rint< K > &	operator<<= (rint< K > &, const T &)
template<size_t K, typename T>
rint< K > &	operator>>= (rint< K > &, const T &)
template<size_t K, size_t MG>
rmint< K, MG > &	operator++ (rmint< K, MG > &)
template<size_t K, size_t MG>
rmint< K, MG >	operator++ (rmint< K, MG > &, int)
template<size_t K, size_t MG>
rmint< K, MG > &	operator+= (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
	__RECINT_IS_ARITH (T, rmint< K, MG > &) operator+ =(rmint<K, MG>&, const T&)
template<size_t K, size_t MG>
rmint< K, MG >	operator+ (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
	__RECINT_IS_ARITH (T, rmint< K, MG >) operator+(const rmint< K
template<size_t K, size_t MG, typename T>
MG const T &	__RECINT_IS_ARITH (T, rmint< K, MG >) operator+(const T &
template<size_t K, size_t MG>
MG const T const rmint< K, MG > &rmint< K, MG > &	add (rmint< K, MG > &, const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
rmint< K, MG > &	add (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
MG const rmint< K, MG > const T &	__RECINT_IS_ARITH (T, rmint< K, MG > &) add(rmint< K
template<size_t K, size_t MG>
rmint< K, MG > &	add (rmint< K, MG > &a, const rmint< K, MG > &b, const rmint< K, MG > &c)
rmint< K, MG >	cp (c)
	add (r, a.Value, b.Value, cp.Value)
	if (r||a.Value >=a.p) sub(a.Value
rmint< K, MG >	bp (b)
	add (r, a.Value, bp.Value)
template<size_t K>
rmint< K, MGI > &	addmul (rmint< K, MGI > &, const rmint< K, MGI > &, const rmint< K, MGI > &)
template<size_t K, typename T>
	__RECINT_IS_ARITH (T, void) addmul(rmint< K
	addmul (a, b, cr)
template<size_t K>
void	exp (rmint< K, MG_INACTIVE > &, const rmint< K, MG_INACTIVE > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, void >::type	exp (rmint< K, MG_INACTIVE > &, const rmint< K, MG_INACTIVE > &, const T &)
template<size_t K>
rmint< K, MG_INACTIVE > &	inv (rmint< K, MG_INACTIVE > &, const rmint< K, MG_INACTIVE > &)
template<size_t K>
rmint< K, MG_INACTIVE > &	inv (rmint< K, MG_INACTIVE > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG_INACTIVE > & >::type	inv (rmint< K, MG_INACTIVE > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	mul (rmint< K, MG_INACTIVE > &, const rmint< K, MG_INACTIVE > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	mul (rmint< K, MG_INACTIVE > &, const T &)
template<size_t K>
rmint< K, MGI > &	reduction (rmint< K, MGI > &t, const ruint< K+1 > &c)
template<size_t K>
rmint< K, MGI > &	reduction (rmint< K, MGI > &t, const ruint< K > &c)
template<size_t K>
rmint< K, MGI > &	reduction (rmint< K, MGI > &t, const rmint< K, MGI > &c)
template<size_t K>
rmint< K, MGI > &	reduction (rmint< K, MGI > &t)
template<size_t K>
ruint< K >	get_ruint (const rmint< K, MGI > &a)
template<size_t K>
rmint< K, MGI > &	get_ready (rmint< K, MGI > &a)
template<size_t K, size_t MG>
bool	operator== (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
bool	operator== (const rmint< K, MG > &, const ruint< K > &)
template<size_t K, size_t MG, typename T>
	__RECINT_IS_ARITH (T, bool) operator ==(const T&, const rmint<K, MG>&)
template<size_t K, size_t MG>
bool	operator!= (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
bool	operator!= (const rmint< K, MG > &, const ruint< K > &)
template<size_t K, size_t MG>
bool	operator> (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
MG const T &	__RECINT_IS_ARITH (T, bool) operator>(const T &
template<size_t K, size_t MG>
MG const T const rmint< K, MG > &bool	operator>= (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
bool	operator< (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
MG const T const rmint< K, MG > &bool	operator<= (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K>
bool	operator== (const rmint< K, MGI > &a, const ruint< K > &b)
template<size_t K>
bool	operator== (const rmint< K, MGA > &a, const ruint< K > &b)
template<size_t K, typename T>
	__RECINT_IS_ARITH (T, bool) operator
T	__RECINT_IS_ARITH (T, bool) operator<(const T &b
return	operator> (reduction(ar).Value, b)
template<size_t K>
bool	operator<= (const rmint< K, MGI > &a, const rmint< K, MGI > &b)
template<size_t K>
bool	operator<= (const rmint< K, MGA > &a, const rmint< K, MGA > &b)
template<size_t K, size_t MG>
rmint< K, MG > &	mpz_to_rmint (rmint< K, MG > &, const mpz_class &)
template<size_t K, size_t MG>
mpz_class &	rmint_to_mpz (mpz_class &, const rmint< K, MG > &)
template<size_t K, size_t MG>
std::ostream &	operator<< (std::ostream &, const rmint< K, MG > &)
template<size_t K, size_t MG>
std::istream &	operator>> (std::istream &, rmint< K, MG > &)
template<size_t K, size_t MG>
std::ostream &	write_raw (std::ostream &out, const rmint< K, MG > &a)
template<size_t K, size_t MG>
std::istream &	read_raw (std::istream &is, rmint< K, MG > &a)
template<size_t K, size_t MG>
rmint< K, MG > &	operator%= (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG > & >::type	operator%= (rmint< K, MG > &, const T &)
template<size_t K, size_t MG>
rmint< K, MG > &	operator/= (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG > & >::type	operator/= (rmint< K, MG > &, const T &)
template<size_t K, size_t MG>
rmint< K, MG >	operator/ (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG > >::type	operator/ (const rmint< K, MG > &, const T &)
template<size_t K, size_t MG>
rmint< K, MG >	operator% (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG > >::type	operator% (const rmint< K, MG > &, const T &)
template<size_t K, size_t MG>
void	div (rmint< K, MG > &, const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
void	div (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	div (rmint< K, MG > &, const rmint< K, MG > &, const T &)
template<size_t K, size_t MG, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	div (rmint< K, MG > &, const T &)
template<size_t K, size_t MG>
void	mod (rmint< K, MG > &, const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
void	mod (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	mod (rmint< K, MG > &, const rmint< K, MG > &, const T &)
template<size_t K, size_t MG, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	mod (rmint< K, MG > &, const T &)
template<size_t K, size_t MG>
bool	is_quadratic_residue (const rmint< K, MG > &a)
template<size_t K, size_t MG>
void	square_root (rmint< K, MG > &r, const rmint< K, MG > &a)
template<size_t K>
rmint< K, MGA > &	addmul (rmint< K, MGA > &, const rmint< K, MGA > &, const rmint< K, MGA > &)
template<size_t K>
void	exp (rmint< K, MG_ACTIVE > &, const rmint< K, MG_ACTIVE > &, const UDItype &)
template<size_t K>
void	exp (rmint< K, MG_ACTIVE > &, const rmint< K, MG_ACTIVE > &, const ruint< K > &)
template<size_t K>
rmint< K, MG_ACTIVE > &	inv (rmint< K, MG_ACTIVE > &a, const rmint< K, MG_ACTIVE > &b)
template<size_t K>
rmint< K, MG_ACTIVE > &	inv (rmint< K, MG_ACTIVE > &a)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG_ACTIVE > & >::type	inv (rmint< K, MG_ACTIVE > &a, const T &b)
template<size_t K>
ruint< K > &	arazi_qi (ruint< K > &u, const ruint< K > &a)
template<>
ruint< 6 > &	arazi_qi (ruint< 6 > &u, const ruint< 6 > &a)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	mul (rmint< K, MG_ACTIVE > &a, const rmint< K, MG_ACTIVE > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	mul (rmint< K, MG_ACTIVE > &a, const T &b)
template<size_t K>
rmint< K, MGA > &	to_mg (rmint< K, MGA > &a, const rmint< K, MGA > &b)
template<size_t K>
rmint< K, MGA > &	to_mg (rmint< K, MGA > &a)
template<size_t K>
rmint< K, MGA > &	reduction (rmint< K, MGA > &t, const ruint< K+1 > &c)
template<size_t K>
rmint< K, MGA > &	reduction (rmint< K, MGA > &t, const ruint< K > &c)
template<size_t K>
rmint< K, MGA > &	reduction (rmint< K, MGA > &t, const rmint< K, MGA > &c)
template<size_t K>
rmint< K, MGA > &	reduction (rmint< K, MGA > &t)
template<size_t K>
ruint< K >	get_ruint (const rmint< K, MGA > &a)
template<size_t K>
rmint< K, MGA > &	get_ready (rmint< K, MGA > &a)
template<size_t K, size_t MG>
void	reset (rmint< K, MG > &a)
template<size_t K, size_t MG>
void	copy (rmint< K, MG > &a, const rmint< K, MG > &b)
template<size_t K, size_t MG>
rmint< K, MG > &	operator*= (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
rmint< K, MG >	operator* (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
MG const T const rmint< K, MG > &void	mul (rmint< K, MG > &, const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
void	mul (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
void	square (rmint< K, MG > &a, const rmint< K, MG > &b)
template<size_t K, size_t MG>
void	square (rmint< K, MG > &a)
template<size_t K, size_t MG>
void	mul (rmint< K, MG > &a, const rmint< K, MG > &b, const rmint< K, MG > &c)
template<size_t K, size_t MG>
rmint< K, MG >	operator- (const rmint< K, MG > &)
template<size_t K, size_t MG>
rmint< K, MG > &	neg (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
rmint< K, MG > &	neg (rmint< K, MG > &)
template<size_t K, size_t MG>
void	rand (rmint< K, MG > &a)
template<size_t K, size_t MG>
rmint< K, MG > &	operator-- (rmint< K, MG > &)
template<size_t K, size_t MG>
rmint< K, MG >	operator-- (rmint< K, MG > &, int)
template<size_t K, size_t MG>
rmint< K, MG > &	operator-= (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
rmint< K, MG >	operator- (const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
MG const T const rmint< K, MG > &rmint< K, MG > &	sub (rmint< K, MG > &, const rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
rmint< K, MG > &	sub (rmint< K, MG > &, const rmint< K, MG > &)
template<size_t K, size_t MG>
rmint< K, MG > &	sub (rmint< K, MG > &a, const rmint< K, MG > &b, const rmint< K, MG > &c)
return	sub (a, b, cp)
return	sub (a, bp)
template<size_t K>
rint< K > &	operator*= (rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type	operator*= (rint< K > &, const T &)
template<size_t K>
rint< K >	operator* (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type	operator* (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type	operator* (const T &, const rint< K > &)
template<size_t K>
rint< K > &	mul (rint< K > &a, const rint< K > &b, const rint< K > &c)
template<size_t K>
rint< K > &	mul (rint< K > &a, const rint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type	mul (rint< K > &a, const rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type	mul (rint< K > &a, const T &c)
template<size_t K>
void	lmul (rint< K+1 > &, const rint< K > &, const rint< K > &)
template<size_t K>
void	addmul (rint< K > &, const rint< K > &, const rint< K > &)
template<size_t K>
void	lsquare (rint< K+1 > &a, const rint< K > &b)
template<size_t K>
rint< K > &	rand (rint< K > &a)
template<size_t K>
void	reset (rint< K > &a)
template<size_t K>
void	copy (rint< K > &a, const rint< K > &b)
template<size_t K>
rint< K > &	operator-- (rint< K > &)
template<size_t K>
rint< K >	operator-- (rint< K > &, int)
template<size_t K>
rint< K > &	operator-= (rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, rint< K > & >::type	operator-= (rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, rint< K > & >::type	operator-= (rint< K > &, const T &)
template<size_t K>
rint< K >	operator- (const rint< K > &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, rint< K > >::type	operator- (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, rint< K > >::type	operator- (const T &, const rint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, rint< K > >::type	operator- (const rint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, rint< K > >::type	operator- (const T &, const rint< K > &)
template<size_t K>
void	sub (bool &r, rint< K > &a, const rint< K > &b, const rint< K > &c)
template<size_t K>
void	sub (bool &r, rint< K > &a, const rint< K > &c)
template<size_t K>
rint< K > &	sub (rint< K > &a, const rint< K > &b, const rint< K > &c)
template<size_t K>
rint< K > &	sub (rint< K > &a, const rint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (bool &r, rint< K > &a, const rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (bool &r, rint< K > &a, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (rint< K > &a, const rint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (rint< K > &a, const T &c)
template<size_t K>
void	sub_1 (bool &r, rint< K > &a, const rint< K > &b)
template<size_t K>
void	sub_1 (bool &r, rint< K > &a)
template<size_t K>
void	sub_1 (rint< K > &a, const rint< K > &b)
template<size_t K>
void	sub_1 (rint< K > &a)
template<size_t K>
ruint< K > &	operator++ (ruint< K > &)
template<size_t K>
ruint< K >	operator++ (ruint< K > &, int)
template<size_t K>
ruint< K > &	operator+= (ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > & >::type	operator+= (ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > & >::type	operator+= (ruint< K > &, const T &)
template<size_t K>
ruint< K >	operator+ (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type	operator+ (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type	operator+ (const T &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > >::type	operator+ (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > >::type	operator+ (const T &, const ruint< K > &)
template<size_t K>
void	add (bool &r, ruint< K > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	add (bool &r, ruint< K > &a, const ruint< K > &c)
template<size_t K>
void	add (ruint< K > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	add (ruint< K > &a, const ruint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (bool &r, ruint< K > &a, const ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (bool &r, ruint< K > &a, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (ruint< K > &a, const ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (ruint< K > &a, const T &c)
template<size_t K>
void	add_1 (bool &r, ruint< K > &a, const ruint< K > &b)
template<size_t K>
void	add_1 (bool &r, ruint< K > &a)
template<size_t K>
void	add_1 (ruint< K > &a, const ruint< K > &b)
template<size_t K>
void	add_1 (ruint< K > &a)
template<size_t K>
void	add_wc (bool &r, ruint< K > &a, const ruint< K > &b, const ruint< K > &c, const bool &cy)
template<size_t K>
void	add_wc (bool &r, ruint< K > &a, const ruint< K > &c, const bool &cy)
template<size_t K>
void	add_wc (ruint< K > &a, const ruint< K > &b, const ruint< K > &c, const bool &cy)
template<size_t K>
void	add_wc (ruint< K > &a, const ruint< K > &c, const bool &cy)
template<>
void	add (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b, const ruint< 6+1 > &c)
template<>
void	add (bool &r, ruint< 6 > &a, const ruint< 6 > &b, const ruint< 6 > &c)
template<>
void	add (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b)
template<>
void	add (bool &r, ruint< 6 > &a, const ruint< 6 > &b)
template<>
void	add (ruint< 6+1 > &a, const ruint< 6+1 > &b, const ruint< 6+1 > &c)
template<>
void	add (ruint< 6 > &a, const ruint< 6 > &b, const ruint< 6 > &c)
template<>
void	add (ruint< 6+1 > &a, const ruint< 6+1 > &b)
template<>
void	add (ruint< 6 > &a, const ruint< 6 > &b)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b, const T &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (bool &r, ruint< 6 > &a, const ruint< 6 > &b, const T &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (bool &r, ruint< 6+1 > &a, const T &b)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	add (bool &r, ruint< 6 > &a, const T &b)
template<>
void	add_1 (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b)
template<>
void	add_1 (bool &r, ruint< 6 > &a, const ruint< 6 > &b)
template<>
void	add_1 (bool &r, ruint< 6+1 > &a)
template<>
void	add_1 (bool &r, ruint< 6 > &a)
template<>
void	add_1 (ruint< 6+1 > &a, const ruint< 6+1 > &b)
template<>
void	add_1 (ruint< 6 > &a, const ruint< 6 > &b)
template<>
void	add_1 (ruint< 6+1 > &a)
template<>
void	add_1 (ruint< 6 > &a)
template<>
void	add_wc (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b, const ruint< 6+1 > &c, const bool &cy)
template<>
void	add_wc (bool &r, ruint< 6 > &a, const ruint< 6 > &b, const ruint< 6 > &c, const bool &cy)
template<>
void	add_wc (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b, const bool &cy)
template<>
void	add_wc (bool &r, ruint< 6 > &a, const ruint< 6 > &b, const bool &cy)
template<>
void	add_wc (ruint< 6+1 > &a, const ruint< 6+1 > &b, const ruint< 6+1 > &c, const bool &cy)
template<>
void	add_wc (ruint< 6 > &a, const ruint< 6 > &b, const ruint< 6 > &c, const bool &cy)
template<>
void	add_wc (ruint< 6+1 > &a, const ruint< 6+1 > &b, const bool &cy)
template<>
void	add_wc (ruint< 6 > &a, const ruint< 6 > &b, const bool &cy)
template<size_t K>
void	laddmul (bool &r, ruint< K+1 > &a, const ruint< K > &b, const ruint< K > &c, const ruint< K > &d)
template<size_t K>
void	laddmul (bool &r, ruint< K > &ah, ruint< K > &al, const ruint< K > &b, const ruint< K > &c, const ruint< K > &d)
template<size_t K>
void	laddmul (ruint< K+1 > &a, const ruint< K > &b, const ruint< K > &c, const ruint< K > &d)
template<size_t K>
void	laddmul (ruint< K > &ah, ruint< K > &al, const ruint< K > &b, const ruint< K > &c, const ruint< K > &d)
template<size_t K>
void	laddmul (bool &r, ruint< K+1 > &a, const ruint< K > &b, const ruint< K > &c, const ruint< K+1 > &d)
template<size_t K>
void	laddmul (bool &r, ruint< K > &ah, ruint< K > &al, const ruint< K > &b, const ruint< K > &c, const ruint< K+1 > &d)
template<size_t K>
void	addmul (ruint< K > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	addmul (ruint< K > &a, const ruint< K > &b, const UDItype &c)
template<>
void	laddmul (bool &r, ruint< 6 > &ah, ruint< 6 > &al, const ruint< 6 > &b, const ruint< 6 > &c, const ruint< 6 > &d)
template<>
void	laddmul (ruint< 6 > &ah, ruint< 6 > &al, const ruint< 6 > &b, const ruint< 6 > &c, const ruint< 6 > &d)
template<>
void	laddmul (bool &r, ruint< 6 > &ah, ruint< 6 > &al, const ruint< 6 > &b, const ruint< 6 > &c, const ruint< 6+1 > &d)
template<>
void	addmul (ruint< 6 > &a, const ruint< 6 > &b, const ruint< 6 > &c)
template<size_t K>
bool	operator== (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator== (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator== (const T &, const ruint< K > &)
template<size_t K>
bool	operator!= (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator!= (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator!= (const T &, const ruint< K > &)
template<size_t K>
bool	operator> (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator> (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator> (const T &, const ruint< K > &)
template<size_t K>
bool	operator>= (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator>= (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator>= (const T &, const ruint< K > &)
template<size_t K>
bool	operator< (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator< (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator< (const T &, const ruint< K > &)
template<size_t K>
bool	operator<= (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator<= (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, bool >::type	operator<= (const T &, const ruint< K > &)
template<size_t K>
int	cmp (const ruint< K > &a, const ruint< K > &b)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, int >::type	cmp (const ruint< K > &a, const T &b)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, int >::type	cmp (const ruint< K > &a, const T &b)
template<>
int	cmp (const ruint< 6 > &a, const ruint< 6 > &b)
template<typename T>
std::enable_if< std::is_unsigned< T >::value, int >::type	cmp (const ruint< 6 > &a, const T &b)
template<typename T>
std::enable_if< std::is_signed< T >::value, int >::type	cmp (const ruint< 6 > &a, const T &b)
template<size_t K>
ruint< K > &	mpz_to_ruint (ruint< K > &, const mpz_class &)
template<size_t K>
mpz_class &	ruint_to_mpz (mpz_class &, const ruint< K > &)
template<size_t K>
mpz_ptr	ruint_to_mpz_t (mpz_ptr a, const ruint< K > &b)
template<size_t K>
ruint< K > &	mpz_t_to_ruint (ruint< K > &a, mpz_srcptr b)
template<size_t K>
std::ostream &	operator<< (std::ostream &, const ruint< K > &)
template<size_t K>
std::istream &	operator>> (std::istream &, ruint< K > &)
template<>
std::ostream &	operator<< (std::ostream &out, const ruint< 6 > &a)
template<size_t K>
std::ostream &	display_dec (std::ostream &out, const ruint< K > &a)
template<size_t K>
std::ostream &	display_hex (std::ostream &out, const ruint< K > &a)
template<>
std::ostream &	display_hex (std::ostream &out, const ruint< 6 > &a)
template<size_t K>
std::ostream &	write_raw (std::ostream &out, const ruint< K > &a)
template<size_t K>
std::istream &	read_raw (std::istream &is, ruint< K > &a)
template<size_t K>
ruint< K > &	operator%= (ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type	operator%= (ruint< K > &, const T &)
template<size_t K>
ruint< K > &	operator/= (ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > & >::type	operator/= (ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > & >::type	operator/= (ruint< K > &, const T &)
template<size_t K>
ruint< K >	operator% (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > >::type	operator% (const ruint< K > &, const T &)
template<size_t K>
ruint< K >	operator/ (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type	operator/ (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > >::type	operator/ (const ruint< K > &, const T &)
template<size_t K>
void	div_3_2 (ruint< K > &q, ruint< K > &r1, ruint< K > &r0, const ruint< K > &a2, const ruint< K > &a1, const ruint< K > &a0, const ruint< K > &b1, const ruint< K > &b0)
template<size_t K>
void	div_2_1 (ruint< K > &q, ruint< K > &r, const ruint< K > &a1, const ruint< K > &a0, const ruint< K > &b)
template<size_t K>
void	div (ruint< K > &q, ruint< K > &r, const ruint< K > &a, const ruint< K > &b)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	div (ruint< K > &q, T &r, const ruint< K > &a, const T &b)
template<size_t K>
ruint< K > &	div_q (ruint< K > &q, const ruint< K > &a, const ruint< K > &b)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type	div_q (ruint< K > &q, const ruint< K > &a, const T &b)
template<size_t K>
ruint< K > &	div_r (ruint< K > &r, const ruint< K > &a, const ruint< K > &b)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, T & >::type	div_r (T &r, const ruint< K > &a, const T &b)
template<>
void	div_3_2 (ruint< 6 > &q, ruint< 6 > &r1, ruint< 6 > &r0, const ruint< 6 > &a2, const ruint< 6 > &a1, const ruint< 6 > &a0, const ruint< 6 > &b1, const ruint< 6 > &b0)
template<>
void	div_2_1 (ruint< 6 > &q, ruint< 6 > &r, const ruint< 6 > &ah, const ruint< 6 > &al, const ruint< 6 > &b)
void	udiv_qrnd (limb &q, limb &r, const limb &a, const limb &b)
template<>
void	div (ruint< 6 > &q, ruint< 6 > &r, const ruint< 6 > &a, const ruint< 6 > &b)
template<size_t K>
void	exp_mod (ruint< K > &a, const ruint< K > &b, const ruint< K > &c, const ruint< K > &n)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, void >::type	exp_mod (ruint< K > &a, const ruint< K > &b, const T &c, const ruint< K > &n)
template<size_t K>
ruint< K >	operator~ (const ruint< K > &c)
template<size_t K>
ruint< K >	operator- (const ruint< K > &c)
template<size_t K>
ruint< K > &	neg (ruint< K > &, const ruint< K > &)
template<size_t K>
ruint< K > &	neg (ruint< K > &)
template<size_t K>
ruint< K > &	operator|= (ruint< K > &b, const ruint< K > &c)
template<size_t K>
ruint< K > &	operator^= (ruint< K > &b, const ruint< K > &c)
template<size_t K>
ruint< K > &	operator&= (ruint< K > &b, const ruint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type	operator|= (ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type	operator^= (ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type	operator&= (ruint< K > &b, const T &c)
template<size_t K>
ruint< K >	operator| (const ruint< K > &b, const ruint< K > &c)
template<size_t K>
ruint< K >	operator^ (const ruint< K > &b, const ruint< K > &c)
template<size_t K>
ruint< K >	operator& (const ruint< K > &b, const ruint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > >::type	operator| (const ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > >::type	operator^ (const ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, T >::type	operator& (const ruint< K > &b, const T &c)
template<size_t K>
ruint< K > &	max_pow_two (ruint< K > &a)
template<size_t K>
bool	highest_bit (const ruint< K > &a)
template<size_t K>
bool	lowest_bit (const ruint< K > &a)
template<size_t K>
void	set_highest_bit (ruint< K > &a)
template<size_t K>
void	set_lowest_bit (ruint< K > &a)
template<size_t K>
void	set_highest_word (ruint< K > &a, const limb w)
template<size_t K>
void	set_lowest_word (ruint< K > &a, const limb w)
template<>
ruint< 6 >	operator~ (const ruint< 6 > &c)
template<>
ruint< 6 > &	neg (ruint< 6 > &r, const ruint< 6 > &c)
template<>
ruint< 6 > &	operator|= (ruint< 6 > &b, const ruint< 6 > &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< 6 > & >::type	operator|= (ruint< 6 > &b, const T &c)
template<>
ruint< 6 > &	operator^= (ruint< 6 > &b, const ruint< 6 > &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< 6 > & >::type	operator^= (ruint< 6 > &b, const T &c)
template<>
ruint< 6 > &	operator&= (ruint< 6 > &b, const ruint< 6 > &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< 6 > & >::type	operator&= (ruint< 6 > &b, const T &c)
template<>
ruint< 6 > &	max_pow_two (ruint< 6 > &a)
template<>
bool	highest_bit (const ruint< 6 > &a)
template<>
bool	lowest_bit (const ruint< 6 > &a)
template<>
void	set_highest_bit (ruint< 6 > &a)
template<>
void	set_lowest_bit (ruint< 6 > &a)
template<>
void	set_highest_word (ruint< 6 > &a, const limb w)
template<>
void	set_lowest_word (ruint< 6 > &a, const limb w)
template<size_t K>
ruint< K > &	gcd (ruint< K > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
ruint< K >	gcd (const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	bezout_mod (ruint< K > &x, ruint< K > &y, const ruint< K > &c, const ruint< K > &d)
template<size_t K>
ruint< K > &	inv_mod (ruint< K > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	reset (ruint< K > &a)
template<size_t K>
ruint< K > &	fill_with_1 (ruint< K > &a)
template<size_t K>
void	copy (ruint< K > &a, const ruint< K > &b)
template<size_t K>
void	pointers_list (limb **p, const ruint< K > &a)
template<size_t K>
void	set_limb (ruint< K > &a, const limb &b, unsigned int index)
template<size_t K>
limb	ms_limb (const ruint< K > &a)
template<size_t K>
limb	get_limb (const ruint< K > &a, unsigned int index)
template<size_t K>
const limb *	get_limb_p (const ruint< K > &a, unsigned int index)
template<size_t K>
const limb *	begin (const ruint< K > &a)
template<>
void	reset (ruint< 6 > &a)
template<>
ruint< 6 > &	fill_with_1 (ruint< 6 > &a)
template<>
void	copy (ruint< 6 > &a, const ruint< 6 > &b)
template<>
void	pointers_list (limb **tab, const ruint< 6 > &a)
template<>
void	set_limb (ruint< 6 > &a, const limb &b, unsigned int index)
template<>
limb	ms_limb (const ruint< 6 > &a)
template<>
limb	get_limb (const ruint< 6 > &a, unsigned int)
template<>
const limb *	get_limb_p (const ruint< 6 > &a, unsigned int)
template<>
const limb *	begin (const ruint< 6 > &a)
template<size_t K>
ruint< K > &	operator*= (ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > & >::type	operator*= (ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > & >::type	operator*= (ruint< K > &, const T &)
template<size_t K>
ruint< K >	operator* (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type	operator* (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type	operator* (const T &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > >::type	operator* (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > >::type	operator* (const T &, const ruint< K > &)
template<size_t K>
void	lmul_naive (ruint< K+1 > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	lmul_naive (ruint< K > &ah, ruint< K > &al, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	lmul_kara (ruint< K+1 > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	lmul_kara (ruint< K > &ah, ruint< K > &al, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	lmul (ruint< K+1 > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	lmul (ruint< K > &ah, ruint< K > &al, const ruint< K > &b, const ruint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	lmul (ruint< K+1 > &a, const ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	lmul (limb &ah, ruint< K > &al, const ruint< K > &b, const T &c)
template<size_t K>
ruint< K > &	mul (ruint< K > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
ruint< K > &	mul (ruint< K > &a, const ruint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type	mul (ruint< K > &a, const ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type	mul (ruint< K > &a, const T &c)
template<size_t K>
ruint< K+1 > &	lsquare (ruint< K+1 > &a, const ruint< K > &b)
template<size_t K>
ruint< K > &	square (ruint< K > &al, const ruint< K > &b)
template<>
void	lmul_naive (ruint< 6 > &ah, ruint< 6 > &al, const ruint< 6 > &b, const ruint< 6 > &c)
template<>
void	lmul_kara (ruint< 6 > &ah, ruint< 6 > &al, const ruint< 6 > &b, const ruint< 6 > &c)
template<>
void	lmul (ruint< 6 > &ah, ruint< 6 > &al, const ruint< 6 > &b, const ruint< 6 > &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	lmul (limb &ret, ruint< 6 > &a, const ruint< 6 > &b, const T &c)
template<>
ruint< 6 > &	mul (ruint< 6 > &al, const ruint< 6 > &b, const ruint< 6 > &c)
template<>
ruint< 6 > &	mul (ruint< 6 > &al, const ruint< 6 > &c)
template<>
ruint< 6+1 > &	lsquare (ruint< 6+1 > &a, const ruint< 6 > &b)
template<>
ruint< 6 > &	square (ruint< 6 > &al, const ruint< 6 > &b)
template<size_t K>
ruint< K > &	rand (ruint< K > &a)
void	srand (const limb s)
template<>
ruint< 6 > &	rand (ruint< 6 > &a)
template<size_t K, typename T>
ruint< K >	operator<< (const ruint< K > &, const T &)
template<size_t K, typename T>
ruint< K >	operator>> (const ruint< K > &, const T &)
template<size_t K, typename T>
ruint< K > &	operator<<= (ruint< K > &, const T &)
template<size_t K, typename T>
ruint< K > &	operator>>= (ruint< K > &, const T &)
template<size_t K, typename T>
ruint< K > &	left_shift (ruint< K > &a, const ruint< K > &b, const T &c)
template<size_t K>
ruint< K > &	left_shift_1 (bool &z, ruint< K > &a, const ruint< K > &b)
template<size_t K>
ruint< K > &	left_shift_1 (ruint< K > &a, const ruint< K > &b)
template<size_t K, typename T>
ruint< K > &	right_shift (ruint< K > &a, const ruint< K > &b, const T &c)
template<size_t K>
ruint< K > &	right_shift_1 (bool &z, ruint< K > &a, const ruint< K > &b)
template<size_t K>
ruint< K > &	right_shift_1 (ruint< K > &a, const ruint< K > &b)
template<size_t K, typename T>
void	left_shift (ruint< K+1 > &b, const ruint< K > &a, const T &m)
template<typename T>
ruint< 6 > &	left_shift (ruint< 6 > &b, const ruint< 6 > &a, const T &d)
template<>
ruint< 6 > &	left_shift_1 (bool &z, ruint< 6 > &b, const ruint< 6 > &a)
template<typename T>
ruint< 6 > &	right_shift (ruint< 6 > &b, const ruint< 6 > &a, const T &d)
template<>
ruint< 6 > &	right_shift_1 (bool &z, ruint< 6 > &b, const ruint< 6 > &a)
template<size_t K>
ruint< K > &	operator-- (ruint< K > &)
template<size_t K>
ruint< K >	operator-- (ruint< K > &, int)
template<size_t K>
ruint< K > &	operator-= (ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > & >::type	operator-= (ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > & >::type	operator-= (ruint< K > &, const T &)
template<size_t K>
ruint< K >	operator- (const ruint< K > &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type	operator- (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type	operator- (const T &, const ruint< K > &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > >::type	operator- (const ruint< K > &, const T &)
template<size_t K, typename T>
std::enable_if< std::is_signed< T >::value, ruint< K > >::type	operator- (const T &, const ruint< K > &)
template<size_t K>
void	sub (bool &r, ruint< K > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
void	sub (bool &r, ruint< K > &a, const ruint< K > &c)
template<size_t K>
ruint< K > &	sub (ruint< K > &a, const ruint< K > &b, const ruint< K > &c)
template<size_t K>
ruint< K > &	sub (ruint< K > &a, const ruint< K > &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (bool &r, ruint< K > &a, const ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (bool &r, ruint< K > &a, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (ruint< K > &a, const ruint< K > &b, const T &c)
template<size_t K, typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (ruint< K > &a, const T &c)
template<size_t K>
void	sub_1 (bool &r, ruint< K > &a, const ruint< K > &b)
template<size_t K>
void	sub_1 (bool &r, ruint< K > &a)
template<size_t K>
void	sub_1 (ruint< K > &a, const ruint< K > &b)
template<size_t K>
void	sub_1 (ruint< K > &a)
template<size_t K>
void	sub_wc (bool &r, ruint< K > &a, const ruint< K > &b, const ruint< K > &c, const bool &cy)
template<size_t K>
void	sub_wc (bool &r, ruint< K > &a, const ruint< K > &c, const bool &cy)
template<size_t K>
void	sub_wc (ruint< K > &a, const ruint< K > &b, const ruint< K > &c, const bool &cy)
template<size_t K>
void	sub_wc (ruint< K > &a, const ruint< K > &c, const bool &cy)
template<>
void	sub (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b, const ruint< 6+1 > &c)
template<>
void	sub (bool &r, ruint< 6 > &a, const ruint< 6 > &b, const ruint< 6 > &c)
template<>
void	sub (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b)
template<>
void	sub (bool &r, ruint< 6 > &a, const ruint< 6 > &b)
template<>
ruint< 6+1 > &	sub (ruint< 6+1 > &a, const ruint< 6+1 > &b, const ruint< 6+1 > &c)
template<>
ruint< 6 > &	sub (ruint< 6 > &a, const ruint< 6 > &b, const ruint< 6 > &c)
template<>
ruint< 6+1 > &	sub (ruint< 6+1 > &a, const ruint< 6+1 > &b)
template<>
ruint< 6 > &	sub (ruint< 6 > &a, const ruint< 6 > &b)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b, const T &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (bool &r, ruint< 6 > &a, const ruint< 6 > &b, const T &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (bool &r, ruint< 6+1 > &a, const T &b)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (bool &r, ruint< 6 > &a, const T &b)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (ruint< 6+1 > &a, const ruint< 6+1 > &b, const T &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (ruint< 6 > &a, const ruint< 6 > &b, const T &c)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (ruint< 6+1 > &a, const T &b)
template<typename T>
std::enable_if< std::is_arithmetic< T >::value, void >::type	sub (ruint< 6 > &a, const T &b)
template<>
void	sub_1 (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b)
template<>
void	sub_1 (bool &r, ruint< 6 > &a, const ruint< 6 > &b)
template<>
void	sub_1 (bool &r, ruint< 6+1 > &a)
template<>
void	sub_1 (bool &r, ruint< 6 > &a)
template<>
void	sub_1 (ruint< 6+1 > &a, const ruint< 6+1 > &b)
template<>
void	sub_1 (ruint< 6 > &a, const ruint< 6 > &b)
template<>
void	sub_1 (ruint< 6+1 > &a)
template<>
void	sub_1 (ruint< 6 > &a)
template<>
void	sub_wc (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b, const ruint< 6+1 > &c, const bool &cy)
template<>
void	sub_wc (bool &r, ruint< 6 > &a, const ruint< 6 > &b, const ruint< 6 > &c, const bool &cy)
template<>
void	sub_wc (bool &r, ruint< 6+1 > &a, const ruint< 6+1 > &b, const bool &cy)
template<>
void	sub_wc (bool &r, ruint< 6 > &a, const ruint< 6 > &b, const bool &cy)
template<>
void	sub_wc (ruint< 6+1 > &a, const ruint< 6+1 > &b, const ruint< 6+1 > &c, const bool &cy)
template<>
void	sub_wc (ruint< 6 > &a, const ruint< 6 > &b, const ruint< 6 > &c, const bool &cy)
template<>
void	sub_wc (ruint< 6+1 > &a, const ruint< 6+1 > &b, const bool &cy)
template<>
void	sub_wc (ruint< 6 > &a, const ruint< 6 > &b, const bool &cy)
template<size_t K>
void	normalization (UDItype &d, const ruint< K > &b)
template<size_t K>
void	mod_n (ruint< K > &a, const ruint< K+1 > &b, const ruint< K > &n)
template<size_t K>
void	mod_n (ruint< K > &a, const ruint< K > &b, const ruint< K > &n)
template<size_t K>
void	mod_n (ruint< K > &a, const ruint< K > &n)

Variables
const unsigned char	__clz_tab [129]
MG &	a
MG const rmint< K, MG > &	b
MG const rmint< K, MG > const T &	c
a	p
template<size_t K>
ruint< K >	rmint< K, MG_INACTIVE >::p = 0
template<size_t K>
ruint< K >	rmint< K, MG_ACTIVE >::p = 0
template<size_t K>
ruint< K >	rmint< K, MG_ACTIVE >::p1 = 0
template<size_t K>
ruint< K >	rmint< K, MG_ACTIVE >::r = 0

Detailed Description

NOTE : For this common file, either basic/reduc.h or mg/reduc.h has to be pre-included.

The same goes for (basic|mg)/arith/mul.h

Typedef Documentation

limb

typedef uint64_t limb

UWtype

typedef uint64_t UWtype

UHWtype

typedef uint64_t UHWtype

UDWtype

typedef uint64_t UDWtype

UDItype

typedef uint64_t UDItype

USItype

typedef uint32_t USItype

DItype

typedef int64_t DItype

SItype

typedef int32_t SItype

rmint64

using rmint64 = rmint<6>

rmint128

using rmint128 = rmint<7>

rmint256

using rmint256 = rmint<8>

rmint512

using rmint512 = rmint<9>

rint64

using rint64 = rint<6>

rint128

using rint128 = rint<7>

rint256

using rint256 = rint<8>

rint512

using rint512 = rint<9>

ruint64

using ruint64 = ruint<6>

ruint128

using ruint128 = ruint<7>

ruint256

using ruint256 = ruint<8>

ruint512

using ruint512 = ruint<9>

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MG_INACTIVE
MG_ACTIVE

Function Documentation

operator++() [1/6]

template<size_t K>

rint< K > & operator++ ( rint< K > & a )

inline

operator++() [2/6]

template<size_t K>

rint< K > operator++ ( rint< K > & a, int  )

inline

operator+=() [1/7]

template<size_t K>

rint< K > & operator+= ( rint< K > & a, const rint< K > & b )

inline

operator+=() [2/7]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, rint< K > & >::type operator+= ( rint< K > & a, const T & b )

inline

operator+=() [3/7]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, rint< K > & >::type operator+= ( rint< K > & a, const T & b )

inline

operator+() [1/13]

template<size_t K>

rint< K > operator+ ( const rint< K > & b, const rint< K > & c )

inline

operator+() [2/13]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, rint< K > >::type operator+ ( const rint< K > & b, const T & c )

inline

operator+() [3/13]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, rint< K > >::type operator+ ( const T & c, const rint< K > & b )

inline

operator+() [4/13]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, rint< K > >::type operator+ ( const rint< K > & b, const T & c )

inline

operator+() [5/13]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, rint< K > >::type operator+ ( const T & c, const rint< K > & b )

inline

add() [1/33]

template<size_t K>

void add ( bool & r, rint< K > & a, const rint< K > & b, const rint< K > & c )

inline

add() [2/33]

template<size_t K>

void add ( bool & r, rint< K > & a, const rint< K > & c )

inline

add() [3/33]

template<size_t K>

void add ( rint< K > & a, const rint< K > & b, const rint< K > & c )

inline

add() [4/33]

template<size_t K>

void add ( rint< K > & a, const rint< K > & c )

inline

add() [5/33]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( bool & r, rint< K > & a, const rint< K > & b, const T & c )

inline

add() [6/33]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( bool & r, rint< K > & a, const T & c )

inline

add() [7/33]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( rint< K > & a, const rint< K > & b, const T & c )

inline

add() [8/33]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( rint< K > & a, const T & c )

inline

add_1() [1/16]

template<size_t K>

void add_1 ( bool & r, rint< K > & a, const rint< K > & b )

inline

add_1() [2/16]

template<size_t K>

void add_1 ( bool & r, rint< K > & a )

inline

add_1() [3/16]

template<size_t K>

void add_1 ( rint< K > & a, const rint< K > & b )

inline

add_1() [4/16]

template<size_t K>

void add_1 ( rint< K > & a )

inline

operator+() [6/13]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type operator+ ( const rint< K > & b, const T & c )

inline

operator+() [7/13]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type operator+ ( const T & c, const rint< K > & b )

inline

operator==() [1/10]

template<size_t K>

bool operator== ( const rint< K > & a, const rint< K > & b )

inline

operator==() [2/10]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator== ( const rint< K > & a, const T & b )

inline

operator==() [3/10]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator== ( const T & b, const rint< K > & a )

inline

operator!=() [1/8]

template<size_t K>

bool operator!= ( const rint< K > & a, const rint< K > & b )

inline

operator!=() [2/8]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator!= ( const rint< K > & a, const T & b )

inline

operator!=() [3/8]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator!= ( const T & b, const rint< K > & a )

inline

operator>() [1/8]

template<size_t K>

bool operator> ( const rint< K > & a, const rint< K > & b )

inline

operator>() [2/8]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator> ( const rint< K > & a, const T & b )

inline

operator>() [3/8]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator> ( const T & b, const rint< K > & a )

inline

operator>=() [1/7]

template<size_t K>

bool operator>= ( const rint< K > & a, const rint< K > & b )

inline

operator>=() [2/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator>= ( const rint< K > & a, const T & b )

inline

operator>=() [3/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator>= ( const T & b, const rint< K > & a )

inline

operator<() [1/7]

template<size_t K>

bool operator< ( const rint< K > & a, const rint< K > & b )

inline

operator<() [2/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator< ( const rint< K > & a, const T & b )

inline

operator<() [3/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator< ( const T & b, const rint< K > & a )

inline

operator<=() [1/9]

template<size_t K>

bool operator<= ( const rint< K > & a, const rint< K > & b )

inline

operator<=() [2/9]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator<= ( const rint< K > & a, const T & b )

inline

operator<=() [3/9]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator<= ( const T & b, const rint< K > & a )

inline

cmp() [1/9]

template<size_t K>

int cmp ( const rint< K > & a, const rint< K > & b )

inline

cmp() [2/9]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, int >::type cmp ( const rint< K > & a, const T & b )

inline

cmp() [3/9]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, int >::type cmp ( const rint< K > & a, const T & b )

inline

mpz_to_rint() [1/2]

template<size_t K>

rint< K > & mpz_to_rint	(	ruint< K > &	,
		const mpz_class &	)

rint_to_mpz()

template<size_t K>

mpz_class & rint_to_mpz ( mpz_class & a, const rint< K > & b )

inline

mpz_to_rint() [2/2]

template<size_t K>

rint< K > & mpz_to_rint ( rint< K > & a, const mpz_class & b )

inline

rint_to_mpz_t()

template<size_t K>

mpz_ptr rint_to_mpz_t ( mpz_ptr a, const rint< K > & b )

inline

mpz_t_to_rint()

template<size_t K>

rint< K > & mpz_t_to_rint ( rint< K > & a, mpz_srcptr b )

inline

operator<<() [1/6]

template<size_t K>

std::ostream & operator<< ( std::ostream & out, const rint< K > & a )

inline

display_dec() [1/2]

template<size_t K>

std::ostream & display_dec ( std::ostream & out, const rint< K > & a )

inline

operator>>() [1/5]

template<size_t K>

std::istream & operator>> ( std::istream & is, rint< K > & a )

inline

operator%=() [1/6]

template<size_t K>

rint< K > & operator%= ( rint< K > & a, const rint< K > & b )

inline

operator%=() [2/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type operator%= ( rint< K > & a, const T & b )

inline

operator/=() [1/7]

template<size_t K>

rint< K > & operator/= ( rint< K > & a, const rint< K > & b )

inline

operator/=() [2/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type operator/= ( rint< K > & a, const T & b )

inline

operator%() [1/6]

template<size_t K>

rint< K > operator% ( const rint< K > & b, const rint< K > & c )

inline

operator%() [2/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type operator% ( const rint< K > & b, const T & c )

inline

operator/() [1/7]

template<size_t K>

rint< K > operator/ ( const rint< K > & b, const rint< K > & c )

inline

operator/() [2/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type operator/ ( const rint< K > & b, const T & c )

inline

div_q() [1/4]

template<size_t K>

rint< K > & div_q ( rint< K > & q, const rint< K > & a, const rint< K > & b )

inline

div_q() [2/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type div_q ( rint< K > & q, const rint< K > & a, const T & b )

inline

div_r() [1/4]

template<size_t K>

rint< K > & div_r ( rint< K > & r, const rint< K > & a, const rint< K > & b )

inline

div_r() [2/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, T & >::type div_r ( T & r, const rint< K > & a, const T & b )

inline

inv_mod() [1/2]

template<size_t K>

rint< K > & inv_mod ( rint< K > & a, const rint< K > & b, const rint< K > & c )

inline

mod_n() [1/5]

template<size_t K, size_t R>

void mod_n ( rint< K > & a, const rint< R > & b, const rint< K > & c )

inline

mod_n() [2/5]

template<size_t K>

void mod_n ( rint< K > & a, const rint< K > & n )

inline

__recint_umul_ppmm()

UWtype __recint_umul_ppmm ( UWtype * , UWtype , UWtype  )

extern

__recint_umul_ppmm_r()

UWtype __recint_umul_ppmm_r ( UWtype , UWtype , UWtype *  )

extern

__recint_udiv_qrnnd()

UWtype __recint_udiv_qrnnd ( UWtype * , UWtype , UWtype , UWtype  )

extern

__recint_udiv_qrnnd_r()

UWtype __recint_udiv_qrnnd_r ( UWtype , UWtype , UWtype , UWtype *  )

extern

operator~() [1/3]

template<size_t K>

rint< K > operator~ ( const rint< K > & c )

inline

operator-() [1/14]

template<size_t K>

rint< K > operator- ( const rint< K > & c )

inline

neg() [1/7]

template<size_t K>

rint< K > & neg ( rint< K > & r, const rint< K > & c )

inline

neg() [2/7]

template<size_t K>

rint< K > & neg ( rint< K > & r )

inline

operator|=() [1/6]

template<size_t K>

rint< K > & operator|= ( rint< K > & b, const rint< K > & c )

inline

operator^=() [1/6]

template<size_t K>

rint< K > & operator^= ( rint< K > & b, const rint< K > & c )

inline

operator&=() [1/6]

template<size_t K>

rint< K > & operator&= ( rint< K > & b, const rint< K > & c )

inline

operator|=() [2/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type operator|=	(	rint< K > &	b,
		const T &	c )

operator^=() [2/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type operator^= ( rint< K > & b, const T & c )

inline

operator&=() [2/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type operator&= ( rint< K > & b, const T & c )

inline

operator|() [1/4]

template<size_t K>

rint< K > operator| ( const rint< K > & b, const rint< K > & c )

inline

operator^() [1/4]

template<size_t K>

rint< K > operator^ ( const rint< K > & b, const rint< K > & c )

inline

operator&() [1/4]

template<size_t K>

rint< K > operator& ( const rint< K > & b, const rint< K > & c )

inline

operator|() [2/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type operator|	(	const rint< K > &	b,
		const T &	c )

operator^() [2/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type operator^	(	const rint< K > &	b,
		const T &	c )

operator&() [2/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, T >::type operator&	(	const rint< K > &	b,
		const T &	c )

operator<<() [2/6]

template<size_t K, typename T>

rint< K > operator<<	(	const rint< K > &	b,
		const T &	c )

operator>>() [2/5]

template<size_t K, typename T>

rint< K > operator>>	(	const rint< K > &	b,
		const T &	c )

operator<<=() [1/2]

template<size_t K, typename T>

rint< K > & operator<<=	(	rint< K > &	b,
		const T &	c )

operator>>=() [1/2]

template<size_t K, typename T>

rint< K > & operator>>=	(	rint< K > &	b,
		const T &	c )

operator++() [3/6]

template<size_t K, size_t MG>

rmint< K, MG > & operator++ ( rmint< K, MG > & a )

inline

operator++() [4/6]

template<size_t K, size_t MG>

rmint< K, MG > operator++ ( rmint< K, MG > & a, int  )

inline

operator+=() [4/7]

template<size_t K, size_t MG>

rmint< K, MG > & operator+= ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

__RECINT_IS_ARITH() [1/9]

template<size_t K, size_t MG, typename T>

__RECINT_IS_ARITH ( T , rmint< K, MG > &  ) =(rmint<K, MG>&, const T&)

inline

operator+() [8/13]

template<size_t K, size_t MG>

rmint< K, MG > operator+	(	const rmint< K, MG > &	,
		const rmint< K, MG > &	)

__RECINT_IS_ARITH() [2/9]

template<size_t K, size_t MG, typename T>

__RECINT_IS_ARITH	(	T	,
		rmint< K, MG >	) const

__RECINT_IS_ARITH() [3/9]

template<size_t K, size_t MG, typename T>

MG const T & __RECINT_IS_ARITH	(	T	,
		rmint< K, MG >	) const &

add() [9/33]

template<size_t K, size_t MG>

MG const T const rmint< K, MG > &rmint< K, MG > & add ( rmint< K, MG > & a, const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

add() [10/33]

template<size_t K, size_t MG>

rmint< K, MG > & add ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

__RECINT_IS_ARITH() [4/9]

template<size_t K, size_t MG, typename T>

MG const rmint< K, MG > const T & __RECINT_IS_ARITH	(	T	,
		rmint< K, MG > &	)

add() [11/33]

template<size_t K, size_t MG>

rmint< K, MG > & add ( rmint< K, MG > & a, const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

cp()

rmint< K, MG > cp

(

c

)

add() [12/33]

add	(	r	,
		a.	Value,
		b.	Value,
		cp.	Value )

if()

if

(

r||a.Value >=a.

p

)

bp()

rmint< K, MG > bp

(

b

)

add() [13/33]

add	(	r	,
		a.	Value,
		bp.	Value )

addmul() [1/7]

template<size_t K>

rmint< K, MGI > & addmul ( rmint< K, MGI > & a, const rmint< K, MGI > & b, const rmint< K, MGI > & c )

inline

__RECINT_IS_ARITH() [5/9]

template<size_t K, typename T>

__RECINT_IS_ARITH ( T , void  )

inline

addmul() [2/7]

addmul	(	a	,
		b	,
		cr	)

exp() [1/4]

template<size_t K>

void exp ( rmint< K, MG_INACTIVE > & a, const rmint< K, MG_INACTIVE > & b, const ruint< K > & c )

inline

exp() [2/4]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, void >::type exp ( rmint< K, MG_INACTIVE > & a, const rmint< K, MG_INACTIVE > & b, const T & c )

inline

inv() [1/6]

template<size_t K>

rmint< K, MG_INACTIVE > & inv ( rmint< K, MG_INACTIVE > & a, const rmint< K, MG_INACTIVE > & b )

inline

inv() [2/6]

template<size_t K>

rmint< K, MG_INACTIVE > & inv ( rmint< K, MG_INACTIVE > & a )

inline

inv() [3/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG_INACTIVE > & >::type inv ( rmint< K, MG_INACTIVE > & a, const T & b )

inline

mul() [1/17]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type mul ( rmint< K, MG_INACTIVE > & a, const rmint< K, MG_INACTIVE > & b, const T & c )

inline

mul() [2/17]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type mul ( rmint< K, MG_INACTIVE > & a, const T & b )

inline

reduction() [1/8]

template<size_t K>

rmint< K, MGI > & reduction ( rmint< K, MGI > & t, const ruint< K+1 > & c )

inline

reduction() [2/8]

template<size_t K>

rmint< K, MGI > & reduction ( rmint< K, MGI > & t, const ruint< K > & c )

inline

reduction() [3/8]

template<size_t K>

rmint< K, MGI > & reduction ( rmint< K, MGI > & t, const rmint< K, MGI > & c )

inline

reduction() [4/8]

template<size_t K>

rmint< K, MGI > & reduction ( rmint< K, MGI > & t )

inline

get_ruint() [1/2]

template<size_t K>

ruint< K > get_ruint ( const rmint< K, MGI > & a )

inline

get_ready() [1/2]

template<size_t K>

rmint< K, MGI > & get_ready ( rmint< K, MGI > & a )

inline

operator==() [4/10]

template<size_t K, size_t MG>

bool operator== ( const rmint< K, MG > & a, const rmint< K, MG > & b )

inline

operator==() [5/10]

template<size_t K, size_t MG>

bool operator==	(	const rmint< K, MG > &	,
		const ruint< K > &	)

__RECINT_IS_ARITH() [6/9]

template<size_t K, size_t MG, typename T>

__RECINT_IS_ARITH	(	T	,
		bool	) ==(const T&, const rmint<K, MG>&)

operator!=() [4/8]

template<size_t K, size_t MG>

bool operator!=	(	const rmint< K, MG > &	,
		const rmint< K, MG > &	)

operator!=() [5/8]

template<size_t K, size_t MG>

bool operator!=	(	const rmint< K, MG > &	,
		const ruint< K > &	)

operator>() [4/8]

template<size_t K, size_t MG>

bool operator>	(	const rmint< K, MG > &	,
		const rmint< K, MG > &	)

__RECINT_IS_ARITH() [7/9]

template<size_t K, size_t MG, typename T>

MG const T & __RECINT_IS_ARITH	(	T	,
		bool	) const &

operator>=() [4/7]

template<size_t K, size_t MG>

MG const T const rmint< K, MG > &bool operator>=	(	const rmint< K, MG > &	,
		const rmint< K, MG > &	)

operator<() [4/7]

template<size_t K, size_t MG>

bool operator<	(	const rmint< K, MG > &	,
		const rmint< K, MG > &	)

operator<=() [4/9]

template<size_t K, size_t MG>

MG const T const rmint< K, MG > &bool operator<=	(	const rmint< K, MG > &	,
		const rmint< K, MG > &	)

operator==() [6/10]

template<size_t K>

bool operator== ( const rmint< K, MGI > & a, const ruint< K > & b )

inline

operator==() [7/10]

template<size_t K>

bool operator== ( const rmint< K, MGA > & a, const ruint< K > & b )

inline

__RECINT_IS_ARITH() [8/9]

template<size_t K, typename T>

__RECINT_IS_ARITH ( T , bool  )

inline

__RECINT_IS_ARITH() [9/9]

T __RECINT_IS_ARITH ( T , bool  ) const &

inline

operator>() [5/8]

return operator>	(	reduction(ar).	Value,
		b	)

operator<=() [5/9]

template<size_t K>

bool operator<= ( const rmint< K, MGI > & a, const rmint< K, MGI > & b )

inline

operator<=() [6/9]

template<size_t K>

bool operator<= ( const rmint< K, MGA > & a, const rmint< K, MGA > & b )

inline

mpz_to_rmint()

template<size_t K, size_t MG>

rmint< K, MG > & mpz_to_rmint ( rmint< K, MG > & a, const mpz_class & b )

inline

rmint_to_mpz()

template<size_t K, size_t MG>

mpz_class & rmint_to_mpz ( mpz_class & a, const rmint< K, MG > & b )

inline

operator<<() [3/6]

template<size_t K, size_t MG>

std::ostream & operator<< ( std::ostream & out, const rmint< K, MG > & a )

inline

operator>>() [3/5]

template<size_t K, size_t MG>

std::istream & operator>> ( std::istream & is, rmint< K, MG > & a )

inline

write_raw() [1/2]

template<size_t K, size_t MG>

std::ostream & write_raw ( std::ostream & out, const rmint< K, MG > & a )

inline

read_raw() [1/2]

template<size_t K, size_t MG>

std::istream & read_raw ( std::istream & is, rmint< K, MG > & a )

inline

operator%=() [3/6]

template<size_t K, size_t MG>

rmint< K, MG > & operator%= ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

operator%=() [4/6]

template<size_t K, size_t MG, typename T>

std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG > & >::type operator%= ( rmint< K, MG > & a, const T & b )

inline

operator/=() [3/7]

template<size_t K, size_t MG>

rmint< K, MG > & operator/= ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

operator/=() [4/7]

template<size_t K, size_t MG, typename T>

std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG > & >::type operator/= ( rmint< K, MG > & a, const T & b )

inline

operator/() [3/7]

template<size_t K, size_t MG>

rmint< K, MG > operator/ ( const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

operator/() [4/7]

template<size_t K, size_t MG, typename T>

std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG > >::type operator/ ( const rmint< K, MG > & b, const T & c )

inline

operator%() [3/6]

template<size_t K, size_t MG>

rmint< K, MG > operator% ( const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

operator%() [4/6]

template<size_t K, size_t MG, typename T>

std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG > >::type operator% ( const rmint< K, MG > & b, const T & c )

inline

div() [1/7]

template<size_t K, size_t MG>

void div ( rmint< K, MG > & a, const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

div() [2/7]

template<size_t K, size_t MG>

void div ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

div() [3/7]

template<size_t K, size_t MG, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type div ( rmint< K, MG > & a, const rmint< K, MG > & b, const T & c )

inline

div() [4/7]

template<size_t K, size_t MG, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type div ( rmint< K, MG > & a, const T & b )

inline

mod() [1/4]

template<size_t K, size_t MG>

void mod ( rmint< K, MG > & a, const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

mod() [2/4]

template<size_t K, size_t MG>

void mod ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

mod() [3/4]

template<size_t K, size_t MG, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type mod ( rmint< K, MG > & a, const rmint< K, MG > & b, const T & c )

inline

mod() [4/4]

template<size_t K, size_t MG, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type mod ( rmint< K, MG > & a, const T & b )

inline

is_quadratic_residue()

template<size_t K, size_t MG>

bool is_quadratic_residue ( const rmint< K, MG > & a )

inline

square_root()

template<size_t K, size_t MG>

void square_root ( rmint< K, MG > & r, const rmint< K, MG > & a )

inline

addmul() [3/7]

template<size_t K>

rmint< K, MGA > & addmul ( rmint< K, MGA > & a, const rmint< K, MGA > & b, const rmint< K, MGA > & c )

inline

exp() [3/4]

template<size_t K>

void exp ( rmint< K, MG_ACTIVE > & a, const rmint< K, MG_ACTIVE > & b, const UDItype & c )

inline

exp() [4/4]

template<size_t K>

void exp ( rmint< K, MG_ACTIVE > & a, const rmint< K, MG_ACTIVE > & b, const ruint< K > & c )

inline

inv() [4/6]

template<size_t K>

rmint< K, MG_ACTIVE > & inv ( rmint< K, MG_ACTIVE > & a, const rmint< K, MG_ACTIVE > & b )

inline

inv() [5/6]

template<size_t K>

rmint< K, MG_ACTIVE > & inv ( rmint< K, MG_ACTIVE > & a )

inline

inv() [6/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rmint< K, MG_ACTIVE > & >::type inv ( rmint< K, MG_ACTIVE > & a, const T & b )

inline

arazi_qi() [1/2]

template<size_t K>

ruint< K > & arazi_qi ( ruint< K > & u, const ruint< K > & a )

inline

arazi_qi() [2/2]

template<>

ruint< 6 > & arazi_qi ( ruint< 6 > & u, const ruint< 6 > & a )

inline

mul() [3/17]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type mul ( rmint< K, MG_ACTIVE > & a, const rmint< K, MG_ACTIVE > & b, const T & c )

inline

mul() [4/17]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type mul ( rmint< K, MG_ACTIVE > & a, const T & b )

inline

to_mg() [1/2]

template<size_t K>

rmint< K, MGA > & to_mg ( rmint< K, MGA > & a, const rmint< K, MGA > & b )

inline

to_mg() [2/2]

template<size_t K>

rmint< K, MGA > & to_mg ( rmint< K, MGA > & a )

inline

reduction() [5/8]

template<size_t K>

rmint< K, MGA > & reduction ( rmint< K, MGA > & t, const ruint< K+1 > & c )

inline

reduction() [6/8]

template<size_t K>

rmint< K, MGA > & reduction ( rmint< K, MGA > & t, const ruint< K > & c )

inline

reduction() [7/8]

template<size_t K>

rmint< K, MGA > & reduction ( rmint< K, MGA > & t, const rmint< K, MGA > & c )

inline

reduction() [8/8]

template<size_t K>

rmint< K, MGA > & reduction ( rmint< K, MGA > & t )

inline

get_ruint() [2/2]

template<size_t K>

ruint< K > get_ruint ( const rmint< K, MGA > & a )

inline

get_ready() [2/2]

template<size_t K>

rmint< K, MGA > & get_ready ( rmint< K, MGA > & a )

inline

reset() [1/4]

template<size_t K, size_t MG>

void reset ( rmint< K, MG > & a )

inline

copy() [1/4]

template<size_t K, size_t MG>

void copy ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

operator*=() [1/6]

template<size_t K, size_t MG>

rmint< K, MG > & operator*= ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

operator*() [1/9]

template<size_t K, size_t MG>

rmint< K, MG > operator*	(	const rmint< K, MG > &	,
		const rmint< K, MG > &	)

mul() [5/17]

template<size_t K, size_t MG>

MG const T const rmint< K, MG > &void mul ( rmint< K, MG > & a, const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

mul() [6/17]

template<size_t K, size_t MG>

void mul ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

square() [1/4]

template<size_t K, size_t MG>

void square ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

square() [2/4]

template<size_t K, size_t MG>

void square ( rmint< K, MG > & a )

inline

mul() [7/17]

template<size_t K, size_t MG>

void mul ( rmint< K, MG > & a, const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

operator-() [2/14]

template<size_t K, size_t MG>

rmint< K, MG > operator- ( const rmint< K, MG > & b )

inline

neg() [3/7]

template<size_t K, size_t MG>

rmint< K, MG > & neg ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

neg() [4/7]

template<size_t K, size_t MG>

rmint< K, MG > & neg ( rmint< K, MG > & a )

inline

rand() [1/4]

template<size_t K, size_t MG>

void rand ( rmint< K, MG > & a )

inline

operator--() [1/6]

template<size_t K, size_t MG>

rmint< K, MG > & operator-- ( rmint< K, MG > & a )

inline

operator--() [2/6]

template<size_t K, size_t MG>

rmint< K, MG > operator-- ( rmint< K, MG > & a, int  )

inline

operator-=() [1/7]

template<size_t K, size_t MG>

rmint< K, MG > & operator-= ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

operator-() [3/14]

template<size_t K, size_t MG>

rmint< K, MG > operator-	(	const rmint< K, MG > &	,
		const rmint< K, MG > &	)

sub() [1/37]

template<size_t K, size_t MG>

MG const T const rmint< K, MG > &rmint< K, MG > & sub ( rmint< K, MG > & a, const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

sub() [2/37]

template<size_t K, size_t MG>

rmint< K, MG > & sub ( rmint< K, MG > & a, const rmint< K, MG > & b )

inline

sub() [3/37]

template<size_t K, size_t MG>

rmint< K, MG > & sub ( rmint< K, MG > & a, const rmint< K, MG > & b, const rmint< K, MG > & c )

inline

sub() [4/37]

return sub	(	a	,
		b	,
		cp	)

sub() [5/37]

return sub	(	a	,
		bp	)

operator*=() [2/6]

template<size_t K>

rint< K > & operator*= ( rint< K > & a, const rint< K > & b )

inline

operator*=() [3/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type operator*= ( rint< K > & a, const T & b )

inline

operator*() [2/9]

template<size_t K>

rint< K > operator* ( const rint< K > & b, const rint< K > & c )

inline

operator*() [3/9]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type operator* ( const rint< K > & b, const T & c )

inline

operator*() [4/9]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > >::type operator* ( const T & c, const rint< K > & b )

inline

mul() [8/17]

template<size_t K>

rint< K > & mul ( rint< K > & a, const rint< K > & b, const rint< K > & c )

inline

mul() [9/17]

template<size_t K>

rint< K > & mul ( rint< K > & a, const rint< K > & c )

inline

mul() [10/17]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type mul ( rint< K > & a, const rint< K > & b, const T & c )

inline

mul() [11/17]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, rint< K > & >::type mul ( rint< K > & a, const T & c )

inline

lmul() [1/7]

template<size_t K>

void lmul ( rint< K+1 > & a, const rint< K > & b, const rint< K > & c )

inline

addmul() [4/7]

template<size_t K>

void addmul ( rint< K > & a, const rint< K > & b, const rint< K > & c )

inline

lsquare() [1/3]

template<size_t K>

void lsquare ( rint< K+1 > & a, const rint< K > & b )

inline

rand() [2/4]

template<size_t K>

rint< K > & rand ( rint< K > & a )

inline

reset() [2/4]

template<size_t K>

void reset ( rint< K > & a )

inline

copy() [2/4]

template<size_t K>

void copy ( rint< K > & a, const rint< K > & b )

inline

operator--() [3/6]

template<size_t K>

rint< K > & operator-- ( rint< K > & a )

inline

operator--() [4/6]

template<size_t K>

rint< K > operator-- ( rint< K > & a, int  )

inline

operator-=() [2/7]

template<size_t K>

rint< K > & operator-= ( rint< K > & a, const rint< K > & b )

inline

operator-=() [3/7]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, rint< K > & >::type operator-= ( rint< K > & a, const T & b )

inline

operator-=() [4/7]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, rint< K > & >::type operator-= ( rint< K > & a, const T & b )

inline

operator-() [4/14]

template<size_t K>

rint< K > operator- ( const rint< K > & b, const rint< K > & c )

inline

operator-() [5/14]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, rint< K > >::type operator- ( const rint< K > & b, const T & c )

inline

operator-() [6/14]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, rint< K > >::type operator- ( const T & c, const rint< K > & b )

inline

operator-() [7/14]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, rint< K > >::type operator- ( const rint< K > & b, const T & c )

inline

operator-() [8/14]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, rint< K > >::type operator- ( const T & c, const rint< K > & b )

inline

sub() [6/37]

template<size_t K>

void sub ( bool & r, rint< K > & a, const rint< K > & b, const rint< K > & c )

inline

sub() [7/37]

template<size_t K>

void sub ( bool & r, rint< K > & a, const rint< K > & c )

inline

sub() [8/37]

template<size_t K>

rint< K > & sub ( rint< K > & a, const rint< K > & b, const rint< K > & c )

inline

sub() [9/37]

template<size_t K>

rint< K > & sub ( rint< K > & a, const rint< K > & c )

inline

sub() [10/37]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( bool & r, rint< K > & a, const rint< K > & b, const T & c )

inline

sub() [11/37]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( bool & r, rint< K > & a, const T & c )

inline

sub() [12/37]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( rint< K > & a, const rint< K > & b, const T & c )

inline

sub() [13/37]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( rint< K > & a, const T & c )

inline

sub_1() [1/16]

template<size_t K>

void sub_1 ( bool & r, rint< K > & a, const rint< K > & b )

inline

sub_1() [2/16]

template<size_t K>

void sub_1 ( bool & r, rint< K > & a )

inline

sub_1() [3/16]

template<size_t K>

void sub_1 ( rint< K > & a, const rint< K > & b )

inline

sub_1() [4/16]

template<size_t K>

void sub_1 ( rint< K > & a )

inline

operator++() [5/6]

template<size_t K>

ruint< K > & operator++ ( ruint< K > & a )

inline

operator++() [6/6]

template<size_t K>

ruint< K > operator++ ( ruint< K > & a, int  )

inline

operator+=() [5/7]

template<size_t K>

ruint< K > & operator+= ( ruint< K > & a, const ruint< K > & b )

inline

operator+=() [6/7]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > & >::type operator+= ( ruint< K > & a, const T & b )

inline

operator+=() [7/7]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > & >::type operator+= ( ruint< K > & a, const T & b )

inline

operator+() [9/13]

template<size_t K>

ruint< K > operator+ ( const ruint< K > & b, const ruint< K > & c )

inline

operator+() [10/13]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type operator+ ( const ruint< K > & b, const T & c )

inline

operator+() [11/13]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type operator+ ( const T & c, const ruint< K > & b )

inline

operator+() [12/13]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > >::type operator+ ( const ruint< K > & b, const T & c )

inline

operator+() [13/13]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > >::type operator+ ( const T & c, const ruint< K > & b )

inline

add() [14/33]

template<size_t K>

void add ( bool & r, ruint< K > & a, const ruint< K > & b, const ruint< K > & c )

inline

add() [15/33]

template<size_t K>

void add ( bool & r, ruint< K > & a, const ruint< K > & c )

inline

add() [16/33]

template<size_t K>

void add ( ruint< K > & a, const ruint< K > & b, const ruint< K > & c )

inline

add() [17/33]

template<size_t K>

void add ( ruint< K > & a, const ruint< K > & c )

inline

add() [18/33]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( bool & r, ruint< K > & a, const ruint< K > & b, const T & c )

inline

add() [19/33]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( bool & r, ruint< K > & a, const T & c )

inline

add() [20/33]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( ruint< K > & a, const ruint< K > & b, const T & c )

inline

add() [21/33]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( ruint< K > & a, const T & c )

inline

add_1() [5/16]

template<size_t K>

void add_1 ( bool & r, ruint< K > & a, const ruint< K > & b )

inline

add_1() [6/16]

template<size_t K>

void add_1 ( bool & r, ruint< K > & a )

inline

add_1() [7/16]

template<size_t K>

void add_1 ( ruint< K > & a, const ruint< K > & b )

inline

add_1() [8/16]

template<size_t K>

void add_1 ( ruint< K > & a )

inline

add_wc() [1/12]

template<size_t K>

void add_wc ( bool & r, ruint< K > & a, const ruint< K > & b, const ruint< K > & c, const bool & cy )

inline

add_wc() [2/12]

template<size_t K>

void add_wc ( bool & r, ruint< K > & a, const ruint< K > & c, const bool & cy )

inline

add_wc() [3/12]

template<size_t K>

void add_wc ( ruint< K > & a, const ruint< K > & b, const ruint< K > & c, const bool & cy )

inline

add_wc() [4/12]

template<size_t K>

void add_wc ( ruint< K > & a, const ruint< K > & c, const bool & cy )

inline

add() [22/33]

template<>

void add ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b, const ruint< 6+1 > & c )

inline

add() [23/33]

template<>

void add ( bool & r, ruint< 6 > & a, const ruint< 6 > & b, const ruint< 6 > & c )

inline

add() [24/33]

template<>

void add ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b )

inline

add() [25/33]

template<>

void add ( bool & r, ruint< 6 > & a, const ruint< 6 > & b )

inline

add() [26/33]

template<>

void add ( ruint< 6+1 > & a, const ruint< 6+1 > & b, const ruint< 6+1 > & c )

inline

add() [27/33]

template<>

void add ( ruint< 6 > & a, const ruint< 6 > & b, const ruint< 6 > & c )

inline

add() [28/33]

template<>

void add ( ruint< 6+1 > & a, const ruint< 6+1 > & b )

inline

add() [29/33]

template<>

void add ( ruint< 6 > & a, const ruint< 6 > & b )

inline

add() [30/33]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b, const T & c )

inline

add() [31/33]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( bool & r, ruint< 6 > & a, const ruint< 6 > & b, const T & c )

inline

add() [32/33]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( bool & r, ruint< 6+1 > & a, const T & b )

inline

add() [33/33]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type add ( bool & r, ruint< 6 > & a, const T & b )

inline

add_1() [9/16]

template<>

void add_1 ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b )

inline

add_1() [10/16]

template<>

void add_1 ( bool & r, ruint< 6 > & a, const ruint< 6 > & b )

inline

add_1() [11/16]

template<>

void add_1 ( bool & r, ruint< 6+1 > & a )

inline

add_1() [12/16]

template<>

void add_1 ( bool & r, ruint< 6 > & a )

inline

add_1() [13/16]

template<>

void add_1 ( ruint< 6+1 > & a, const ruint< 6+1 > & b )

inline

add_1() [14/16]

template<>

void add_1 ( ruint< 6 > & a, const ruint< 6 > & b )

inline

add_1() [15/16]

template<>

void add_1 ( ruint< 6+1 > & a )

inline

add_1() [16/16]

template<>

void add_1 ( ruint< 6 > & a )

inline

add_wc() [5/12]

template<>

void add_wc ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b, const ruint< 6+1 > & c, const bool & cy )

inline

add_wc() [6/12]

template<>

void add_wc ( bool & r, ruint< 6 > & a, const ruint< 6 > & b, const ruint< 6 > & c, const bool & cy )

inline

add_wc() [7/12]

template<>

void add_wc ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b, const bool & cy )

inline

add_wc() [8/12]

template<>

void add_wc ( bool & r, ruint< 6 > & a, const ruint< 6 > & b, const bool & cy )

inline

add_wc() [9/12]

template<>

void add_wc ( ruint< 6+1 > & a, const ruint< 6+1 > & b, const ruint< 6+1 > & c, const bool & cy )

inline

add_wc() [10/12]

template<>

void add_wc ( ruint< 6 > & a, const ruint< 6 > & b, const ruint< 6 > & c, const bool & cy )

inline

add_wc() [11/12]

template<>

void add_wc ( ruint< 6+1 > & a, const ruint< 6+1 > & b, const bool & cy )

inline

add_wc() [12/12]

template<>

void add_wc ( ruint< 6 > & a, const ruint< 6 > & b, const bool & cy )

inline

laddmul() [1/9]

template<size_t K>

void laddmul ( bool & r, ruint< K+1 > & a, const ruint< K > & b, const ruint< K > & c, const ruint< K > & d )

inline

laddmul() [2/9]

template<size_t K>

void laddmul ( bool & r, ruint< K > & ah, ruint< K > & al, const ruint< K > & b, const ruint< K > & c, const ruint< K > & d )

inline

laddmul() [3/9]

template<size_t K>

void laddmul ( ruint< K+1 > & a, const ruint< K > & b, const ruint< K > & c, const ruint< K > & d )

inline

laddmul() [4/9]

template<size_t K>

void laddmul ( ruint< K > & ah, ruint< K > & al, const ruint< K > & b, const ruint< K > & c, const ruint< K > & d )

inline

laddmul() [5/9]

template<size_t K>

void laddmul ( bool & r, ruint< K+1 > & a, const ruint< K > & b, const ruint< K > & c, const ruint< K+1 > & d )

inline

laddmul() [6/9]

template<size_t K>

void laddmul ( bool & r, ruint< K > & ah, ruint< K > & al, const ruint< K > & b, const ruint< K > & c, const ruint< K+1 > & d )

inline

addmul() [5/7]

template<size_t K>

void addmul ( ruint< K > & a, const ruint< K > & b, const ruint< K > & c )

inline

addmul() [6/7]

template<size_t K>

void addmul ( ruint< K > & a, const ruint< K > & b, const UDItype & c )

inline

laddmul() [7/9]

template<>

void laddmul ( bool & r, ruint< 6 > & ah, ruint< 6 > & al, const ruint< 6 > & b, const ruint< 6 > & c, const ruint< 6 > & d )

inline

laddmul() [8/9]

template<>

void laddmul ( ruint< 6 > & ah, ruint< 6 > & al, const ruint< 6 > & b, const ruint< 6 > & c, const ruint< 6 > & d )

inline

laddmul() [9/9]

template<>

void laddmul ( bool & r, ruint< 6 > & ah, ruint< 6 > & al, const ruint< 6 > & b, const ruint< 6 > & c, const ruint< 6+1 > & d )

inline

addmul() [7/7]

template<>

void addmul ( ruint< 6 > & a, const ruint< 6 > & b, const ruint< 6 > & c )

inline

operator==() [8/10]

template<size_t K>

bool operator== ( const ruint< K > & a, const ruint< K > & b )

inline

operator==() [9/10]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator== ( const ruint< K > & a, const T & b )

inline

operator==() [10/10]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator== ( const T & b, const ruint< K > & a )

inline

operator!=() [6/8]

template<size_t K>

bool operator!= ( const ruint< K > & a, const ruint< K > & b )

inline

operator!=() [7/8]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator!= ( const ruint< K > & a, const T & b )

inline

operator!=() [8/8]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator!= ( const T & b, const ruint< K > & a )

inline

operator>() [6/8]

template<size_t K>

bool operator> ( const ruint< K > & a, const ruint< K > & b )

inline

operator>() [7/8]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator> ( const ruint< K > & a, const T & b )

inline

operator>() [8/8]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator> ( const T & b, const ruint< K > & a )

inline

operator>=() [5/7]

template<size_t K>

bool operator>= ( const ruint< K > & a, const ruint< K > & b )

inline

operator>=() [6/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator>= ( const ruint< K > & a, const T & b )

inline

operator>=() [7/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator>= ( const T & b, const ruint< K > & a )

inline

operator<() [5/7]

template<size_t K>

bool operator< ( const ruint< K > & a, const ruint< K > & b )

inline

operator<() [6/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator< ( const ruint< K > & a, const T & b )

inline

operator<() [7/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator< ( const T & b, const ruint< K > & a )

inline

operator<=() [7/9]

template<size_t K>

bool operator<= ( const ruint< K > & a, const ruint< K > & b )

inline

operator<=() [8/9]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator<= ( const ruint< K > & a, const T & b )

inline

operator<=() [9/9]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, bool >::type operator<= ( const T & b, const ruint< K > & a )

inline

cmp() [4/9]

template<size_t K>

int cmp ( const ruint< K > & a, const ruint< K > & b )

inline

cmp() [5/9]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, int >::type cmp ( const ruint< K > & a, const T & b )

inline

cmp() [6/9]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, int >::type cmp ( const ruint< K > & a, const T & b )

inline

cmp() [7/9]

template<>

int cmp ( const ruint< 6 > & a, const ruint< 6 > & b )

inline

cmp() [8/9]

template<typename T>

std::enable_if< std::is_unsigned< T >::value, int >::type cmp ( const ruint< 6 > & a, const T & b )

inline

cmp() [9/9]

template<typename T>

std::enable_if< std::is_signed< T >::value, int >::type cmp ( const ruint< 6 > & a, const T & b )

inline

mpz_to_ruint()

template<size_t K>

ruint< K > & mpz_to_ruint ( ruint< K > & a, const mpz_class & b )

inline

ruint_to_mpz()

template<size_t K>

mpz_class & ruint_to_mpz ( mpz_class & a, const ruint< K > & b )

inline

ruint_to_mpz_t()

template<size_t K>

mpz_ptr ruint_to_mpz_t ( mpz_ptr a, const ruint< K > & b )

inline

mpz_t_to_ruint()

template<size_t K>

ruint< K > & mpz_t_to_ruint ( ruint< K > & a, mpz_srcptr b )

inline

operator<<() [4/6]

template<size_t K>

std::ostream & operator<< ( std::ostream & out, const ruint< K > & a )

inline

operator>>() [4/5]

template<size_t K>

std::istream & operator>> ( std::istream & is, ruint< K > & a )

inline

operator<<() [5/6]

template<>

std::ostream & operator<< ( std::ostream & out, const ruint< 6 > & a )

inline

display_dec() [2/2]

template<size_t K>

std::ostream & display_dec ( std::ostream & out, const ruint< K > & a )

inline

display_hex() [1/2]

template<size_t K>

std::ostream & display_hex ( std::ostream & out, const ruint< K > & a )

inline

display_hex() [2/2]

template<>

std::ostream & display_hex ( std::ostream & out, const ruint< 6 > & a )

inline

write_raw() [2/2]

template<size_t K>

std::ostream & write_raw ( std::ostream & out, const ruint< K > & a )

inline

read_raw() [2/2]

template<size_t K>

std::istream & read_raw ( std::istream & is, ruint< K > & a )

inline

operator%=() [5/6]

template<size_t K>

ruint< K > & operator%= ( ruint< K > & a, const ruint< K > & b )

inline

operator%=() [6/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type operator%= ( ruint< K > & a, const T & b )

inline

operator/=() [5/7]

template<size_t K>

ruint< K > & operator/= ( ruint< K > & a, const ruint< K > & b )

inline

operator/=() [6/7]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > & >::type operator/= ( ruint< K > & a, const T & b )

inline

operator/=() [7/7]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > & >::type operator/= ( ruint< K > & a, const T & b )

inline

operator%() [5/6]

template<size_t K>

ruint< K > operator% ( const ruint< K > & b, const ruint< K > & c )

inline

operator%() [6/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > >::type operator% ( const ruint< K > & b, const T & c )

inline

operator/() [5/7]

template<size_t K>

ruint< K > operator/ ( const ruint< K > & b, const ruint< K > & c )

inline

operator/() [6/7]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type operator/ ( const ruint< K > & b, const T & c )

inline

operator/() [7/7]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > >::type operator/ ( const ruint< K > & b, const T & c )

inline

div_3_2() [1/2]

template<size_t K>

void div_3_2 ( ruint< K > & q, ruint< K > & r1, ruint< K > & r0, const ruint< K > & a2, const ruint< K > & a1, const ruint< K > & a0, const ruint< K > & b1, const ruint< K > & b0 )

inline

div_2_1() [1/2]

template<size_t K>

void div_2_1 ( ruint< K > & q, ruint< K > & r, const ruint< K > & a1, const ruint< K > & a0, const ruint< K > & b )

inline

div() [5/7]

template<size_t K>

void div ( ruint< K > & q, ruint< K > & r, const ruint< K > & a, const ruint< K > & b )

inline

div() [6/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type div ( ruint< K > & q, T & r, const ruint< K > & a, const T & b )

inline

div_q() [3/4]

template<size_t K>

ruint< K > & div_q ( ruint< K > & q, const ruint< K > & a, const ruint< K > & b )

inline

div_q() [4/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type div_q ( ruint< K > & q, const ruint< K > & a, const T & b )

inline

div_r() [3/4]

template<size_t K>

ruint< K > & div_r ( ruint< K > & r, const ruint< K > & a, const ruint< K > & b )

inline

div_r() [4/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, T & >::type div_r ( T & r, const ruint< K > & a, const T & b )

inline

div_3_2() [2/2]

template<>

void div_3_2 ( ruint< 6 > & q, ruint< 6 > & r1, ruint< 6 > & r0, const ruint< 6 > & a2, const ruint< 6 > & a1, const ruint< 6 > & a0, const ruint< 6 > & b1, const ruint< 6 > & b0 )

inline

div_2_1() [2/2]

template<>

void div_2_1 ( ruint< 6 > & q, ruint< 6 > & r, const ruint< 6 > & ah, const ruint< 6 > & al, const ruint< 6 > & b )

inline

udiv_qrnd()

void udiv_qrnd ( limb & q, limb & r, const limb & a, const limb & b )

inline

div() [7/7]

template<>

void div ( ruint< 6 > & q, ruint< 6 > & r, const ruint< 6 > & a, const ruint< 6 > & b )

inline

exp_mod() [1/2]

template<size_t K>

void exp_mod ( ruint< K > & a, const ruint< K > & b, const ruint< K > & c, const ruint< K > & n )

inline

exp_mod() [2/2]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, void >::type exp_mod ( ruint< K > & a, const ruint< K > & b, const T & c, const ruint< K > & n )

inline

operator~() [2/3]

template<size_t K>

ruint< K > operator~ ( const ruint< K > & c )

inline

operator-() [9/14]

template<size_t K>

ruint< K > operator- ( const ruint< K > & c )

inline

neg() [5/7]

template<size_t K>

ruint< K > & neg ( ruint< K > & r, const ruint< K > & c )

inline

neg() [6/7]

template<size_t K>

ruint< K > & neg ( ruint< K > & r )

inline

operator|=() [3/6]

template<size_t K>

ruint< K > & operator|= ( ruint< K > & b, const ruint< K > & c )

inline

operator^=() [3/6]

template<size_t K>

ruint< K > & operator^= ( ruint< K > & b, const ruint< K > & c )

inline

operator&=() [3/6]

template<size_t K>

ruint< K > & operator&= ( ruint< K > & b, const ruint< K > & c )

inline

operator|=() [4/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type operator|= ( ruint< K > & b, const T & c )

inline

operator^=() [4/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type operator^= ( ruint< K > & b, const T & c )

inline

operator&=() [4/6]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type operator&= ( ruint< K > & b, const T & c )

inline

operator|() [3/4]

template<size_t K>

ruint< K > operator| ( const ruint< K > & b, const ruint< K > & c )

inline

operator^() [3/4]

template<size_t K>

ruint< K > operator^ ( const ruint< K > & b, const ruint< K > & c )

inline

operator&() [3/4]

template<size_t K>

ruint< K > operator& ( const ruint< K > & b, const ruint< K > & c )

inline

operator|() [4/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > >::type operator| ( const ruint< K > & b, const T & c )

inline

operator^() [4/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > >::type operator^ ( const ruint< K > & b, const T & c )

inline

operator&() [4/4]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, T >::type operator& ( const ruint< K > & b, const T & c )

inline

max_pow_two() [1/2]

template<size_t K>

ruint< K > & max_pow_two ( ruint< K > & a )

inline

highest_bit() [1/2]

template<size_t K>

bool highest_bit ( const ruint< K > & a )

inline

lowest_bit() [1/2]

template<size_t K>

bool lowest_bit ( const ruint< K > & a )

inline

set_highest_bit() [1/2]

template<size_t K>

void set_highest_bit ( ruint< K > & a )

inline

set_lowest_bit() [1/2]

template<size_t K>

void set_lowest_bit ( ruint< K > & a )

inline

set_highest_word() [1/2]

template<size_t K>

void set_highest_word ( ruint< K > & a, const limb w )

inline

set_lowest_word() [1/2]

template<size_t K>

void set_lowest_word ( ruint< K > & a, const limb w )

inline

operator~() [3/3]

template<>

ruint< 6 > operator~ ( const ruint< 6 > & c )

inline

neg() [7/7]

template<>

ruint< 6 > & neg ( ruint< 6 > & r, const ruint< 6 > & c )

inline

operator|=() [5/6]

template<>

ruint< 6 > & operator|= ( ruint< 6 > & b, const ruint< 6 > & c )

inline

operator|=() [6/6]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< 6 > & >::type operator|= ( ruint< 6 > & b, const T & c )

inline

operator^=() [5/6]

template<>

ruint< 6 > & operator^= ( ruint< 6 > & b, const ruint< 6 > & c )

inline

operator^=() [6/6]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< 6 > & >::type operator^= ( ruint< 6 > & b, const T & c )

inline

operator&=() [5/6]

template<>

ruint< 6 > & operator&= ( ruint< 6 > & b, const ruint< 6 > & c )

inline

operator&=() [6/6]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< 6 > & >::type operator&= ( ruint< 6 > & b, const T & c )

inline

max_pow_two() [2/2]

template<>

ruint< 6 > & max_pow_two ( ruint< 6 > & a )

inline

highest_bit() [2/2]

template<>

bool highest_bit ( const ruint< 6 > & a )

inline

lowest_bit() [2/2]

template<>

bool lowest_bit ( const ruint< 6 > & a )

inline

set_highest_bit() [2/2]

template<>

void set_highest_bit ( ruint< 6 > & a )

inline

set_lowest_bit() [2/2]

template<>

void set_lowest_bit ( ruint< 6 > & a )

inline

set_highest_word() [2/2]

template<>

void set_highest_word ( ruint< 6 > & a, const limb w )

inline

set_lowest_word() [2/2]

template<>

void set_lowest_word ( ruint< 6 > & a, const limb w )

inline

gcd() [1/2]

template<size_t K>

ruint< K > & gcd ( ruint< K > & a, const ruint< K > & b, const ruint< K > & c )

inline

gcd() [2/2]

template<size_t K>

ruint< K > gcd ( const ruint< K > & b, const ruint< K > & c )

inline

bezout_mod()

template<size_t K>

void bezout_mod ( ruint< K > & x, ruint< K > & y, const ruint< K > & c, const ruint< K > & d )

inline

inv_mod() [2/2]

template<size_t K>

ruint< K > & inv_mod ( ruint< K > & a, const ruint< K > & b, const ruint< K > & c )

inline

reset() [3/4]

template<size_t K>

void reset ( ruint< K > & a )

inline

fill_with_1() [1/2]

template<size_t K>

ruint< K > & fill_with_1 ( ruint< K > & a )

inline

copy() [3/4]

template<size_t K>

void copy ( ruint< K > & a, const ruint< K > & b )

inline

pointers_list() [1/2]

template<size_t K>

void pointers_list ( limb ** p, const ruint< K > & a )

inline

set_limb() [1/2]

template<size_t K>

void set_limb ( ruint< K > & a, const limb & b, unsigned int index )

inline

ms_limb() [1/2]

template<size_t K>

limb ms_limb ( const ruint< K > & a )

inline

get_limb() [1/2]

template<size_t K>

limb get_limb ( const ruint< K > & a, unsigned int index )

inline

get_limb_p() [1/2]

template<size_t K>

const limb * get_limb_p ( const ruint< K > & a, unsigned int index )

inline

begin() [1/2]

template<size_t K>

const limb * begin ( const ruint< K > & a )

inline

reset() [4/4]

template<>

void reset ( ruint< 6 > & a )

inline

fill_with_1() [2/2]

template<>

ruint< 6 > & fill_with_1 ( ruint< 6 > & a )

inline

copy() [4/4]

template<>

void copy ( ruint< 6 > & a, const ruint< 6 > & b )

inline

pointers_list() [2/2]

template<>

void pointers_list ( limb ** tab, const ruint< 6 > & a )

inline

set_limb() [2/2]

template<>

void set_limb ( ruint< 6 > & a, const limb & b, unsigned int index )

inline

ms_limb() [2/2]

template<>

limb ms_limb ( const ruint< 6 > & a )

inline

get_limb() [2/2]

template<>

limb get_limb ( const ruint< 6 > & a, unsigned int  )

inline

get_limb_p() [2/2]

template<>

const limb * get_limb_p ( const ruint< 6 > & a, unsigned int  )

inline

begin() [2/2]

template<>

const limb * begin ( const ruint< 6 > & a )

inline

operator*=() [4/6]

template<size_t K>

ruint< K > & operator*= ( ruint< K > & a, const ruint< K > & b )

inline

operator*=() [5/6]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > & >::type operator*= ( ruint< K > & a, const T & b )

inline

operator*=() [6/6]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > & >::type operator*= ( ruint< K > & a, const T & b )

inline

operator*() [5/9]

template<size_t K>

ruint< K > operator* ( const ruint< K > & b, const ruint< K > & c )

inline

operator*() [6/9]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type operator* ( const ruint< K > & b, const T & c )

inline

operator*() [7/9]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type operator* ( const T & c, const ruint< K > & b )

inline

operator*() [8/9]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > >::type operator* ( const ruint< K > & b, const T & c )

inline

operator*() [9/9]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > >::type operator* ( const T & c, const ruint< K > & b )

inline

lmul_naive() [1/3]

template<size_t K>

void lmul_naive ( ruint< K+1 > & a, const ruint< K > & b, const ruint< K > & c )

inline

lmul_naive() [2/3]

template<size_t K>

void lmul_naive ( ruint< K > & ah, ruint< K > & al, const ruint< K > & b, const ruint< K > & c )

inline

lmul_kara() [1/3]

template<size_t K>

void lmul_kara ( ruint< K+1 > & a, const ruint< K > & b, const ruint< K > & c )

inline

lmul_kara() [2/3]

template<size_t K>

void lmul_kara ( ruint< K > & ah, ruint< K > & al, const ruint< K > & b, const ruint< K > & c )

inline

lmul() [2/7]

template<size_t K>

void lmul ( ruint< K+1 > & a, const ruint< K > & b, const ruint< K > & c )

inline

lmul() [3/7]

template<size_t K>

void lmul ( ruint< K > & ah, ruint< K > & al, const ruint< K > & b, const ruint< K > & c )

inline

lmul() [4/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type lmul ( ruint< K+1 > & a, const ruint< K > & b, const T & c )

inline

lmul() [5/7]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type lmul ( limb & ah, ruint< K > & al, const ruint< K > & b, const T & c )

inline

mul() [12/17]

template<size_t K>

ruint< K > & mul ( ruint< K > & a, const ruint< K > & b, const ruint< K > & c )

inline

mul() [13/17]

template<size_t K>

ruint< K > & mul ( ruint< K > & a, const ruint< K > & c )

inline

mul() [14/17]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type mul ( ruint< K > & a, const ruint< K > & b, const T & c )

inline

mul() [15/17]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, ruint< K > & >::type mul ( ruint< K > & a, const T & c )

inline

lsquare() [2/3]

template<size_t K>

ruint< K+1 > & lsquare ( ruint< K+1 > & a, const ruint< K > & b )

inline

square() [3/4]

template<size_t K>

ruint< K > & square ( ruint< K > & al, const ruint< K > & b )

inline

lmul_naive() [3/3]

template<>

void lmul_naive ( ruint< 6 > & ah, ruint< 6 > & al, const ruint< 6 > & b, const ruint< 6 > & c )

inline

lmul_kara() [3/3]

template<>

void lmul_kara ( ruint< 6 > & ah, ruint< 6 > & al, const ruint< 6 > & b, const ruint< 6 > & c )

inline

lmul() [6/7]

template<>

void lmul ( ruint< 6 > & ah, ruint< 6 > & al, const ruint< 6 > & b, const ruint< 6 > & c )

inline

lmul() [7/7]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type lmul ( limb & ret, ruint< 6 > & a, const ruint< 6 > & b, const T & c )

inline

mul() [16/17]

template<>

ruint< 6 > & mul ( ruint< 6 > & al, const ruint< 6 > & b, const ruint< 6 > & c )

inline

mul() [17/17]

template<>

ruint< 6 > & mul ( ruint< 6 > & al, const ruint< 6 > & c )

inline

lsquare() [3/3]

template<>

ruint< 6+1 > & lsquare ( ruint< 6+1 > & a, const ruint< 6 > & b )

inline

square() [4/4]

template<>

ruint< 6 > & square ( ruint< 6 > & al, const ruint< 6 > & b )

inline

rand() [3/4]

template<size_t K>

ruint< K > & rand ( ruint< K > & a )

inline

srand()

void srand ( const limb s )

inline

rand() [4/4]

template<>

ruint< 6 > & rand ( ruint< 6 > & a )

inline

operator<<() [6/6]

template<size_t K, typename T>

ruint< K > operator<< ( const ruint< K > & a, const T & d )

inline

operator>>() [5/5]

template<size_t K, typename T>

ruint< K > operator>> ( const ruint< K > & a, const T & d )

inline

operator<<=() [2/2]

template<size_t K, typename T>

ruint< K > & operator<<= ( ruint< K > & b, const T & c )

inline

operator>>=() [2/2]

template<size_t K, typename T>

ruint< K > & operator>>= ( ruint< K > & b, const T & c )

inline

left_shift() [1/3]

template<size_t K, typename T>

ruint< K > & left_shift ( ruint< K > & a, const ruint< K > & b, const T & c )

inline

left_shift_1() [1/3]

template<size_t K>

ruint< K > & left_shift_1 ( bool & z, ruint< K > & a, const ruint< K > & b )

inline

left_shift_1() [2/3]

template<size_t K>

ruint< K > & left_shift_1 ( ruint< K > & a, const ruint< K > & b )

inline

right_shift() [1/2]

template<size_t K, typename T>

ruint< K > & right_shift ( ruint< K > & a, const ruint< K > & b, const T & c )

inline

right_shift_1() [1/3]

template<size_t K>

ruint< K > & right_shift_1 ( bool & z, ruint< K > & a, const ruint< K > & b )

inline

right_shift_1() [2/3]

template<size_t K>

ruint< K > & right_shift_1 ( ruint< K > & a, const ruint< K > & b )

inline

left_shift() [2/3]

template<size_t K, typename T>

void left_shift ( ruint< K+1 > & b, const ruint< K > & a, const T & m )

inline

left_shift() [3/3]

template<typename T>

ruint< 6 > & left_shift ( ruint< 6 > & b, const ruint< 6 > & a, const T & d )

inline

left_shift_1() [3/3]

template<>

ruint< 6 > & left_shift_1 ( bool & z, ruint< 6 > & b, const ruint< 6 > & a )

inline

right_shift() [2/2]

template<typename T>

ruint< 6 > & right_shift ( ruint< 6 > & b, const ruint< 6 > & a, const T & d )

inline

right_shift_1() [3/3]

template<>

ruint< 6 > & right_shift_1 ( bool & z, ruint< 6 > & b, const ruint< 6 > & a )

inline

operator--() [5/6]

template<size_t K>

ruint< K > & operator-- ( ruint< K > & a )

inline

operator--() [6/6]

template<size_t K>

ruint< K > operator-- ( ruint< K > & a, int  )

inline

operator-=() [5/7]

template<size_t K>

ruint< K > & operator-= ( ruint< K > & a, const ruint< K > & b )

inline

operator-=() [6/7]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > & >::type operator-= ( ruint< K > & a, const T & b )

inline

operator-=() [7/7]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > & >::type operator-= ( ruint< K > & a, const T & b )

inline

operator-() [10/14]

template<size_t K>

ruint< K > operator- ( const ruint< K > & b, const ruint< K > & c )

inline

operator-() [11/14]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type operator- ( const ruint< K > & b, const T & c )

inline

operator-() [12/14]

template<size_t K, typename T>

std::enable_if< std::is_unsigned< T >::value, ruint< K > >::type operator- ( const T & c, const ruint< K > & b )

inline

operator-() [13/14]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > >::type operator- ( const ruint< K > & b, const T & c )

inline

operator-() [14/14]

template<size_t K, typename T>

std::enable_if< std::is_signed< T >::value, ruint< K > >::type operator- ( const T & c, const ruint< K > & b )

inline

sub() [14/37]

template<size_t K>

void sub ( bool & r, ruint< K > & a, const ruint< K > & b, const ruint< K > & c )

inline

sub() [15/37]

template<size_t K>

void sub ( bool & r, ruint< K > & a, const ruint< K > & c )

inline

sub() [16/37]

template<size_t K>

ruint< K > & sub ( ruint< K > & a, const ruint< K > & b, const ruint< K > & c )

inline

sub() [17/37]

template<size_t K>

ruint< K > & sub ( ruint< K > & a, const ruint< K > & c )

inline

sub() [18/37]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( bool & r, ruint< K > & a, const ruint< K > & b, const T & c )

inline

sub() [19/37]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( bool & r, ruint< K > & a, const T & c )

inline

sub() [20/37]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( ruint< K > & a, const ruint< K > & b, const T & c )

inline

sub() [21/37]

template<size_t K, typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( ruint< K > & a, const T & c )

inline

sub_1() [5/16]

template<size_t K>

void sub_1 ( bool & r, ruint< K > & a, const ruint< K > & b )

inline

sub_1() [6/16]

template<size_t K>

void sub_1 ( bool & r, ruint< K > & a )

inline

sub_1() [7/16]

template<size_t K>

void sub_1 ( ruint< K > & a, const ruint< K > & b )

inline

sub_1() [8/16]

template<size_t K>

void sub_1 ( ruint< K > & a )

inline

sub_wc() [1/12]

template<size_t K>

void sub_wc ( bool & r, ruint< K > & a, const ruint< K > & b, const ruint< K > & c, const bool & cy )

inline

sub_wc() [2/12]

template<size_t K>

void sub_wc ( bool & r, ruint< K > & a, const ruint< K > & c, const bool & cy )

inline

sub_wc() [3/12]

template<size_t K>

void sub_wc ( ruint< K > & a, const ruint< K > & b, const ruint< K > & c, const bool & cy )

inline

sub_wc() [4/12]

template<size_t K>

void sub_wc ( ruint< K > & a, const ruint< K > & c, const bool & cy )

inline

sub() [22/37]

template<>

void sub ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b, const ruint< 6+1 > & c )

inline

sub() [23/37]

template<>

void sub ( bool & r, ruint< 6 > & a, const ruint< 6 > & b, const ruint< 6 > & c )

inline

sub() [24/37]

template<>

void sub ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b )

inline

sub() [25/37]

template<>

void sub ( bool & r, ruint< 6 > & a, const ruint< 6 > & b )

inline

sub() [26/37]

template<>

ruint< 6+1 > & sub ( ruint< 6+1 > & a, const ruint< 6+1 > & b, const ruint< 6+1 > & c )

inline

sub() [27/37]

template<>

ruint< 6 > & sub ( ruint< 6 > & a, const ruint< 6 > & b, const ruint< 6 > & c )

inline

sub() [28/37]

template<>

ruint< 6+1 > & sub ( ruint< 6+1 > & a, const ruint< 6+1 > & b )

inline

sub() [29/37]

template<>

ruint< 6 > & sub ( ruint< 6 > & a, const ruint< 6 > & b )

inline

sub() [30/37]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b, const T & c )

inline

sub() [31/37]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( bool & r, ruint< 6 > & a, const ruint< 6 > & b, const T & c )

inline

sub() [32/37]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( bool & r, ruint< 6+1 > & a, const T & b )

inline

sub() [33/37]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( bool & r, ruint< 6 > & a, const T & b )

inline

sub() [34/37]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( ruint< 6+1 > & a, const ruint< 6+1 > & b, const T & c )

inline

sub() [35/37]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( ruint< 6 > & a, const ruint< 6 > & b, const T & c )

inline

sub() [36/37]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( ruint< 6+1 > & a, const T & b )

inline

sub() [37/37]

template<typename T>

std::enable_if< std::is_arithmetic< T >::value, void >::type sub ( ruint< 6 > & a, const T & b )

inline

sub_1() [9/16]

template<>

void sub_1 ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b )

inline

sub_1() [10/16]

template<>

void sub_1 ( bool & r, ruint< 6 > & a, const ruint< 6 > & b )

inline

sub_1() [11/16]

template<>

void sub_1 ( bool & r, ruint< 6+1 > & a )

inline

sub_1() [12/16]

template<>

void sub_1 ( bool & r, ruint< 6 > & a )

inline

sub_1() [13/16]

template<>

void sub_1 ( ruint< 6+1 > & a, const ruint< 6+1 > & b )

inline

sub_1() [14/16]

template<>

void sub_1 ( ruint< 6 > & a, const ruint< 6 > & b )

inline

sub_1() [15/16]

template<>

void sub_1 ( ruint< 6+1 > & a )

inline

sub_1() [16/16]

template<>

void sub_1 ( ruint< 6 > & a )

inline

sub_wc() [5/12]

template<>

void sub_wc ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b, const ruint< 6+1 > & c, const bool & cy )

inline

sub_wc() [6/12]

template<>

void sub_wc ( bool & r, ruint< 6 > & a, const ruint< 6 > & b, const ruint< 6 > & c, const bool & cy )

inline

sub_wc() [7/12]

template<>

void sub_wc ( bool & r, ruint< 6+1 > & a, const ruint< 6+1 > & b, const bool & cy )

inline

sub_wc() [8/12]

template<>

void sub_wc ( bool & r, ruint< 6 > & a, const ruint< 6 > & b, const bool & cy )

inline

sub_wc() [9/12]

template<>

void sub_wc ( ruint< 6+1 > & a, const ruint< 6+1 > & b, const ruint< 6+1 > & c, const bool & cy )

inline

sub_wc() [10/12]

template<>

void sub_wc ( ruint< 6 > & a, const ruint< 6 > & b, const ruint< 6 > & c, const bool & cy )

inline

sub_wc() [11/12]

template<>

void sub_wc ( ruint< 6+1 > & a, const ruint< 6+1 > & b, const bool & cy )

inline

sub_wc() [12/12]

template<>

void sub_wc ( ruint< 6 > & a, const ruint< 6 > & b, const bool & cy )

inline

normalization()

template<size_t K>

void normalization ( UDItype & d, const ruint< K > & b )

inline

mod_n() [3/5]

template<size_t K>

void mod_n ( ruint< K > & a, const ruint< K+1 > & b, const ruint< K > & n )

inline

mod_n() [4/5]

template<size_t K>

void mod_n ( ruint< K > & a, const ruint< K > & b, const ruint< K > & n )

inline

mod_n() [5/5]

template<size_t K>

void mod_n ( ruint< K > & a, const ruint< K > & n )

inline

Variable Documentation

__clz_tab

const unsigned char __clz_tab[129]

extern

a

MG & a

Initial value:

{
        rmint<K, MGA> ar(a)

b

MG const T & b

Initial value:

{
        bool r

c

MG const rmint< K, MG > const T & c

Initial value:

{
        bool r

p

a p

rmint< K, MG_INACTIVE >::p

template<size_t K>

ruint<K> rmint< K, MG_INACTIVE >::p = 0

rmint< K, MG_ACTIVE >::p

template<size_t K>

ruint<K> rmint< K, MG_ACTIVE >::p = 0

rmint< K, MG_ACTIVE >::p1

template<size_t K>

ruint<K> rmint< K, MG_ACTIVE >::p1 = 0

rmint< K, MG_ACTIVE >::r

template<size_t K>

ruint<K> rmint< K, MG_ACTIVE >::r = 0