Arageli Namespace Reference

Classes
struct	algebraic_config_default
class	algebraic
	Algebraic number class. More...
struct	factory< algebraic< TP, TS, Poly, Seg, Cfg > >
class	big_float
class	big_int
	Big integer number. More...
struct	fromnull_t
struct	fromspace_t
struct	fromineq_t
struct	fromeq_t
struct	fromgen_t
struct	frombasis_t
struct	fromdual_t
class	cannot_represent_cone
	This exception is generated when the implementation cannon represent cone in required way. More...
class	cone_default_config
class	cone
	The polyhedral cone representation as a set of facets or a set of generators. More...
struct	factory< cone< TT, M, CFG > >
	Specialization of factory structure for cone template class. More...
class	CCounter
class	exception
	Base for all exception classes. More...
class	assert_failed
	Exception class that can be trhowed when failed the some assertion. More...
class	out_of_range
	Exception situation: an index out of range while indexing the some structure. More...
class	invalid_argument
	Exceprion situation: invalid argument in call of the some operation. More...
class	division_by_zero
	Exception situation: division by zero. More...
class	matrix_is_singular
	Exception situation: the some matrix is singular. More...
class	incorrect_string
	Exception situation: the some object have failed initialization from a string. More...
struct	factory
	Common implementation of factory for the specific type. More...
struct	unary_function_traits_base
	Holds additional information about unary function. More...
struct	binary_function_traits_base
struct	ternary_function_traits_base
struct	unary_function_traits
struct	binary_function_traits
struct	ternary_function_traits
class	interval
	Represents an interval (open, close or semi-open; it depends on performed operations). More...
class	apply_iterator
class	Iterpair
struct	nonsquare_t
	Type for helper object fromsize. More...
struct	colwise_t
	Type for helper object for columnwise filling of the matrix. More...
struct	diag_t
	Type for helper object diag. More...
struct	eye_t
	Type for helper object eye. More...
struct	frommat_t
class	matrix
	Template class matrix. More...
struct	factory< matrix< T, REFCNT > >
	Specialization of the template 'factory' for the Arageli::matrix template. More...
struct	type_traits< matrix< T, REFCNT > >
struct	cnc_value_type
struct	cnc_value_type< const T >
struct	cnc_reference
struct	cnc_reference< const T >
struct	cnc_pointer
struct	cnc_pointer< const T >
struct	cnc_iterator
struct	cnc_iterator< const T >
struct	binary_function_gate_slot
	Gate slot for mixed computations. More...
struct	fromempty_t
struct	fromivert_t
struct	fromvert_t
class	polyhedron_default_config
class	polyhedron
	The polyhedron representation as the base cone. More...
class	pstricks_color_map
class	polynom
struct	rand_config
struct	rnd
class	rational_base
	Base for all rationals. More...
class	rational
	Implementation of a Rational Number. More...
struct	select_numer
	Unary functor: selects a numerator of an argument of type rational. More...
struct	select_denom
	Unary functor: selects a denominator of an argument of type rational. More...
struct	factory< rational< T1 > >
struct	type_traits< rational< T > >
	Specialization of type_traits for rational. More...
class	refcntr
class	refcntr_proxy< T, true, TC, A >
class	refcntr_proxy< T, false, TC, A >
struct	residue_config_default
class	residue
class	sideset
	WARNING! Temporary implimentation. Only facets with vertices indexes. More...
struct	smith_norm
	Normalize for resulting elements of Smith form. More...
class	no_unique_solution
	An exception for non-one-point solution for a linear system. More...
class	monom
	Monom template definition. More...
struct	type_traits< monom< F, I > >
struct	factory< monom< F, I > >
struct	monom_degree_less
	Binary predicate for two monoms for degrees comparision. More...
struct	monom_degree_equal
	Binary predicate for two monoms for equality degrees determination. More...
struct	coef_extractor
	Óíàðíûé ôóíêòîð: ïî ìîíîìó âîçâðàùàåò ññûëêó íà åãî êîýôôèöèåíò. More...
struct	degree_extractor
	Óíàðíûé ôóíêòîð: ïî ìîíîìó âîçâðàùàåò ññûëêó íà åãî ñòåïåíü. More...
struct	norm_monom_seq_t
	Type for helper object norm_monom_seq. More...
struct	any_monom_seq_t
	Type for helper object any_monom_seq. More...
struct	sparse_polynom_base
	Base for all sparse polynomials. More...
class	sparse_polynom
struct	factory< sparse_polynom< F, I, REFCNT > >
struct	type_traits< sparse_polynom< F, I, REFCNT > >
struct	matrix_line
	A line descriptor for matrix output. More...
struct	matrix_box
	A box (or frame) descriptor for matrix output. More...
struct	matrix_frames
	Contains information about horizontals and verticals lines and boxes for matrix output. More...
struct	true_type
struct	false_type
struct	bool_type< false >
struct	bool_type< true >
struct	equal_types
	General form for defferent types. More...
struct	equal_types< T, T >
	Specialized form for the same type. More...
struct	omit_const
	General form (for types without exterior const). More...
struct	omit_const < const T >
	Specialized form (for types with exterior const). More...
struct	omit_asterisk
	General form (for types without exterior *). More...
struct	omit_asterisk< T * >
	Specialized form (for types with exterior const). More...
struct	omit_ref
	General form (for types without exterior *). More...
struct	omit_ref< T & >
	Specialized form (for types with exterior const). More...
struct	omit_const_ref
	Omitting const &. More...
struct	type_pair_traits_default
	Minimal specialization for type_pair_traits. More...
struct	type_pair_traits_helper< T1, T2, true, true >
struct	type_pair_traits_helper< T1, T2, true, false >
struct	type_pair_traits_helper< T1, T2, false, true >
struct	type_pair_traits_helper< T1, T2, false, false >
struct	type_pair_traits
	Generic implementation of type_pair_traits --- information about two types. More...
struct	type_pair_traits_for_the_same
	Pattern for type_pair_traits in case two identical types. More...
struct	type_pair_traits< T, T >
	Specialization of type_pair_traits for two identical types. More...
struct	auto_type_category_by_numeric_limits
	Determines type category for particular type. More...
struct	type_traits_default
	Minimal implementation for each specialization of type_traits. More...
struct	type_traits
	General specialization of root of additional information service about type. More...
struct	type_traits_iterator
struct	type_traits< T * >
struct	type_traits< T[Size]>
struct	type_traits_string
struct	type_traits< const char * >
struct	type_traits< char * >
struct	type_traits< const char[Size]>
struct	type_traits< char[Size]>
struct	type_traits< const wchar_t * >
struct	type_traits< wchar_t * >
struct	type_traits< const wchar_t[Size]>
struct	type_traits< wchar_t[Size]>
struct	type_traits_iostream
struct	vec_binary_function_traits
struct	fromseq_t
struct	fromval_t
struct	fromvec_t
struct	fromsize_t
struct	fromstr_t
struct	_element_type_vec_val_1
struct	_element_type_vec_val_1< X, true >
struct	_element_type_vec_val
class	vector
	Template class vector definition. More...
struct	type_traits< vector< T, REFCNT > >
struct	unary_function_traits< Tag, vector< T, REFCNT > >
struct	bfgs_vector_helper_1
struct	bfgs_vector_helper_1< Tag, V1, V2, false, false, Tag_class >
struct	bfgs_vector_helper_1< Tag, V1, V2, false, true, Tag_class >
struct	bfgs_vector_helper_1< Tag, V1, V2, true, false, Tag_class >
struct	bfgs_vector_helper_2
struct	bfgs_vector_helper_3
struct	binary_function_gate_slot< Tag, vector< T, REFCNT >, T1, T2 >
struct	binary_function_gate_slot< Tag, const vector< T, REFCNT >, T1, T2 >
struct	binary_function_gate_slot< Tag, vector< T, REFCNT > &, T1, T2 >
struct	binary_function_gate_slot< Tag, const vector< T, REFCNT > &, T1, T2 >
struct	factory< vector< T, REFCNT > >
	Specialization of the template 'factory' for the Arageli::vector template. More...
struct	factory< std::complex< T2 > >
	Specialization of common factory template for std::complex. More...
