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	NBLIMB
struct	NBLIMB< 6 >
struct	NBBITS
struct	NBBITS< 6 >
class	rmint< K, MG_INACTIVE >
class	rmint
class	rmint< K, MG_ACTIVE >
class	rint
struct	sdiv
class	ruint
class	ruint< 0 >
class	ruint< 1 >
class	ruint< 2 >
class	ruint< 3 >
class	ruint< 4 >
class	ruint< 5 >
class	ruint< 6 >

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 > &)
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
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
MG &	a
MG const rmint< K, MG > &	b
MG const rmint< K, MG > const T &	c
a	p

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]

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

inline

operator++() [2/6]

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

inline

operator+=() [1/7]

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

inline

operator+=() [2/7]

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

inline

operator+=() [3/7]

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

inline

operator+() [1/13]

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

inline

operator+() [2/13]

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

inline

operator+() [3/13]

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

inline

operator+() [4/13]

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

inline

operator+() [5/13]

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

inline

add() [1/33]

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

inline

add() [2/33]

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

inline

add() [3/33]

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

inline

add() [4/33]

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

inline

add() [5/33]

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]

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

inline

add() [7/33]

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]

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

inline

add_1() [1/16]

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

inline

add_1() [2/16]

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

inline

add_1() [3/16]

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

inline

add_1() [4/16]

void add_1 ( rint< K > &  a )

inline

operator+() [6/13]

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

inline

operator+() [7/13]

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

inline

operator==() [1/10]

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

inline

operator==() [2/10]

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

inline

operator==() [3/10]

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

inline

operator!=() [1/8]

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

inline

operator!=() [2/8]

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

inline

operator!=() [3/8]

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

inline

operator>() [1/7]

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

inline

operator>() [2/7]

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

inline

operator>() [3/7]

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

inline

operator>=() [1/7]

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

inline

operator>=() [2/7]

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

inline

operator>=() [3/7]

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

inline

operator<() [1/7]

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

inline

operator<() [2/7]

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

inline

operator<() [3/7]

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

inline

operator<=() [1/7]

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

inline

operator<=() [2/7]

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

inline

operator<=() [3/7]

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

inline

cmp() [1/9]

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

inline

cmp() [2/9]

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

inline

cmp() [3/9]

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

inline

mpz_to_rint() [1/2]

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

rint_to_mpz()

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

inline

mpz_to_rint() [2/2]

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

inline

rint_to_mpz_t()

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

inline

mpz_t_to_rint()

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

inline

operator<<() [1/6]

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

inline

display_dec() [1/2]

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

inline

operator>>() [1/5]

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

inline

operator%=() [1/6]

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

inline

operator%=() [2/6]

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

inline

operator/=() [1/7]

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

inline

operator/=() [2/7]

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

inline

operator%() [1/6]

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

inline

operator%() [2/6]

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

inline

operator/() [1/7]

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

inline

operator/() [2/7]

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

inline

div_q() [1/4]

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

inline

div_q() [2/4]

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]

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

inline

div_r() [2/4]

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]

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

inline

mod_n() [1/5]

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

inline

mod_n() [2/5]

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

inline

operator~() [1/3]

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

inline

operator-() [1/14]

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

inline

neg() [1/7]

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

inline

neg() [2/7]

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

inline

operator|=() [1/6]

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

inline

operator^=() [1/6]

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

inline

operator&=() [1/6]

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

inline

operator|=() [2/6]

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

operator^=() [2/6]

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

inline

operator&=() [2/6]

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

inline

operator|() [1/4]

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

inline

operator^() [1/4]

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

inline

operator&() [1/4]

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

inline

operator|() [2/4]

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

operator^() [2/4]

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

operator&() [2/4]

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

operator<<() [2/6]

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

operator>>() [2/5]

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

operator<<=() [1/2]

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

operator>>=() [1/2]

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

operator++() [3/6]

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

inline

operator++() [4/6]

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

inline

operator+=() [4/7]

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

inline

