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_intoperator<<= (big_int &a, const T &b)
big_intoperator>>= (big_int &a, std::size_t b)
template<typename T>
big_intoperator>>= (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_intoperator+= (big_int &b, const big_int &c)
big_intoperator-= (big_int &b, const big_int &c)
big_intoperator *= (big_int &b, const big_int &c)
big_intoperator/= (big_int &b, const big_int &c)
big_intoperator%= (big_int &b, const big_int &c)

Helper functions for the factory class.

template<typename T>
const T & unit ()
 единичный элемент
template<typename 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>
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>
null (const T &)
 нулевой элемент
template<typename T>
bool is_null (const T &x)
 проверка на равенство нулевому элементу
template<typename 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>
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>
euclid (T a, T b, const T_factory &tfctr)
 Processes the Euclidean algorithm on a and b.
template<typename T>
euclid (const T &a, const T &b)
 Processes the Euclidean algorithm on a and b.
template<typename T, typename T_factory>
euclid_binary (T a, T b, const T_factory &tfctr)
 Processes the Euclidean algorithm on a and b.
template<typename 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>
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>
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>
gcd (const T &a, const T &b, const T_factory &tfctr, const type_category::type &)
template<typename T, typename T_factory>
gcd (const T &a, const T &b, const T_factory &tfctr, const type_category::integer &)
template<typename T, typename T_factory>
gcd (const T &a, const T &b, const T_factory &tfctr)
 Computes GCD for a and b.
template<typename 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>
gcd (const vector< T, REFCNT > &x, const T_factory &tfctr)
 Computes GCD for all items of vector 'x'.
template<typename T, bool REFCNT>
gcd (const vector< T, REFCNT > &x)
 Computes GCD for all items of vector 'x'.
template<typename T>
gcd3 (const T &a, const T &b, const T &c)
 Compute GCD(a, b, c).
template<typename 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>
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>
lcm (const T &a, const T &b, const T_factory &tfctr)
 Computes LCM for a and b.
template<typename T>
lcm (const T &a, const T &b)
 Computes LCM for a and b.
template<typename T, bool REFCNT, typename T_factory>
lcm (const vector< T, REFCNT > &x, const T_factory &tfctr)
 Computes LCM for all items of vector 'x'.
template<typename T, bool REFCNT>
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>
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>
pollard_pm1 (const T &n, const N &no_of_iter=10000)
 Pollard p-1 method (Simple variant).
template<typename T, typename T_factory>
rho_pollard (const T &n, const T_factory &tfctr)
 Pollard's rho algorithm.
template<typename T>
rho_pollard (const T &n)
 Pollard's rho algorithm.
template<typename T, typename N, typename T_factory>
brent (const T &n, N no_of_iter, const T_factory &tfctr)
 Pollard's rho algorithm.
template<typename T, typename N>
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>
next_prime_successive_checking (T x)
 Finds the next after x prime number via successive test for each number.
template<typename T>
prev_prime_successive_checking (T x)
 Finds the previous before x prime number via successive test for each number.
template<typename T>
next_prime (const T &x)
 Finds the next after x prime number via appropriate algorithm.
template<typename T>
prev_prime (const T &x)
 Finds the previous before x prime number via appropriate algorithm.
template<typename T>
next_probably_prime (T x)
 Finds the next after x probably prime number via appropriate algorithm.
template<typename 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>
rsa_encyph (const T &x, const T &c, const T &key)
template<typename 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>
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::digitget_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_floatoperator+= (big_float &b, const big_float &c)
big_floatoperator-= (big_float &b, const big_float &c)
big_floatoperator *= (big_float &b, const big_float &c)
big_floatoperator/= (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_intoperator+= (big_int &b, char c)
char & operator+= (char &b, const big_int &c)
big_intoperator+= (big_int &b, signed char c)
signed char & operator+= (signed char &b, const big_int &c)
big_intoperator+= (big_int &b, unsigned char c)
unsigned char & operator+= (unsigned char &b, const big_int &c)
big_intoperator+= (big_int &b, signed short c)
signed short & operator+= (signed short &b, const big_int &c)
big_intoperator+= (big_int &b, unsigned short c)
unsigned short & operator+= (unsigned short &b, const big_int &c)
big_intoperator+= (big_int &b, signed int c)
signed int & operator+= (signed int &b, const big_int &c)
big_intoperator+= (big_int &b, unsigned int c)
unsigned int & operator+= (unsigned int &b, const big_int &c)
big_intoperator+= (big_int &b, signed long c)
signed long & operator+= (signed long &b, const big_int &c)
big_intoperator+= (big_int &b, unsigned long c)
unsigned long & operator+= (unsigned long &b, const big_int &c)
big_intoperator+= (big_int &b, bool c)
bool & operator+= (bool &b, const big_int &c)
big_intoperator-= (big_int &b, char c)
char & operator-= (char &b, const big_int &c)
big_intoperator-= (big_int &b, signed char c)
signed char & operator-= (signed char &b, const big_int &c)
big_intoperator-= (big_int &b, unsigned char c)
unsigned char & operator-= (unsigned char &b, const big_int &c)
big_intoperator-= (big_int &b, signed short c)
signed short & operator-= (signed short &b, const big_int &c)
big_intoperator-= (big_int &b, unsigned short c)
unsigned short & operator-= (unsigned short &b, const big_int &c)
big_intoperator-= (big_int &b, signed int c)
signed int & operator-= (signed int &b, const big_int &c)
big_intoperator-= (big_int &b, unsigned int c)
unsigned int & operator-= (unsigned int &b, const big_int &c)
big_intoperator-= (big_int &b, signed long c)
signed long & operator-= (signed long &b, const big_int &c)
big_intoperator-= (big_int &b, unsigned long c)
unsigned long & operator-= (unsigned long &b, const big_int &c)
big_intoperator-= (big_int &b, bool c)
bool & operator-= (bool &b, const big_int &c)
big_intoperator *= (big_int &b, char c)
char & operator *= (char &b, const big_int &c)
big_intoperator *= (big_int &b, signed char c)
signed char & operator *= (signed char &b, const big_int &c)
big_intoperator *= (big_int &b, unsigned char c)
unsigned char & operator *= (unsigned char &b, const big_int &c)
big_intoperator *= (big_int &b, signed short c)
signed short & operator *= (signed short &b, const big_int &c)
big_intoperator *= (big_int &b, unsigned short c)
unsigned short & operator *= (unsigned short &b, const big_int &c)
big_intoperator *= (big_int &b, signed int c)
signed int & operator *= (signed int &b, const big_int &c)
big_intoperator *= (big_int &b, unsigned int c)
unsigned int & operator *= (unsigned int &b, const big_int &c)
big_intoperator *= (big_int &b, signed long c)
signed long & operator *= (signed long &b, const big_int &c)
big_intoperator *= (big_int &b, unsigned long c)
unsigned long & operator *= (unsigned long &b, const big_int &c)
big_intoperator *= (big_int &b, bool c)
bool & operator *= (bool &b, const big_int &c)
big_intoperator/= (big_int &b, char c)
char & operator/= (char &b, const big_int &c)
big_intoperator/= (big_int &b, signed char c)
signed char & operator/= (signed char &b, const big_int &c)
big_intoperator/= (big_int &b, unsigned char c)
unsigned char & operator/= (unsigned char &b, const big_int &c)
big_intoperator/= (big_int &b, signed short c)
signed short & operator/= (signed short &b, const big_int &c)
big_intoperator/= (big_int &b, unsigned short c)
unsigned short & operator/= (unsigned short &b, const big_int &c)
big_intoperator/= (big_int &b, signed int c)
signed int & operator/= (signed int &b, const big_int &c)
big_intoperator/= (big_int &b, unsigned int c)
unsigned int & operator/= (unsigned int &b, const big_int &c)
big_intoperator/= (big_int &b, signed long c)
signed long & operator/= (signed long &b, const big_int &c)
big_intoperator/= (big_int &b, unsigned long c)
unsigned long & operator/= (unsigned long &b, const big_int &c)
big_intoperator/= (big_int &b, bool c)
bool & operator/= (bool &b, const big_int &c)
big_intoperator+= (big_int &b, float c)
float & operator+= (float &b, const big_int &c)
big_intoperator+= (big_int &b, double c)
double & operator+= (double &b, const big_int &c)
big_intoperator+= (big_int &b, long double c)
long double & operator+= (long double &b, const big_int &c)
big_intoperator-= (big_int &b, float c)
float & operator-= (float &b, const big_int &c)
big_intoperator-= (big_int &b, double c)
double & operator-= (double &b, const big_int &c)
big_intoperator-= (big_int &b, long double c)
long double & operator-= (long double &b, const big_int &c)
big_intoperator *= (big_int &b, float c)
float & operator *= (float &b, const big_int &c)
big_intoperator *= (big_int &b, double c)
double & operator *= (double &b, const big_int &c)
big_intoperator *= (big_int &b, long double c)
long double & operator *= (long double &b, const big_int &c)
big_intoperator/= (big_int &b, float c)
float & operator/= (float &b, const big_int &c)
big_intoperator/= (big_int &b, double c)
double & operator/= (double &b, const big_int &c)
big_intoperator/= (big_int &b, long double c)
long double & operator/= (long double &b, const big_int &c)
big_intoperator%= (big_int &b, char c)
char & operator%= (char &b, const big_int &c)
big_intoperator%= (big_int &b, signed char c)
signed char & operator%= (signed char &b, const big_int &c)
big_intoperator%= (big_int &b, unsigned char c)
unsigned char & operator%= (unsigned char &b, const big_int &c)
big_intoperator%= (big_int &b, signed short c)
signed short & operator%= (signed short &b, const big_int &c)
big_intoperator%= (big_int &b, unsigned short c)
unsigned short & operator%= (unsigned short &b, const big_int &c)
big_intoperator%= (big_int &b, signed int c)
signed int & operator%= (signed int &b, const big_int &c)
big_intoperator%= (big_int &b, unsigned int c)
unsigned int & operator%= (unsigned int &b, const big_int &c)
big_intoperator%= (big_int &b, signed long c)
signed long & operator%= (signed long &b, const big_int &c)
big_intoperator%= (big_int &b, unsigned long c)
unsigned long & operator%= (unsigned long &b, const big_int &c)
big_intoperator%= (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)
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)
bool operator== (char b, const big_int &c)
bool operator== (const big_int &b, char c)
bool operator!= (char b, const big_int &c)
bool operator!= (const big_int &b, char c)
bool operator<= (char b, const big_int &c)
bool operator<= (const big_int &b, char c)
bool operator>= (char b, const big_int &c)
bool operator>= (const big_int &b, char c)
bool operator< (char b, const big_int &c)
bool operator< (const big_int &b, char c)
bool operator> (char b, const big_int &c)
bool operator> (const big_int &b, char c)
bool operator== (signed char b, const big_int &c)
bool operator== (const big_int &b, signed char c)
bool operator!= (signed char b, const big_int &c)
bool operator!= (const big_int &b, signed char c)
bool operator<= (signed char b, const big_int &c)
bool operator<= (const big_int &b, signed char c)
bool operator>= (signed char b, const big_int &c)
bool operator>= (const big_int &b, signed char c)
bool operator< (signed char b, const big_int &c)
bool operator< (const big_int &b, signed char c)
bool operator> (signed char b, const big_int &c)
bool operator> (const big_int &b, signed char c)
bool operator== (unsigned char b, const big_int &c)
bool operator== (const big_int &b, unsigned char c)
bool operator!= (unsigned char b, const big_int &c)
bool operator!= (const big_int &b, unsigned char c)
bool operator<= (unsigned char b, const big_int &c)
bool operator<= (const big_int &b, unsigned char c)
bool operator>= (unsigned char b, const big_int &c)
bool operator>= (const big_int &b, unsigned char c)
bool operator< (unsigned char b, const big_int &c)
bool operator< (const big_int &b, unsigned char c)
bool operator> (unsigned char b, const big_int &c)
bool operator> (const big_int &b, unsigned char c)
bool operator== (signed short b, const big_int &c)
bool operator== (const big_int &b, signed short c)
bool operator!= (signed short b, const big_int &c)
bool operator!= (const big_int &b, signed short c)
bool operator<= (signed short b, const big_int &c)
bool operator<= (const big_int &b, signed short c)
bool operator>= (signed short b, const big_int &c)
bool operator>= (const big_int &b, signed short c)
bool operator< (signed short b, const big_int &c)
bool operator< (const big_int &b, signed short c)
bool operator> (signed short b, const big_int &c)
bool operator> (const big_int &b, signed short c)
bool operator== (unsigned short b, const big_int &c)
bool operator== (const big_int &b, unsigned short c)
bool operator!= (unsigned short b, const big_int &c)
bool operator!= (const big_int &b, unsigned short c)
bool operator<= (unsigned short b, const big_int &c)
bool operator<= (const big_int &b, unsigned short c)
bool operator>= (unsigned short b, const big_int &c)
bool operator>= (const big_int &b, unsigned short c)
bool operator< (unsigned short b, const big_int &c)
bool operator< (const big_int &b, unsigned short c)
bool operator> (unsigned short b, const big_int &c)
bool operator> (const big_int &b, unsigned short c)
bool operator== (signed int b, const big_int &c)
bool operator== (const big_int &b, signed int c)
bool operator!= (signed int b, const big_int &c)
bool operator!= (const big_int &b, signed int c)
bool operator<= (signed int b, const big_int &c)
bool operator<= (const big_int &b, signed int c)
bool operator>= (signed int b, const big_int &c)
bool operator>= (const big_int &b, signed int c)
bool operator< (signed int b, const big_int &c)
bool operator< (const big_int &b, signed int c)
bool operator> (signed int b, const big_int &c)
bool operator> (const big_int &b, signed int c)
bool operator== (unsigned int b, const big_int &c)
bool operator== (const big_int &b, unsigned int c)
bool operator!= (unsigned int b, const big_int &c)
bool operator!= (const big_int &b, unsigned int c)
bool operator<= (unsigned int b, const big_int &c)
bool operator<= (const big_int &b, unsigned int c)
bool operator>= (unsigned int b, const big_int &c)
bool operator>= (const big_int &b, unsigned int c)
bool operator< (unsigned int b, const big_int &c)
bool operator< (const big_int &b, unsigned int c)
bool operator> (unsigned int b, const big_int &c)
bool operator> (const big_int &b, unsigned int c)
bool operator== (signed long b, const big_int &c)
bool operator== (const big_int &b, signed long c)
bool operator!= (signed long b, const big_int &c)
bool operator!= (const big_int &b, signed long c)
bool operator<= (signed long b, const big_int &c)
bool operator<= (const big_int &b, signed long c)
bool operator>= (signed long b, const big_int &c)
bool operator>= (const big_int &b, signed long c)
bool operator< (signed long b, const big_int &c)
bool operator< (const big_int &b, signed long c)
bool operator> (signed long b, const big_int &c)
bool operator> (const big_int &b, signed long c)
bool operator== (unsigned long b, const big_int &c)
bool operator== (const big_int &b, unsigned long c)
bool operator!= (unsigned long b, const big_int &c)
bool operator!= (const big_int &b, unsigned long c)
bool operator<= (unsigned long b, const big_int &c)
bool operator<= (const big_int &b, unsigned long c)
bool operator>= (unsigned long b, const big_int &c)
bool operator>= (const big_int &b, unsigned long c)
bool operator< (unsigned long b, const big_int &c)
bool operator< (const big_int &b, unsigned long c)
bool operator> (unsigned long b, const big_int &c)
bool operator> (const big_int &b, unsigned long c)
bool operator== (bool b, const big_int &c)
bool operator== (const big_int &b, bool c)
bool operator!= (bool b, const big_int &c)
bool operator!= (const big_int &b, bool c)
bool operator<= (bool b, const big_int &c)
bool operator<= (const big_int &b, bool c)
bool operator>= (bool b, const big_int &c)
bool operator>= (const big_int &b, bool c)
bool operator< (bool b, const big_int &c)
bool operator< (const big_int &b, bool c)
bool operator> (bool b, const big_int &c)
bool operator> (const big_int &b, bool c)
bool operator== (float b, const big_int &c)
bool operator== (const big_int &b, float c)
bool operator!= (float b, const big_int &c)
bool operator!= (const big_int &b, float c)
bool operator<= (float b, const big_int &c)
bool operator<= (const big_int &b, float c)
bool operator>= (float b, const big_int &c)
bool operator>= (const big_int &b, float c)
bool operator< (float b, const big_int &c)
bool operator< (const big_int &b, float c)
bool operator> (float b, const big_int &c)
bool operator> (const big_int &b, float c)
bool operator== (double b, const big_int &c)
bool operator== (const big_int &b, double c)
bool operator!= (double b, const big_int &c)
bool operator!= (const big_int &b, double c)
bool operator<= (double b, const big_int &c)
bool operator<= (const big_int &b, double c)
bool operator>= (double b, const big_int &c)
bool operator>= (const big_int &b, double c)
bool operator< (double b, const big_int &c)
bool operator< (const big_int &b, double c)
bool operator> (double b, const big_int &c)
bool operator> (const big_int &b, double c)
bool operator== (long double b, const big_int &c)
bool operator== (const big_int &b, long double c)
bool operator!= (long double b, const big_int &c)
bool operator!= (const big_int &b, long double c)
bool operator<= (long double b, const big_int &c)
bool operator<= (const big_int &b, long double c)
bool operator>= (long double b, const big_int &c)
bool operator>= (const big_int &b, long double c)
bool operator< (long double b, const big_int &c)
bool operator< (const big_int &b, long double c)
bool operator> (long double b, const big_int &c)
bool operator> (const big_int &b, long double c)
bool is_null (const big_int &x)
bool is_unit (const big_int &x)
bool is_opposite_unit (const big_int &x)
bool is_positive (const big_int &x)
bool is_negative (const big_int &x)
bool is_even (const big_int &x)
bool is_odd (const big_int &x)
template<typename T>
intsqrt (const T &a)
 Integer square root of a.
big_int sqrt (const big_int &a)
big_int abs (const big_int &x)
 Returns absolutly value of x.
big_int pow (const big_int &x, int p)
 Raise x in to a power p.
big_int pow (const big_int &x, const big_int &p)
 Raise x in to a power p.
big_int log2 (const big_int &x)
 Returns the base-2 logarithm of abs(x). If x == 0, returns -1.
template<typename T1, typename T2>
int cmp (const T1 &a, const T2 &b)
 Performs Arageli like comparision.
template<typename T>
int sign (const T &x)
 Sign of element.
template<typename T>
bool is_even (const T &x)
 Returns true if x is even.
template<typename T>
bool is_odd (const T &x)
 Returns true if x is odd.
template<typename T1, typename T2>
bool is_divisible (const T1 &a, const T2 &b)
 Returns true if a is divisible by b.
template<typename T>
bool is_positive (const T &x)
 Returns true if x is greater then null.
template<typename T>
bool is_negative (const T &x)
 Returns true if x is less then null.
template<typename T>
bool is_integer (const T &x)
 Returns true if x is integer.
template<typename Out, typename T, typename M, typename CFG>
void output_list (Out &out, const cone< T, M, CFG > &x)
template<typename Out, typename T, typename M, typename CFG>
Out & operator<< (Out &out, const cone< T, M, CFG > &x)
template<typename T1, typename M1, typename CFG1, typename T2, typename M2, typename CFG2>
cone< T1, M1, CFG1 > intersection (cone< T1, M1, CFG1 > a, const cone< T2, M2, CFG2 > &b)
template<typename T1, typename M1, typename CFG1, typename T2, typename M2, typename CFG2>
cone< T1, M1, CFG1 > cone_union (cone< T1, M1, CFG1 > a, const cone< T2, M2, CFG2 > &b)
template<typename T1, typename M1, typename CFG1, typename T2, typename M2, typename CFG2>
int cmp (const cone< T1, M1, CFG1 > &a, const cone< T2, M2, CFG2 > &b)
std::ostream & operator<< (std::ostream &out, const exception &e)
 ARAGELI_UNARY_FUNCTION_TRAITS (indirection, typename omit_asterisk< Arg >::type, false, false)
 ARAGELI_UNARY_FUNCTION_TRAITS (postfix_increment, typename omit_ref< Arg >::type, true, false)
 ARAGELI_UNARY_FUNCTION_TRAITS (postfix_decrement, typename omit_ref< Arg >::type, true, false)
 ARAGELI_BINARY_FUNCTION_TRAITS (subscript, typename omit_asterisk< Arg1 >::type, false, false, false)
template<typename M>
void gauss_field_row_iter (M &a, typename M::size_type row, typename M::size_type col)
 Gauss elimination of column col with row manipulation.
template<typename M>
void gauss_field_col_iter (M &a, typename M::size_type row, typename M::size_type col)
 Gauss elimination of row with column manipulation.
template<typename M, typename T>
void gauss_bareiss_row_iter (M &a, typename M::size_type row, typename M::size_type col, T &det, T &det_denom)
 Gauss-Bareiss elimination of column col with row manipulation.
template<typename M, typename T>
void gauss_bareiss_col_iter (M &a, typename M::size_type row, typename M::size_type col, T &det, T &det_denom)
 Gauss-Bareiss elimination of row with column manipulation.
template<typename M>
void gauss_bareiss_row_iter (M &a, typename M::size_type row, typename M::size_type col)
 Gauss-Bareiss elimination of column col with row manipulation.
template<typename M>
void gauss_bareiss_col_iter (M &a, typename M::size_type row, typename M::size_type col)
 Gauss-Bareiss elimination of row with column manipulation.
template<typename A, typename B, typename Q, typename Basis, typename T, typename T_factory, typename Ctrler>
void rref_gauss_field (const A &a, B &b, Q &q, Basis &basis, T &det, const T_factory &tfctr, Ctrler ctrler)
 Produces the reduced row echelon form B of the matrix a over a field.
template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void rref_gauss_field (const A &a, B &b, Q &q, Basis &basis, T &det, Ctrler ctrler)
 Produces the reduced row echelon form B of a matrix A.
template<typename A, typename B, typename Q, typename Basis, typename T>
void rref_gauss_field (const A &a, B &b, Q &q, Basis &basis, T &det)
 Produces the reduced row echelon form B of a matrix A.
template<typename A, typename B, typename Q, typename Basis>
void rref_gauss_field (const A &a, B &b, Q &q, Basis &basis)
 Produces the reduced row echelon form B of a matrix A.
template<typename A, typename B, typename Q>
void rref_gauss_field (const A &a, B &b, Q &q)
 Produces the reduced row echelon form B of a matrix A.
template<typename A, typename B>
void rref_gauss_field (const A &a, B &b)
 Produces the reduced row echelon form B of a matrix A.
template<typename A>
rref_gauss_field (const A &a)
 Produces the reduced row echelon form B of a matrix A.
template<typename A, typename B, typename Q, typename Basis, typename T, typename T_factory, typename Ctrler>
void rref_field (const A &a, B &b, Q &q, Basis &basis, T &det, const T_factory &tfctr, Ctrler ctrler)
 Produces the reduced row echelon form B of the matrix a over a field.
template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void rref_field (const A &a, B &b, Q &q, Basis &basis, T &det, Ctrler ctrler)
 Produces the reduced row echelon form B of the matrix a over a field.
template<typename A, typename B, typename Q, typename Basis, typename T>
void rref_field (const A &a, B &b, Q &q, Basis &basis, T &det)
 Produces the reduced row echelon form B of the matrix a over a field.
template<typename A, typename B, typename Q, typename Basis>
void rref_field (const A &a, B &b, Q &q, Basis &basis)
 Produces the reduced row echelon form B of the matrix a over a field.
template<typename A, typename B, typename Q>
void rref_field (const A &a, B &b, Q &q)
 Produces the reduced row echelon form B of the matrix a over a field.
template<typename A, typename B>
void rref_field (const A &a, B &b)
 Produces the reduced row echelon form B of the matrix a over a field.
template<typename A>
rref_field (const A &a)
 Produces the reduced row echelon form B of the matrix a over a field.
template<typename A1, typename A2, typename I>
void mat_col_copy_order (const A1 &a1, A2 &a2, const I &idx)
 Copies columns from a1 to a2 in order indexes in idx then tails the rest.
template<typename A1, typename A2, typename I>
void vec_copy_order (const A1 &a1, A2 &a2, const I &idx)
 Copies elements from a1 to a2 in order indexes in idx then tails the rest.
template<typename A, typename B>
void vec_inverse_permutation (const A &a, B &b)
 Inverses permutation vector.
template<typename A, typename B, typename Q, typename Basis_in, typename Basis_out, typename Det>
void rref_order (const A &a, B &b, Q &q, const Basis_in &basis_in, Basis_out &basis_out, Det &det)
 Produces the reduced row echelon from B of the matrix A with a specific column order.
template<typename T, bool REFCNT>
matrix< T, REFCNT > inverse (const matrix< T, REFCNT > &A)
 Matrix inversion.
template<typename T, bool REFCNT>
det (const matrix< T, REFCNT > &A)
 Returns determinant of A.
template<typename T, bool REFCNT>
matrix< T, REFCNT >::size_type rank (const matrix< T, REFCNT > &A)
 Returns a rank of a matrix.
template<typename A, typename B, typename Q, typename Basis, typename T, typename T_factory, typename Ctrler>
void rref_gauss_bareiss (const A &a, B &b, Q &q, Basis &basis, T &det, const T_factory &tfctr, Ctrler ctrler)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void rref_gauss_bareiss (const A &a, B &b, Q &q, Basis &basis, T &det, Ctrler ctrler)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q, typename Basis, typename T>
void rref_gauss_bareiss (const A &a, B &b, Q &q, Basis &basis, T &det)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q, typename Basis>
void rref_gauss_bareiss (const A &a, B &b, Q &q, Basis &basis)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q>
void rref_gauss_bareiss (const A &a, B &b, Q &q)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B>
void rref_gauss_bareiss (const A &a, B &b)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A>
rref_gauss_bareiss (const A &a)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q, typename Basis, typename T, typename T_factory, typename Ctrler>
void rref_int (const A &a, B &b, Q &q, Basis &basis, T &det, const T_factory &tfctr, Ctrler ctrler)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void rref_int (const A &a, B &b, Q &q, Basis &basis, T &det, Ctrler ctrler)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q, typename Basis, typename T>
void rref_int (const A &a, B &b, Q &q, Basis &basis, T &det)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q, typename Basis>
void rref_int (const A &a, B &b, Q &q, Basis &basis)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q>
void rref_int (const A &a, B &b, Q &q)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B>
void rref_int (const A &a, B &b)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A>
rref_int (const A &a)
 Produces the reduced row echelon form B of the matrix a over an integer domain.
template<typename A, typename B, typename Q, typename Basis, typename T, typename T_factory, typename Ctrler>
void rref (const A &a, B &b, Q &q, Basis &basis, T &det, const T_factory &tfctr, Ctrler ctrler)
 Produces the reduced row echelon form B of the matrix a.
template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void rref (const A &a, B &b, Q &q, Basis &basis, T &det, Ctrler ctrler)
 Produces the reduced row echelon form B of the matrix a.
template<typename A, typename B, typename Q, typename Basis, typename T>
void rref (const A &a, B &b, Q &q, Basis &basis, T &det)
 Produces the reduced row echelon form B of the matrix a.
template<typename A, typename B, typename Q, typename Basis>
void rref (const A &a, B &b, Q &q, Basis &basis)
 Produces the reduced row echelon form B of the matrix a.
template<typename A, typename B, typename Q>
void rref (const A &a, B &b, Q &q)
 Produces the reduced row echelon form B of the matrix a.
template<typename A, typename B>
void rref (const A &a, B &b)
 Produces the reduced row echelon form B of the matrix a.
template<typename A>
rref (const A &a)
 Produces the reduced row echelon form B of the matrix a.
template<typename T, bool REFCNT>
det_int (const matrix< T, REFCNT > &A)
 Returns determinant of integer matrix A.
template<typename T, bool REFCNT>
matrix< T, REFCNT >::size_type rank_int (const matrix< T, REFCNT > &A)
 Returns a rank of integer matrix.
template<class T>
matrix< T > hermite_old (const matrix< T > &m_)
 The old original function for producing Hermite form.
template<typename MA, typename MH, typename MU>
void hermite_upper (const MA &A, MH &H, MU &U)
 Produces the upper Hermite form H of an integer matrix A.
template<typename MA, typename MH, typename MU>
void hermite_lower (const MA &A, MH &H, MU &U)
 Produces the lower Hermite form H of an integer matrix A.
template<typename M>
hermite (const M &A)
 Produces the upper Hermite form H of an integer matrix A.
template<typename M>
hermite_transform_matrix (const M &A)
 Produces the unimodular princpal left transform U such that U*A is a Hermite form of an integer matrix A.
template<typename T, typename T_factory>
inverse_mod (const T &a, const T &m, const T_factory &tfctr)
 Returns inversion of a modulo n.
template<typename T>
inverse_mod (const T &a, const T &n)
 Returns inversion of a modulo n.
template<typename T, typename I, typename T_factory>
power_mod (T a, I n, const T &m, const T_factory &tfctr)
 Exponentiates a in to power n modulo m via squaring and adding.
template<typename T, typename I>
power_mod (const T &a, const I &n, const T &m)
 Exponentiates a in to power n modulo m via squaring and adding.
template<typename T1, typename T2, typename T3>
T3 mod (const T1 &a, const T2 &b, const T3 &d)
template<typename T1, typename T2>
T2 mod (const T1 &a, const T2 &b)
 Compute a modulo b.
template<typename T1, typename T2, typename T3>
T3 div_mod (const T1 &a, const T2 &b, const T3 &d)
 Compute a/b modulo d.
template<typename T1, typename T2, typename T3>
T3 rem_mod (const T1 &a, const T2 &b, const T3 &d)
 Compute residue of division a by b modulo d.
template<typename T1, typename T2>
T2 ann (const T1 &a, const T2 &n)
 Compute n/gcd(a, n).
template<typename T1, typename T2, typename T3>
T3 quo_mod (const T1 &a, const T2 &b, const T3 &d)
template<typename T>
split (const T &a, const T &d)
template<typename T>
stab (const T &a, const T &b, const T &N)
template<typename T>
split_stab (const T &a, const T &b, const T &N)
template<typename T>
unit (const T &a, const T &N)
template<typename T>
stab (const T &a, const T &b, const T &N, const T &d)
template<typename T>
split_stab (const T &a, const T &b, const T &N, const T &d)
template<typename T>
split_mod (const T &a, const T &d)
template<typename T>
stab_mod (const T &a, const T &b, const T &N)
template<typename T>
stab_mod (const T &a, const T &b, const T &N, const T &d)
template<typename T>
bool is_invertible_mod (const T &a, const T &N)
 Returns true iff a is invertible element modulo N.
template<typename T>
std::size_t nbits (const T &a)
 Compute number of bit in binary notation of a.
template<typename T, typename T_factory>
std::size_t nbits (T a, const T_factory &tfctr)
 Compute number of bit in binary notation of a.
template<typename T, typename T_factory>
factorial_successive_multiplication (T a, const T_factory &tfctr)
 Computes factorial via just successive multiplication (by definition).
template<typename T>
factorial_successive_multiplication (const T &a)
 Computes factorial via just successive multiplication (by definition).
template<typename T, typename T_factory>
factorial_even_odd_multiplication (T a, const T_factory &tfctr)
 Computes factorial via even and odd multiplier separation.
template<typename T>
factorial_even_odd_multiplication (const T &a)
 Computes factorial via even and odd multiplier separation.
template<typename T, typename T_factory>
factorial (const T &a, const T_factory &tfctr)
 Computes factorial of a via apropriate algorithm.
template<typename T>
factorial (const T &a)
 Computes factorial of a via apropriate algorithm.
template<typename T, typename TT>
sqrt_mod_shenks (const T &a, const T &n, const TT &tt)
 The Shenks algorithm (square root of a modulo n, for n = 1 (mod 4)).
template<typename T>
sqrt_mod_shenks (const T &a, const T &n)
 The Shenks algorithm (square root of a modulo n, for n = 1 (mod 4)).
template<typename Gen, typename IntGen>
void intconvex_simple (const Gen &gen, IntGen &intgen)
 A convex hull of integer points of a polyhedron.
template<typename A, typename T, typename Ctrler>
void intcount_barvinok (const A &a, T &res, Ctrler ctrler)
 Counts all integer points in bodily polytope.
template<typename A, typename T>
void intcount_barvinok (const A &a, T &res)
 Counts all integer points in bodily polytope.
template<typename A>
A::element_type intcount_barvinok (const A &a)
 Counts all integer points in bodily polytope.
template<typename T>
interval< T > operator+ (const interval< T > &a, const interval< T > &b)
template<typename T>
interval< T > operator- (const interval< T > &a, const interval< T > &b)
template<typename T>
interval< T > operator * (const interval< T > &a, const interval< T > &b)
template<typename T>
interval< T > operator/ (const interval< T > &a, const interval< T > &b)
template<typename T1, typename T2>
bool are_overlap_intervals_oooo (const T1 &a, const T2 &b)
template<typename Seg1, typename Seg2>
bool is_overlap_segs (const Seg1 &a, const Seg2 &b)
template<typename Out, typename T>
Out & operator<< (Out &out, const interval< T > &x)
template<typename In, typename T>
In & operator>> (In &in, interval< T > &x)
template<typename T1, typename T2>
bool are_comparable_oooo (const interval< T1 > &a, const interval< T2 > &b)
 Determines if a and b are exactly comparable as two open intervals.
template<typename T1, typename T2>
int cmp (const interval< T1 > &a, const interval< T2 > &b)
 Semi-lexicographical comparision between two intervals.
template<typename T1, typename T2>
bool operator< (const interval< T1 > &a, const interval< T2 > &b)
template<typename T1, typename T2>
bool operator> (const interval< T1 > &a, const interval< T2 > &b)
template<typename T1, typename T2>
bool operator<= (const interval< T1 > &a, const interval< T2 > &b)
template<typename T1, typename T2>
bool operator>= (const interval< T1 > &a, const interval< T2 > &b)
template<typename T1, typename T2>
bool operator== (const interval< T1 > &a, const interval< T2 > &b)
template<typename T1, typename T2>
bool operator!= (const interval< T1 > &a, const interval< T2 > &b)
template<typename T>
interval< T > abs (const interval< T > &x)
template<typename T, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & output_polynom_first_default (std::basic_ostream< Ch, ChT > &out, const T &x)
 Default ouputting method for subexpression as the first coefficient in a polynomial.
template<typename T, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & output_polynom_internal_default (std::basic_ostream< Ch, ChT > &out, const T &x)
 Default ouputting method for subexpression as an internal coefficient in a polynomial.
template<typename T, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & output_pow_default (std::basic_ostream< Ch, ChT > &out, const T &x)
 Default ouputting method for subexpression as a degree of variable in a polynomial.
template<typename T, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & input_polynom_first_default (std::basic_istream< Ch, ChT > &in, T &x)
 Default inputting method for subexpression as the first coefficient in a polynomial.
template<typename T, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & input_polynom_internal_default (std::basic_istream< Ch, ChT > &in, T &x)
 Default inputting method for subexpression as an internal coefficient in a polynomial.
template<typename T, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & input_pow_default (std::basic_istream< Ch, ChT > &in, T &x)
 Default inutting method for subexpression as a degree of variable in a polynomial.
template<typename T, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & output_polynom_first (std::basic_ostream< Ch, ChT > &out, const T &x)
template<typename T, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & output_polynom_internal (std::basic_ostream< Ch, ChT > &out, const T &x)
template<typename T, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & output_pow (std::basic_ostream< Ch, ChT > &out, const T &x)
template<typename T, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & input_polynom_first (std::basic_istream< Ch, ChT > &in, T &x)
template<typename T, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & input_polynom_internal (std::basic_istream< Ch, ChT > &in, T &x)
template<typename T, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & input_pow (std::basic_istream< Ch, ChT > &in, T &x)
template<typename T, typename TB, typename F>
apply_iterator< T, TB, F > operator+ (apply_iterator< T, TB, F > x, typename apply_iterator< T, TB, F >::difference_type n)
template<typename T, typename TB, typename F>
apply_iterator< T, TB, F > operator- (apply_iterator< T, TB, F > x, typename apply_iterator< T, TB, F >::difference_type n)
template<typename T, typename TB, typename F>
std::iterator_traits< TB
>::difference_type 
operator- (const apply_iterator< T, TB, F > &a, const apply_iterator< T, TB, F > &b)
template<typename T, typename TB, typename F>
bool operator== (const apply_iterator< T, TB, F > &a, const apply_iterator< T, TB, F > &b)
template<typename T, typename TB, typename F>
bool operator!= (const apply_iterator< T, TB, F > &a, const apply_iterator< T, TB, F > &b)
template<typename T, typename TB, typename F>
bool operator< (const apply_iterator< T, TB, F > &a, const apply_iterator< T, TB, F > &b)
template<typename T, typename TB, typename F>
bool operator> (const apply_iterator< T, TB, F > &a, const apply_iterator< T, TB, F > &b)
template<typename T, typename TB, typename F>
bool operator<= (const apply_iterator< T, TB, F > &a, const apply_iterator< T, TB, F > &b)
template<typename T, typename TB, typename F>
bool operator>= (const apply_iterator< T, TB, F > &a, const apply_iterator< T, TB, F > &b)
template<typename T, typename TB1, typename TB2, typename F>
std::iterator_traits< TB1
>::difference_type 
operator- (const Iterpair< T, TB1, TB2, F > &a, const Iterpair< T, TB1, TB2, F > &b)
template<typename T, typename TB1, typename TB2, typename F>
bool operator== (const Iterpair< T, TB1, TB2, F > &a, const Iterpair< T, TB1, TB2, F > &b)
template<typename T, typename TB1, typename TB2, typename F>
bool operator!= (const Iterpair< T, TB1, TB2, F > &a, const Iterpair< T, TB1, TB2, F > &b)
template<typename T, typename TB1, typename TB2, typename F>
bool operator< (const Iterpair< T, TB1, TB2, F > &a, const Iterpair< T, TB1, TB2, F > &b)
template<typename T, typename TB1, typename TB2, typename F>
bool operator> (const Iterpair< T, TB1, TB2, F > &a, const Iterpair< T, TB1, TB2, F > &b)
template<typename T, typename TB1, typename TB2, typename F>
bool operator<= (const Iterpair< T, TB1, TB2, F > &a, const Iterpair< T, TB1, TB2, F > &b)
template<typename T, typename TB1, typename TB2, typename F>
bool operator>= (const Iterpair< T, TB1, TB2, F > &a, const Iterpair< T, TB1, TB2, F > &b)
template<typename B_type, typename H_type>
bool lll_reduction (B_type &B, H_type &H)
 LLL basis reduction.
big_int entier (const big_int &de)
big_int frac (const big_int &de, std::size_t kbits)
std::size_t lg10 (const big_int &b)
 Returns lg (b).
std::size_t lg10 (std::size_t b)
 Returns lg (b).
big_int power_of_ten (std::size_t pow)
 Returns 10^pow.
big_int entier_1 (const big_int &be)
big_int frac_1 (const big_int &de, std::size_t kbits)
 Returns 10 ^ {de/log2_10} with kbits - 1 precision.
void do_bin_convert (const big_int &dm, const big_int &de, std::size_t p, big_int &bm, big_int &be)
std::size_t do_dec_convert (big_int &dm, big_int &de, std::size_t p, const big_int &bm, const big_int &be)
template<typename T, bool REFCNT>
matrix< T, true > transpose (const matrix< T, REFCNT > &a)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
int cmp (const matrix< T1, REFCNT1 > &a, const matrix< T2, REFCNT2 > &b)
 Lexicographical comparision of two matrix.
template<typename T1, typename T2, typename T3>
T3 & each_add_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & add_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & add_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & each_sub_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & sub_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & sub_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & each_mul_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & mul_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & mul_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & each_div_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & div_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & div_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & each_mod_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & mod_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & mod_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & each_bitand_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & bitand_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & bitand_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & each_bitor_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & bitor_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & bitor_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & each_bitxor_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & bitxor_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & bitxor_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & each_shl_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & shl_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & shl_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & each_shr_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & shr_matrix_scalar (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & shr_scalar_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & mul_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & div_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & add_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & sub_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & mod_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & bitand_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & bitor_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & bitxor_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & shl_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, typename T2, typename T3>
T3 & shr_matrix_matrix (const T1 &a, const T2 &b, T3 &res)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > operator * (const matrix< T1, REFCNT1 > &m, const vector< T2, REFCNT2 > &x)
 Matrix by vector multiplication.
template<typename T2, bool REFCNT2, typename T1, bool REFCNT1>
vector< T2, REFCNT2 > operator * (const vector< T2, REFCNT2 > &x, const matrix< T1, REFCNT1 > &m)
 Vector by matrix multiplication.
template<typename T, bool REFCNT>
std::ostream & output_list (std::ostream &out, const matrix< T, REFCNT > &x, const char *first_bracket=matrix_output_list_first_bracket_default, const char *second_bracket=matrix_output_list_second_bracket_default, const char *row_separator=matrix_output_list_row_separator_default, const char *first_row_bracket=matrix_output_list_first_row_bracket_default, const char *second_row_bracket=matrix_output_list_second_row_bracket_default, const char *col_separator=matrix_output_list_col_separator_default)
 Simple output of the matrix.
template<typename T, bool REFCNT>
std::istream & input_list (std::istream &out, matrix< T, REFCNT > &x, const char *first_bracket=matrix_input_list_first_bracket_default, const char *second_bracket=matrix_input_list_second_bracket_default, const char *row_separator=matrix_input_list_row_separator_default, const char *first_row_bracket=matrix_input_list_first_row_bracket_default, const char *second_row_bracket=matrix_input_list_second_row_bracket_default, const char *col_separator=matrix_input_list_col_separator_default)
 Simple input of the matrix.
template<typename T, bool REFCNT>
std::ostream & output_aligned (std::ostream &out, const matrix< T, REFCNT > &x, const char *left_col=matrix_output_aligned_left_col_default, const char *right_col=matrix_output_aligned_right_col_default, const char *inter_col=matrix_output_aligned_inter_col_default)
 Aligned output of the matrix.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
std::ostream & output_aligned_ver_pair (std::ostream &out, const matrix< T1, REFCNT1 > &m1, const matrix< T2, REFCNT2 > &m2, const char *left_col="|| ", const char *right_col=" ||", const char *inter_col=" ", const char *hsplitter="-")
 Vertical aligned output of a pair of matrices.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
std::ostream & output_aligned_hor_pair (std::ostream &out, const matrix< T1, REFCNT1 > &m1, const matrix< T2, REFCNT2 > &m2, const char *left_col="|| ", const char *right_col=" ||", const char *inter_col=" ", const char *vsplitter=" | ")
 Horizontal aligned output of a pair of matrices.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
std::ostream & output_aligned_corner_triplet_br (std::ostream &out, const matrix< T1, REFCNT1 > &m1, const matrix< T2, REFCNT2 > &m2, const matrix< T3, REFCNT3 > &m3, const char *left_col="|| ", const char *right_col=" ||", const char *inter_col=" ", const char *vsplitter=" | ", const char *hsplitter="-")
 Aligned output of a triplet of matrices.
template<typename T, bool REFCNT>
std::ostream & operator<< (std::ostream &out, const matrix< T, REFCNT > &x)
 Standard output routine (default type of outputting) for the matrix.
template<typename T, bool REFCNT>
std::istream & operator>> (std::istream &out, matrix< T, REFCNT > &x)
 Standard input routine (default type of inputting) for the matrix.
template<typename T, bool REFCNT>
std::ofstream & operator<< (std::ofstream &out, const matrix< T, REFCNT > &x)
 WARNING! TEMPORARY DEFINITION!!!
template<typename T, bool REFCNT>
std::ifstream & operator>> (std::ifstream &out, matrix< T, REFCNT > &x)
 WARNING! TEMPORARY DEFINITION!!!
template<typename T, bool REFCNT>
std::ostream & operator<< (std::ostringstream &out, const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream & operator>> (std::istringstream &out, matrix< T, REFCNT > &x)
 Standard input routine (default type of inputting) for the matrix.
template<typename T, bool REFCNT>
matrix< T, REFCNT > opposite (const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
matrix< T, REFCNT > & opposite (const matrix< T, REFCNT > &x, matrix< T, REFCNT > *y)
template<typename T, bool REFCNT>
matrix< T, REFCNT > & opposite (matrix< T, REFCNT > *x)
template<typename T, bool REFCNT>
matrix< T, REFCNT > & inverse (const matrix< T, REFCNT > &x, matrix< T, REFCNT > *y)
template<typename T, bool REFCNT>
matrix< T, REFCNT > & inverse (matrix< T, REFCNT > *x)
template<typename T, bool REFCNT>
bool is_unit (const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
bool is_opposite_unit (const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
bool is_null (const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream & output_polynom_first (std::ostream &out, const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream & output_polynom_internal (std::ostream &out, const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream & output_pow (std::ostream &out, const matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream & input_polynom_first (std::istream &in, matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream & input_polynom_internal (std::istream &in, matrix< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream & input_pow (std::istream &in, matrix< T, REFCNT > &x)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
void fill_submatrix_col (const matrix< T1, REFCNT1 > &orig, const vector< T2, REFCNT2 > &indexes, matrix< T3, REFCNT3 > &res)
 Makes submatrix from columns of another matrix with particular indexes.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
void fill_submatrix_row (const matrix< T1, REFCNT1 > &orig, const vector< T2, REFCNT2 > &indexes, matrix< T3, REFCNT3 > &res)
 Makes submatrix from rows of another matrix with particular indexes.
template<typename T>
safe_reference (const T &x)
 Makes and returns a temporary copy of the argument.
template<typename T1, typename T2, typename Outiter>
void generate_range_helper (T1 &t1, const T2 &t2, Outiter outiter)
template<typename T1, typename T2, typename T3, typename Outiter>
void generate_range_helper (T1 &t1, const T2 &t2, const T3 &t3, Outiter outiter)
template<typename T1, typename T2, typename Outiter>
void generate_range_helper_wo_inc (T1 &t1, const T2 &t2, Outiter outiter)
template<typename Outiter>
void generate_range_helper (bool &t1, bool t2, Outiter outiter)
template<typename Outiter>
void generate_range_helper (float &t1, float t2, Outiter outiter)
template<typename Outiter>
void generate_range_helper (double &t1, double t2, Outiter outiter)
template<typename Outiter>
void generate_range_helper (long double &t1, long double t2, Outiter outiter)
template<typename A, typename F, typename Q, typename E, typename Ctrler>
void skeleton_motzkin_burger (A &a, F &f, Q &q, E &e, Ctrler ctrler)
 The Motzkin-Burger algorithm without modifications.
template<typename A, typename F, typename Q, typename E>
void skeleton_motzkin_burger (A &a, F &f, Q &q, E &e)
 The Motzkin-Burger algorithm without modifications.
template<typename A, typename F, typename Q, typename E, typename Ctrler>
void skeleton_motzkin_burger_min (A &a, F &f, Q &q, E &e, Ctrler ctrler)
 The Motzkin-Burger algorithm with selecting minimum elements.
template<typename A, typename F, typename Q, typename E>
void skeleton_motzkin_burger_min (A &a, F &f, Q &q, E &e)
 The Motzkin-Burger algorithm with selecting minimum elements.
template<typename A, typename F, typename Q, typename E, typename Ctrler>
void skeleton_motzkin_burger_max (A &a, F &f, Q &q, E &e, Ctrler ctrler)
 The Motzkin-Burger algorithm with selecting maximum elements.
template<typename A, typename F, typename Q, typename E>
void skeleton_motzkin_burger_max (A &a, F &f, Q &q, E &e)
 The Motzkin-Burger algorithm with selecting maximum elements.
template<typename A, typename F, typename Q, typename E>
void integer_conv_motzkin_burger (A &a, F &f, Q &q, E &e)
template<typename P1, typename P2, typename PQ, typename PR>
void polynom_divide_simple (const P1 &p1, const P2 &p2, PQ &pq, PR &pr)
 Division of two univariate polynomials with quotient and remainder.
template<typename P1, typename P2, typename PQ, typename PR, typename T>
void polynom_pseudodivide_simple (const P1 &p1, const P2 &p2, PQ &pq, PR &pr, T &multiplier)
template<typename P, typename T>
T & polynom_rational_to_int_value (const P &p, T &res)
template<typename Pr, typename Pi, typename X>
void polynom_rational_to_int (const Pr &pr, Pi &pi, const X &x)
template<typename P1, typename P2, typename PQ, typename PR>
void polynom_divide_rational_simple (P1 p1, P2 p2, PQ &pq, PR &pr)
template<typename P1, typename P2, typename PQ, typename PR>
void polynom_divide (const P1 &p1, const P2 &p2, PQ &pq, PR &pr, const type_category::type &)
template<typename P1, typename P2, typename PQ, typename PR>
void polynom_divide (const P1 &p1, const P2 &p2, PQ &pq, PR &pr, const type_category::rational &)
template<typename P1, typename P2, typename PQ, typename PR>
void polynom_divide (const P1 &p1, const P2 &p2, PQ &pq, PR &pr)
template<typename P, typename M>
void sparse_polynom_reduction_mod (P &p, const M &m)
 Polynom coefficients reduction modulo m.
template<typename P>
P::coef_type max_abs_coef (const P &p)
 Computes maximum of absolute values of coefficients of polynom p.
template<typename P>
P::coef_type max_abs_coef_wo_leading (const P &p)
 Computes maximum of absolute values of coefficients of polynom p without leading coef.
template<typename P>
P::coef_type polynom_content (const P &x)
template<typename P>
polynom_primpart (const P &x)
template<typename T, typename P>
root_upper_bound_cauchy (const P &p)
template<typename P, typename V>
V & squarefree_factorize_poly_rational (const P &h, V &res)
template<typename P>
reciprocal_poly (const P &p)
template<typename Out, typename T, typename R, typename M, typename CFG>
void output_vrml (Out &out, const polyhedron< T, R, M, CFG > &p)
 VRML Output. WARNING! The view will be correct only in wired mode.
template<typename Out, typename P, typename X1, typename Y1, typename X2, typename Y2, typename Viewdir, typename Colormap>
void output_polytope_pstricks_3d (Out &out, const P &p, double x1, double y1, double x2, double y2, double linewidth, const Viewdir &viewdir, const Colormap &colormap)
 PostScript LaTeX Output with pstricks package. WARNING! Only for 3-dim polytopes.
template<typename F, typename FT>
std::ostream & operator<< (std::ostream &s, const polynom< F > &v)
template<typename F, typename FT>
polynom< F > abs (const polynom< F > &maxVal)
template<typename F, typename FT>
polynom< F > normalize (const polynom< F > &val)
template<typename T, typename I, typename T_factory>
power (T a, I n, const T_factory &tfctr)
 Exponentiates a in to positive integer power n via squaring and adding.
template<typename T, typename I>
power (const T &a, const I &n)
 Exponentiates a in to positive integer power n via squaring and adding.
template<typename T, typename I, typename T_factory>
pow2 (I n, const T_factory &tfctr)
 Exponentiates 2 in to positive integer power n via left shift operator.
template<typename T, typename I>
pow2 (I n)
 Exponentiates 2 in to positive integer power n via left shift operator.
template<typename T>
log2 (T x)
 Returns the base-2 logarithm of x. The default version.
template<typename T1, typename T2, typename Q, typename R>
void divide (const T1 &a, const T2 &b, Q &q, R &r)
 Performs division produced quotient and remainder.
template<typename T1, typename T2, typename Q, typename R>
void prdivide (const T1 &a, const T2 &b, Q &q, R &r)
 Performs division produced quotient and POSITIVE remainder (pr).
template<typename T1, typename T2>
T1 prquot (const T1 &a, const T2 &b)
 Returns quotient of pr-division of a by b.
template<typename T1, typename T2>
T2 prrem (const T1 &a, const T2 &b)
 Returns remainder of pr-division of a by b.
template<typename T>
square (const T &a)
 Returns square of a.
int pow (int x, int y)
char rand (char maxVal)
unsigned char rand (unsigned char maxVal)
short rand (short maxVal)
unsigned short rand (unsigned short maxVal)
int rand (int maxVal)
unsigned int rand (unsigned int maxVal)
long rand (long maxVal)
unsigned long rand (unsigned long maxVal)
big_int rand (big_int maxVal)
template<typename T>
rational< T > rand (const rational< T > &maxVal)
template<typename F, typename I>
monom< F, I > rand (const monom< F, I > &maxVal)
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT > rand (const sparse_polynom< F, I, REFCNT > &maxVal)
template<typename T, bool REFCNT>
matrix< T, REFCNT > rand (const matrix< T, REFCNT > &maxVal)
template<typename T, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & output_list (std::basic_ostream< Ch, ChT > &out, const rational< T > &x, const Ch *first_bracket=rational_output_list_first_bracket_default, const Ch *second_bracket=rational_output_list_second_bracket_default, const Ch *separator=rational_output_list_separator_default)
template<typename T, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & input_list (std::basic_istream< Ch, ChT > &in, rational< T > &x, const Ch *first_bracket=rational_input_list_first_bracket_default, const Ch *second_bracket=rational_input_list_second_bracket_default, const Ch *separator=rational_input_list_separator_default)
template<typename T, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & output_default (std::basic_ostream< Ch, ChT > &out, const rational< T > &x, const Ch *oblique=rational_output_default_oblique_default)
template<typename T, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & input_default (std::basic_istream< Ch, ChT > &in, rational< T > &x, const Ch *oblique=rational_input_default_oblique_default)
template<typename T, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & operator<< (std::basic_ostream< Ch, ChT > &out, const rational< T > &x)
 Reads a rational from a string notation.
template<typename T, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & operator>> (std::basic_istream< Ch, ChT > &in, rational< T > &x)
 Writes a rational to a string notation.
template<typename T1, typename T2>
int cmp (const rational< T1 > &a, const rational< T2 > &b)
 Comparison of two rationals.
template<typename T>
int sign (const rational< T > &x)
template<typename T>
bool is_coprime (const rational< T > &a, const rational< T > &b)
template<typename T>
rational< T > gcd (const rational< T > &a, const rational< T > &b)
template<typename T>
ifloor (const rational< T > &x)
 Floor of x.
template<typename T>
iceil (const rational< T > &x)
 Ceiling of x.
template<typename T>
rational< T > frac (const rational< T > &x)
 Fractional part of x.
template<typename T1>
bool is_null (const rational< T1 > &x)
template<typename T1>
rational< T1 > opposite (const rational< T1 > &x)
template<typename T1>
rational< T1 > & opposite (const rational< T1 > &x, rational< T1 > *y)
template<typename T1>
rational< T1 > & opposite (rational< T1 > *x)
template<typename T1>
rational< T1 > inverse (const rational< T1 > &x)
template<typename T1>
rational< T1 > & inverse (const rational< T1 > &x, rational< T1 > *y)
template<typename T1>
rational< T1 > & inverse (rational< T1 > *x)
template<typename T1>
std::ostream & output_polynom_first (std::ostream &out, const rational< T1 > &x)
template<typename T1>
std::ostream & output_polynom_internal (std::ostream &out, const rational< T1 > &x)
template<typename T1>
std::ostream & output_pow (std::ostream &out, const rational< T1 > &x)
template<typename T1>
std::istream & input_polynom_first (std::istream &in, rational< T1 > &x)
template<typename T1>
std::istream & input_polynom_internal (std::istream &in, rational< T1 > &x)
template<typename T1>
std::istream & input_pow (std::istream &in, rational< T1 > &x)
template<typename T>
rational< T > abs (const rational< T > &x)
 Absolute value of x.
template<typename T>
rational< T > floor (const rational< T > &x)
 Floor of x.
template<typename T>
rational< T > ceil (const rational< T > &x)
 Ceiling of x.
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue< T1, M1, Config1 > operator+ (residue< T1, M1, Config1 > a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue< T1, M1, Config1 > operator- (residue< T1, M1, Config1 > a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue< T1, M1, Config1 > operator * (residue< T1, M1, Config1 > a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue< T1, M1, Config1 > operator/ (residue< T1, M1, Config1 > a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue< T1, M1, Config1 > operator% (residue< T1, M1, Config1 > a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool operator== (const residue< T1, M1, Config1 > &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2>
bool operator== (const residue< T1, M1, Config1 > &a, const T2 &b)
template<typename T1, typename T2, typename M2, typename Config2>
bool operator== (const T1 &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool operator!= (const residue< T1, M1, Config1 > &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2>
bool operator!= (const residue< T1, M1, Config1 > &a, const T2 &b)
template<typename T1, typename T2, typename M2, typename Config2>
bool operator!= (const T1 &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool operator< (const residue< T1, M1, Config1 > &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2>
bool operator< (const residue< T1, M1, Config1 > &a, const T2 &b)
template<typename T1, typename T2, typename M2, typename Config2>
bool operator< (const T1 &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool operator<= (const residue< T1, M1, Config1 > &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2>
bool operator<= (const residue< T1, M1, Config1 > &a, const T2 &b)
template<typename T1, typename T2, typename M2, typename Config2>
bool operator<= (const T1 &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool operator> (const residue< T1, M1, Config1 > &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2>
bool operator> (const residue< T1, M1, Config1 > &a, const T2 &b)
template<typename T1, typename T2, typename M2, typename Config2>
bool operator> (const T1 &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool operator>= (const residue< T1, M1, Config1 > &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2>
bool operator>= (const residue< T1, M1, Config1 > &a, const T2 &b)
template<typename T1, typename T2, typename M2, typename Config2>
bool operator>= (const T1 &a, const residue< T2, M2, Config2 > &b)
template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
int cmp (residue< T1, M1, Config1 > a, const residue< T2, M2, Config2 > &b)
template<typename T, typename M, typename Config>
std::ostream & operator<< (std::ostream &out, const residue< T, M, Config > &x)
template<typename T, typename M, typename Config>
std::istream & operator>> (std::istream &in, residue< T, M, Config > &x)
template<typename T, typename M, typename Config>
const residue< T, M, Config > & abs (const residue< T, M, Config > &x)
template<typename P1, typename P2, typename M>
M & sylvester_fill (const P1 &p1, const P2 &p2, M &res)
 Fills non-zero elements in Sylvester matrix from two polynomials.
template<typename P1, typename P2, typename M, typename MTFactory>
M & sylvester (const P1 &p1, const P2 &p2, M &res, MTFactory fctr)
 Creates Sylvester matrix from two polynomials.
template<typename P1, typename P2, typename M>
M & sylvester (const P1 &p1, const P2 &p2, M &res)
 Creates Sylvester matrix from two polynomials.
template<typename P1, typename P2>
matrix< typename P1::coef_type > sylvester (const P1 &p1, const P2 &p2)
 Creates Sylvester matrix from two polynomials.
template<typename P1, typename P2, typename SRChain, typename PCFactory>
void subresultants_nonmodular (const P1 &p1, const P2 &p2, SRChain &s, PCFactory fctr)
 Computes the chain of subresultants of two polynomials.
template<typename P1, typename P2, typename SRChain>
void subresultants_nonmodular (const P1 &p1, const P2 &p2, SRChain &s)
 Computes the chain of subresultants of two polynomials.
template<typename P1, typename P2, typename PCFactory>
P1::coef_type resultant_nonmodular (const P1 &p1, const P2 &p2, PCFactory fctr)
 Computes the resultant of two polynomials.
template<typename P1, typename P2>
P1::coef_type resultant_nonmodular (const P1 &p1, const P2 &p2)
 Computes the resultant of two polynomials.
template<typename P1, typename P2, typename PCFactory>
P1::coef_type resultant (const P1 &p1, const P2 &p2, PCFactory fctr)
 Computes the resultant of two polynomials.
template<typename P1, typename P2>
P1::coef_type resultant (const P1 &p1, const P2 &p2)
 Computes the resultant of two polynomials.
template<typename A, typename F, typename Q, typename E, typename Ctrler>
void skeleton (A &a, F &f, Q &q, E &e, const Ctrler &ctrler)
 The algorithm for double-description of a polyhedal cone.
template<typename A, typename F, typename Q, typename E>
void skeleton (A &a, F &f, Q &q, E &e)
 The algorithm for double-description of a polyhedal cone.
template<typename MA, typename MB, typename MP, typename MQ, typename Rank, typename T_det, typename T_factory, typename Ctrler, typename Norm>
void smith (const MA &A, MB &B, MP &P, MQ &Q, Rank &rank, T_det &det, const T_factory &tfctr, Ctrler ctrler, Norm norm)
 Produces normal diagonal form B of integer matrix A.
template<typename MA, typename MB, typename MP, typename MQ, typename Rank, typename T_det, typename Ctrler>
void smith (const MA &A, MB &B, MP &P, MQ &Q, Rank &rank, T_det &det, Ctrler ctrler)
 Produces normal diagonal form B of integer matrix A.
template<typename MA, typename MB, typename MP, typename MQ, typename Rank, typename T_det>
void smith (const MA &A, MB &B, MP &P, MQ &Q, Rank &rank, T_det &det)
 Produces normal diagonal form B of integer matrix A.
template<typename M>
smith (const M &a)
 Produces normal diagonal form B of integer matrix A.
template<typename MA, typename MB, typename MP, typename MQ, typename Rank, typename T_det>
void smith_storjohann (const MA &A, MB &B, MP &P, MQ &Q, Rank &rank, T_det &det)
 Produces normal diagonal form B of integer matrix A.
template<typename MA, typename MB, typename MP, typename MQ, typename Rank, typename T_det>
void smith_near_optimal (const MA &A, MB &B, MP &P, MQ &Q, Rank &rank, T_det &det)
 Produces normal diagonal form B of integer matrix A.
template<typename A, typename B, typename GX, typename Offset>
solve_linsys_result solve_linsys (const A &a, const B &b, Offset &offset, GX &gx)
 Solve heterogeneous linear system.
template<typename A, typename B, typename X>
solve_linsys_result solve_linsys (const A &a, const B &b, X &x)
 Solve a heterogeneous linear system.
template<typename A, typename B>
solve_linsys (const A &a, const B &b)
 Solve a heterogeneous linear system.
template<typename A>
solve_linsys (const A &a)
 Solve a homogeneous linear system.
template<typename F, typename I>
bool is_unit (const monom< F, I > &x)
template<typename F, typename I>
bool is_opposite_unit (const monom< F, I > &x)
template<typename F, typename I>
bool is_null (const monom< F, I > &x)
template<typename F, typename I>
monom< F, I > opposite (const monom< F, I > &x)
template<typename F, typename I>
monom< F, I > & opposite (const monom< F, I > &x, monom< F, I > *y)
template<typename F, typename I>
monom< F, I > & opposite (monom< F, I > *x)
template<typename F, typename I>
monom< F, I > inverse (const monom< F, I > &x)
template<typename F, typename I>
monom< F, I > & inverse (const monom< F, I > &x, monom< F, I > *y)
template<typename F, typename I>
monom< F, I > & inverse (monom< F, I > *x)
template<typename F, typename I>
std::ostream & output_polynom_first (std::ostream &out, const monom< F, I > &x)
template<typename F, typename I>
std::ostream & output_polynom_internal (std::ostream &out, const monom< F, I > &x)
template<typename F, typename I>
std::ostream & output_pow (std::ostream &out, const monom< F, I > &x)
template<typename F, typename I>
std::istream & input_polynom_first (std::istream &in, monom< F, I > &x)
template<typename F, typename I>
std::istream & input_polynom_internal (std::istream &in, monom< F, I > &x)
template<typename F, typename I>
std::istream & input_pow (std::istream &in, monom< F, I > &x)
template<typename F1, typename I1, typename F2, typename I2>
int cmp (const monom< F1, I1 > &m1, const monom< F2, I2 > &m2)
template<typename F1, typename I1, typename F2>
int cmp (const monom< F1, I1 > &m1, const F2 &b)
template<typename F1, typename F2, typename I2>
int cmp (const F1 &a, const monom< F2, I2 > &m2)
template<typename F, typename I, typename Factory_coef>
int sign (const monom< F, I > &x)
 Determines the sign of monom, i.e. sign of the its coefficient.
template<typename Ch, typename ChT, typename F, typename I>
std::basic_ostream< Ch, ChT > & output_list (std::basic_ostream< Ch, ChT > &out, const monom< F, I > &x, 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 of monom.
template<typename Ch, typename ChT, typename F, typename I>
std::basic_ostream< Ch, ChT > & output_var (std::basic_ostream< Ch, ChT > &out, const monom< F, I > &x, bool first_a=true, const char *var=monom_output_var_var_default, const char *mul=monom_output_var_mul_default, const char *pow=monom_output_var_pow_default)
 Выводит моном в привычном виде, с указанием формальной переменной.
template<typename Ch, typename ChT, typename F, typename I>
std::basic_istream< Ch, ChT > & input_list (std::basic_istream< Ch, ChT > &in, monom< F, I > &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 intputting for monom.
template<typename Ch, typename ChT, typename F, typename I, typename Factory_coef>
std::basic_istream< Ch, ChT > & input_var (std::basic_istream< Ch, ChT > &in, monom< F, I > &x, bool first_a, const Factory_coef &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 with variable symbol for monom.
template<typename Ch, typename ChT, typename F, typename I>
std::basic_istream< Ch, ChT > & input_var (std::basic_istream< Ch, ChT > &in, monom< F, I > &x, bool first_a=true, 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 with variable symbol for monom.
template<typename Ch, typename ChT, typename F, typename I>
std::basic_ostream< Ch, ChT > & output_aligned (std::basic_ostream< Ch, ChT > &out, const monom< F, I > &x, bool first_a=true, 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 monom in aligned form. (Restricted implementation.).
template<typename F, typename I, typename Ch, typename ChT>
std::basic_ostream< Ch, ChT > & operator<< (std::basic_ostream< Ch, ChT > &out, const monom< F, I > &x)
 Стандартный способ вывода монома: совпадает с output_var.
template<typename F, typename I, typename Ch, typename ChT>
std::basic_istream< Ch, ChT > & operator>> (std::basic_istream< Ch, ChT > &in, monom< F, I > &x)
 Стандартный способ ввода монома: совпадает с input_var.
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
int cmp (const sparse_polynom< F1, I1, REFCNT1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b)
 Lexicographical comparision of two polynomials.
template<typename F, typename I, bool REFCNT>
bool is_primitive (const sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
bool is_unit (const sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
bool is_opposite_unit (const sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
bool is_null (const sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT > opposite (const sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT > & opposite (const sparse_polynom< F, I, REFCNT > &x, sparse_polynom< F, I, REFCNT > *y)
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT > & opposite (sparse_polynom< F, I, REFCNT > *x)
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT > inverse (const sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT > & inverse (const sparse_polynom< F, I, REFCNT > &x, sparse_polynom< F, I, REFCNT > *y)
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT > & inverse (sparse_polynom< F, I, REFCNT > *x)
template<typename F, typename I, bool REFCNT>
std::ostream & output_polynom_first (std::ostream &out, const sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
std::ostream & output_polynom_internal (std::ostream &out, const sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
std::ostream & output_pow (std::ostream &out, const sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
std::istream & input_polynom_first (std::istream &in, sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
std::istream & input_polynom_internal (std::istream &in, sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
std::istream & input_pow (std::istream &in, sparse_polynom< F, I, REFCNT > &x)
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT > euclid (sparse_polynom< F, I, REFCNT > a, sparse_polynom< F, I, REFCNT > b)
 Specialization of euclid for sparse_polynom.
template<typename F, typename I, bool REFCNT>
bool is_coprime (const sparse_polynom< F, I, REFCNT > &a, const sparse_polynom< F, I, REFCNT > &b)
 Specialization of is_coprime for sparse_polynom.
template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2, typename Q, typename R>
void prdivide (const sparse_polynom< F1, I1, REFCNT1 > &a, const sparse_polynom< F2, I2, REFCNT2 > &b, Q &q, R &r)
template<typename F1, typename I1, bool REFCNT1, typename I2>
sparse_polynom< F1, I1, REFCNT1 > pow (const sparse_polynom< F1, I1, REFCNT1 > &a, const I2 &n)
template<typename F, typename I>
monom< F, I > abs (const monom< F, I > &x)
 Absolute value for monom.
template<typename F, typename I, bool REFCNT>
sparse_polynom< F, I, REFCNT > abs (const sparse_polynom< F, I, REFCNT > &x)
 Absolute value for polynomial.
template<typename T>
sin (const T &x)
template<typename T>
cos (const T &x)
template<typename T>
tan (const T &x)
template<typename T>
sinh (const T &x)
template<typename T>
cosh (const T &x)
template<typename T>
tanh (const T &x)
template<typename T>
asin (const T &x)
template<typename T>
acos (const T &x)
template<typename T>
atan (const T &x)
template<typename T>
abs (const T &x)
template<typename T>
exp (const T &x)
template<typename T>
floor (const T &x)
template<typename T>
ceil (const T &x)
template<typename T>
log (const T &x)
template<typename T>
log10 (const T &x)
template<typename T>
sqrt (const T &x)
template<typename T1, typename T2>
T1 pow (const T1 &x, const T2 &y)
template<typename T1, typename T2>
void swap (T1 &x, T2 &y)
template<typename P, typename SS>
void sturm_diff_sys (const P &p, SS &ss)
 Builds full Sturm system for polynomial.
template<typename SS, typename T>
SS::size_type sturm_sign_changes (const SS &ss, const T &x, int signpx)
 Number of sign changes for Sturm system in point 'x' with precomputed sign.
template<typename SS, typename T>
SS::size_type sturm_sign_changes (const SS &ss, const T &x)
 Number of sign changes for Sturm system in point 'x'.
template<typename SS, typename Seg>
SS::size_type sturm_number_roots (const SS &ss, const Seg &seg)
 Number of roots of polynomial ss.front() on segment 'seg' by Sturm system 'ss'.
template<typename SS, typename SegT, bool SegREFCNT>
vector< typename SS::size_type > sturm_number_roots (const SS &ss, const vector< SegT, SegREFCNT > &lims)
 Vector version of simple sturm_number_roots.
template<typename T, typename P, typename LIMS, typename SegBound>
void sturm (const P &p, LIMS &lims, SegBound bs)
 Real root location for polynomial by the Sturm algorithm on segment bs.
template<typename T, typename P, typename LIMS>
void sturm (const P &p, LIMS &lims)
 All real root location for polynomial by the Sturm algorithm.
template<typename P, typename Lims>
bool interval_root_dichotomy (const P &p, int lsign, Lims &lims)
 Dichotomy of an interval with one root of a polynomial to double precision.
template<typename P, typename Lims, typename T>
bool interval_root_precise (const P &p, Lims &lims, const T &e)
 Fits intervals that located the roots to 'e' precision.
template<typename T, typename P, typename Roots, typename Prec>
void roots_poly_real (const P &p, Roots &roots, Prec &prec, const T &e=null< T >())
 Computes all real roots of polynomial with precision 'e'.
template<typename Out, typename T>
void output_latex_verb (Out &out, const T &x, bool in_math=false, ex_environ_priority eep=eep_alone)
 Verbativ output in LaTeX.
template<typename Out, typename T>
void output_latex (Out &out, const T &x, bool in_math=false, ex_environ_priority eep=eep_alone)
 Outputs the object in LaTeX notation. Common case.
template<typename Out, typename T>
void output_latex_math (Out &out, const T &x, bool in_math=false, ex_environ_priority eep=eep_alone)
 Encloses the standard output of x in $ brackets.
template<typename Out, typename T>
void output_latex (Out &out, const rational< T > &x, bool in_math, ex_environ_priority eep, std::size_t minlensimple, bool externsign=true)
 Outputs a rational in LaTeX notation.
template<typename Out, typename T>
void output_latex (Out &out, const rational< T > &x, bool in_math, ex_environ_priority eep)
template<typename Out, typename T>
void output_latex (Out &out, const rational< T > &x, bool in_math)
template<typename Out, typename T>
void output_latex (Out &out, const rational< T > &x)
template<typename Out, typename T, bool REFCNT>
void output_latex (Out &out, const vector< T, REFCNT > &x, bool in_math, ex_environ_priority eep, bool hor, const char *first_bracket="(", const char *second_bracket=")", const char *delim=",")
 Outputs a vector in LaTeX notation.
template<typename Out, typename T, bool REFCNT>
void output_latex (Out &out, const vector< T, REFCNT > &x, bool in_math, ex_environ_priority eep)
template<typename Out, typename T, bool REFCNT>
void output_latex (Out &out, const vector< T, REFCNT > &x, bool in_math)
template<typename Out, typename T, bool REFCNT>
void output_latex (Out &out, const vector< T, REFCNT > &x)
template<typename Out, typename T, bool REFCNT>
void output_latex (Out &out, const matrix< T, REFCNT > &x, bool in_math, ex_environ_priority eep, bool transposed, const char *first_bracket="(", const char *second_bracket=")")
 Outputs a matrix in LaTeX notation.
template<typename Out, typename T, bool REFCNT>
void output_latex (Out &out, const matrix< T, REFCNT > &x)
template<typename Out, typename T, bool REFCNT>
void output_latex (Out &out, const matrix< T, REFCNT > &x, bool in_math)
template<typename Out, typename T, bool REFCNT>
void output_latex (Out &out, const matrix< T, REFCNT > &x, bool in_math, ex_environ_priority eep)
template<typename Out, typename F, typename I>
void output_latex (Out &out, const monom< F, I > &x, bool in_math, ex_environ_priority eep, bool first, const char *var="x")
 Outputs a monom in LaTeX notation.
template<typename Out, typename F, typename I>
void output_latex (Out &out, const monom< F, I > &x, bool in_math, ex_environ_priority eep)
template<typename Out, typename F, typename I>
void output_latex (Out &out, const monom< F, I > &x, bool in_math)
template<typename Out, typename F, typename I>
void output_latex (Out &out, const monom< F, I > &x)
template<typename Out, typename F, typename I, bool REFCNT>
void output_latex (Out &out, const sparse_polynom< F, I, REFCNT > &x, bool in_math, ex_environ_priority eep, const char *var)
 Outputs a sparse_polynom in LaTeX notation.
template<typename Out, typename F, typename I, bool REFCNT>
void output_latex (Out &out, const sparse_polynom< F, I, REFCNT > &x, bool in_math, ex_environ_priority eep)
template<typename Out, typename F, typename I, bool REFCNT>
void output_latex (Out &out, const sparse_polynom< F, I, REFCNT > &x, bool in_math)
template<typename Out, typename F, typename I, bool REFCNT>
void output_latex (Out &out, const sparse_polynom< F, I, REFCNT > &x)
template<typename T, bool REFCNT, typename Ch, typename ChT, typename In_hor, typename In_ver, typename In_box>
void output_latex_matrix_frames (std::basic_ostream< Ch, ChT > &out, const matrix< T, REFCNT > &x, const matrix_frames< In_hor, In_ver, In_box > &mf, bool in_math=false, bool transposed=false, const char *first_bracket="(", const char *second_bracket=")")
 Outputs a matrix in LaTeX notation with lines and boxes.
template<typename Q, typename Dim1, typename TR, typename Dim2, typename Ctrler>
void triangulate_simple_1 (const Q &q, const Dim1 &dim, TR &tr, const Dim2 &subspdim, Ctrler ctrler)
 Triangulates a cone with structure matrix q.
template<typename Q, typename Dim1, typename TR, typename Dim2>
void triangulate_simple_1 (const Q &q, const Dim1 &dim, TR &tr, const Dim2 &subspdim)
 Triangulates a cone with the relations matrix q.
template<typename Q, typename Dim1, typename TR>
void triangulate_simple_1 (const Q &q, const Dim1 &dim, TR &tr)
 Triangulates a pointed cone with the relations matrix q.
template<typename Vec, typename Index>
cnc_reference< Vec >::type vec_operator_sqbrackets_index_vector (Vec *vec, const Index &ind, const type_category::integer &)
template<typename Vec, typename Index>
indexed_subvector< Vec, vector<
typename Vec::size_type > > 
vec_operator_sqbrackets_index_vector (Vec *vec, const Index &ind, const type_category::string &)
template<typename Vec, typename Index>
indexed_subvector< Vec, Index > vec_operator_sqbrackets_index_vector (Vec *vec, const Index &ind, const type_category::type &)
template<typename Vec, typename UFunc>
void apply1_wores_vec (Vec &a, UFunc f)
template<typename Vec1, typename Vec2, typename BinOp>
void apply2_wores_vec_by_vec (Vec1 &a, Vec2 &b, BinOp f)
template<typename Vec, typename Val, typename BinOp>
void apply2_wores_vec_by_val (Vec &a, Val &b, BinOp f)
template<typename Val, typename Vec, typename BinOp>
void apply2_wores_val_by_vec (Val &a, Vec &b, BinOp f)
template<typename Vec1, typename Vec2, typename VecRes, typename Func2>
VecRes & apply2_vec_by_vec (const Vec1 &a, const Vec2 &b, VecRes &res, Func2 f)
template<typename Vec1, typename Vec2, typename Func2>
Vec1 apply2_vec_by_vec (const Vec1 &a, const Vec2 &b, Func2 f)
template<typename Vec, typename Val, typename VecRes, typename Func2>
VecRes & apply2_vec_by_val (const Vec &a, const Val &b, VecRes &res, Func2 f)
template<typename Vec, typename Val, typename Func2>
Vec apply2_vec_by_val (const Vec &a, const Val &b, Func2 f)
template<typename Val, typename Vec, typename VecRes, typename Func2>
VecRes & apply2_val_by_vec (const Val &a, const Vec &b, VecRes &res, Func2 f)
template<typename Val, typename Vec, typename Func2>
Vec apply2_val_by_vec (const Val &a, const Vec &b, Func2 f)
template<typename Vec1, typename Vec2, typename VecRes, typename Func3>
VecRes & apply3_vec_by_vec (const Vec1 &a, const Vec2 &b, VecRes &res, Func3 f)
template<typename Vec1, typename Vec2, typename Func3>
Vec1 apply3_vec_by_vec (const Vec1 &a, const Vec2 &b, Func3 f)
template<typename Vec, typename Val, typename VecRes, typename Func3>
VecRes & apply3_vec_by_val (const Vec &a, const Val &b, VecRes &res, Func3 f)
template<typename Vec, typename Val, typename Func3>
Vec apply3_vec_by_val (const Vec &a, const Val &b, Func3 f)
template<typename Val, typename Vec, typename VecRes, typename Func3>
VecRes & apply3_val_by_vec (const Val &a, const Vec &b, VecRes &res, Func3 f)
template<typename Val, typename Vec, typename Func3>
Vec apply3_val_by_vec (const Val &a, const Vec &b, Func3 f)
template<typename Vec1, typename Vec2, typename Cmp>
int cmp_vec_by_vec (const Vec1 &a, const Vec2 &b, Cmp cmp)
template<typename Vec, typename Val, typename Cmp>
int cmp_vec_by_val (const Vec &a, const Val &val, Cmp cmp)
template<typename Val, typename Vec, typename Cmp>
int cmp_val_by_vec (const Val &val, const Vec &a, Cmp cmp)
template<typename Vec1, typename Vec2>
int cmpdef_vec_by_vec (const Vec1 &a, const Vec2 &b)
template<typename Vec, typename Val>
int cmpdef_vec_by_val (const Vec &a, const Val &val)
template<typename Val, typename Vec>
int cmpdef_val_by_vec (const Val &val, const Vec &a)
template<typename Vec1, typename Vec2, typename Cmp>
bool allcmp_vec_by_vec (const Vec1 &a, const Vec2 &b, Cmp cmp)
template<typename Vec, typename Val, typename Cmp>
bool allcmp_vec_by_val (const Vec &a, const Val &val, Cmp cmp)
template<typename Val, typename Vec, typename Cmp>
bool allcmp_val_by_vec (const Val &val, const Vec &a, Cmp cmp)
template<typename Vec1, typename Vec2, typename Cmp>
Vec1::template other_element_type_refcnt<
bool, true >::type 
eachcmp_vec_by_vec (const Vec1 &a, const Vec2 &b, Cmp cmp)
template<typename Vec, typename Val, typename Cmp>
Vec::template other_element_type_refcnt<
bool, true >::type 
eachcmp_vec_by_val (const Vec &a, const Val &val, Cmp cmp)
template<typename Val, typename Vec, typename Cmp>
Vec::template other_element_type_refcnt<
bool, true >::type 
eachcmp_val_by_vec (const Val &val, const Vec &a, Cmp cmp)
template<typename Vec1, typename Vec2, typename Cmp>
Vec1::template other_element_type_refcnt<
int, true >::type 
elwisecmp_vec_by_vec (const Vec1 &a, const Vec2 &b, Cmp cmp)
template<typename Vec, typename Val, typename Cmp>
Vec::template other_element_type_refcnt<
int, true >::type 
elwisecmp_vec_by_val (const Vec &a, const Val &val, Cmp cmp)
template<typename Val, typename Vec, typename Cmp>
Vec::template other_element_type_refcnt<
int, true >::type 
elwisecmp_val_by_vec (const Val &val, const Vec &a, Cmp cmp)
template<typename Index, typename T>
bool all_in_range (const Index &ind, const T &left, const T &right)
template<typename Out, typename Vec>
Out & vec_output_list (Out &out, const Vec &x, const char *first_bracket=vector_output_list_first_bracket_default, const char *second_bracket=vector_output_list_second_bracket_default, const char *separator=vector_output_list_separator_default)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_plus (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_minus (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_multiplies (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_divides (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_modulus (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_bitwise_or (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_bitwise_and (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_bitwise_xor (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_shift_left (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > & left_assign_shift_right (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T1_factory>
T1 dotprod (const vector< T1, REFCNT1 > &a, const vector< T2, REFCNT2 > &b, const T1_factory &t1fctr)
 Dot product (scalar product) of two vectors.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
T1 dotprod (const vector< T1, REFCNT1 > &a, const vector< T2, REFCNT2 > &b)
 Dot product (scalar product) of two vectors.
template<typename T, bool REFCNT, typename T2, typename T2_factory>
T2 & product (const vector< T, REFCNT > &x, T2 &res, const T2_factory &t2fctr)
 Multiplies all elements of vector.
template<typename T, bool REFCNT, typename T2, typename T2_factory>
T2 & sum (const vector< T, REFCNT > &x, T2 &res, const T2_factory &t2fctr)
 Sums all elements of vector.
template<typename T, bool REFCNT, typename T2>
T2 & product (const vector< T, REFCNT > &x, T2 &res)
 Multiplies all elements of vector.
template<typename T, bool REFCNT, typename T2>
T2 & sum (const vector< T, REFCNT > &x, T2 &res)
 Sums all elements of vector.
template<typename T, bool REFCNT>
product (const vector< T, REFCNT > &x)
 Multiplies all elements of vector.
template<typename T, bool REFCNT>
sum (const vector< T, REFCNT > &x)
 Sums all elements of vector.
template<typename Out, typename T, bool REFCNT>
Out & output_list (Out &out, const vector< T, REFCNT > &x, const char *first_bracket=vector_output_list_first_bracket_default, const char *second_bracket=vector_output_list_second_bracket_default, const char *separator=vector_output_list_separator_default)
 Simple output of the vector.
template<typename In, typename T, bool REFCNT>
In & input_list (In &in, vector< T, REFCNT > &x, const char *first_bracket=vector_input_list_first_bracket_default, const char *second_bracket=vector_input_list_second_bracket_default, const char *separator=vector_input_list_separator_default, const char *range=vector_input_list_range_default)
 Simple input of the vector.
template<typename T, bool REFCNT>
std::ostream & output_aligned (std::ostream &out, const vector< T, REFCNT > &x, const char *left_col=vector_output_aligned_left_col_default, const char *right_col=vector_output_aligned_right_col_default)
 Aligned output of the vector.
template<typename T, bool REFCNT>
std::ostream & vector_output_row (std::ostream &out, const vector< T, REFCNT > &x)
 Prints vector as a row-vector.
template<typename T, bool REFCNT>
std::ostream & vector_output_col (std::ostream &out, const vector< T, REFCNT > &x)
 Prints vector as a column-vector.
template<typename T, bool REFCNT>
std::ostream & operator<< (std::ostream &out, const vector< T, REFCNT > &x)
 Standard output routine (default type of outputting) for the vector.
template<typename T, bool REFCNT>
std::istream & operator>> (std::istream &in, vector< T, REFCNT > &x)
 Standard input routine (default type of inputting) for the vector.
template<typename T, bool REFCNT>
std::ofstream & operator<< (std::ofstream &out, const vector< T, REFCNT > &x)
 WARNING! TEMPORARY!.
template<typename T, bool REFCNT>
std::ifstream & operator>> (std::ifstream &in, vector< T, REFCNT > &x)
 WARNING! TEMPORARY!.
template<typename T, bool REFCNT>
std::ostringstream & operator<< (std::ostringstream &out, const vector< T, REFCNT > &x)
 WARNING! TEMPORARY!.
template<typename T, bool REFCNT>
std::istringstream & operator>> (std::istringstream &in, vector< T, REFCNT > &x)
 WARNING! TEMPORARY!.
template<typename T, bool REFCNT>
vector< T, REFCNT > opposite (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, REFCNT > & opposite (const vector< T, REFCNT > &x, vector< T, REFCNT > *y)
template<typename T, bool REFCNT>
vector< T, REFCNT > & opposite (vector< T, REFCNT > *x)
template<typename T, bool REFCNT>
vector< T, REFCNT > inverse (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, REFCNT > & inverse (const vector< T, REFCNT > &x, vector< T, REFCNT > *y)
template<typename T, bool REFCNT>
vector< T, REFCNT > & inverse (vector< T, REFCNT > *x)
template<typename T, bool REFCNT>
bool is_unit (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
bool is_opposite_unit (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
bool is_null (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream & output_polynom_first (std::ostream &out, const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream & output_polynom_internal (std::ostream &out, const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream & output_pow (std::ostream &out, const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream & input_polynom_first (std::istream &in, vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream & input_polynom_internal (std::istream &in, vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream & input_pow (std::istream &in, vector< T, REFCNT > &x)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
void fill_subvector (const vector< T1, REFCNT1 > &orig, const vector< T2, REFCNT2 > &indexes, vector< T3, REFCNT3 > &res)
 Makes subvector from another vector and index vector.

Variables

const int PREC_MIN = 2
const unsigned long PREC_MAX = _Internal::max_digit
const unsigned long D_PREC_MAX = ( long ) (_Internal::max_digit * log ( 2.0l ) / log ( 10.0l ))
CCounter counter_big_int_sum_GC
CCounter counter_big_int_mul_GC
CCounter counter_big_int_div_GC
const char * matrix_output_list_first_bracket_default = "("
const char * matrix_output_list_second_bracket_default = ")"
const char * matrix_output_list_row_separator_default = ", "
const char * matrix_output_list_first_row_bracket_default = "("
const char * matrix_output_list_second_row_bracket_default = ")"
const char * matrix_output_list_col_separator_default = ", "
const char * matrix_input_list_first_bracket_default = "("
const char * matrix_input_list_second_bracket_default = ")"
const char * matrix_input_list_row_separator_default = ","
const char * matrix_input_list_first_row_bracket_default = "("
const char * matrix_input_list_second_row_bracket_default = ")"
const char * matrix_input_list_col_separator_default = ","
const char * matrix_output_aligned_left_col_default = "||"
const char * matrix_output_aligned_right_col_default = "||"
const char * matrix_output_aligned_inter_col_default = " "
const colwise_t colwise = colwise_t()
 Helper object for columnwise filling of the matrix.
const diag_t diag = diag_t()
 Helper object for construct a diagonal matrix.
const eye_t eye = eye_t()
 Helper object for construct an indentity matrix.
const frommat_t frommat = frommat_t()
const char * matrix_output_list_first_bracket_default
const char * matrix_output_list_second_bracket_default
const char * matrix_output_list_row_separator_default
const char * matrix_output_list_first_row_bracket_default
const char * matrix_output_list_second_row_bracket_default
const char * matrix_output_list_col_separator_default
const char * matrix_input_list_first_bracket_default
const char * matrix_input_list_second_bracket_default
const char * matrix_input_list_row_separator_default
const char * matrix_input_list_first_row_bracket_default
const char * matrix_input_list_second_row_bracket_default
const char * matrix_input_list_col_separator_default
const char * matrix_output_aligned_left_col_default
const char * matrix_output_aligned_right_col_default
const char * matrix_output_aligned_inter_col_default
const fromempty_t fromempty = fromempty_t()
const fromivert_t fromivert = fromivert_t()
const fromvert_t fromvert = fromvert_t()
const char * rational_output_list_first_bracket_default = "("
const char * rational_output_list_second_bracket_default = ")"
const char * rational_output_list_separator_default = ", "
const char * rational_input_list_first_bracket_default = "("
const char * rational_input_list_second_bracket_default = ")"
const char * rational_input_list_separator_default = ","
const char * rational_output_default_oblique_default = "/"
const char * rational_input_default_oblique_default = "/"
const char * rational_output_list_first_bracket_default
const char * rational_output_list_second_bracket_default
const char * rational_output_list_separator_default
const char * rational_input_list_first_bracket_default
const char * rational_input_list_second_bracket_default
const char * rational_input_list_separator_default
const char * rational_output_default_oblique_default
const char * rational_input_default_oblique_default
const char * monom_input_list_first_bracket_default = "("
const char * monom_output_list_first_bracket_default = "("
const char * monom_input_list_second_bracket_default = ")"
const char * monom_output_list_second_bracket_default = ")"
const char * monom_input_list_separator_default = ","
const char * monom_output_list_separator_default = ", "
const char * monom_input_var_mul_default = "*"
const char * monom_output_var_mul_default = "*"
const char * monom_input_var_var_default = "x"
const char * monom_output_var_var_default = "x"
const char * monom_input_var_pow_default = "^"
const char * monom_output_var_pow_default = "^"
const char * monom_input_list_first_bracket_default
const char * monom_output_list_first_bracket_default
const char * monom_input_list_second_bracket_default
const char * monom_output_list_second_bracket_default
const char * monom_input_list_separator_default
const char * monom_output_list_separator_default
const char * monom_input_var_mul_default
const char * monom_output_var_mul_default
const char * monom_input_var_var_default
const char * monom_output_var_var_default
const char * monom_input_var_pow_default
const char * monom_output_var_pow_default
const char * vector_output_list_first_bracket_default = "("
const char * vector_output_list_second_bracket_default = ")"
const char * vector_output_list_separator_default = ", "
const char * vector_input_list_first_bracket_default = "("
const char * vector_input_list_second_bracket_default = ")"
const char * vector_input_list_separator_default = ","
const char * vector_input_list_range_default = ":"
const char * vector_output_aligned_left_col_default = "||"
const char * vector_output_aligned_right_col_default = "||"
const char * vector_output_list_first_bracket_default
const char * vector_output_list_second_bracket_default
const char * vector_output_list_separator_default
const char * vector_input_list_first_bracket_default
const char * vector_input_list_second_bracket_default
const char * vector_input_list_separator_default
const char * vector_input_list_range_default
const char * vector_output_aligned_left_col_default
const char * vector_output_aligned_right_col_default
const fromseq_t fromseq = fromseq_t()
const fromval_t fromval = fromval_t()
const fromvec_t fromvec = fromvec_t()
const fromsize_t fromsize = fromsize_t()
const fromstr_t fromstr = fromstr_t()


Typedef Documentation

typedef unsigned long long Arageli::counter_t

Definition at line 17 of file counter.hpp.


Enumeration Type Documentation

enum Arageli::interval_kind

Kind of interval.

Enumerator:
interval_empty  empty as a segment
interval_point  point as a segment
interval_length  have a nonzero length

Definition at line 46 of file interval.hpp.

enum Arageli::solve_linsys_result

Enumerator:
SLR_EMPTY 
SLR_UNIQUE 
SLR_MULTIPLE 

Definition at line 43 of file solve_linsys.hpp.

enum Arageli::monoms_order

Enumerator:
mo_inc 
mo_dec 

Definition at line 1733 of file sparse_polynom.hpp.

enum Arageli::ex_environ_priority

Type of environment (context) for an expression.

These values helps to bracket placing in nested expressions.

Enumerator:
eep_alone  an expression is alone (matrix or vector item, power of another expression and so on)
eep_add 
eep_mul  multiplicative context (coefficient of monom with degree that greater than 0 and so on)

Definition at line 42 of file texout.hpp.

enum Arageli::matrix_line_type

Type of a line that used in matrix output functions with boxes and dividing lines.

Enumerator:
mlt_solid  Solid line "_______".
mlt_dot  Dotted line "......." (it's not supported for boxes yet).
mlt_hatch  Hatched line "_ _ _ _" (it's not supported for boxes yet).
mlt_chain  Chain line "_ . _ ." (it's not supported for boxes yet).

Definition at line 364 of file texout.hpp.


Function Documentation

template<typename D1, typename T1>
bool Arageli::is_null ( const _Internal::module_2pm1< D1, T1 > &  a  )  [inline]

Definition at line 222 of file _utility.hpp.

template<typename D1, typename T1>
bool Arageli::is_unit ( const _Internal::module_2pm1< D1, T1 > &  a  )  [inline]

Definition at line 226 of file _utility.hpp.

template<typename T1, typename D2, typename T2>
T1 Arageli::prrem ( const T1 &  aa,
const _Internal::module_2pm1< D2, T2 > &  b 
) [inline]

Definition at line 231 of file _utility.hpp.

template<typename Out, typename D, typename T>
Out& Arageli::operator<< ( Out &  out,
const _Internal::module_2pm1< D, T > &  x 
) [inline]

Definition at line 282 of file _utility.hpp.

template<typename In, typename D, typename T>
In& Arageli::operator>> ( In &  in,
_Internal::module_2pm1< D, T > &  x 
) [inline]

Definition at line 290 of file _utility.hpp.

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> Arageli::operator+ ( algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 320 of file algebraic.hpp.

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> Arageli::operator- ( algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 321 of file algebraic.hpp.

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> Arageli::operator * ( algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 322 of file algebraic.hpp.

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> Arageli::operator/ ( algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 323 of file algebraic.hpp.

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> Arageli::operator% ( algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 324 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator== ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 366 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool Arageli::operator== ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const TS2 &  b 
) [inline]

Definition at line 366 of file algebraic.hpp.

template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator== ( const TS1 &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 366 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator!= ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 367 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool Arageli::operator!= ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const TS2 &  b 
) [inline]

Definition at line 367 of file algebraic.hpp.

template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator!= ( const TS1 &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 367 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator< ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 368 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool Arageli::operator< ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const TS2 &  b 
) [inline]

Definition at line 368 of file algebraic.hpp.

template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator< ( const TS1 &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 368 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator<= ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 369 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool Arageli::operator<= ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const TS2 &  b 
) [inline]

Definition at line 369 of file algebraic.hpp.

template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator<= ( const TS1 &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 369 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator> ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 370 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool Arageli::operator> ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const TS2 &  b 
) [inline]

Definition at line 370 of file algebraic.hpp.

template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator> ( const TS1 &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 370 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator>= ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 371 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool Arageli::operator>= ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const TS2 &  b 
) [inline]

Definition at line 371 of file algebraic.hpp.

template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool Arageli::operator>= ( const TS1 &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 371 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
int Arageli::cmp ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
)

Definition at line 380 of file algebraic.hpp.

template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2>
int Arageli::cmp ( const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  a,
const TP2 &  b 
) [inline]

Definition at line 400 of file algebraic.hpp.

template<typename TP1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
int Arageli::cmp ( const TP1 &  a,
const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &  b 
) [inline]

Definition at line 413 of file algebraic.hpp.

template<typename Out, typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1>
Out& Arageli::operator<< ( Out &  out,
const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &  x 
) [inline]

Definition at line 425 of file algebraic.hpp.

template<typename PolyVec, typename SegVec, typename Rslt, typename P, typename Seg, typename F>
void Arageli::algebraic_func_rslt ( const PolyVec &  polyvec,
SegVec  segvec,
Rslt  rslt,
P &  p,
Seg &  seg,
f 
)

Arbitrary function on algebraic numbers based on precomputed resultant.

template<typename P1, typename Seg1, typename P2, typename Seg2, typename P3, typename Seg3>
void Arageli::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 Arageli::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 Arageli::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 Arageli::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 Arageli::bareiss ( const MA &  A,
MB &  B,
MQ &  Q,
Basis &  basis,
T_det &  det 
)

Produces the Gauss-Jordan form B of an integer matrix A.

Returns B, Q, basis, det:

template<typename MA, typename MP, typename MQ, typename Rank, typename T_det>
void Arageli::bareiss_pq ( const MA &  A,
MP &  P,
MQ &  Q,
Rank &  rank,
T_det &  det 
)

Produces the Gauss form B of an integer matrix A.

Returns P, Q, rank, det:

template<typename MA>
MA Arageli::adjoint ( const MA &  A  ) 

template<typename MA, typename MP, typename T_det>
void Arageli::adjoint ( const MA &  A,
MP &  P,
T_det &  det 
)

template<typename MA>
MA::element_type Arageli::det_brs ( const MA &  A  ) 

template<typename MA>
MA::size_type Arageli::rank_brs ( const MA &  A  ) 

template<typename T, typename Res>
Res& Arageli::indirection ( const T &  x,
Res &  res 
) [inline]

Definition at line 41 of file basefuncs.hpp.

template<typename T, typename Res>
Res& Arageli::address ( const T &  x,
Res &  res 
) [inline]

Definition at line 42 of file basefuncs.hpp.

template<typename T, typename Res>
Res& Arageli::unary_plus ( const T &  x,
Res &  res 
) [inline]

Definition at line 43 of file basefuncs.hpp.

template<typename T, typename Res>
Res& Arageli::unary_minus ( const T &  x,
Res &  res 
) [inline]

Definition at line 44 of file basefuncs.hpp.

template<typename T, typename Res>
Res& Arageli::logical_not ( const T &  x,
Res &  res 
) [inline]

Definition at line 45 of file basefuncs.hpp.

template<typename T, typename Res>
Res& Arageli::bitwise_not ( const T &  x,
Res &  res 
) [inline]

Definition at line 46 of file basefuncs.hpp.

template<typename T, typename Res>
Res& Arageli::prefix_increment ( T &  x,
Res &  res 
) [inline]

Definition at line 51 of file basefuncs.hpp.

template<typename T, typename Res>
Res& Arageli::prefix_decrement ( T &  x,
Res &  res 
) [inline]

Definition at line 55 of file basefuncs.hpp.

template<typename T, typename Res>
Res& Arageli::postfix_increment ( T &  x,
Res &  res 
) [inline]

Definition at line 59 of file basefuncs.hpp.

template<typename T, typename Res>
Res& Arageli::postfix_decrement ( T &  x,
Res &  res 
) [inline]

Definition at line 63 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::plus ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 73 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::minus ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 74 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::multiplies ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 75 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::divides ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 76 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::modulus ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 77 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::logical_or ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 78 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::logical_and ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 79 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::equal_to ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 80 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::not_equal_to ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 81 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::greater ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 82 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::less ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 83 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::greater_equal ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 84 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::less_equal ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 85 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::bitwise_or ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 86 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::bitwise_and ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 87 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::bitwise_xor ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 88 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::shift_left ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 89 of file basefuncs.hpp.

template<typename T1, typename T2, typename Res>
Res& Arageli::shift_right ( const T1 &  x,
const T2 &  y,
Res &  res 
) [inline]

Definition at line 90 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_plus ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 105 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_plus ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 105 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_minus ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 106 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_minus ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 106 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_multiplies ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 107 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_multiplies ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 107 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_divides ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 108 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_divides ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 108 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_modulus ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 109 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_modulus ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 109 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_bitwise_or ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 110 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_bitwise_or ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 110 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_bitwise_and ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 111 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_bitwise_and ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 111 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_bitwise_xor ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 112 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_bitwise_xor ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 112 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_shift_left ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 113 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_shift_left ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 113 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_shift_right ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 114 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_shift_right ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 114 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_logical_or ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 126 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_logical_or ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 126 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_logical_and ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 127 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_logical_and ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 127 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_equal_to ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 128 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::assign_equal_to ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line 128 of file basefuncs.hpp.

template<typename T1, typename T2>
T1& Arageli::right_assign_not_equal_to ( T1 &  x,
const T2 &  y 
) [inline]

Definition at line