struct	unary_function_traits< function_tag::address, Arg >
struct	unary_function_traits< function_tag::unary_plus, Arg >
struct	unary_function_traits< function_tag::unary_minus, Arg >
struct	unary_function_traits< function_tag::logical_not, Arg >
struct	unary_function_traits< function_tag::bitwise_not, Arg >
struct	unary_function_traits< function_tag::prefix_increment, Arg >
struct	unary_function_traits< function_tag::prefix_decrement, Arg >
struct	unary_function_traits< function_tag::parentheses_0, Arg >
struct	binary_function_traits< function_tag::parentheses_1, Arg1, Arg2 >
struct	ternary_function_traits< function_tag::parentheses_2, Arg1, Arg2, Arg3 >
struct	binary_function_traits< function_tag::plus, Arg1, Arg2 >
struct	binary_function_traits< function_tag::minus, Arg1, Arg2 >
struct	binary_function_traits< function_tag::multiplies, Arg1, Arg2 >
struct	binary_function_traits< function_tag::divides, Arg1, Arg2 >
struct	binary_function_traits< function_tag::modulus, Arg1, Arg2 >
struct	binary_function_traits< function_tag::logical_or, Arg1, Arg2 >
struct	binary_function_traits< function_tag::logical_and, Arg1, Arg2 >
struct	binary_function_traits< function_tag::equal_to, Arg1, Arg2 >
struct	binary_function_traits< function_tag::not_equal_to, Arg1, Arg2 >
struct	binary_function_traits< function_tag::greater, Arg1, Arg2 >
struct	binary_function_traits< function_tag::less, Arg1, Arg2 >
struct	binary_function_traits< function_tag::greater_equal, Arg1, Arg2 >
struct	binary_function_traits< function_tag::less_equal, Arg1, Arg2 >
struct	binary_function_traits< function_tag::bitwise_or, Arg1, Arg2 >
struct	binary_function_traits< function_tag::bitwise_and, Arg1, Arg2 >
struct	binary_function_traits< function_tag::bitwise_xor, Arg1, Arg2 >
struct	binary_function_traits< function_tag::shift_left, Arg1, Arg2 >
struct	binary_function_traits< function_tag::shift_right, Arg1, Arg2 >
struct	binary_function_traits< function_tag::all_equal_to, Arg1, Arg2 >
struct	binary_function_traits< function_tag::all_not_equal_to, Arg1, Arg2 >
struct	binary_function_traits< function_tag::all_greater, Arg1, Arg2 >
struct	binary_function_traits< function_tag::all_less, Arg1, Arg2 >
struct	binary_function_traits< function_tag::all_greater_equal, Arg1, Arg2 >
struct	binary_function_traits< function_tag::all_less_equal, Arg1, Arg2 >
struct	binary_function_traits< function_tag::each_equal_to, Arg1, Arg2 >
struct	binary_function_traits< function_tag::each_not_equal_to, Arg1, Arg2 >
struct	binary_function_traits< function_tag::each_greater, Arg1, Arg2 >
struct	binary_function_traits< function_tag::each_less, Arg1, Arg2 >
struct	binary_function_traits< function_tag::each_greater_equal, Arg1, Arg2 >
struct	binary_function_traits< function_tag::each_less_equal, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_plus, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_minus, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_multiplies, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_divides, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_modulus, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_bitwise_or, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_bitwise_and, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_bitwise_xor, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_shift_left, Arg1, Arg2 >
struct	binary_function_traits< function_tag::assign_shift_right, Arg1, Arg2 >
struct	binary_function_traits< function_tag::left_assign_plus, Arg1, Arg2 >
struct	binary_function_traits< function_tag::left_assign_minus, Arg1, Arg2 >
struct	binary_function_traits< function_tag::left_assign_multiplies, Arg1, Arg2 >
struct	binary_function_traits< function_tag::left_assign_modulus, Arg1, Arg2 >
struct	binary_function_traits< function_tag::left_assign_bitwise_or, Arg1, Arg2 >
struct	binary_function_traits< function_tag::left_assign_bitwise_and, Arg1, Arg2 >
struct	binary_function_traits< function_tag::left_assign_bitwise_xor, Arg1, Arg2 >
struct	binary_function_traits< function_tag::left_assign_shift_left, Arg1, Arg2 >
struct	binary_function_traits< function_tag::left_assign_shift_right, Arg1, Arg2 >
struct	type_traits< std::complex< T > >
	Specialization of type_traits template class for std::complex. More...
struct	type_traits< std::basic_string< Char, CharTr, A > >
struct	type_traits< std::basic_istream< Ch, ChT > >
struct	type_traits< std::basic_ostream< Ch, ChT > >
struct	binary_function_traits< function_tag::subscript, vector< T, REFCNT >, Index >
struct	binary_function_traits< function_tag::subscript, const vector< T, REFCNT >, Index >
struct	binary_function_traits< function_tag::parentheses_1, vector< T, REFCNT >, Index >
struct	binary_function_traits< function_tag::parentheses_1, const vector< T, REFCNT >, Index >
struct	bfgs_vector_helper_1< function_tag::cmp, V1, V2, false, false, Tag_class >
struct	bfgs_vector_helper_1< function_tag::cmp, V1, V2, false, true, Tag_class >
struct	bfgs_vector_helper_1< function_tag::cmp, V1, V2, true, false, Tag_class >
struct	bfgs_vector_helper_1< function_tag::each_cmp, V1, V2, false, false, Tag_class >
struct	bfgs_vector_helper_1< function_tag::each_cmp, V1, V2, false, true, Tag_class >
struct	bfgs_vector_helper_1< function_tag::each_cmp, V1, V2, true, false, Tag_class >
struct	bfgs_vector_helper_1< Tag, V1, V2, false, false, function_tag::each_compare >
struct	bfgs_vector_helper_1< Tag, V1, V2, false, true, function_tag::each_compare >
struct	bfgs_vector_helper_1< Tag, V1, V2, true, false, function_tag::each_compare >
struct	bfgs_vector_helper_1< Tag, V1, V2, false, false, function_tag::all_compare >
struct	bfgs_vector_helper_1< Tag, V1, V2, false, true, function_tag::all_compare >
struct	bfgs_vector_helper_1< Tag, V1, V2, true, false, function_tag::all_compare >
Namespaces
namespace	_Internal
namespace	ctrl
namespace	func
	Function representations as classes.
namespace	function_tag
namespace	gfunc
namespace	iomanip
namespace	simplex_method
namespace	type_category
	Category of type.
Sorted and nonsorted helper objects.
enum	monoms_order { mo_inc, mo_dec }
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT >	diff (const sparse_polynom< F, I, REFCNT > &x)
	Pefrorms differentiation of polynomial x by common symbolic rules.
template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > &	output_list (std::basic_ostream< Ch, ChT > &out, const sparse_polynom< F, I, REFCNT > &x, monoms_order mo=mo_inc, const char *first_bracket=monom_output_list_first_bracket_default, const char *second_bracket=monom_output_list_second_bracket_default, const char *separator=monom_output_list_separator_default)
	Simple outputting as monom list.
template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > &	output_var (std::basic_ostream< Ch, ChT > &out, const sparse_polynom< F, I, REFCNT > &x, monoms_order mo=mo_inc, const char *var=monom_output_var_var_default, const char *mul=monom_output_var_mul_default, const char *pow=monom_output_var_pow_default)
	Outputting of polynomial with variable symbol.
template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > &	input_list (std::basic_istream< Ch, ChT > &in, sparse_polynom< F, I, REFCNT > &x, const char *first_bracket=monom_input_list_first_bracket_default, const char *second_bracket=monom_input_list_second_bracket_default, const char *separator=monom_input_list_separator_default)
	Simple inputting of a polynomial.
template<typename F, typename I, bool REFCNT, typename Ch, typename ChT, typename Coef_factory>
std::basic_istream< Ch, ChT > &	input_var (std::basic_istream< Ch, ChT > &in, sparse_polynom< F, I, REFCNT > &x, const Coef_factory &fctr, const char *var=monom_input_var_var_default, const char *mul=monom_input_var_mul_default, const char *pow=monom_input_var_pow_default)
	Inputting of a polynomial with variable symbol.
template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > &	input_var (std::basic_istream< Ch, ChT > &in, sparse_polynom< F, I, REFCNT > &x, const char *var=monom_input_var_var_default, const char *mul=monom_input_var_mul_default, const char *pow=monom_input_var_pow_default)
	Inputting of a polynomial with variable symbol.
template<typename Ch, typename ChT, typename F, typename I, bool REFCNT>
std::basic_ostream< Ch, ChT > &	output_aligned (std::basic_ostream< Ch, ChT > &out, const sparse_polynom< F, I, REFCNT > &x, monoms_order mo=mo_inc, const char *var=monom_output_var_var_default, const char *mul=monom_output_var_mul_default, const char *pow=monom_output_var_pow_default)
	Oputputs polynomial in aligned form. (Restricted implementation.).
template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > &	operator<< (std::basic_ostream< Ch, ChT > &out, const sparse_polynom< F, I, REFCNT > &x)
	Ñòàíàðòíûé âûâîä ïîëèíîìà. Ñîâïàäàåò ñ sparse_polynom_output_var.
template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > &	operator>> (std::basic_istream< Ch, ChT > &in, sparse_polynom< F, I, REFCNT > &x)
	Ñòàíàðòíûé âûâîä ïîëèíîìà. Ñîâïàäàåò ñ sparse_polynom_input_var.
static const norm_monom_seq_t	norm_monom_seq = norm_monom_seq_t()
	Helper object for choosing method that gives sorted monom sequence.
static const any_monom_seq_t	any_monom_seq = any_monom_seq_t()
	Helper object for choosing method that gives unsorted monom sequence.
Standard integer mathematical operations.
big_int	operator+ (const big_int &b, const big_int &c)
big_int	operator- (const big_int &b, const big_int &c)
big_int	operator * (const big_int &b, const big_int &c)
big_int	operator% (const big_int &b, const big_int &c)
big_int	operator/ (const big_int &b, const big_int &c)
big_int	operator<< (const big_int &a, std::size_t n)
big_int	operator>> (const big_int &a, std::size_t n)
big_int	operator & (const big_int &a, const big_int &b)
big_int	operator| (const big_int &a, const big_int &b)
big_int	operator^ (const big_int &a, const big_int &b)
template<typename T>
big_int	operator<< (const big_int &a, const T &b)
template<typename T>
big_int	operator>> (const big_int &a, const T &b)
template<typename T>
big_int &	operator<<= (big_int &a, const T &b)
big_int &	operator>>= (big_int &a, std::size_t b)
template<typename T>
big_int &	operator>>= (big_int &a, const T &b)
Standard comparision operations.
bool	operator== (const big_int &a, const big_int &b)
bool	operator!= (const big_int &a, const big_int &b)
bool	operator< (const big_int &a, const big_int &b)
bool	operator> (const big_int &a, const big_int &b)
bool	operator<= (const big_int &a, const big_int &b)
bool	operator>= (const big_int &a, const big_int &b)
Computed assignment operators.
big_int &	operator+= (big_int &b, const big_int &c)
big_int &	operator-= (big_int &b, const big_int &c)
big_int &	operator *= (big_int &b, const big_int &c)
big_int &	operator/= (big_int &b, const big_int &c)
big_int &	operator%= (big_int &b, const big_int &c)
Helper functions for the factory class.
template<typename T>
const T &	unit ()
	åäèíè÷íûé ýëåìåíò
template<typename T>
T	unit (const T &x)
	åäèíè÷íûé ýëåìåíò
template<typename T>
bool	is_unit (const T &x)
	ïðîâåðêà íà ðàâåíñòâî åäèíè÷íîìó ýëåìåíòó