__RECINT_IS_ARITH() [1/8]

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

inline

operator+() [8/13]

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

__RECINT_IS_ARITH() [2/8]

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

__RECINT_IS_ARITH() [3/8]

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

add() [9/33]

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

inline

add() [10/33]

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

inline

__RECINT_IS_ARITH() [4/8]

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

add() [11/33]

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

inline

cp()

rmint<K, MG> RecInt::cp

(

c

)

add() [12/33]

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

if()

if

(

r||a.Value >=a.

p

)

bp()

rmint<K, MG> RecInt::bp

(

b

)

Examples

examples/Integer/givaro-ssh-keygen.C.

add() [13/33]

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

addmul() [1/7]

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

inline

__RECINT_IS_ARITH() [5/8]

__RECINT_IS_ARITH ( T  , void    )

inline

addmul() [2/7]

addmul	(	a	,
		b	,
		cr
	)

exp() [1/4]

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

inline

exp() [2/4]

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]

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

inline

inv() [2/6]

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

inline

inv() [3/6]

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]

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]

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

inline

reduction() [1/8]

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

inline

reduction() [2/8]

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

inline

reduction() [3/8]

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

inline

reduction() [4/8]

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

inline

get_ruint() [1/2]

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

inline

get_ready() [1/2]

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

inline

operator==() [4/10]

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

inline

operator==() [5/10]

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

__RECINT_IS_ARITH() [6/8]

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

operator!=() [4/8]

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

operator!=() [5/8]

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

operator>() [4/7]

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

__RECINT_IS_ARITH() [7/8]

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

operator>=() [4/7]

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

operator<() [4/7]

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

operator<=() [4/7]

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

operator==() [6/10]

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

inline

operator==() [7/10]

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

inline

__RECINT_IS_ARITH() [8/8]

RecInt::__RECINT_IS_ARITH ( T  , bool    )

inline

mpz_to_rmint()

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

inline

rmint_to_mpz()

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

inline

operator<<() [3/6]

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

inline

operator>>() [3/5]

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

inline

write_raw() [1/2]

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

inline

read_raw() [1/2]

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

inline

operator%=() [3/6]

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

inline

operator%=() [4/6]

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

inline

operator/=() [3/7]

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

inline

operator/=() [4/7]

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

inline

operator/() [3/7]

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

inline

operator/() [4/7]

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]

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

inline

operator%() [4/6]

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]

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

inline

div() [2/7]

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

inline

div() [3/7]

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]

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

inline

mod() [1/4]

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

inline

mod() [2/4]

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

inline

mod() [3/4]

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]

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

inline

is_quadratic_residue()

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

inline

square_root()

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

inline

addmul() [3/7]

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

inline

exp() [3/4]

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

inline

exp() [4/4]

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

inline

inv() [4/6]

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

inline

inv() [5/6]

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

inline

inv() [6/6]

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]

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

inline

arazi_qi() [2/2]

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

inline

mul() [3/17]

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]

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

inline

to_mg() [1/2]

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

inline

to_mg() [2/2]

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

inline

reduction() [5/8]

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

inline

reduction() [6/8]

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

inline

reduction() [7/8]

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

inline

reduction() [8/8]

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

inline

get_ruint() [2/2]

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

inline

get_ready() [2/2]

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

inline

reset() [1/4]

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

inline

copy() [1/4]

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

inline

operator*=() [1/6]

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

inline

operator*() [1/9]

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

mul() [5/17]

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

inline

mul() [6/17]

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

inline

square() [1/4]

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

inline

square() [2/4]

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

inline

mul() [7/17]

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

inline

operator-() [2/14]

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

inline

neg() [3/7]

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

inline

neg() [4/7]

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

inline

rand() [1/4]

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

inline

operator--() [1/6]

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

inline

operator--() [2/6]

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

inline

operator-=() [1/7]

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

inline

operator-() [3/14]

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

sub() [1/37]

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

inline

sub() [2/37]

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

inline

sub() [3/37]

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

inline