template<typename T>
const T &	opposite_unit ()
	ïðîòèâîïîëîæíûé ê åäèíè÷íîìó ýëåìåíòó (-1)
template<typename T>
T	opposite_unit (const T &x)
	ïðîòèâîïîëîæíûé ê åäèíè÷íîìó ýëåìåíòó (-1)
template<typename T>
bool	is_opposite_unit (const T &x)
	ïðîâåðêà íà ðàâåíñòâî -1
template<typename T>
const T &	null ()
	íóëåâîé ýëåìåíò
template<typename T>
T	null (const T &)
	íóëåâîé ýëåìåíò
template<typename T>
bool	is_null (const T &x)
	ïðîâåðêà íà ðàâåíñòâî íóëåâîìó ýëåìåíòó
template<typename T>
T	opposite (const T &x)
	ïðîòèâîïîëîæíûé ýëåìåíò
template<typename T>
T &	opposite (const T &x, T *y)
	ïðîòèâîïîëîæíûé ýëåìåíò
template<typename T>
T &	opposite (T *x)
	ïðîòèâîïîëîæíûé ýëåìåíò
template<typename T>
T	inverse (const T &x)
	îáðàòíûé ýëåìåíò ê äàííîìó
template<typename T>
T &	inverse (const T &x, T *y)
	îáðàòíûé ýëåìåíò ê äàííîìó
template<typename T>
T &	inverse (T *x)
	îáðàòíûé ýëåìåíò ê äàííîìó
A test for primality.
template<typename T>
bool	is_prime (const T &x)
	Determines if x is prime via appropriate algorithm for T.
template<typename T, typename T_factory>
bool	is_prime_division (const T &x, const T_factory &tfctr)
	Determines if x is prime via consecutive division by sample divisors.
template<typename T>
bool	is_prime_division (const T &x)
	Determines if x is prime via consecutive division by sample divisors.
template<typename T, typename N, typename T_factory>
bool	is_pseudoprime_miller_rabin (const T &x, const N &n, const T_factory &tfctr)
	Determines if x is prime via Miller-Rabin algorithm.
template<typename T>
bool	is_prime_AKS_classic (const T &n)
	Determines if x is prime.
template<typename T>
bool	is_prime_AKS (const T &n)
	Determines if x is prime.
template<typename T, typename N>
bool	is_pseudoprime_miller_rabin (const T &x, const N &n)
	Determines if x is prime via Miller-Rabin algorithm.
template<typename T, typename N, typename T_factory>
bool	is_pseudoprime_solovay_strassen (const T &x, const N &n, const T_factory &tfctr)
	Determines if x is prime via Solovey-Strassen algorithm.
template<typename T, typename N>
bool	is_prime_solovey_strassen (const T &x, const N &n)
	Determines if x is prime via Solovey-Strassen algorithm.
template<typename T, typename T_factory>
bool	is_prime (const T &x, const T_factory &tfctr)
	Determines if x is prime via appropriate algorithm for T.
template<typename T, typename T_factory>
bool	is_probably_prime (const T &x, const T_factory &tfctr)
	Determines if x is probably prime via appropriate algorithm for T.
template<typename T>
bool	is_probably_prime (const T &x)
	Determines if x is probably prime via appropriate algorithm for T.
template<typename Out, typename T>
Out	small_primes (Out primes, const T &N)
	Fills sequence with first N primes.
template<typename T, typename N>
int	is_prime_small_primes_division (const T &n, const N &np)
template<typename T>
int	is_prime_small_primes_division (const T &n)
template<typename T, typename T_factory>
bool	is_composite (const T &x, const T_factory &tfctr)
	Determines if x is composite.
template<typename T>
bool	is_composite (const T &x)
	Determines if x is composite.
The Euclidean algorithm.
template<typename T, typename T_factory>
T	euclid (T a, T b, const T_factory &tfctr)
	Processes the Euclidean algorithm on a and b.
template<typename T>
T	euclid (const T &a, const T &b)
	Processes the Euclidean algorithm on a and b.
template<typename T, typename T_factory>
T	euclid_binary (T a, T b, const T_factory &tfctr)
	Processes the Euclidean algorithm on a and b.
template<typename T>
T	euclid_binary (const T &a, const T &b)
	Processes the Euclidean algorithm on a and b.
template<typename T, bool REFCNT, typename T_factory, typename T1, bool REFCNT1>
vector< T, REFCNT >	euclid (const vector< T, REFCNT > &a, const vector< T1, REFCNT1 > &b, const T_factory &tfctr)
	Computes Euclidean algorithm for each corresponding pair of a and b.
template<typename T, bool REFCNT, typename T1, bool REFCNT1>
vector< T, REFCNT >	euclid (const vector< T, REFCNT > &a, const vector< T1, REFCNT1 > &b)
	Computes Euclidean algorithm for each corresponding pair of a and b.
template<typename T, typename T_factory>
T	euclid_bezout (const T &a, const T &b, T &u, T &v, const T_factory &tfctr)
	The greatest common divisor and Bezout's coefficients.
template<typename T>
T	euclid_bezout (const T &a, const T &b, T &u, T &v)
	The greatest common divisor and Bezout's coefficients.
The GCD and LCM algorithms.
template<typename T, typename T_factory>
T	gcd (const T &a, const T &b, const T_factory &tfctr, const type_category::type &)
template<typename T, typename T_factory>
T	gcd (const T &a, const T &b, const T_factory &tfctr, const type_category::integer &)
template<typename T, typename T_factory>
T	gcd (const T &a, const T &b, const T_factory &tfctr)
	Computes GCD for a and b.
template<typename T>
T	gcd (const T &a, const T &b)
	Computes GCD for a and b.
template<typename T1, typename T2>
T1	gcd (const T1 &a, const T2 &b)
	Computes GCD for a and b.
template<typename T, bool REFCNT, typename T_factory>
T	gcd (const vector< T, REFCNT > &x, const T_factory &tfctr)
	Computes GCD for all items of vector 'x'.
template<typename T, bool REFCNT>
T	gcd (const vector< T, REFCNT > &x)
	Computes GCD for all items of vector 'x'.
template<typename T>
T	gcd3 (const T &a, const T &b, const T &c)
	Compute GCD(a, b, c).
template<typename T>
T	gcdex (const T &a, const T &b, T &u, T &v, T &w, T &z)
	Extended GCD; abs(u*z - w*v) == 1; a*w + b*z == 0.
template<typename T>
T	gcdex (const T &a, const T &b, const T &N, T &u, T &v, T &w, T &z)
template<typename T, bool REFCNT, typename T_factory, typename T1, bool REFCNT1>
vector< T, REFCNT >	gcd_vec (const vector< T, REFCNT > &a, const vector< T1, REFCNT1 > &b, const T_factory &tfctr)
	Computes GCD for each corresponding pair of a and b.
template<typename T, bool REFCNT, typename T_factory, typename T1, bool REFCNT1>
vector< T, REFCNT >	gcd (const vector< T, REFCNT > &a, const vector< T1, REFCNT1 > &b, const T_factory &tfctr)
	Computes GCD for each corresponding pair of a and b.
template<typename T, bool REFCNT, typename T_factory>
vector< T, REFCNT >	gcd (const vector< T, REFCNT > &a, const vector< T, REFCNT > &b, const T_factory &tfctr)
	Computes GCD for each corresponding pair of a and b.
template<typename T, bool REFCNT, typename T1, bool REFCNT1>
vector< T, REFCNT >	gcd (const vector< T, REFCNT > &a, const vector< T1, REFCNT1 > &b)
	Computes GCD for each corresponding pair of a and b.
template<typename T, bool REFCNT>
vector< T, REFCNT >	gcd (const vector< T, REFCNT > &a, const vector< T, REFCNT > &b)
	Computes GCD for each corresponding pair of a and b.
template<typename T, typename T_factory>
T	lcm (const T &a, const T &b, const T_factory &tfctr)
	Computes LCM for a and b.
template<typename T>
T	lcm (const T &a, const T &b)
	Computes LCM for a and b.
template<typename T, bool REFCNT, typename T_factory>
T	lcm (const vector< T, REFCNT > &x, const T_factory &tfctr)
	Computes LCM for all items of vector 'x'.
template<typename T, bool REFCNT>
T	lcm (const vector< T, REFCNT > &x)
	Computes LCM for all items of vector 'x'.
template<typename T, bool REFCNT, typename T_factory, typename T1, bool REFCNT1>
vector< T, REFCNT >	lcm_vec (const vector< T, REFCNT > &a, const vector< T1, REFCNT1 > &b, const T_factory &tfctr)
	Computes LCM for each corresponding pair of a and b.
template<typename T, bool REFCNT, typename T_factory, typename T1, bool REFCNT1>
vector< T, REFCNT >	lcm (const vector< T, REFCNT > &a, const vector< T1, REFCNT1 > &b, const T_factory &tfctr)
	Computes LCM for each corresponding pair of a and b.
template<typename T, bool REFCNT, typename T_factory>
vector< T, REFCNT >	lcm (const vector< T, REFCNT > &a, const vector< T, REFCNT > &b, const T_factory &tfctr)
	Computes LCM for each corresponding pair of a and b.
template<typename T, bool REFCNT, typename T1, bool REFCNT1>
vector< T, REFCNT >	lcm (const vector< T, REFCNT > &a, const vector< T1, REFCNT1 > &b)
	Computes LCM for each corresponding pair of a and b.
template<typename T, bool REFCNT>
vector< T, REFCNT >	lcm (const vector< T, REFCNT > &a, const vector< T, REFCNT > &b)
A test for relative primality.
template<typename T, typename T_factory>
bool	is_coprime (const T &a, const T &b, const T_factory &tfctr)
	Returns true if two objects are coprime.
template<typename T>
bool	is_coprime (const T &a, const T &b)
	Returns true if two objects are coprime.
template<typename T, bool REFCNT, typename T_factory>
bool	is_coprime (const vector< T, REFCNT > &x, const T_factory &tfctr)
	Returns true if all objects in the vector are coprime.
template<typename T, bool REFCNT>
bool	is_coprime (const vector< T, REFCNT > &x)
	Returns true if all objects in the vector are coprime.
Jacobi symbol.
template<typename T, typename T_factory>
int	jacobi (T a, T n, const T_factory &tfctr)
	Computes the Jacobi symbol (a/n).
template<typename T>
int	jacobi (const T &a, const T &n)
	Computes the Jacobi symbol (a/n).
Standard comparision operators.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	operator<= (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	operator<= (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	operator<= (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	operator>= (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	operator>= (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	operator>= (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	operator< (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	operator< (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	operator< (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	operator> (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	operator> (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	operator> (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	operator== (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	operator== (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	operator== (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	operator!= (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
bool	operator!= (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
bool	operator!= (const T1 &a, const matrix< T2, REFCNT2 > &b)
Binary operators with matrices and scalars.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator+ (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator+ (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator+ (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator+ (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator+ (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator+ (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator+ (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator+ (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator+ (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator- (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator- (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator- (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator- (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator- (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator- (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator- (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator- (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator- (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator * (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator * (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator * (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator * (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator * (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator * (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator * (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator * (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator * (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator/ (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator/ (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator/ (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator/ (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator/ (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator/ (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator/ (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator/ (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator/ (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator% (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator% (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator% (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator% (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator% (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator% (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator% (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator% (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator% (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator & (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator & (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator & (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator & (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator & (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator & (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator & (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator & (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator & (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator| (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator| (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator| (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator| (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator| (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator| (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator| (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator| (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator| (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator^ (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator^ (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator^ (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator^ (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator^ (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator^ (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator^ (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator^ (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator^ (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator<< (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator<< (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator<< (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator<< (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator<< (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator<< (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator<< (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator<< (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator<< (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix< T1, REFCNT1 >	operator>> (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2>
matrix< T1, REFCNT1 >	operator>> (const matrix< T1, REFCNT1 > &a, const T2 &b)
template<typename T1, typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator>> (const T1 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< T1, REFCNT1 >	operator>> (const matrix< T1, REFCNT1 > &a, const T1 &b)
template<typename T2, bool REFCNT2>
matrix< T2, REFCNT2 >	operator>> (const T2 &a, const matrix< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1>
matrix< rational< T1 >, REFCNT1 >	operator>> (const matrix< rational< T1 >, REFCNT1 > &a, const rational< T1 > &b)
template<typename T2, bool REFCNT2>
matrix< rational< T2 >, REFCNT2 >	operator>> (const rational< T2 > &a, const matrix< rational< T2 >, REFCNT2 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator>> (const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &a, const sparse_polynom< T1, D1, REFCNT1 > &b)
template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 >	operator>> (const sparse_polynom< T1, D1, REFCNT1 > &a, const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &b)
Factorization.
template<typename T1, typename T2, bool REFCNT2, typename T_factory>
vector< T2, REFCNT2 > &	factorize_division (T1 x, vector< T2, REFCNT2 > &res, const T_factory &tfctr)
	Factorizes x into a set of prime factors via consecutive division.
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	factorize_division (const T1 &x, vector< T2, REFCNT2 > &res)
	Factorizes x into a set of prime factors via consecutive division.
template<typename T, typename T_factory>
vector< T, true >	factorize_division (const T &x, const T_factory &tfctr)
	Factorizes x into a set of prime factors via consecutive division.
template<typename T>
vector< T, true >	factorize_division (const T &x)
	Factorizes x into a set of prime factors via consecutive division.
template<typename T1, typename T2, bool REFCNT2, typename T_factory>
vector< T2, REFCNT2 > &	factorize (const T1 &x, vector< T2, REFCNT2 > &res, const T_factory &tfctr)
	Factorizes x into a set of prime factors via appropriate algorithm for T.
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	factorize (const T1 &x, vector< T2, REFCNT2 > &res)
	Factorizes x into a set of prime factors via appropriate algorithm for T.
template<typename T, typename T_factory>
vector< T, true >	factorize (const T &x, const T_factory &tfctr)
	Factorizes x into a set of prime factors via appropriate algorithm for T.
template<typename T>
vector< T, true >	factorize (const T &x)
	Factorizes x into a set of prime factors via appropriate algorithm for T.
Partial factorization.
template<typename T1, typename T2, bool REFCNT2, typename T3, typename T4>
vector< T2, REFCNT2 > &	partial_factorize_division (T1 x, vector< T2, REFCNT2 > &res, const T3 &max, T4 &rest)
	Partialy factorizes x into a set of prime factors via test division.
template<typename T, typename N, typename T_factory>
T	pollard_pm1 (const T &n, const N &no_of_iter, const T_factory &tfctr)
	Pollard p-1 method (Simple variant).
template<typename T, typename N>
T	pollard_pm1 (const T &n, const N &no_of_iter=10000)
	Pollard p-1 method (Simple variant).
template<typename T, typename T_factory>
T	rho_pollard (const T &n, const T_factory &tfctr)
	Pollard's rho algorithm.
template<typename T>
T	rho_pollard (const T &n)
	Pollard's rho algorithm.
template<typename T, typename N, typename T_factory>
T	brent (const T &n, N no_of_iter, const T_factory &tfctr)
	Pollard's rho algorithm.
template<typename T, typename N>
T	brent (const T &n, N no_of_iter)
	Pollard's rho algorithm.
template<typename T, typename T3, typename T4>
vector< T, true >	partial_factorize_division (const T &x, const T3 &max, T4 &rest)
	Partialy factorizes x into a set of prime factors via test division.
template<typename T1, typename TT1, typename T2, bool REFCNT2, typename T3>
vector< T2, REFCNT2 > &	partial_factorize_division (const T1 &x, vector< T2, REFCNT2 > &res, const T3 &max)
	Partialy factorizes x into a set of prime factors via test division.
template<typename T, typename T3>
vector< T, true >	partial_factorize_division (const T &x, const T3 &max)
	Partialy factorizes x into a set of prime factors via test division.
template<typename T1, typename T2, bool REFCNT2, typename T3, typename T4>
vector< T2, REFCNT2 > &	partial_factorize (const T1 &x, vector< T2, REFCNT2 > &res, const T3 &max, T4 &rest)
	Partialy factorizes x into a set of prime factors via appropriate algorithm for T.
template<typename T, typename T3, typename T4>
vector< T, true >	partial_factorize (const T &x, const T3 &max, T4 &rest)
	Partialy factorizes x into a set of prime factors via appropriate algorithm for T.
template<typename T1, typename TT1, typename T2, bool REFCNT2, typename T3>
vector< T2, REFCNT2 > &	partial_factorize (const T1 &x, vector< T2, REFCNT2 > &res, const T3 &max)
	Partialy factorizes x into a set of prime factors via appropriate algorithm for T.
template<typename T, typename T3>
vector< T, true >	partial_factorize (const T &x, const T3 &max)
	Partialy factorizes x into a set of prime factors via appropriate algorithm for T.
template<typename T1, typename T2, typename T3, typename T4>
const T4 &	factorize_multiplier (T1 x, const T2 &m, T3 &rest, T4 &nm)
	Finds rest and nm such that x = rest * m^nm and rest is not divisible by m; returns reference to nm.
template<typename T1, typename T2, typename T3>
T1	factorize_multiplier (const T1 &x, const T2 &m, T3 &rest)
	Finds rest and nm such that x = rest * m^nm and rest is not divisible by m; returns nm.
template<typename T1, typename T2>
T1	factorize_multiplier (const T1 &x, const T2 &m)
	Finds rest and nm such that x = rest * m^nm and rest is not divisible by m; returns nm.
Prime number generators.
template<typename T>
T	next_prime_successive_checking (T x)
	Finds the next after x prime number via successive test for each number.
template<typename T>
T	prev_prime_successive_checking (T x)
	Finds the previous before x prime number via successive test for each number.
template<typename T>
T	next_prime (const T &x)
	Finds the next after x prime number via appropriate algorithm.
template<typename T>
T	prev_prime (const T &x)
	Finds the previous before x prime number via appropriate algorithm.
template<typename T>
T	next_probably_prime (T x)
	Finds the next after x probably prime number via appropriate algorithm.
template<typename T>
T	prev_probably_prime (T x)
	Finds the previous before x probably prime number via appropriate algorithm.
template<typename T, typename N>
void	rsa_generate_keys (N l, T &c, T &public_key, T &d)
	algorithms.
template<typename T>
T	rsa_encyph (const T &x, const T &c, const T &key)
template<typename T>
T	rsa_decyph (const T &y, const T &d, const T &key)
template<typename T>
bool	is_mersen_prime_degree (const T &n)
	Determines if 2^n-1 is Mersenn prime number.
template<typename T>
T	next_mersen_prime_degree (const T &n)
	Gives such k > n that 2^k-1 is Mersenn prime number, and for all k > m > n, 2^m-1 is not.
Standard arithmetic operations.
template<typename T1, typename T2>
rational< T1 >	operator+ (const rational< T1 > &b, const rational< T2 > &c)
template<typename T1, typename T2>
rational< T1 >	operator- (const rational< T1 > &b, const rational< T2 > &c)
template<typename T1, typename T2>
rational< T1 >	operator * (const rational< T1 > &b, const rational< T2 > &c)
template<typename T1, typename T2>
rational< T1 >	operator/ (const rational< T1 > &b, const rational< T2 > &c)
template<typename T1, typename T2>
rational< T1 >	operator% (const rational< T1 > &b, const rational< T2 > &c)
Standard arithmetic operations.
template<typename T1, typename T2>
rational< T1 > &	operator+= (rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
rational< T1 > &	operator+= (rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator+ (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator+ (const T2 &a, const rational< T1 > &b)
template<typename T1, typename T2>
rational< T1 > &	operator-= (rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
rational< T1 > &	operator-= (rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator- (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator- (const T2 &a, const rational< T1 > &b)
template<typename T1, typename T2>
rational< T1 > &	operator *= (rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
rational< T1 > &	operator *= (rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator * (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator * (const T2 &a, const rational< T1 > &b)
template<typename T1, typename T2>
rational< T1 > &	operator/= (rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
rational< T1 > &	operator/= (rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator/ (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator/ (const T2 &a, const rational< T1 > &b)
template<typename T1, typename T2>
rational< T1 > &	operator%= (rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
rational< T1 > &	operator%= (rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator% (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
rational< T1 >	operator% (const T2 &a, const rational< T1 > &b)
Standard comparision operators.
template<typename T1, typename T2>
bool	operator< (const rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator< (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
bool	operator< (const T1 &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator> (const rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator> (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
bool	operator> (const T1 &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator== (const rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator== (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
bool	operator== (const T1 &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator!= (const rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator!= (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
bool	operator!= (const T1 &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator<= (const rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator<= (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
bool	operator<= (const T1 &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator>= (const rational< T1 > &a, const rational< T2 > &b)
template<typename T1, typename T2>
bool	operator>= (const rational< T1 > &a, const T2 &b)
template<typename T1, typename T2>
bool	operator>= (const T1 &a, const rational< T2 > &b)
Standard comparision operators that based on cmp function.
template<typename F1, typename I1, typename F2, typename I2>
bool	operator== (const monom< F1, I1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2>
bool	operator== (const monom< F1, I1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2>
bool	operator== (const F1 &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2>
bool	operator!= (const monom< F1, I1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2>
bool	operator!= (const monom< F1, I1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2>
bool	operator!= (const F1 &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2>
bool	operator<= (const monom< F1, I1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2>
bool	operator<= (const monom< F1, I1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2>
bool	operator<= (const F1 &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2>
bool	operator>= (const monom< F1, I1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2>
bool	operator>= (const monom< F1, I1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2>
bool	operator>= (const F1 &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2>
bool	operator< (const monom< F1, I1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2>
bool	operator< (const monom< F1, I1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2>
bool	operator< (const F1 &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2>
bool	operator> (const monom< F1, I1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2>
bool	operator> (const monom< F1, I1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2>
bool	operator> (const F1 &a, const monom< F2, I2 > &b)
Äîïîëíèòåëüíûå îïåðàòîðû äëÿ ìîíîìîâ; ñî÷åòàíèå ñî ñêàëÿðîì.
template<typename F1, typename I1, typename F2, typename I2>
monom< F1, I1 >	operator+ (const monom< F1, I1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2>
monom< F1, I1 >	operator+ (const monom< F1, I1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2>
monom< F2, I2 >	operator+ (const F1 &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2, typename I2>
monom< F1, I1 >	operator- (const monom< F1, I1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2>
monom< F1, I1 >	operator- (const monom< F1, I1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2>
monom< F2, I2 >	operator- (const F1 &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2, typename I2>
monom< F1, I1 >	operator * (const monom< F1, I1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2>
monom< F1, I1 >	operator * (const monom< F1, I1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2>
monom< F2, I2 >	operator * (const F1 &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2, typename I2>
monom< F1, I1 >	operator/ (const monom< F1, I1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2>
monom< F1, I1 >	operator/ (const monom< F1, I1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2>
monom< F2, I2 >	operator/ (const F1 &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2, typename I2>
monom< F1, I1 >	operator% (const monom< F1, I1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2>
monom< F1, I1 >	operator% (const monom< F1, I1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2>
monom< F2, I2 >	operator% (const F1 &x, const monom< F2, I2 > &y)
Äîïîëíèòåëüíûå îïåðàòîðû äëÿ ìîíîìîâ; ñî÷åòàíèå ñî ñêàëÿðîì.
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F1, I1, REFCNT1 >	operator+ (const sparse_polynom< F1, I1, REFCNT1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom< F1, I1, REFCNT1 >	operator+ (const sparse_polynom< F1, I1, REFCNT1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator+ (const monom< F1, I1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom< F1, I1, REFCNT1 >	operator+ (const sparse_polynom< F1, I1, REFCNT1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator+ (const F1 &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator+ (const sparse_polynom< rational< F1 >, I1, REFCNT1 > &x, const rational< F1 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator+ (const rational< F1 > &x, const sparse_polynom< rational< F1 >, I1, REFCNT1 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F1, I1, REFCNT1 >	operator- (const sparse_polynom< F1, I1, REFCNT1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom< F1, I1, REFCNT1 >	operator- (const sparse_polynom< F1, I1, REFCNT1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator- (const monom< F1, I1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom< F1, I1, REFCNT1 >	operator- (const sparse_polynom< F1, I1, REFCNT1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator- (const F1 &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator- (const sparse_polynom< rational< F1 >, I1, REFCNT1 > &x, const rational< F1 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator- (const rational< F1 > &x, const sparse_polynom< rational< F1 >, I1, REFCNT1 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F1, I1, REFCNT1 >	operator * (const sparse_polynom< F1, I1, REFCNT1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom< F1, I1, REFCNT1 >	operator * (const sparse_polynom< F1, I1, REFCNT1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator * (const monom< F1, I1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom< F1, I1, REFCNT1 >	operator * (const sparse_polynom< F1, I1, REFCNT1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator * (const F1 &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator * (const sparse_polynom< rational< F1 >, I1, REFCNT1 > &x, const rational< F1 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator * (const rational< F1 > &x, const sparse_polynom< rational< F1 >, I1, REFCNT1 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F1, I1, REFCNT1 >	operator/ (const sparse_polynom< F1, I1, REFCNT1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom< F1, I1, REFCNT1 >	operator/ (const sparse_polynom< F1, I1, REFCNT1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator/ (const monom< F1, I1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom< F1, I1, REFCNT1 >	operator/ (const sparse_polynom< F1, I1, REFCNT1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator/ (const F1 &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator/ (const sparse_polynom< rational< F1 >, I1, REFCNT1 > &x, const rational< F1 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator/ (const rational< F1 > &x, const sparse_polynom< rational< F1 >, I1, REFCNT1 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F1, I1, REFCNT1 >	operator% (const sparse_polynom< F1, I1, REFCNT1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom< F1, I1, REFCNT1 >	operator% (const sparse_polynom< F1, I1, REFCNT1 > &x, const monom< F2, I2 > &y)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator% (const monom< F1, I1 > &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom< F1, I1, REFCNT1 >	operator% (const sparse_polynom< F1, I1, REFCNT1 > &x, const F2 &y)
template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom< F2, I2, REFCNT2 >	operator% (const F1 &x, const sparse_polynom< F2, I2, REFCNT2 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator% (const sparse_polynom< rational< F1 >, I1, REFCNT1 > &x, const rational< F1 > &y)
template<typename F1, typename I1, bool REFCNT1>
sparse_polynom< rational< F1 >, I1, REFCNT1 >	operator% (const rational< F1 > &x, const sparse_polynom< rational< F1 >, I1, REFCNT1 > &y)
Standard comparision operators that based on cmp function.
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool	operator== (const sparse_polynom< F1, I1, REFCNT1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool	operator== (const sparse_polynom< F1, I1, REFCNT1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool	operator== (const monom< F1, I1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2>
bool	operator== (const sparse_polynom< F1, I1, REFCNT1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2, bool REFCNT2>
bool	operator== (const F1 &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool	operator!= (const sparse_polynom< F1, I1, REFCNT1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool	operator!= (const sparse_polynom< F1, I1, REFCNT1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool	operator!= (const monom< F1, I1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2>
bool	operator!= (const sparse_polynom< F1, I1, REFCNT1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2, bool REFCNT2>
bool	operator!= (const F1 &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool	operator<= (const sparse_polynom< F1, I1, REFCNT1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool	operator<= (const sparse_polynom< F1, I1, REFCNT1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool	operator<= (const monom< F1, I1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2>
bool	operator<= (const sparse_polynom< F1, I1, REFCNT1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2, bool REFCNT2>
bool	operator<= (const F1 &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool	operator>= (const sparse_polynom< F1, I1, REFCNT1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool	operator>= (const sparse_polynom< F1, I1, REFCNT1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool	operator>= (const monom< F1, I1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2>
bool	operator>= (const sparse_polynom< F1, I1, REFCNT1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2, bool REFCNT2>
bool	operator>= (const F1 &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool	operator< (const sparse_polynom< F1, I1, REFCNT1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool	operator< (const sparse_polynom< F1, I1, REFCNT1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool	operator< (const monom< F1, I1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2>
bool	operator< (const sparse_polynom< F1, I1, REFCNT1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2, bool REFCNT2>
bool	operator< (const F1 &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool	operator> (const sparse_polynom< F1, I1, REFCNT1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool	operator> (const sparse_polynom< F1, I1, REFCNT1 > &a, const monom< F2, I2 > &b)
template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool	operator> (const monom< F1, I1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
template<typename F1, typename I1, bool REFCNT1, typename F2>
bool	operator> (const sparse_polynom< F1, I1, REFCNT1 > &a, const F2 &b)
template<typename F1, typename F2, typename I2, bool REFCNT2>
bool	operator> (const F1 &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
LaTeX output for built-in types and big_int
template<typename Out>
void	output_latex (Out &out, const signed int &x, bool in_math=false, ex_environ_priority eep=eep_alone)
template<typename Out>
void	output_latex (Out &out, const unsigned int &x, bool in_math=false, ex_environ_priority eep=eep_alone)
template<typename Out>
void	output_latex (Out &out, const signed short int &x, bool in_math=false, ex_environ_priority eep=eep_alone)
template<typename Out>
void	output_latex (Out &out, const unsigned short int &x, bool in_math=false, ex_environ_priority eep=eep_alone)
template<typename Out>
void	output_latex (Out &out, const signed long int &x, bool in_math=false, ex_environ_priority eep=eep_alone)
template<typename Out>
void	output_latex (Out &out, const unsigned long int &x, bool in_math=false, ex_environ_priority eep=eep_alone)
template<typename Out>
void	output_latex (Out &out, const float &x, bool in_math=false, ex_environ_priority eep=eep_alone)
template<typename Out>
void	output_latex (Out &out, const double &x, bool in_math=false, ex_environ_priority eep=eep_alone)
template<typename Out>
void	output_latex (Out &out, const long double &x, bool in_math=false, ex_environ_priority eep=eep_alone)
template<typename Out>
void	output_latex (Out &out, const big_int &x, bool in_math=false, ex_environ_priority eep=eep_alone)
Matrix frames maker functions.
template<typename In_hor, typename In_ver, typename In_box>
matrix_frames< In_hor, In_ver, In_box >	make_matrix_frames (In_hor hf, In_hor hl, In_ver vf, In_ver vl, In_box bf, In_box bl)
template<typename In_hor, typename In_ver>
matrix_frames< In_hor, In_ver >	make_matrix_frames (In_hor hf, In_hor hl, In_ver vf, In_ver vl)
template<typename In_hor>
matrix_frames< In_hor >	make_matrix_frames (In_hor hf, In_hor hl)
matrix_frames	make_matrix_frames ()
template<typename In_ver>
matrix_frames< const matrix_line *, In_ver >	make_matrix_vers (In_ver vf, In_ver vl)
template<typename In_box>
matrix_frames< const matrix_line *, const matrix_line *, In_box >	make_matrix_boxes (In_box bf, In_box bl)
template<typename In_ver, typename In_box>
matrix_frames< const matrix_line *, In_ver, In_box >	make_matrix_vers_boxes (In_ver vf, In_ver vl, In_box bf, In_box bl)
Boolean as type.
std::ostream &	operator<< (std::ostream &out, const true_type &)
std::ostream &	operator<< (std::ostream &out, const false_type &)
Standard mathematical functions on vector.
template<typename T, bool REFCNT>
vector< T, true >	sin (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	cos (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	tan (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	sinh (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	cosh (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	tanh (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	asin (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	acos (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	atan (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	abs (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	exp (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	floor (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	ceil (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	log (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	log10 (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	sqrt (const vector< T, REFCNT > &x)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
vector< T1, REFCNT1 >	pow (const vector< T1, REFCNT1 > &a, const vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename P>
vector< T1, REFCNT1 >	pow (const vector< T1, REFCNT1 > &a, const P &b)
Rounding Modes for big_float
const int	EXACT = 1
	Rounds to the closest value.
const int	ROUND = 2
	Uses rules of `'manual'' computations.
const int	TO_NEAREST = 3
	Rounds towards the nearest number.
const int	TO_ZERO = 4
	Rounds towards zero.
const int	TO_P_INF = 5
	Rounds towards +infinity.
const int	TO_M_INF = 6
	Rounds towards -infinity.
const int	TO_INF = 7
	Rounds outwards zero.
Special big_float numbers
const int	NAN = 1
const int	PINF = 2
const int	M_INF = 3
const int	P_ZERO = 4
const int	M_ZERO = 5
Helper types and constants to choose a particular cone class constructor.
const fromnull_t	fromnull = fromnull_t()
	Helper constant to create cone as one point (null).
const fromspace_t	fromspace = fromspace_t()
	Helper constant to create cone from dimention.
const fromineq_t	fromineq = fromineq_t()
	Helper constant to create cone from the set of inequalities.
const fromeq_t	fromeq = fromeq_t()
	Helper constant to create cone from the set of equalities.
const fromgen_t	fromgen = fromgen_t()
	Helper constant to create cone from the set of generatrices.
const frombasis_t	frombasis = frombasis_t()
	Helper constant to create cone from the set of basis vectors.
const fromdual_t	fromdual = fromdual_t()
Typedefs
typedef unsigned long long	counter_t
Enumerations
enum	interval_kind { interval_empty = 0, interval_point = 1, interval_length = 2 }
	Kind of interval. More...
enum	solve_linsys_result { SLR_EMPTY, SLR_UNIQUE, SLR_MULTIPLE }
enum	ex_environ_priority { eep_alone, eep_add, eep_mul }
	Type of environment (context) for an expression. More...
enum	matrix_line_type { mlt_solid, mlt_dot, mlt_hatch, mlt_chain }
	Type of a line that used in matrix output functions with boxes and dividing lines. More...
Functions
template<typename D1, typename T1>
bool	is_null (const _Internal::module_2pm1< D1, T1 > &a)
template<typename D1, typename T1>
bool	is_unit (const _Internal::module_2pm1< D1, T1 > &a)
template<typename T1, typename D2, typename T2>
T1	prrem (const T1 &aa, const _Internal::module_2pm1< D2, T2 > &b)
template<typename Out, typename D, typename T>
Out &	operator<< (Out &out, const _Internal::module_2pm1< D, T > &x)
template<typename In, typename D, typename T>
In &	operator>> (In &in, _Internal::module_2pm1< D, T > &x)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	operator+ (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	operator- (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	operator * (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	operator/ (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	operator% (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator== (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	operator== (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator== (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator!= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	operator!= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator!= (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator< (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	operator< (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator< (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator<= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	operator<= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator<= (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator> (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	operator> (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator> (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator>= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	operator>= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	operator>= (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
int	cmp (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2>
int	cmp (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TP2 &b)
template<typename TP1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
int	cmp (const TP1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename Out, typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1>
Out &	operator<< (Out &out, const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &x)
template<typename PolyVec, typename SegVec, typename Rslt, typename P, typename Seg, typename F>
void	algebraic_func_rslt (const PolyVec &polyvec, SegVec segvec, Rslt rslt, P &p, Seg &seg, F f)
	Arbitrary function on algebraic numbers based on precomputed resultant.
template<typename P1, typename Seg1, typename P2, typename Seg2, typename P3, typename Seg3>
void	algebraic_plus (const P1 &p1, const Seg1 &seg1, const P2 &p2, const Seg2 &seg2, P3 &p3, Seg3 &seg3)
template<typename P1, typename Seg1, typename P2, typename Seg2, typename P3, typename Seg3>
void	algebraic_minus (const P1 &p1, const Seg1 &seg1, const P2 &p2, const Seg2 &seg2, P3 &p3, Seg3 &seg3)
template<typename P1, typename Seg1, typename P2, typename Seg2, typename P3, typename Seg3>
void	algebraic_multiplies (const P1 &p1, const Seg1 &seg1, const P2 &p2, const Seg2 &seg2, P3 &p3, Seg3 &seg3)
template<typename P1, typename Seg1, typename P2, typename Seg2, typename P3, typename Seg3>
void	algebraic_divides (const P1 &p1, const Seg1 &seg1, const P2 &p2, Seg2 seg2, P3 &p3, Seg3 &seg3)
template<typename MA, typename MB, typename MQ, typename Basis, typename T_det>
void	bareiss (const MA &A, MB &B, MQ &Q, Basis &basis, T_det &det)
	Produces the Gauss-Jordan form B of an integer matrix A.
template<typename MA, typename MP, typename MQ, typename Rank, typename T_det>
void	bareiss_pq (const MA &A, MP &P, MQ &Q, Rank &rank, T_det &det)
	Produces the Gauss form B of an integer matrix A.
template<typename MA>
MA	adjoint (const MA &A)
template<typename MA, typename MP, typename T_det>
void	adjoint (const MA &A, MP &P, T_det &det)
template<typename MA>
MA::element_type	det_brs (const MA &A)
template<typename MA>
MA::size_type	rank_brs (const MA &A)
template<typename T, typename Res>
Res &	indirection (const T &x, Res &res)
template<typename T, typename Res>
Res &	address (const T &x, Res &res)
template<typename T, typename Res>
Res &	unary_plus (const T &x, Res &res)
template<typename T, typename Res>
Res &	unary_minus (const T &x, Res &res)
template<typename T, typename Res>
Res &	logical_not (const T &x, Res &res)
template<typename T, typename Res>
Res &	bitwise_not (const T &x, Res &res)
template<typename T, typename Res>
Res &	prefix_increment (T &x, Res &res)
template<typename T, typename Res>
Res &	prefix_decrement (T &x, Res &res)
template<typename T, typename Res>
Res &	postfix_increment (T &x, Res &res)
template<typename T, typename Res>
Res &	postfix_decrement (T &x, Res &res)
template<typename T1, typename T2, typename Res>
Res &	plus (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	minus (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	multiplies (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	divides (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	modulus (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	logical_or (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	logical_and (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	equal_to (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	not_equal_to (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	greater (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	less (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	greater_equal (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	less_equal (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	bitwise_or (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	bitwise_and (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	bitwise_xor (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	shift_left (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2, typename Res>
Res &	shift_right (const T1 &x, const T2 &y, Res &res)
template<typename T1, typename T2>
T1 &	right_assign_plus (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_plus (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_minus (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_minus (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_multiplies (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_multiplies (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_divides (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_divides (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_modulus (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_modulus (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_bitwise_or (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_bitwise_or (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_bitwise_and (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_bitwise_and (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_bitwise_xor (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_bitwise_xor (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_shift_left (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_shift_left (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_shift_right (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_shift_right (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_logical_or (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_logical_or (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_logical_and (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_logical_and (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_equal_to (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_equal_to (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_not_equal_to (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_not_equal_to (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_greater (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_greater (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_less (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_less (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_greater_equal (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_greater_equal (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	right_assign_less_equal (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	assign_less_equal (T1 &x, const T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_plus (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_minus (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_multiplies (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_divides (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_modulus (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_logical_or (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_logical_and (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_equal_to (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_not_equal_to (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_greater (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_less (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_greater_equal (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_less_equal (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_bitwise_or (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_bitwise_and (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_bitwise_xor (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_shift_left (const T1 &x, T2 &y)
template<typename T1, typename T2>
T1 &	left_assign_shift_right (const T1 &x, T2 &y)
template<typename T>
T &	assign_indirection (T &x)
template<typename T>
T &	assign_address (T &x)
template<typename T>
T &	assign_unary_plus (T &x)
template<typename T>
T &	assign_unary_minus (T &x)
template<typename T>
T &	assign_logical_not (T &x)
template<typename T>
T &	assign_bitwise_not (T &x)
big_int	ln1_25 (std::size_t nbits)
	Returns ln(1.25) with nbits significant bits.
big_int	ln1_25_o (std::size_t nbits)
	Returns ln(1.25) with nbits significant bits with overflow.
big_int	ln1_25_u (std::size_t nbits)
	Returns ln(1.25) with nbits significant bits with imperfection.
big_int	ln2 (std::size_t nbits)
	Returns ln(2) with nbits significant bits.
big_int	ln2_u (std::size_t nbits)
	Returns ln(2) with nbits significant bits with imperfection.
big_int	ln2_o (std::size_t nbits)
	Returns ln(2) with nbits significant bits with oveflow.
big_int	log2_10 (std::size_t nbits)
	Returns log2_10 with nbits significant bits.
big_int	log2_10_o (std::size_t nbits)
	Returns log2_10 with nbits significant bits with oveflow.
big_int	log2_10_u (std::size_t nbits)
	Returns log2_10 with nbits significant bits with imperfection.
big_int	lg_2_o (std::size_t nbits)
	Returns lg2 with nbits significant bits with oveflow.
big_int	lg_2_u (std::size_t nbits)
	Returns lg2 with nbits significant bits with imperfection.
big_int	lg_2 (std::size_t nbits)
	Returns lg2 with nbits significant bits.
big_int	exp_u (big_int arg, std::size_t nbits, int factor=0)
	Returns exp(arg/2^factor) with nbits significant bits with imperfection.
big_int	exp_o (big_int arg, std::size_t nbits, int factor=0)
	Returns exp(arg/2^factor) with nbits significant bits with oveflow.
big_int	exp (big_int arg, std::size_t nbits, int factor=0)
	Returns exp(arg/2^factor) with nbits significant bits.
big_int	exp_2_u (big_int arg, std::size_t nbits, int factor=0)
	Returns 2^(arg/2^factor) with nbits significant bits with imperfection.
big_int	exp_2_o (big_int arg, std::size_t nbits, int factor=0)
	Returns 2^(arg/2^factor) with nbits significant bits with oveflow.
big_int	exp_2 (big_int arg, std::size_t nbits, int factor=0)
	Returns 2^(arg/2^factor) with nbits significant bits.
big_int	e_u (std::size_t nbits)
	Returns e number with nbits significant bits with imperfection.
big_int	e_o (std::size_t nbits)
	Returns e number with nbits significant bits with oveflow.
big_int	e (std::size_t nbits)
	Returns e number with nbits significant bits.
big_int	ln10 (std::size_t nbits)
	Returns ln10 with nbits significant bits.
big_int	ln10_u (std::size_t nbits)
	Returns ln10 with nbits significant bits with imperfection.
big_int	ln10_o (std::size_t nbits)
	Returns ln10 with nbits significant bits with oveflow.
void	big_float_warning (const char *s)
void	big_float_error (const char *s)
void	big_float_fatal_error (const char *s)
unsigned	fracsion (int n, unsigned m)
int	get_exponent_of_double (double d)
_Internal::digit *	get_mantissa_of_double (double d)
int	get_sign (big_int s)
int	cmp (const big_float &a, const big_float &b)
int	operator== (const big_float &a, const big_float &b)
int	operator!= (const big_float &a, const big_float &b)
int	operator> (const big_float &a, const big_float &b)
int	operator>= (const big_float &a, const big_float &b)
int	operator< (const big_float &a, const big_float &b)
int	operator<= (const big_float &a, const big_float &b)
big_float	operator+ (const big_float &a)
big_float	operator- (const big_float &a)
big_float	operator+ (const big_float &b, const big_float &c)
big_float	operator- (const big_float &b, const big_float &c)
big_float	operator * (const big_float &b, const big_float &c)
big_float	operator/ (const big_float &b, const big_float &c)
big_float	add (const big_float &b, const big_float &c)
big_float	sub (const big_float &b, const big_float &c)
big_float	mul (const big_float &b, const big_float &c)
big_float	div (const big_float &b, const big_float &c)
big_float	add (const big_float &b, const big_float &c, long prec)
big_float	sub (const big_float &b, const big_float &c, long prec)
big_float	mul (const big_float &b, const big_float &c, long prec)
big_float	div (const big_float &b, const big_float &c, long prec)
big_float	add (const big_float &b, const big_float &c, long prec, int mode)
big_float	sub (const big_float &b, const big_float &c, long prec, int mode)
big_float	mul (const big_float &b, const big_float &c, long prec, int mode)
big_float	div (const big_float &b, const big_float &c, long prec, int mode)
big_float	divnu (const big_float &b, const big_float &c, long prec, int mode)
big_float	div_i (const big_int &c)
void	reduce_final_zeros (std::basic_string< char > &str)
std::istream &	operator>> (std::istream &is, big_float &fnum)
std::ostream &	operator<< (std::ostream &os, const big_float &fnum)
big_float	ceil (const big_float &a)
big_float	floor (const big_float &a)
big_float	frac (const big_float &a)
big_int	iceil (const big_float &a)
big_int	ifloor (const big_float &a)
big_float	fsqrt (const big_float &b)
big_float	fsqrt (const big_float &bf, long prec)
big_float	fsqrt (const big_float &bf, long prec, int mode)
big_float	nfsqrt (const big_float &bf, long prec, int mode)
big_float	frandom (long prec)
big_float	frandom ()
big_float	frandom1 (long bits, const big_int &exp)
big_float	abs (const big_float &x)
template<typename Outiter>
void	generate_range_helper (big_float &t1, const big_float &t2, Outiter outiter)
big_float &	operator+= (big_float &b, const big_float &c)
big_float &	operator-= (big_float &b, const big_float &c)
big_float &	operator *= (big_float &b, const big_float &c)
big_float &	operator/= (big_float &b, const big_float &c)
void	big_arith_error (const char *s)
void	calc_bdn_radix (digit radix, digit &bdn_radix, std::size_t &chars_per_digit)
int	cmp (const big_int &a, const big_int &b)
	Compares two big integers.
digit	random_digit ()
digit	stream_radix (std::ios &s)
std::ostream &	operator<< (std::ostream &s, const big_int &x)
	Reads a number from a string notation.
void	set_stream_radix (std::ios &s, digit radix)
std::istream &	operator>> (std::istream &s, big_int &x)
	Writes a number to a string notation.
std::size_t	nbits (const big_int &x)
	Returns the number of bits in number. The same as big_int::length.
template<typename TT>
int	sign (const big_int &x)
void	divide (const big_int &a, const big_int &b, big_int &q, big_int &r)
	Divizion with quotient and remainder.
big_int &	operator+= (big_int &b, char c)
char &	operator+= (char &b, const big_int &c)
big_int &	operator+= (big_int &b, signed char c)
signed char &	operator+= (signed char &b, const big_int &c)
big_int &	operator+= (big_int &b, unsigned char c)
unsigned char &	operator+= (unsigned char &b, const big_int &c)
big_int &	operator+= (big_int &b, signed short c)
signed short &	operator+= (signed short &b, const big_int &c)
big_int &	operator+= (big_int &b, unsigned short c)
unsigned short &	operator+= (unsigned short &b, const big_int &c)
big_int &	operator+= (big_int &b, signed int c)
signed int &	operator+= (signed int &b, const big_int &c)
big_int &	operator+= (big_int &b, unsigned int c)
unsigned int &	operator+= (unsigned int &b, const big_int &c)
big_int &	operator+= (big_int &b, signed long c)
signed long &	operator+= (signed long &b, const big_int &c)
big_int &	operator+= (big_int &b, unsigned long c)
unsigned long &	operator+= (unsigned long &b, const big_int &c)
big_int &	operator+= (big_int &b, bool c)
bool &	operator+= (bool &b, const big_int &c)
big_int &	operator-= (big_int &b, char c)
char &	operator-= (char &b, const big_int &c)
big_int &	operator-= (big_int &b, signed char c)
signed char &	operator-= (signed char &b, const big_int &c)
big_int &	operator-= (big_int &b, unsigned char c)
unsigned char &	operator-= (unsigned char &b, const big_int &c)
big_int &	operator-= (big_int &b, signed short c)
signed short &	operator-= (signed short &b, const big_int &c)
big_int &	operator-= (big_int &b, unsigned short c)
unsigned short &	operator-= (unsigned short &b, const big_int &c)
big_int &	operator-= (big_int &b, signed int c)
signed int &	operator-= (signed int &b, const big_int &c)
big_int &	operator-= (big_int &b, unsigned int c)
unsigned int &	operator-= (unsigned int &b, const big_int &c)
big_int &	operator-= (big_int &b, signed long c)
signed long &	operator-= (signed long &b, const big_int &c)
big_int &	operator-= (big_int &b, unsigned long c)
unsigned long &	operator-= (unsigned long &b, const big_int &c)
big_int &	operator-= (big_int &b, bool c)
bool &	operator-= (bool &b, const big_int &c)
big_int &	operator *= (big_int &b, char c)
char &	operator *= (char &b, const big_int &c)
big_int &	operator *= (big_int &b, signed char c)
signed char &	operator *= (signed char &b, const big_int &c)
big_int &	operator *= (big_int &b, unsigned char c)
unsigned char &	operator *= (unsigned char &b, const big_int &c)
big_int &	operator *= (big_int &b, signed short c)
signed short &	operator *= (signed short &b, const big_int &c)
big_int &	operator *= (big_int &b, unsigned short c)
unsigned short &	operator *= (unsigned short &b, const big_int &c)
big_int &	operator *= (big_int &b, signed int c)
signed int &	operator *= (signed int &b, const big_int &c)
big_int &	operator *= (big_int &b, unsigned int c)
unsigned int &	operator *= (unsigned int &b, const big_int &c)
big_int &	operator *= (big_int &b, signed long c)
signed long &	operator *= (signed long &b, const big_int &c)
big_int &	operator *= (big_int &b, unsigned long c)
unsigned long &	operator *= (unsigned long &b, const big_int &c)
big_int &	operator *= (big_int &b, bool c)
bool &	operator *= (bool &b, const big_int &c)
big_int &	operator/= (big_int &b, char c)
char &	operator/= (char &b, const big_int &c)
big_int &	operator/= (big_int &b, signed char c)
signed char &	operator/= (signed char &b, const big_int &c)
big_int &	operator/= (big_int &b, unsigned char c)
unsigned char &	operator/= (unsigned char &b, const big_int &c)
big_int &	operator/= (big_int &b, signed short c)
signed short &	operator/= (signed short &b, const big_int &c)
big_int &	operator/= (big_int &b, unsigned short c)
unsigned short &	operator/= (unsigned short &b, const big_int &c)
big_int &	operator/= (big_int &b, signed int c)
signed int &	operator/= (signed int &b, const big_int &c)
big_int &	operator/= (big_int &b, unsigned int c)
unsigned int &	operator/= (unsigned int &b, const big_int &c)
big_int &	operator/= (big_int &b, signed long c)
signed long &	operator/= (signed long &b, const big_int &c)
big_int &	operator/= (big_int &b, unsigned long c)
unsigned long &	operator/= (unsigned long &b, const big_int &c)
big_int &	operator/= (big_int &b, bool c)
bool &	operator/= (bool &b, const big_int &c)
big_int &	operator+= (big_int &b, float c)
float &	operator+= (float &b, const big_int &c)
big_int &	operator+= (big_int &b, double c)
double &	operator+= (double &b, const big_int &c)
big_int &	operator+= (big_int &b, long double c)
long double &	operator+= (long double &b, const big_int &c)
big_int &	operator-= (big_int &b, float c)
float &	operator-= (float &b, const big_int &c)
big_int &	operator-= (big_int &b, double c)
double &	operator-= (double &b, const big_int &c)
big_int &	operator-= (big_int &b, long double c)
long double &	operator-= (long double &b, const big_int &c)
big_int &	operator *= (big_int &b, float c)
float &	operator *= (float &b, const big_int &c)
big_int &	operator *= (big_int &b, double c)
double &	operator *= (double &b, const big_int &c)
big_int &	operator *= (big_int &b, long double c)
long double &	operator *= (long double &b, const big_int &c)
big_int &	operator/= (big_int &b, float c)
float &	operator/= (float &b, const big_int &c)
big_int &	operator/= (big_int &b, double c)
double &	operator/= (double &b, const big_int &c)
big_int &	operator/= (big_int &b, long double c)
long double &	operator/= (long double &b, const big_int &c)
big_int &	operator%= (big_int &b, char c)
char &	operator%= (char &b, const big_int &c)
big_int &	operator%= (big_int &b, signed char c)
signed char &	operator%= (signed char &b, const big_int &c)
big_int &	operator%= (big_int &b, unsigned char c)
unsigned char &	operator%= (unsigned char &b, const big_int &c)
big_int &	operator%= (big_int &b, signed short c)
signed short &	operator%= (signed short &b, const big_int &c)
big_int &	operator%= (big_int &b, unsigned short c)
unsigned short &	operator%= (unsigned short &b, const big_int &c)
big_int &	operator%= (big_int &b, signed int c)
signed int &	operator%= (signed int &b, const big_int &c)
big_int &	operator%= (big_int &b, unsigned int c)
unsigned int &	operator%= (unsigned int &b, const big_int &c)
big_int &	operator%= (big_int &b, signed long c)
signed long &	operator%= (signed long &b, const big_int &c)
big_int &	operator%= (big_int &b, unsigned long c)
unsigned long &	operator%= (unsigned long &b, const big_int &c)
big_int &	operator%= (big_int &b, bool c)
bool &	operator%= (bool &b, const big_int &c)
big_int	operator+ (char b, const big_int &c)
big_int	operator+ (const big_int &b, char c)
big_int	operator+ (signed char b, const big_int &c)
big_int	operator+ (const big_int &b, signed char c)
big_int	operator+ (unsigned char b, const big_int &c)
big_int	operator+ (const big_int &b, unsigned char c)
big_int	operator+ (signed short b, const big_int &c)
big_int	operator+ (const big_int &b, signed short c)
big_int	operator+ (unsigned short b, const big_int &c)
big_int	operator+ (const big_int &b, unsigned short c)
big_int	operator+ (signed int b, const big_int &c)
big_int	operator+ (const big_int &b, signed int c)
big_int	operator+ (unsigned int b, const big_int &c)
big_int	operator+ (const big_int &b, unsigned int c)
big_int	operator+ (signed long b, const big_int &c)
big_int	operator+ (const big_int &b, signed long c)
big_int	operator+ (unsigned long b, const big_int &c)
big_int	operator+ (const big_int &b, unsigned long c)
big_int	operator+ (bool b, const big_int &c)
big_int	operator+ (const big_int &b, bool c)
big_int	operator- (char b, const big_int &c)
big_int	operator- (const big_int &b, char c)
big_int	operator- (signed char b, const big_int &c)
big_int	operator- (const big_int &b, signed char c)
big_int	operator- (unsigned char b, const big_int &c)
big_int	operator- (const big_int &b, unsigned char c)
big_int	operator- (signed short b, const big_int &c)
big_int	operator- (const big_int &b, signed short c)
big_int	operator- (unsigned short b, const big_int &c)
big_int	operator- (const big_int &b, unsigned short c)
big_int	operator- (signed int b, const big_int &c)
big_int	operator- (const big_int &b, signed int c)
big_int	operator- (unsigned int b, const big_int &c)
big_int	operator- (const big_int &b, unsigned int c)
big_int	operator- (signed long b, const big_int &c)
big_int	operator- (const big_int &b, signed long c)
big_int	operator- (unsigned long b, const big_int &c)
big_int	operator- (const big_int &b, unsigned long c)
big_int	operator- (bool b, const big_int &c)
big_int	operator- (const big_int &b, bool c)
big_int	operator * (char b, const big_int &c)
big_int	operator * (const big_int &b, char c)
big_int	operator * (signed char b, const big_int &c)
big_int	operator * (const big_int &b, signed char c)
big_int	operator * (unsigned char b, const big_int &c)
big_int	operator * (const big_int &b, unsigned char c)
big_int	operator * (signed short b, const big_int &c)
big_int	operator * (const big_int &b, signed short c)
big_int	operator * (unsigned short b, const big_int &c)
big_int	operator * (const big_int &b, unsigned short c)
big_int	operator * (signed int b, const big_int &c)
big_int	operator * (const big_int &b, signed int c)
big_int	operator * (unsigned int b, const big_int &c)
big_int	operator * (const big_int &b, unsigned int c)
big_int	operator * (signed long b, const big_int &c)
big_int	operator * (const big_int &b, signed long c)
big_int	operator * (unsigned long b, const big_int &c)
big_int	operator * (const big_int &b, unsigned long c)
big_int	operator * (bool b, const big_int &c)
big_int	operator * (const big_int &b, bool c)
big_int	operator/ (char b, const big_int &c)
big_int	operator/ (const big_int &b, char c)
big_int	operator/ (signed char b, const big_int &c)
big_int	operator/ (const big_int &b, signed char c)
big_int	operator/ (unsigned char b, const big_int &c)
big_int	operator/ (const big_int &b, unsigned char c)
big_int	operator/ (signed short b, const big_int &c)
big_int	operator/ (const big_int &b, signed short c)
big_int	operator/ (unsigned short b, const big_int &c)
big_int	operator/ (const big_int &b, unsigned short c)
big_int	operator/ (signed int b, const big_int &c)
big_int	operator/ (const big_int &b, signed int c)
big_int	operator/ (unsigned int b, const big_int &c)
big_int	operator/ (const big_int &b, unsigned int c)
big_int	operator/ (signed long b, const big_int &c)
big_int	operator/ (const big_int &b, signed long c)
big_int	operator/ (unsigned long b, const big_int &c)
big_int	operator/ (const big_int &b, unsigned long c)
big_int	operator/ (bool b, const big_int &c)
big_int	operator/ (const big_int &b, bool c)
big_int	operator+ (float b, const big_int &c)
big_int	operator+ (const big_int &b, float c)
big_int	operator+ (double b, const big_int &c)
big_int	operator+ (const big_int &b, double c)
big_int	operator+ (long double b, const big_int &c)
big_int	operator+ (const big_int &b, long double c)
big_int	operator- (float b, const big_int &c)
big_int	operator- (const big_int &b, float c)
big_int	operator- (double b, const big_int &c)
big_int	operator- (const big_int &b, double c)
big_int	operator- (long double b, const big_int &c)
big_int	operator- (const big_int &b, long double c)
big_int	operator * (float b, const big_int &c)
big_int	operator * (const big_int &b, float c)
big_int	operator * (double b, const big_int &c)
big_int	operator * (const big_int &b, double c)
big_int	operator * (long double b, const big_int &c)
big_int	operator * (const big_int &b, long double c)
big_int	operator/ (float b, const big_int &c)
big_int	operator/ (const big_int &b, float c)
big_int	operator/ (double b, const big_int &c)
big_int	operator/ (const big_int &b, double c)
big_int	operator/ (long double b, const big_int &c)
big_int	operator/ (const big_int &b, long double c)
big_int	operator% (char b, const big_int &c)
big_int	operator% (const big_int &b, char c)
big_int	operator% (signed char b, const big_int &c)
big_int	operator% (const big_int &b, signed char c)
big_int	operator% (unsigned char b, const big_int &c)
big_int	operator% (const big_int &b, unsigned char c)
big_int	operator% (signed short b, const big_int &c)
big_int	operator% (const big_int &b, signed short c)