sub() [4/37]

return RecInt::sub	(	a	,
		b	,
		cp
	)

sub() [5/37]

return RecInt::sub	(	a	,
		bp
	)

operator*=() [2/6]

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

inline

operator*=() [3/6]

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

inline

operator*() [2/9]

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

inline

operator*() [3/9]

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

inline

operator*() [4/9]

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

inline

mul() [8/17]

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

inline

mul() [9/17]

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

inline

mul() [10/17]

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]

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

inline

lmul() [1/7]

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

inline

addmul() [4/7]

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

inline

lsquare() [1/3]

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

inline

rand() [2/4]

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

inline

reset() [2/4]

void RecInt::reset ( rint< K > &  a )

inline

copy() [2/4]

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

inline

operator--() [3/6]

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

inline

operator--() [4/6]

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

inline

operator-=() [2/7]

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

inline

operator-=() [3/7]

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

inline

operator-=() [4/7]

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

inline

operator-() [4/14]

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

inline

operator-() [5/14]

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

inline

operator-() [6/14]

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

inline

operator-() [7/14]

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

inline

operator-() [8/14]

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

inline

sub() [6/37]

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

inline

sub() [7/37]

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

inline

sub() [8/37]

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

inline

sub() [9/37]

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

inline

sub() [10/37]

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]

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

inline

sub() [12/37]

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]

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

inline

sub_1() [1/16]

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

inline

sub_1() [2/16]

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

inline

sub_1() [3/16]

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

inline

sub_1() [4/16]

void sub_1 ( rint< K > &  a )

inline

operator++() [5/6]

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

inline

operator++() [6/6]

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

inline

operator+=() [5/7]

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

inline

operator+=() [6/7]

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

inline

operator+=() [7/7]

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

inline

operator+() [9/13]

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

inline

operator+() [10/13]

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

inline

operator+() [11/13]

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

inline

operator+() [12/13]

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

inline

operator+() [13/13]

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

inline

add() [14/33]

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

inline

add() [15/33]

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

inline

add() [16/33]

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

inline

add() [17/33]

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

inline

add() [18/33]

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]

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

inline

add() [20/33]

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]

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

inline

add_1() [5/16]

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

inline

add_1() [6/16]

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

inline

add_1() [7/16]

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

inline

add_1() [8/16]

void add_1 ( ruint< K > &  a )

inline

add_wc() [1/12]

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

inline

add_wc() [2/12]

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

inline

add_wc() [3/12]

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

inline

add_wc() [4/12]

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

inline

add() [22/33]

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

inline

add() [23/33]

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

inline

add() [24/33]

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

inline

add() [25/33]

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

inline

add() [26/33]

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

inline

add() [27/33]

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

inline

add() [28/33]

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

inline

add() [29/33]

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

inline

add() [30/33]

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

inline

add() [31/33]

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

inline

add() [32/33]

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

inline

add() [33/33]

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

inline

add_1() [9/16]

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

inline

add_1() [10/16]

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

inline

add_1() [11/16]

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

inline

add_1() [12/16]

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

inline

add_1() [13/16]

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

inline

add_1() [14/16]

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

inline

add_1() [15/16]

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

inline

add_1() [16/16]

void RecInt::add_1 ( ruint< 6 > &  a )

inline

add_wc() [5/12]

void RecInt::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]

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

inline

add_wc() [7/12]

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

inline

add_wc() [8/12]

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

inline

add_wc() [9/12]

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

inline

add_wc() [10/12]

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

inline

add_wc() [11/12]

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

inline

add_wc() [12/12]

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

inline

laddmul() [1/9]

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

inline

laddmul() [2/9]

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]

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

inline

laddmul() [4/9]

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

inline

laddmul() [5/9]

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]

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]

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

inline

addmul() [6/7]

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

inline

laddmul() [7/9]

void RecInt::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]

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

inline

laddmul() [9/9]

void RecInt::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]

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

inline

operator==() [8/10]

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

inline

operator==() [9/10]

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

inline

operator==() [10/10]

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

inline

operator!=() [6/8]

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

inline

operator!=() [7/8]

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

inline

operator!=() [8/8]

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

inline

operator>() [5/7]

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

inline

operator>() [6/7]

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

inline

operator>() [7/7]

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

inline

operator>=() [5/7]

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

inline

operator>=() [6/7]

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

inline

operator>=() [7/7]

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

inline

operator<() [5/7]

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

inline

operator<() [6/7]

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

inline

operator<() [7/7]

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

inline

operator<=() [5/7]

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

inline

operator<=() [6/7]

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

inline

operator<=() [7/7]

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

inline

cmp() [4/9]

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

inline

cmp() [5/9]

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

inline

cmp() [6/9]

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

inline

cmp() [7/9]

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

inline

cmp() [8/9]

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

inline

cmp() [9/9]

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

inline

mpz_to_ruint()

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

inline

ruint_to_mpz()

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

inline

ruint_to_mpz_t()

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

inline

mpz_t_to_ruint()

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

inline

operator<<() [4/6]

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

inline

operator>>() [4/5]

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

inline

operator<<() [5/6]

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

inline

display_dec() [2/2]

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

inline

display_hex() [1/2]

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

inline

display_hex() [2/2]

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

inline

write_raw() [2/2]

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

inline

read_raw() [2/2]

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

inline

operator%=() [5/6]

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

inline

operator%=() [6/6]

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

inline

operator/=() [5/7]

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

inline

operator/=() [6/7]

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

inline

operator/=() [7/7]

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

inline

operator%() [5/6]

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

inline

operator%() [6/6]

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

inline

operator/() [5/7]

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

inline

operator/() [6/7]

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

inline

operator/() [7/7]

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]

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]

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]

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

inline

div() [6/7]

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]

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

inline

div_q() [4/4]

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]

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

inline

div_r() [4/4]

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]

void RecInt::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]

void RecInt::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 RecInt::udiv_qrnd ( limb &  q, limb &  r, const limb &  a, const limb &  b  )

inline

div() [7/7]

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

inline

exp_mod() [1/2]

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

inline

exp_mod() [2/2]

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]

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

inline

operator-() [9/14]

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

inline

neg() [5/7]

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

inline

neg() [6/7]

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

inline

operator|=() [3/6]

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

inline

operator^=() [3/6]

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

inline

operator&=() [3/6]

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

inline

operator|=() [4/6]

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

inline

operator^=() [4/6]

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

inline

operator&=() [4/6]

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

inline

operator|() [3/4]

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

inline

operator^() [3/4]

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

inline

operator&() [3/4]

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

inline

operator|() [4/4]

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

inline

operator^() [4/4]

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

inline

operator&() [4/4]

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

inline

max_pow_two() [1/2]

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

inline

highest_bit() [1/2]

bool highest_bit ( const ruint< K > &  a )

inline

lowest_bit() [1/2]

bool lowest_bit ( const ruint< K > &  a )

inline

set_highest_bit() [1/2]

void set_highest_bit ( ruint< K > &  a )

inline

set_lowest_bit() [1/2]

void set_lowest_bit ( ruint< K > &  a )

inline

set_highest_word() [1/2]

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

inline

set_lowest_word() [1/2]

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

inline

operator~() [3/3]

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

inline

neg() [7/7]

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

inline

operator|=() [5/6]

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

inline

operator|=() [6/6]

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

inline

operator^=() [5/6]

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

inline

operator^=() [6/6]

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

inline

operator&=() [5/6]

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

inline

operator&=() [6/6]

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

inline

max_pow_two() [2/2]

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

inline

highest_bit() [2/2]

bool RecInt::highest_bit ( const ruint< 6 > &  a )

inline

lowest_bit() [2/2]

bool RecInt::lowest_bit ( const ruint< 6 > &  a )

inline

set_highest_bit() [2/2]

void RecInt::set_highest_bit ( ruint< 6 > &  a )

inline

set_lowest_bit() [2/2]

void RecInt::set_lowest_bit ( ruint< 6 > &  a )

inline

set_highest_word() [2/2]

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

inline

set_lowest_word() [2/2]

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

inline

gcd() [1/2]

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

inline

gcd() [2/2]

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

inline

bezout_mod()

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

inline

inv_mod() [2/2]

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

inline

reset() [3/4]

void reset ( ruint< K > &  a )

inline

fill_with_1() [1/2]

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

inline

copy() [3/4]

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

inline

pointers_list() [1/2]

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

inline

set_limb() [1/2]

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

inline

ms_limb() [1/2]

limb ms_limb ( const ruint< K > &  a )

inline

get_limb() [1/2]

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

inline

get_limb_p() [1/2]

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

inline

begin() [1/2]

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

inline

reset() [4/4]

void RecInt::reset ( ruint< 6 > &  a )

inline

fill_with_1() [2/2]

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

inline

copy() [4/4]

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

inline

pointers_list() [2/2]

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

inline

set_limb() [2/2]

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

inline

ms_limb() [2/2]

limb RecInt::ms_limb ( const ruint< 6 > &  a )

inline

get_limb() [2/2]

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

inline

get_limb_p() [2/2]

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

inline

begin() [2/2]

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

inline

operator*=() [4/6]

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

inline

operator*=() [5/6]

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

inline

operator*=() [6/6]

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

inline

operator*() [5/9]

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

inline

operator*() [6/9]

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

inline

operator*() [7/9]

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

inline

operator*() [8/9]

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

inline

operator*() [9/9]

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

inline

lmul_naive() [1/3]

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

inline

lmul_naive() [2/3]

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

inline

lmul_kara() [1/3]

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

inline

lmul_kara() [2/3]

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

inline

lmul() [2/7]

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

inline

lmul() [3/7]

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

inline

lmul() [4/7]

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]

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]

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

inline

mul() [13/17]

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

inline

mul() [14/17]

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]

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

inline

lsquare() [2/3]

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

inline

square() [3/4]

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

inline

lmul_naive() [3/3]

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

inline

lmul_kara() [3/3]

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

inline

lmul() [6/7]

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

inline

lmul() [7/7]

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

inline

mul() [16/17]

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

inline

mul() [17/17]

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

inline

lsquare() [3/3]

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

inline

square() [4/4]

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

inline

rand() [3/4]

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

inline

srand()

void srand ( const limb  s )

inline

rand() [4/4]

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

inline

operator<<() [6/6]

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

inline

operator>>() [5/5]

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

inline

operator<<=() [2/2]

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

inline

operator>>=() [2/2]

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

inline

left_shift() [1/3]

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

inline

left_shift_1() [1/3]

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

inline

left_shift_1() [2/3]

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

inline

right_shift() [1/2]

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

inline

right_shift_1() [1/3]

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

inline

right_shift_1() [2/3]

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

inline

left_shift() [2/3]

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

inline

left_shift() [3/3]

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

inline

left_shift_1() [3/3]

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

inline

right_shift() [2/2]

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

inline

right_shift_1() [3/3]

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

inline

operator--() [5/6]

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

inline

operator--() [6/6]

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

inline

operator-=() [5/7]

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

inline

operator-=() [6/7]

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

inline

operator-=() [7/7]

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

inline

operator-() [10/14]

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

inline

operator-() [11/14]

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

inline

operator-() [12/14]

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

inline

operator-() [13/14]

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

inline

operator-() [14/14]

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

inline

sub() [14/37]

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

inline

sub() [15/37]

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

inline

sub() [16/37]

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

inline

sub() [17/37]

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

inline

sub() [18/37]

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]

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

inline

sub() [20/37]

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]

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

inline

sub_1() [5/16]

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

inline

sub_1() [6/16]

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

inline

sub_1() [7/16]

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

inline

sub_1() [8/16]

void sub_1 ( ruint< K > &  a )

inline

sub_wc() [1/12]

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

inline

sub_wc() [2/12]

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

inline

sub_wc() [3/12]

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

inline

sub_wc() [4/12]

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

inline

sub() [22/37]

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

inline

sub() [23/37]

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

inline

sub() [24/37]

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

inline

sub() [25/37]

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

inline

sub() [26/37]

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

inline

sub() [27/37]

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

inline

sub() [28/37]

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

inline

sub() [29/37]

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

inline

sub() [30/37]

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

inline

sub() [31/37]

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

inline

sub() [32/37]

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

inline

sub() [33/37]

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

inline

sub() [34/37]

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

inline

sub() [35/37]

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

inline

sub() [36/37]

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

inline

sub() [37/37]

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

inline

sub_1() [9/16]

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

inline

sub_1() [10/16]

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

inline

sub_1() [11/16]

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

inline

sub_1() [12/16]

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

inline

sub_1() [13/16]

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

inline

sub_1() [14/16]

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

inline

sub_1() [15/16]

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

inline

sub_1() [16/16]

void RecInt::sub_1 ( ruint< 6 > &  a )

inline

sub_wc() [5/12]

void RecInt::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]

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

inline

sub_wc() [7/12]

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

inline

sub_wc() [8/12]

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

inline

sub_wc() [9/12]

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

inline

sub_wc() [10/12]

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

inline

sub_wc() [11/12]

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

inline

sub_wc() [12/12]

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

inline

normalization()

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

inline

mod_n() [3/5]

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

inline

mod_n() [4/5]

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

inline

mod_n() [5/5]

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

inline

Variable Documentation

a

MG & a

Examples

examples/FiniteField/Test_Extension.C, examples/FiniteField/all_field.C, examples/FiniteField/domain_to_operatorstyle.C, examples/FiniteField/exponentiation.C, examples/FiniteField/ff_arith.C, examples/FiniteField/kronecker.C, examples/Integer/Fibonacci.C, examples/Integer/ModularSquareRoot.C, examples/Integer/ProbLucas.C, examples/Integer/givaro-ssh-keygen.C, examples/Integer/iexponentiation.C, examples/Integer/igcd.C, examples/Integer/igcdext.C, examples/Integer/ilcm.C, examples/Integer/ispower.C, examples/Integer/isprime.C, examples/Integer/isproot.C, examples/Integer/lambda.C, examples/Integer/lambda_inv.C, examples/Integer/nb_primes.C, examples/Integer/order.C, examples/Integer/phi.C, examples/Integer/primitiveelement.C, examples/Integer/primitiveroot.C, examples/Integer/probable_primroot.C, examples/Polynomial/PolynomialCRT.C, and examples/Polynomial/highorder.C.

b

MG const T & b

Initial value:

{
        bool r

Examples

examples/FiniteField/GF128.C, examples/FiniteField/Test_Extension.C, examples/FiniteField/all_field.C, examples/FiniteField/domain_to_operatorstyle.C, examples/FiniteField/ff_arith.C, examples/FiniteField/kronecker.C, examples/Integer/Fibonacci.C, examples/Integer/ProbLucas.C, examples/Integer/iexponentiation.C, examples/Integer/igcd.C, examples/Integer/igcdext.C, examples/Integer/ilcm.C, examples/Integer/isproot.C, examples/Integer/nb_primes.C, and examples/Polynomial/highorder.C.

c

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

Initial value:

{
        bool r

Examples

examples/FiniteField/GF128.C, examples/FiniteField/all_field.C, examples/FiniteField/domain_to_operatorstyle.C, examples/FiniteField/exponentiation.C, examples/FiniteField/ff_arith.C, examples/FiniteField/kronecker.C, examples/Integer/ProbLucas.C, and examples/Integer/ilcm.C.

p

a p

Examples

examples/FiniteField/GFirreducible.C, examples/Integer/ProbLucas.C, examples/Integer/givaro-ssh-keygen.C, examples/Integer/iexponentiation.C, and examples/Integer/ispower.C.