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 129 of file basefuncs.hpp.

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

Definition at line 129 of file basefuncs.hpp.

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

Definition at line 130 of file basefuncs.hpp.

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

Definition at line 130 of file basefuncs.hpp.

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

Definition at line 131 of file basefuncs.hpp.

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

Definition at line 131 of file basefuncs.hpp.

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

Definition at line 132 of file basefuncs.hpp.

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

Definition at line 132 of file basefuncs.hpp.

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

Definition at line 133 of file basefuncs.hpp.

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

Definition at line 133 of file basefuncs.hpp.

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

Definition at line 141 of file basefuncs.hpp.

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

Definition at line 142 of file basefuncs.hpp.

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

Definition at line 143 of file basefuncs.hpp.

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

Definition at line 144 of file basefuncs.hpp.

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

Definition at line 145 of file basefuncs.hpp.

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

Definition at line 146 of file basefuncs.hpp.

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

Definition at line 147 of file basefuncs.hpp.

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

Definition at line 148 of file basefuncs.hpp.

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

Definition at line 149 of file basefuncs.hpp.

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

Definition at line 150 of file basefuncs.hpp.

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

Definition at line 151 of file basefuncs.hpp.

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

Definition at line 152 of file basefuncs.hpp.

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

Definition at line 153 of file basefuncs.hpp.

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

Definition at line 154 of file basefuncs.hpp.

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

Definition at line 155 of file basefuncs.hpp.

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

Definition at line 156 of file basefuncs.hpp.

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

Definition at line 157 of file basefuncs.hpp.

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

Definition at line 158 of file basefuncs.hpp.

template<typename T>
T& Arageli::assign_indirection ( T &  x  )  [inline]

Definition at line 165 of file basefuncs.hpp.

template<typename T>
T& Arageli::assign_address ( T &  x  )  [inline]

Definition at line 166 of file basefuncs.hpp.

template<typename T>
T& Arageli::assign_unary_plus ( T &  x  )  [inline]

Definition at line 167 of file basefuncs.hpp.

template<typename T>
T& Arageli::assign_unary_minus ( T &  x  )  [inline]

Definition at line 168 of file basefuncs.hpp.

template<typename T>
T& Arageli::assign_logical_not ( T &  x  )  [inline]

Definition at line 169 of file basefuncs.hpp.

template<typename T>
T& Arageli::assign_bitwise_not ( T &  x  )  [inline]

Definition at line 170 of file basefuncs.hpp.

big_int Arageli::ln1_25 ( std::size_t  kbits  ) 

Returns ln(1.25) with nbits significant bits.

Definition at line 30 of file big_const.cpp.

big_int Arageli::ln1_25_o ( std::size_t  kbits  ) 

Returns ln(1.25) with nbits significant bits with overflow.

Definition at line 54 of file big_const.cpp.

big_int Arageli::ln1_25_u ( std::size_t  kbits  ) 

Returns ln(1.25) with nbits significant bits with imperfection.

Definition at line 59 of file big_const.cpp.

big_int Arageli::ln2 ( std::size_t  kbits  ) 

Returns ln(2) with nbits significant bits.

Definition at line 65 of file big_const.cpp.

big_int Arageli::ln2_u ( std::size_t  kbits  ) 

Returns ln(2) with nbits significant bits with imperfection.

Definition at line 87 of file big_const.cpp.

big_int Arageli::ln2_o ( std::size_t  kbits  ) 

Returns ln(2) with nbits significant bits with oveflow.

Definition at line 92 of file big_const.cpp.

big_int Arageli::log2_10 ( std::size_t  nbits  ) 

Returns log2_10 with nbits significant bits.

Definition at line 99 of file big_const.cpp.

big_int Arageli::log2_10_o ( std::size_t  nbits  ) 

Returns log2_10 with nbits significant bits with oveflow.

Definition at line 105 of file big_const.cpp.

big_int Arageli::log2_10_u ( std::size_t  nbits  ) 

Returns log2_10 with nbits significant bits with imperfection.

Definition at line 110 of file big_const.cpp.

big_int Arageli::lg_2_o ( std::size_t  nbits  ) 

Returns lg2 with nbits significant bits with oveflow.

Definition at line 117 of file big_const.cpp.

big_int Arageli::lg_2_u ( std::size_t  nbits  ) 

Returns lg2 with nbits significant bits with imperfection.

Definition at line 122 of file big_const.cpp.

big_int Arageli::lg_2 ( std::size_t  nbits  ) 

Returns lg2 with nbits significant bits.

Definition at line 127 of file big_const.cpp.

big_int Arageli::exp_u ( big_int  arg,
std::size_t  kbits,
int  factor = 0 
)

Returns exp(arg/2^factor) with nbits significant bits with imperfection.

Definition at line 138 of file big_const.cpp.

big_int Arageli::exp_o ( big_int  arg,
std::size_t  kbits,
int  factor = 0 
)

Returns exp(arg/2^factor) with nbits significant bits with oveflow.

Definition at line 145 of file big_const.cpp.

big_int Arageli::exp ( big_int  arg,
std::size_t  kbits,
int  factor = 0 
)

Returns exp(arg/2^factor) with nbits significant bits.

Definition at line 152 of file big_const.cpp.

big_int Arageli::exp_2_u ( big_int  arg,
std::size_t  kbits,
int  factor = 0 
)

Returns 2^(arg/2^factor) with nbits significant bits with imperfection.

Definition at line 179 of file big_const.cpp.

big_int Arageli::exp_2_o ( big_int  arg,
std::size_t  kbits,
int  factor = 0 
)

Returns 2^(arg/2^factor) with nbits significant bits with oveflow.

Definition at line 184 of file big_const.cpp.

big_int Arageli::exp_2 ( big_int  arg,
std::size_t  kbits,
int  factor = 0 
)

Returns 2^(arg/2^factor) with nbits significant bits.

Definition at line 189 of file big_const.cpp.

big_int Arageli::e_u ( std::size_t  kbits  ) 

Returns e number with nbits significant bits with imperfection.

Definition at line 213 of file big_const.cpp.

big_int Arageli::e_o ( std::size_t  kbits  ) 

Returns e number with nbits significant bits with oveflow.

Definition at line 218 of file big_const.cpp.

big_int Arageli::e ( std::size_t  kbits  ) 

Returns e number with nbits significant bits.

Definition at line 224 of file big_const.cpp.

big_int Arageli::ln10 ( std::size_t  nbits  ) 

Returns ln10 with nbits significant bits.

big_int Arageli::ln10_u ( std::size_t  nbits  ) 

Returns ln10 with nbits significant bits with imperfection.

big_int Arageli::ln10_o ( std::size_t  nbits  ) 

Returns ln10 with nbits significant bits with oveflow.

void Arageli::big_float_warning ( const char *  s  ) 

Definition at line 34 of file big_float.cpp.

void Arageli::big_float_error ( const char *  s  ) 

Definition at line 39 of file big_float.cpp.

void Arageli::big_float_fatal_error ( const char *  s  ) 

Definition at line 44 of file big_float.cpp.

unsigned Arageli::fracsion ( int  n,
unsigned  m 
)

Definition at line 65 of file big_float.cpp.

int Arageli::get_exponent_of_double ( double  d  ) 

Definition at line 72 of file big_float.cpp.

_Internal::digit* Arageli::get_mantissa_of_double ( double  d  ) 

Definition at line 83 of file big_float.cpp.

int Arageli::get_sign ( big_int  s  )  [inline]

Definition at line 120 of file big_float.cpp.

int Arageli::cmp ( const big_float &  a,
const big_float &  b 
)

Returns

Definition at line 447 of file big_float.cpp.

int Arageli::operator== ( const big_float &  a,
const big_float &  b 
)

Definition at line 453 of file big_float.cpp.

int Arageli::operator!= ( const big_float &  a,
const big_float &  b 
)

Definition at line 458 of file big_float.cpp.

int Arageli::operator> ( const big_float &  a,
const big_float &  b 
)

Definition at line 463 of file big_float.cpp.

int Arageli::operator>= ( const big_float &  a,
const big_float &  b 
)

Definition at line 468 of file big_float.cpp.

int Arageli::operator< ( const big_float &  a,
const big_float &  b 
)

Definition at line 473 of file big_float.cpp.

int Arageli::operator<= ( const big_float &  a,
const big_float &  b 
)

Definition at line 478 of file big_float.cpp.

big_float Arageli::operator+ ( const big_float &  a  ) 

Definition at line 499 of file big_float.cpp.

big_float Arageli::operator- ( const big_float &  a  ) 

Definition at line 505 of file big_float.cpp.

big_float Arageli::operator+ ( const big_float &  b,
const big_float &  c 
)

Definition at line 514 of file big_float.cpp.

big_float Arageli::operator- ( const big_float &  b,
const big_float &  c 
)

Definition at line 520 of file big_float.cpp.

big_float Arageli::operator * ( const big_float &  b,
const big_float &  c 
)

Definition at line 526 of file big_float.cpp.

big_float Arageli::operator/ ( const big_float &  b,
const big_float &  c 
)

Definition at line 532 of file big_float.cpp.

big_float Arageli::add ( const big_float &  b,
const big_float &  c 
)

Definition at line 538 of file big_float.cpp.

big_float Arageli::sub ( const big_float &  b,
const big_float &  c 
)

Definition at line 544 of file big_float.cpp.

big_float Arageli::mul ( const big_float &  b,
const big_float &  c 
)

Definition at line 550 of file big_float.cpp.

big_float Arageli::div ( const big_float &  b,
const big_float &  c 
)

Definition at line 556 of file big_float.cpp.

big_float Arageli::add ( const big_float &  b,
const big_float &  c,
long  prec 
)

Definition at line 562 of file big_float.cpp.

big_float Arageli::sub ( const big_float &  b,
const big_float &  c,
long  prec 
)

Definition at line 568 of file big_float.cpp.

big_float Arageli::mul ( const big_float &  b,
const big_float &  c,
long  prec 
)

Definition at line 574 of file big_float.cpp.

big_float Arageli::div ( const big_float &  b,
const big_float &  c,
long  prec 
)

Definition at line 580 of file big_float.cpp.

big_float Arageli::add ( const big_float &  b,
const big_float &  c,
long  prec,
int  mode 
)

Addition. Up to prec binary digits in rounding mode mode. The parameters prec and mode are optional and have the global defult values which can be set by set_global_precision and set_rounding_mode.

Definition at line 586 of file big_float.cpp.

big_float Arageli::sub ( const big_float &  b,
const big_float &  c,
long  prec,
int  mode 
)

Subtraction. Up to prec binary digits in rounding mode mode The parameters prec and mode are optional and have the global defult values which can be set by set_global_precision and set_rounding_mode.

Definition at line 659 of file big_float.cpp.

big_float Arageli::mul ( const big_float &  b,
const big_float &  c,
long  prec,
int  mode 
)

Multiplication. Up to prec binary digits in rounding mode mode The parameters prec and mode are optional and have the global defult values which can be set by set_global_precision and set_rounding_mode.

Definition at line 668 of file big_float.cpp.

big_float Arageli::div ( const big_float &  b,
const big_float &  c,
long  prec,
int  mode 
)

Divizion. Up to prec binary digits The parameters prec and mode are optional and have the global defult values which can be set by set_global_precision

Definition at line 714 of file big_float.cpp.

big_float Arageli::divnu ( const big_float &  b,
const big_float &  c,
long  prec,
int  mode 
)

Definition at line 731 of file big_float.cpp.

big_float Arageli::div_i ( const big_int &  c  ) 

Definition at line 759 of file big_float.cpp.

void Arageli::reduce_final_zeros ( std::basic_string< char > &  str  ) 

Definition at line 813 of file big_float.cpp.

std::istream& Arageli::operator>> ( std::istream &  is,
big_float &  fnum 
)

Definition at line 826 of file big_float.cpp.

std::ostream& Arageli::operator<< ( std::ostream &  os,
const big_float &  fnum 
)

Definition at line 914 of file big_float.cpp.

big_float Arageli::ceil ( const big_float &  a  ) 

Definition at line 1128 of file big_float.cpp.

big_float Arageli::floor ( const big_float &  a  ) 

Definition at line 1150 of file big_float.cpp.

big_float Arageli::frac ( const big_float &  a  ) 

Definition at line 1173 of file big_float.cpp.

big_int Arageli::iceil ( const big_float &  a  ) 

Definition at line 1187 of file big_float.cpp.

big_int Arageli::ifloor ( const big_float &  a  ) 

Definition at line 1208 of file big_float.cpp.

big_float Arageli::fsqrt ( const big_float &  b  ) 

Definition at line 1228 of file big_float.cpp.

big_float Arageli::fsqrt ( const big_float &  bf,
long  prec 
)

Definition at line 1235 of file big_float.cpp.

big_float Arageli::fsqrt ( const big_float &  bf,
long  prec,
int  mode 
)

Square rooting. Up to prec binary digits The parameters prec and mode are optional and have the global defult values which can be set by set_global_precision.

Definition at line 1240 of file big_float.cpp.

big_float Arageli::nfsqrt ( const big_float &  bf,
long  prec,
int  mode 
)

Definition at line 1271 of file big_float.cpp.

big_float Arageli::frandom ( long  prec  ) 

Definition at line 1299 of file big_float.cpp.

big_float Arageli::frandom (  ) 

Definition at line 1305 of file big_float.cpp.

big_float Arageli::frandom1 ( long  bits,
const big_int &  exp = 0 
)

Definition at line 1310 of file big_float.cpp.

big_float Arageli::abs ( const big_float &  x  )  [inline]

Definition at line 240 of file big_float.hpp.

template<typename Outiter>
void Arageli::generate_range_helper ( big_float &  t1,
const big_float &  t2,
Outiter  outiter 
) [inline]

Definition at line 245 of file big_float.hpp.

big_float& Arageli::operator+= ( big_float &  b,
const big_float &  c 
) [inline]

Definition at line 249 of file big_float.hpp.

big_float& Arageli::operator-= ( big_float &  b,
const big_float &  c 
) [inline]

Definition at line 252 of file big_float.hpp.

big_float& Arageli::operator *= ( big_float &  b,
const big_float &  c 
) [inline]

Definition at line 255 of file big_float.hpp.

big_float& Arageli::operator/= ( big_float &  b,
const big_float &  c 
) [inline]

Definition at line 258 of file big_float.hpp.

void Arageli::big_arith_error ( const char *  s  ) 

Definition at line 333 of file big_int.cpp.

void Arageli::calc_bdn_radix ( digit  radix,
digit bdn_radix,
std::size_t &  chars_per_digit 
)

Definition at line 425 of file big_int.cpp.

big_int Arageli::operator+ ( const big_int &  b,
const big_int &  c 
)

Definition at line 550 of file big_int.cpp.

big_int Arageli::operator- ( const big_int &  b,
const big_int &  c 
)

Definition at line 625 of file big_int.cpp.

big_int Arageli::operator * ( const big_int &  b,
const big_int &  c 
)

Definition at line 636 of file big_int.cpp.

big_int Arageli::operator% ( const big_int &  b,
const big_int &  c 
)

Definition at line 762 of file big_int.cpp.

big_int Arageli::operator/ ( const big_int &  b,
const big_int &  c 
)

Definition at line 770 of file big_int.cpp.

int Arageli::cmp ( const big_int &  a,
const big_int &  b 
)

Compares two big integers.

Returns

Definition at line 785 of file big_int.cpp.

digit Arageli::random_digit (  ) 

Definition at line 826 of file big_int.cpp.

digit Arageli::stream_radix ( std::ios &  s  ) 

Definition at line 921 of file big_int.cpp.

std::ostream & Arageli::operator<< ( std::ostream &  s,
const big_int &  x 
)

Reads a number from a string notation.

Definition at line 930 of file big_int.cpp.

void Arageli::set_stream_radix ( std::ios &  s,
digit  radix 
) [inline]

Definition at line 978 of file big_int.cpp.

std::istream & Arageli::operator>> ( std::istream &  s,
big_int &  x 
)

Writes a number to a string notation.

Definition at line 990 of file big_int.cpp.

big_int Arageli::operator<< ( const big_int &  a,
std::size_t  n 
)

Definition at line 1281 of file big_int.cpp.

big_int Arageli::operator>> ( const big_int &  a,
std::size_t  n 
)

Definition at line 1319 of file big_int.cpp.

big_int Arageli::operator & ( const big_int &  a,
const big_int &  b 
)

Definition at line 1355 of file big_int.cpp.

std::size_t Arageli::nbits ( const big_int &  x  )  [inline]

Returns the number of bits in number. The same as big_int::length.

Definition at line 469 of file big_int.hpp.

template<typename TT>
int Arageli::sign ( const big_int &  x  )  [inline]

Definition at line 489 of file big_int.hpp.

big_int Arageli::operator| ( const big_int &  a,
const big_int &  b 
)

big_int Arageli::operator^ ( const big_int &  a,
const big_int &  b 
)

template<typename T>
big_int Arageli::operator<< ( const big_int &  a,
const T &  b 
) [inline]

Requirements: b is representable as std::size_t.

Definition at line 512 of file big_int.hpp.

template<typename T>
big_int Arageli::operator>> ( const big_int &  a,
const T &  b 
) [inline]

Requirements: b is representable as std::size_t.

Definition at line 517 of file big_int.hpp.

template<typename T>
big_int& Arageli::operator<<= ( big_int &  a,
const T &  b 
) [inline]

Definition at line 521 of file big_int.hpp.

big_int& Arageli::operator>>= ( big_int &  a,
std::size_t  b 
) [inline]

Definition at line 524 of file big_int.hpp.

template<typename T>
big_int& Arageli::operator>>= ( big_int &  a,
const T &  b 
) [inline]

Definition at line 546 of file big_int.hpp.

void Arageli::divide ( const big_int &  a,
const big_int &  b,
big_int &  q,
big_int &  r 
) [inline]

Divizion with quotient and remainder.

Divides a by b and stores quotient in q and remainder in r.

Parameters:
a a dividend
b a divizor, b must not be a zero
q a quotient
r a remainder

Definition at line 560 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  a,
const big_int &  b 
) [inline]

Definition at line 571 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  a,
const big_int &  b 
) [inline]

Definition at line 572 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  a,
const big_int &  b 
) [inline]

Definition at line 573 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  a,
const big_int &  b 
) [inline]

Definition at line 574 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  a,
const big_int &  b 
) [inline]

Definition at line 575 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  a,
const big_int &  b 
) [inline]

Definition at line 576 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
const big_int &  c 
) [inline]

Definition at line 594 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
const big_int &  c 
) [inline]

Definition at line 595 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
const big_int &  c 
) [inline]

Definition at line 596 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
const big_int &  c 
) [inline]

Definition at line 597 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
const big_int &  c 
) [inline]

Definition at line 598 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
char  c 
) [inline]

Definition at line 712 of file big_int.hpp.

char& Arageli::operator+= ( char &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
signed char  c 
) [inline]

Definition at line 712 of file big_int.hpp.

signed char& Arageli::operator+= ( signed char &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
unsigned char  c 
) [inline]

Definition at line 712 of file big_int.hpp.

unsigned char& Arageli::operator+= ( unsigned char &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
signed short  c 
) [inline]

Definition at line 712 of file big_int.hpp.

signed short& Arageli::operator+= ( signed short &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
unsigned short  c 
) [inline]

Definition at line 712 of file big_int.hpp.

unsigned short& Arageli::operator+= ( unsigned short &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
signed int  c 
) [inline]

Definition at line 712 of file big_int.hpp.

signed int& Arageli::operator+= ( signed int &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
unsigned int  c 
) [inline]

Definition at line 712 of file big_int.hpp.

unsigned int& Arageli::operator+= ( unsigned int &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
signed long  c 
) [inline]

Definition at line 712 of file big_int.hpp.

signed long& Arageli::operator+= ( signed long &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
unsigned long  c 
) [inline]

Definition at line 712 of file big_int.hpp.

unsigned long& Arageli::operator+= ( unsigned long &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
bool  c 
) [inline]

Definition at line 712 of file big_int.hpp.

bool& Arageli::operator+= ( bool &  b,
const big_int &  c 
) [inline]

Definition at line 712 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
char  c 
) [inline]

Definition at line 713 of file big_int.hpp.

char& Arageli::operator-= ( char &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
signed char  c 
) [inline]

Definition at line 713 of file big_int.hpp.

signed char& Arageli::operator-= ( signed char &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
unsigned char  c 
) [inline]

Definition at line 713 of file big_int.hpp.

unsigned char& Arageli::operator-= ( unsigned char &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
signed short  c 
) [inline]

Definition at line 713 of file big_int.hpp.

signed short& Arageli::operator-= ( signed short &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
unsigned short  c 
) [inline]

Definition at line 713 of file big_int.hpp.

unsigned short& Arageli::operator-= ( unsigned short &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
signed int  c 
) [inline]

Definition at line 713 of file big_int.hpp.

signed int& Arageli::operator-= ( signed int &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
unsigned int  c 
) [inline]

Definition at line 713 of file big_int.hpp.

unsigned int& Arageli::operator-= ( unsigned int &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
signed long  c 
) [inline]

Definition at line 713 of file big_int.hpp.

signed long& Arageli::operator-= ( signed long &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
unsigned long  c 
) [inline]

Definition at line 713 of file big_int.hpp.

unsigned long& Arageli::operator-= ( unsigned long &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
bool  c 
) [inline]

Definition at line 713 of file big_int.hpp.

bool& Arageli::operator-= ( bool &  b,
const big_int &  c 
) [inline]

Definition at line 713 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
char  c 
) [inline]

Definition at line 714 of file big_int.hpp.

char& Arageli::operator *= ( char &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
signed char  c 
) [inline]

Definition at line 714 of file big_int.hpp.

signed char& Arageli::operator *= ( signed char &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
unsigned char  c 
) [inline]

Definition at line 714 of file big_int.hpp.

unsigned char& Arageli::operator *= ( unsigned char &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
signed short  c 
) [inline]

Definition at line 714 of file big_int.hpp.

signed short& Arageli::operator *= ( signed short &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
unsigned short  c 
) [inline]

Definition at line 714 of file big_int.hpp.

unsigned short& Arageli::operator *= ( unsigned short &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
signed int  c 
) [inline]

Definition at line 714 of file big_int.hpp.

signed int& Arageli::operator *= ( signed int &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
unsigned int  c 
) [inline]

Definition at line 714 of file big_int.hpp.

unsigned int& Arageli::operator *= ( unsigned int &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
signed long  c 
) [inline]

Definition at line 714 of file big_int.hpp.

signed long& Arageli::operator *= ( signed long &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
unsigned long  c 
) [inline]

Definition at line 714 of file big_int.hpp.

unsigned long& Arageli::operator *= ( unsigned long &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
bool  c 
) [inline]

Definition at line 714 of file big_int.hpp.

bool& Arageli::operator *= ( bool &  b,
const big_int &  c 
) [inline]

Definition at line 714 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
char  c 
) [inline]

Definition at line 715 of file big_int.hpp.

char& Arageli::operator/= ( char &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
signed char  c 
) [inline]

Definition at line 715 of file big_int.hpp.

signed char& Arageli::operator/= ( signed char &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
unsigned char  c 
) [inline]

Definition at line 715 of file big_int.hpp.

unsigned char& Arageli::operator/= ( unsigned char &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
signed short  c 
) [inline]

Definition at line 715 of file big_int.hpp.

signed short& Arageli::operator/= ( signed short &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
unsigned short  c 
) [inline]

Definition at line 715 of file big_int.hpp.

unsigned short& Arageli::operator/= ( unsigned short &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
signed int  c 
) [inline]

Definition at line 715 of file big_int.hpp.

signed int& Arageli::operator/= ( signed int &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
unsigned int  c 
) [inline]

Definition at line 715 of file big_int.hpp.

unsigned int& Arageli::operator/= ( unsigned int &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
signed long  c 
) [inline]

Definition at line 715 of file big_int.hpp.

signed long& Arageli::operator/= ( signed long &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
unsigned long  c 
) [inline]

Definition at line 715 of file big_int.hpp.

unsigned long& Arageli::operator/= ( unsigned long &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
bool  c 
) [inline]

Definition at line 715 of file big_int.hpp.

bool& Arageli::operator/= ( bool &  b,
const big_int &  c 
) [inline]

Definition at line 715 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
float  c 
) [inline]

Definition at line 717 of file big_int.hpp.

float& Arageli::operator+= ( float &  b,
const big_int &  c 
) [inline]

Definition at line 717 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
double  c 
) [inline]

Definition at line 717 of file big_int.hpp.

double& Arageli::operator+= ( double &  b,
const big_int &  c 
) [inline]

Definition at line 717 of file big_int.hpp.

big_int& Arageli::operator+= ( big_int &  b,
long double  c 
) [inline]

Definition at line 717 of file big_int.hpp.

long double& Arageli::operator+= ( long double &  b,
const big_int &  c 
) [inline]

Definition at line 717 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
float  c 
) [inline]

Definition at line 718 of file big_int.hpp.

float& Arageli::operator-= ( float &  b,
const big_int &  c 
) [inline]

Definition at line 718 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
double  c 
) [inline]

Definition at line 718 of file big_int.hpp.

double& Arageli::operator-= ( double &  b,
const big_int &  c 
) [inline]

Definition at line 718 of file big_int.hpp.

big_int& Arageli::operator-= ( big_int &  b,
long double  c 
) [inline]

Definition at line 718 of file big_int.hpp.

long double& Arageli::operator-= ( long double &  b,
const big_int &  c 
) [inline]

Definition at line 718 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
float  c 
) [inline]

Definition at line 719 of file big_int.hpp.

float& Arageli::operator *= ( float &  b,
const big_int &  c 
) [inline]

Definition at line 719 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
double  c 
) [inline]

Definition at line 719 of file big_int.hpp.

double& Arageli::operator *= ( double &  b,
const big_int &  c 
) [inline]

Definition at line 719 of file big_int.hpp.

big_int& Arageli::operator *= ( big_int &  b,
long double  c 
) [inline]

Definition at line 719 of file big_int.hpp.

long double& Arageli::operator *= ( long double &  b,
const big_int &  c 
) [inline]

Definition at line 719 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
float  c 
) [inline]

Definition at line 720 of file big_int.hpp.

float& Arageli::operator/= ( float &  b,
const big_int &  c 
) [inline]

Definition at line 720 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
double  c 
) [inline]

Definition at line 720 of file big_int.hpp.

double& Arageli::operator/= ( double &  b,
const big_int &  c 
) [inline]

Definition at line 720 of file big_int.hpp.

big_int& Arageli::operator/= ( big_int &  b,
long double  c 
) [inline]

Definition at line 720 of file big_int.hpp.

long double& Arageli::operator/= ( long double &  b,
const big_int &  c 
) [inline]

Definition at line 720 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
char  c 
) [inline]

Definition at line 722 of file big_int.hpp.

char& Arageli::operator%= ( char &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
signed char  c 
) [inline]

Definition at line 722 of file big_int.hpp.

signed char& Arageli::operator%= ( signed char &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
unsigned char  c 
) [inline]

Definition at line 722 of file big_int.hpp.

unsigned char& Arageli::operator%= ( unsigned char &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
signed short  c 
) [inline]

Definition at line 722 of file big_int.hpp.

signed short& Arageli::operator%= ( signed short &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
unsigned short  c 
) [inline]

Definition at line 722 of file big_int.hpp.

unsigned short& Arageli::operator%= ( unsigned short &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
signed int  c 
) [inline]

Definition at line 722 of file big_int.hpp.

signed int& Arageli::operator%= ( signed int &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
unsigned int  c 
) [inline]

Definition at line 722 of file big_int.hpp.

unsigned int& Arageli::operator%= ( unsigned int &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
signed long  c 
) [inline]

Definition at line 722 of file big_int.hpp.

signed long& Arageli::operator%= ( signed long &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
unsigned long  c 
) [inline]

Definition at line 722 of file big_int.hpp.

unsigned long& Arageli::operator%= ( unsigned long &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int& Arageli::operator%= ( big_int &  b,
bool  c 
) [inline]

Definition at line 722 of file big_int.hpp.

bool& Arageli::operator%= ( bool &  b,
const big_int &  c 
) [inline]

Definition at line 722 of file big_int.hpp.

big_int Arageli::operator+ ( char  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
char  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( bool  b,
const big_int &  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
bool  c 
) [inline]

Definition at line 731 of file big_int.hpp.

big_int Arageli::operator- ( char  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
char  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( bool  b,
const big_int &  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
bool  c 
) [inline]

Definition at line 732 of file big_int.hpp.

big_int Arageli::operator * ( char  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
char  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( bool  b,
const big_int &  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
bool  c 
) [inline]

Definition at line 733 of file big_int.hpp.

big_int Arageli::operator/ ( char  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
char  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( bool  b,
const big_int &  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
bool  c 
) [inline]

Definition at line 734 of file big_int.hpp.

big_int Arageli::operator+ ( float  b,
const big_int &  c 
) [inline]

Definition at line 736 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
float  c 
) [inline]

Definition at line 736 of file big_int.hpp.

big_int Arageli::operator+ ( double  b,
const big_int &  c 
) [inline]

Definition at line 736 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
double  c 
) [inline]

Definition at line 736 of file big_int.hpp.

big_int Arageli::operator+ ( long double  b,
const big_int &  c 
) [inline]

Definition at line 736 of file big_int.hpp.

big_int Arageli::operator+ ( const big_int &  b,
long double  c 
) [inline]

Definition at line 736 of file big_int.hpp.

big_int Arageli::operator- ( float  b,
const big_int &  c 
) [inline]

Definition at line 737 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
float  c 
) [inline]

Definition at line 737 of file big_int.hpp.

big_int Arageli::operator- ( double  b,
const big_int &  c 
) [inline]

Definition at line 737 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
double  c 
) [inline]

Definition at line 737 of file big_int.hpp.

big_int Arageli::operator- ( long double  b,
const big_int &  c 
) [inline]

Definition at line 737 of file big_int.hpp.

big_int Arageli::operator- ( const big_int &  b,
long double  c 
) [inline]

Definition at line 737 of file big_int.hpp.

big_int Arageli::operator * ( float  b,
const big_int &  c 
) [inline]

Definition at line 738 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
float  c 
) [inline]

Definition at line 738 of file big_int.hpp.

big_int Arageli::operator * ( double  b,
const big_int &  c 
) [inline]

Definition at line 738 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
double  c 
) [inline]

Definition at line 738 of file big_int.hpp.

big_int Arageli::operator * ( long double  b,
const big_int &  c 
) [inline]

Definition at line 738 of file big_int.hpp.

big_int Arageli::operator * ( const big_int &  b,
long double  c 
) [inline]

Definition at line 738 of file big_int.hpp.

big_int Arageli::operator/ ( float  b,
const big_int &  c 
) [inline]

Definition at line 739 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
float  c 
) [inline]

Definition at line 739 of file big_int.hpp.

big_int Arageli::operator/ ( double  b,
const big_int &  c 
) [inline]

Definition at line 739 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
double  c 
) [inline]

Definition at line 739 of file big_int.hpp.

big_int Arageli::operator/ ( long double  b,
const big_int &  c 
) [inline]

Definition at line 739 of file big_int.hpp.

big_int Arageli::operator/ ( const big_int &  b,
long double  c 
) [inline]

Definition at line 739 of file big_int.hpp.

big_int Arageli::operator% ( char  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
char  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( bool  b,
const big_int &  c 
) [inline]

Definition at line 741 of file big_int.hpp.

big_int Arageli::operator% ( const big_int &  b,
bool  c 
) [inline]

Definition at line 741 of file big_int.hpp.

bool Arageli::operator== ( char  b,
const big_int &  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
char  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator!= ( char  b,
const big_int &  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
char  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator<= ( char  b,
const big_int &  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
char  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator>= ( char  b,
const big_int &  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
char  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator< ( char  b,
const big_int &  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
char  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator> ( char  b,
const big_int &  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
char  c 
) [inline]

Definition at line 759 of file big_int.hpp.

bool Arageli::operator== ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator!= ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator<= ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator>= ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator< ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator> ( signed char  b,
const big_int &  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
signed char  c 
) [inline]

Definition at line 760 of file big_int.hpp.

bool Arageli::operator== ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator!= ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator<= ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator>= ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator< ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator> ( unsigned char  b,
const big_int &  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
unsigned char  c 
) [inline]

Definition at line 761 of file big_int.hpp.

bool Arageli::operator== ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator!= ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator<= ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator>= ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator< ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator> ( signed short  b,
const big_int &  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
signed short  c 
) [inline]

Definition at line 762 of file big_int.hpp.

bool Arageli::operator== ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator!= ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator<= ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator>= ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator< ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator> ( unsigned short  b,
const big_int &  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
unsigned short  c 
) [inline]

Definition at line 763 of file big_int.hpp.

bool Arageli::operator== ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator!= ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator<= ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator>= ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator< ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator> ( signed int  b,
const big_int &  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
signed int  c 
) [inline]

Definition at line 764 of file big_int.hpp.

bool Arageli::operator== ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator!= ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator<= ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator>= ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator< ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator> ( unsigned int  b,
const big_int &  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
unsigned int  c 
) [inline]

Definition at line 765 of file big_int.hpp.

bool Arageli::operator== ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator!= ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator<= ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator>= ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator< ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator> ( signed long  b,
const big_int &  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
signed long  c 
) [inline]

Definition at line 766 of file big_int.hpp.

bool Arageli::operator== ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator!= ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator<= ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator>= ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator< ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator> ( unsigned long  b,
const big_int &  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
unsigned long  c 
) [inline]

Definition at line 767 of file big_int.hpp.

bool Arageli::operator== ( bool  b,
const big_int &  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
bool  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator!= ( bool  b,
const big_int &  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
bool  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator<= ( bool  b,
const big_int &  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
bool  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator>= ( bool  b,
const big_int &  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
bool  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator< ( bool  b,
const big_int &  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
bool  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator> ( bool  b,
const big_int &  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
bool  c 
) [inline]

Definition at line 768 of file big_int.hpp.

bool Arageli::operator== ( float  b,
const big_int &  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
float  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator!= ( float  b,
const big_int &  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
float  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator<= ( float  b,
const big_int &  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
float  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator>= ( float  b,
const big_int &  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
float  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator< ( float  b,
const big_int &  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
float  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator> ( float  b,
const big_int &  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
float  c 
) [inline]

Definition at line 770 of file big_int.hpp.

bool Arageli::operator== ( double  b,
const big_int &  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
double  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator!= ( double  b,
const big_int &  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
double  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator<= ( double  b,
const big_int &  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
double  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator>= ( double  b,
const big_int &  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
double  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator< ( double  b,
const big_int &  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
double  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator> ( double  b,
const big_int &  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
double  c 
) [inline]

Definition at line 771 of file big_int.hpp.

bool Arageli::operator== ( long double  b,
const big_int &  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator== ( const big_int &  b,
long double  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator!= ( long double  b,
const big_int &  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator!= ( const big_int &  b,
long double  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator<= ( long double  b,
const big_int &  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator<= ( const big_int &  b,
long double  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator>= ( long double  b,
const big_int &  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator>= ( const big_int &  b,
long double  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator< ( long double  b,
const big_int &  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator< ( const big_int &  b,
long double  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator> ( long double  b,
const big_int &  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::operator> ( const big_int &  b,
long double  c 
) [inline]

Definition at line 772 of file big_int.hpp.

bool Arageli::is_null ( const big_int &  x  )  [inline]

Definition at line 791 of file big_int.hpp.

bool Arageli::is_unit ( const big_int &  x  )  [inline]

Definition at line 794 of file big_int.hpp.

bool Arageli::is_opposite_unit ( const big_int &  x  )  [inline]

Definition at line 797 of file big_int.hpp.

bool Arageli::is_positive ( const big_int &  x  )  [inline]

Definition at line 800 of file big_int.hpp.

bool Arageli::is_negative ( const big_int &  x  )  [inline]

Definition at line 803 of file big_int.hpp.

bool Arageli::is_even ( const big_int &  x  )  [inline]

Definition at line 806 of file big_int.hpp.

bool Arageli::is_odd ( const big_int &  x  )  [inline]

Definition at line 810 of file big_int.hpp.

template<typename T>
T Arageli::intsqrt ( const T &  a  ) 

Integer square root of a.

Returns the biggest x such that x^2 <= a. Requirement: a is positive.

big_int Arageli::sqrt ( const big_int &  a  )  [inline]

Definition at line 823 of file big_int.hpp.

big_int Arageli::abs ( const big_int &  x  )  [inline]

Returns absolutly value of x.

Definition at line 827 of file big_int.hpp.

big_int Arageli::pow ( const big_int &  x,
int  p 
) [inline]

Raise x in to a power p.

Just uses Arageli::power.

Definition at line 835 of file big_int.hpp.

big_int Arageli::pow ( const big_int &  x,
const big_int &  p 
) [inline]

Raise x in to a power p.

Just uses Arageli::power.

Definition at line 840 of file big_int.hpp.

big_int Arageli::log2 ( const big_int &  x  )  [inline]

Returns the base-2 logarithm of abs(x). If x == 0, returns -1.

Definition at line 844 of file big_int.hpp.

template<typename T1, typename T2>
int Arageli::cmp ( const T1 &  a,
const T2 &  b 
) [inline]

Performs Arageli like comparision.

There is specialization of this function (or an overloaded version) for each main Arageli object. Returns

Definition at line 35 of file cmp.hpp.

template<typename T>
int Arageli::sign ( const T &  x  )  [inline]

Sign of element.

Returns +1, 0 or -1.

Definition at line 50 of file cmp.hpp.

template<typename T>
bool Arageli::is_even ( const T &  x  )  [inline]

Returns true if x is even.

Definition at line 56 of file cmp.hpp.

template<typename T>
bool Arageli::is_odd ( const T &  x  )  [inline]

Returns true if x is odd.

Definition at line 62 of file cmp.hpp.

template<typename T1, typename T2>
bool Arageli::is_divisible ( const T1 &  a,
const T2 &  b 
) [inline]

Returns true if a is divisible by b.

Definition at line 68 of file cmp.hpp.

template<typename T>
bool Arageli::is_positive ( const T &  x  )  [inline]

Returns true if x is greater then null.

Definition at line 74 of file cmp.hpp.

template<typename T>
bool Arageli::is_negative ( const T &  x  )  [inline]

Returns true if x is less then null.

Definition at line 79 of file cmp.hpp.

template<typename T>
bool Arageli::is_integer ( const T &  x  )  [inline]

Returns true if x is integer.

Definition at line 85 of file cmp.hpp.

template<typename Out, typename T, typename M, typename CFG>
void Arageli::output_list ( Out &  out,
const cone< T, M, CFG > &  x 
)

template<typename Out, typename T, typename M, typename CFG>
Out& Arageli::operator<< ( Out &  out,
const cone< T, M, CFG > &  x 
) [inline]

Definition at line 739 of file cone.hpp.

template<typename T1, typename M1, typename CFG1, typename T2, typename M2, typename CFG2>
cone<T1, M1, CFG1> Arageli::intersection ( cone< T1, M1, CFG1 >  a,
const cone< T2, M2, CFG2 > &  b 
) [inline]

Definition at line 750 of file cone.hpp.

template<typename T1, typename M1, typename CFG1, typename T2, typename M2, typename CFG2>
cone<T1, M1, CFG1> Arageli::cone_union ( cone< T1, M1, CFG1 >  a,
const cone< T2, M2, CFG2 > &  b 
) [inline]

Definition at line 763 of file cone.hpp.

template<typename T1, typename M1, typename CFG1, typename T2, typename M2, typename CFG2>
int Arageli::cmp ( const cone< T1, M1, CFG1 > &  a,
const cone< T2, M2, CFG2 > &  b 
)

Definition at line 776 of file cone.hpp.

std::ostream& Arageli::operator<< ( std::ostream &  out,
const exception &  e 
) [inline]

Definition at line 83 of file exception.hpp.

template<typename T>
const T& Arageli::unit (  )  [inline]

åäèíè÷íûé ýëåìåíò

Definition at line 85 of file factory.hpp.

template<typename T>
T Arageli::unit ( const T &  x  )  [inline]

åäèíè÷íûé ýëåìåíò

Definition at line 90 of file factory.hpp.

template<typename T>
bool Arageli::is_unit ( const T &  x  )  [inline]

ïðîâåðêà íà ðàâåíñòâî åäèíè÷íîìó ýëåìåíòó

Definition at line 95 of file factory.hpp.

template<typename T>
const T& Arageli::opposite_unit (  )  [inline]

ïðîòèâîïîëîæíûé ê åäèíè÷íîìó ýëåìåíòó (-1)

Definition at line 100 of file factory.hpp.

template<typename T>
T Arageli::opposite_unit ( const T &  x  )  [inline]

ïðîòèâîïîëîæíûé ê åäèíè÷íîìó ýëåìåíòó (-1)

Definition at line 105 of file factory.hpp.

template<typename T>
bool Arageli::is_opposite_unit ( const T &  x  )  [inline]

ïðîâåðêà íà ðàâåíñòâî -1

Definition at line 110 of file factory.hpp.

template<typename T>
const T& Arageli::null (  )  [inline]

íóëåâîé ýëåìåíò

Definition at line 115 of file factory.hpp.

template<typename T>
T Arageli::null ( const T &   )  [inline]

íóëåâîé ýëåìåíò

Definition at line 120 of file factory.hpp.

template<typename T>
bool Arageli::is_null ( const T &  x  )  [inline]

ïðîâåðêà íà ðàâåíñòâî íóëåâîìó ýëåìåíòó

Definition at line 125 of file factory.hpp.

template<typename T>
T Arageli::opposite ( const T &  x  )  [inline]

ïðîòèâîïîëîæíûé ýëåìåíò

Definition at line 130 of file factory.hpp.

template<typename T>
T& Arageli::opposite ( const T &  x,
T *  y 
) [inline]

ïðîòèâîïîëîæíûé ýëåìåíò

Definition at line 135 of file factory.hpp.

template<typename T>
T& Arageli::opposite ( T *  x  )  [inline]

ïðîòèâîïîëîæíûé ýëåìåíò

Definition at line 140 of file factory.hpp.

template<typename T>
T Arageli::inverse ( const T &  x  )  [inline]

îáðàòíûé ýëåìåíò ê äàííîìó

Definition at line 145 of file factory.hpp.

template<typename T>
T& Arageli::inverse ( const T &  x,
T *  y 
) [inline]

îáðàòíûé ýëåìåíò ê äàííîìó

Definition at line 150 of file factory.hpp.

template<typename T>
T& Arageli::inverse ( T *  x  )  [inline]

îáðàòíûé ýëåìåíò ê äàííîìó

Definition at line 155 of file factory.hpp.

Arageli::ARAGELI_UNARY_FUNCTION_TRAITS ( indirection  ,
typename omit_asterisk< Arg >::type  ,
false  ,
false   
)

Arageli::ARAGELI_UNARY_FUNCTION_TRAITS ( postfix_increment  ,
typename omit_ref< Arg >::type  ,
true  ,
false   
)

Arageli::ARAGELI_UNARY_FUNCTION_TRAITS ( postfix_decrement  ,
typename omit_ref< Arg >::type  ,
true  ,
false   
)

Arageli::ARAGELI_BINARY_FUNCTION_TRAITS ( subscript  ,
typename omit_asterisk< Arg1 >::type  ,
false  ,
false  ,
false   
)

template<typename T>
bool Arageli::is_prime ( const T &  x  )  [inline]

Determines if x is prime via appropriate algorithm for T.

Definition at line 86 of file prime.hpp.

template<typename M>
void Arageli::gauss_field_row_iter ( M &  a,
typename M::size_type  row,
typename M::size_type  col 
)

Gauss elimination of column col with row manipulation.

Eliminates nonzeros in column col exclude the element (row, col) by row manipulation. Pivot element (row, col) becomes 1.

template<typename M>
void Arageli::gauss_field_col_iter ( M &  a,
typename M::size_type  row,
typename M::size_type  col 
)

Gauss elimination of row with column manipulation.

Eliminates nonzeros in row exclude the element (row, col) by column manipulation. Pivot element (row, col) becomes 1.

template<typename M, typename T>
void Arageli::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.

Eliminates nonzeros in column col exclude the element (row, col) by row manipulation.

template<typename M, typename T>
void Arageli::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.

Eliminates nonzeros in row exclude the element (row, col) by column manipulation.

template<typename M>
void Arageli::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.

Eliminates nonzeros in column col exclude the element (row, col) by row manipulation.

Definition at line 102 of file gauss.hpp.

template<typename M>
void Arageli::gauss_bareiss_col_iter ( M &  a,
typename M::size_type  row,
typename M::size_type  col 
)

Gauss-Bareiss elimination of row with column manipulation.

Eliminates nonzeros in row exclude the element (row, col) by column manipulation.

Definition at line 118 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T, typename T_factory, typename Ctrler>
void Arageli::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.

Elementary row operations are performed on a, a matrix over a field, to reduce it to reduced row echelon (Gauss-Jordan) form. Returns b, q, basis, det:

template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void Arageli::rref_gauss_field ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det,
Ctrler  ctrler 
) [inline]

Produces the reduced row echelon form B of a matrix A.

Definition at line 270 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T>
void Arageli::rref_gauss_field ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det 
) [inline]

Produces the reduced row echelon form B of a matrix A.

Definition at line 276 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis>
void Arageli::rref_gauss_field ( const A &  a,
B &  b,
Q &  q,
Basis &  basis 
) [inline]

Produces the reduced row echelon form B of a matrix A.

Definition at line 282 of file gauss.hpp.

template<typename A, typename B, typename Q>
void Arageli::rref_gauss_field ( const A &  a,
B &  b,
Q &  q 
) [inline]

Produces the reduced row echelon form B of a matrix A.

Definition at line 292 of file gauss.hpp.

template<typename A, typename B>
void Arageli::rref_gauss_field ( const A &  a,
B &  b 
) [inline]

Produces the reduced row echelon form B of a matrix A.

Definition at line 303 of file gauss.hpp.

template<typename A>
A Arageli::rref_gauss_field ( const A &  a  )  [inline]

Produces the reduced row echelon form B of a matrix A.

Definition at line 315 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T, typename T_factory, typename Ctrler>
void Arageli::rref_field ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det,
const T_factory &  tfctr,
Ctrler  ctrler 
) [inline]

Produces the reduced row echelon form B of the matrix a over a field.

It's the same that rref_gauss_field funtion.

Definition at line 336 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void Arageli::rref_field ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det,
Ctrler  ctrler 
) [inline]

Produces the reduced row echelon form B of the matrix a over a field.

Definition at line 352 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T>
void Arageli::rref_field ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det 
) [inline]

Produces the reduced row echelon form B of the matrix a over a field.

Definition at line 358 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis>
void Arageli::rref_field ( const A &  a,
B &  b,
Q &  q,
Basis &  basis 
) [inline]

Produces the reduced row echelon form B of the matrix a over a field.

Definition at line 364 of file gauss.hpp.

template<typename A, typename B, typename Q>
void Arageli::rref_field ( const A &  a,
B &  b,
Q &  q 
) [inline]

Produces the reduced row echelon form B of the matrix a over a field.

Definition at line 374 of file gauss.hpp.

template<typename A, typename B>
void Arageli::rref_field ( const A &  a,
B &  b 
) [inline]

Produces the reduced row echelon form B of the matrix a over a field.

Definition at line 385 of file gauss.hpp.

template<typename A>
A Arageli::rref_field ( const A &  a  )  [inline]

Produces the reduced row echelon form B of the matrix a over a field.

Definition at line 397 of file gauss.hpp.

template<typename A1, typename A2, typename I>
void Arageli::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 Arageli::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 Arageli::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 Arageli::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.

Makes RREF(A) with permutated columns according to basis_in. basis_in contains indexes of columns, basis_out indicates additional permutaitaon of columns.

template<typename T, bool REFCNT>
matrix<T, REFCNT> Arageli::inverse ( const matrix< T, REFCNT > &  A  ) 

Matrix inversion.

Returns inversion of matrix A Requirement: A must be square.

template<typename T, bool REFCNT>
T Arageli::det ( const matrix< T, REFCNT > &  A  ) 

Returns determinant of A.

Returns determinant of A. Precondition: A must be square

template<typename T, bool REFCNT>
matrix<T, REFCNT>::size_type Arageli::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 Arageli::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.

Produces the reduced row echelon form B of the integer matrix a by Gauss-Bareiss algorithm. Returns b, q, basis, det:

template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void Arageli::rref_gauss_bareiss ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det,
Ctrler  ctrler 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 503 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T>
void Arageli::rref_gauss_bareiss ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 509 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis>
void Arageli::rref_gauss_bareiss ( const A &  a,
B &  b,
Q &  q,
Basis &  basis 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 515 of file gauss.hpp.

template<typename A, typename B, typename Q>
void Arageli::rref_gauss_bareiss ( const A &  a,
B &  b,
Q &  q 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 525 of file gauss.hpp.

template<typename A, typename B>
void Arageli::rref_gauss_bareiss ( const A &  a,
B &  b 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 536 of file gauss.hpp.

template<typename A>
A Arageli::rref_gauss_bareiss ( const A &  a  )  [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 548 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T, typename T_factory, typename Ctrler>
void Arageli::rref_int ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det,
const T_factory &  tfctr,
Ctrler  ctrler 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

It's the same that rref_gauss_bareiss funtion.

Definition at line 570 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void Arageli::rref_int ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det,
Ctrler  ctrler 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 586 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T>
void Arageli::rref_int ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 592 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis>
void Arageli::rref_int ( const A &  a,
B &  b,
Q &  q,
Basis &  basis 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 598 of file gauss.hpp.

template<typename A, typename B, typename Q>
void Arageli::rref_int ( const A &  a,
B &  b,
Q &  q 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 608 of file gauss.hpp.

template<typename A, typename B>
void Arageli::rref_int ( const A &  a,
B &  b 
) [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 619 of file gauss.hpp.

template<typename A>
A Arageli::rref_int ( const A &  a  )  [inline]

Produces the reduced row echelon form B of the matrix a over an integer domain.

Definition at line 631 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T, typename T_factory, typename Ctrler>
void Arageli::rref ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det,
const T_factory &  tfctr,
Ctrler  ctrler 
) [inline]

Produces the reduced row echelon form B of the matrix a.

Exact meaning of RREF depends on type of result (integer domain or field); see rref_field and rref_int respectively.

Definition at line 694 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T, typename Ctrler>
void Arageli::rref ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det,
Ctrler  ctrler 
) [inline]

Produces the reduced row echelon form B of the matrix a.

Definition at line 716 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis, typename T>
void Arageli::rref ( const A &  a,
B &  b,
Q &  q,
Basis &  basis,
T &  det 
) [inline]

Produces the reduced row echelon form B of the matrix a.

Definition at line 722 of file gauss.hpp.

template<typename A, typename B, typename Q, typename Basis>
void Arageli::rref ( const A &  a,
B &  b,
Q &  q,
Basis &  basis 
)

Produces the reduced row echelon form B of the matrix a.

Definition at line 728 of file gauss.hpp.

template<typename A, typename B, typename Q>
void Arageli::rref ( const A &  a,
B &  b,
Q &  q 
) [inline]

Produces the reduced row echelon form B of the matrix a.

Definition at line 738 of file gauss.hpp.

template<typename A, typename B>
void Arageli::rref ( const A &  a,
B &  b 
) [inline]

Produces the reduced row echelon form B of the matrix a.

Definition at line 749 of file gauss.hpp.

template<typename A>
A Arageli::rref ( const A &  a  )  [inline]

Produces the reduced row echelon form B of the matrix a.

Definition at line 761 of file gauss.hpp.

template<typename T, bool REFCNT>
T Arageli::det_int ( const matrix< T, REFCNT > &  A  ) 

Returns determinant of integer matrix A.

template<typename T, bool REFCNT>
matrix<T, REFCNT>::size_type Arageli::rank_int ( const matrix< T, REFCNT > &  A  ) 

Returns a rank of integer matrix.

template<typename T, typename T_factory>
T Arageli::euclid ( a,
b,
const T_factory &  tfctr 
)

Processes the Euclidean algorithm on a and b.

If is_null(a) and is_null(b) then the function returns tfctr.unit(a).

template<typename T>
T Arageli::euclid ( const T &  a,
const T &  b 
) [inline]

Processes the Euclidean algorithm on a and b.

Definition at line 45 of file gcd.hpp.

template<typename T, typename T_factory>
T Arageli::euclid_binary ( a,
b,
const T_factory &  tfctr 
)

Processes the Euclidean algorithm on a and b.

If is_null(a) and is_null(b) then the function returns tfctr.unit(a).

template<typename T>
T Arageli::euclid_binary ( const T &  a,
const T &  b 
) [inline]

Processes the Euclidean algorithm on a and b.

Definition at line 57 of file gcd.hpp.

template<typename T, bool REFCNT, typename T_factory, typename T1, bool REFCNT1>
vector<T, REFCNT> Arageli::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.

The factory of tfctr of type T_factory is a factory for type compatible with T or T1.

template<typename T, bool REFCNT, typename T1, bool REFCNT1>
vector<T, REFCNT> Arageli::euclid ( const vector< T, REFCNT > &  a,
const vector< T1, REFCNT1 > &  b 
) [inline]

Computes Euclidean algorithm for each corresponding pair of a and b.

Definition at line 76 of file gcd.hpp.

template<typename T, typename T_factory>
T Arageli::euclid_bezout ( const T &  a,
const T &  b,
T &  u,
T &  v,
const T_factory &  tfctr 
)

The greatest common divisor and Bezout's coefficients.

template<typename T>
T Arageli::euclid_bezout ( const T &  a,
const T &  b,
T &  u,
T &  v 
) [inline]

The greatest common divisor and Bezout's coefficients.

Definition at line 100 of file gcd.hpp.

template<typename T, typename T_factory>
T Arageli::gcd ( const T &  a,
const T &  b,
const T_factory &  tfctr,
const type_category::type &   
) [inline]

Definition at line 112 of file gcd.hpp.

template<typename T, typename T_factory>
T Arageli::gcd ( const T &  a,
const T &  b,
const T_factory &  tfctr,
const type_category::integer &   
) [inline]

Definition at line 116 of file gcd.hpp.

template<typename T, typename T_factory>
T Arageli::gcd ( const T &  a,
const T &  b,
const T_factory &  tfctr 
) [inline]

Computes GCD for a and b.

Definition at line 121 of file gcd.hpp.

template<typename T>
T Arageli::gcd ( const T &  a,
const T &  b 
) [inline]

Computes GCD for a and b.

Definition at line 126 of file gcd.hpp.

template<typename T1, typename T2>
T1 Arageli::gcd ( const T1 &  a,
const T2 &  b 
) [inline]

Computes GCD for a and b.

Definition at line 131 of file gcd.hpp.

template<typename T, bool REFCNT, typename T_factory>
T Arageli::gcd ( const vector< T, REFCNT > &  x,
const T_factory &  tfctr 
)

Computes GCD for all items of vector 'x'.

template<typename T, bool REFCNT>
T Arageli::gcd ( const vector< T, REFCNT > &  x  )  [inline]

Computes GCD for all items of vector 'x'.

Definition at line 140 of file gcd.hpp.

template<typename T>
T Arageli::gcd3 ( const T &  a,
const T &  b,
const T &  c 
) [inline]

Compute GCD(a, b, c).

Definition at line 146 of file gcd.hpp.

template<typename T>
T Arageli::gcdex ( const T &  a,
const T &  b,
T &  u,
T &  v,
T &  w,
T &  z 
)

Extended GCD; abs(u*z - w*v) == 1; a*w + b*z == 0.

template<typename T>
T Arageli::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> Arageli::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> Arageli::gcd ( const vector< T, REFCNT > &  a,
const vector< T1, REFCNT1 > &  b,
const T_factory &  tfctr 
) [inline]

Computes GCD for each corresponding pair of a and b.

Definition at line 181 of file gcd.hpp.

template<typename T, bool REFCNT, typename T_factory>
vector<T, REFCNT> Arageli::gcd ( const vector< T, REFCNT > &  a,
const vector< T, REFCNT > &  b,
const T_factory &  tfctr 
) [inline]

Computes GCD for each corresponding pair of a and b.

Definition at line 192 of file gcd.hpp.

template<typename T, bool REFCNT, typename T1, bool REFCNT1>
vector<T, REFCNT> Arageli::gcd ( const vector< T, REFCNT > &  a,
const vector< T1, REFCNT1 > &  b 
) [inline]

Computes GCD for each corresponding pair of a and b.

Definition at line 203 of file gcd.hpp.

template<typename T, bool REFCNT>
vector<T, REFCNT> Arageli::gcd ( const vector< T, REFCNT > &  a,
const vector< T, REFCNT > &  b 
) [inline]

Computes GCD for each corresponding pair of a and b.

Definition at line 213 of file gcd.hpp.

template<typename T, typename T_factory>
T Arageli::lcm ( const T &  a,
const T &  b,
const T_factory &  tfctr 
) [inline]

Computes LCM for a and b.

Definition at line 222 of file gcd.hpp.

template<typename T>
T Arageli::lcm ( const T &  a,
const T &  b 
) [inline]

Computes LCM for a and b.

Definition at line 227 of file gcd.hpp.

template<typename T, bool REFCNT, typename T_factory>
T Arageli::lcm ( const vector< T, REFCNT > &  x,
const T_factory &  tfctr 
)

Computes LCM for all items of vector 'x'.

template<typename T, bool REFCNT>
T Arageli::lcm ( const vector< T, REFCNT > &  x  )  [inline]

Computes LCM for all items of vector 'x'.

Definition at line 236 of file gcd.hpp.

template<typename T, bool REFCNT, typename T_factory, typename T1, bool REFCNT1>
vector<T, REFCNT> Arageli::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> Arageli::lcm ( const vector< T, REFCNT > &  a,
const vector< T1, REFCNT1 > &  b,
const T_factory &  tfctr 
) [inline]

Computes LCM for each corresponding pair of a and b.

Definition at line 261 of file gcd.hpp.

template<typename T, bool REFCNT, typename T_factory>
vector<T, REFCNT> Arageli::lcm ( const vector< T, REFCNT > &  a,
const vector< T, REFCNT > &  b,
const T_factory &  tfctr 
) [inline]

Computes LCM for each corresponding pair of a and b.

Definition at line 272 of file gcd.hpp.

template<typename T, bool REFCNT, typename T1, bool REFCNT1>
vector<T, REFCNT> Arageli::lcm ( const vector< T, REFCNT > &  a,
const vector< T1, REFCNT1 > &  b 
) [inline]

Computes LCM for each corresponding pair of a and b.

Definition at line 283 of file gcd.hpp.

template<typename T, bool REFCNT>
vector<T, REFCNT> Arageli::lcm ( const vector< T, REFCNT > &  a,
const vector< T, REFCNT > &  b 
) [inline]

Definition at line 292 of file gcd.hpp.

template<typename T, typename T_factory>
bool Arageli::is_coprime ( const T &  a,
const T &  b,
const T_factory &  tfctr 
) [inline]

Returns true if two objects are coprime.

Definition at line 308 of file gcd.hpp.

template<typename T>
bool Arageli::is_coprime ( const T &  a,
const T &  b 
) [inline]

Returns true if two objects are coprime.

Definition at line 313 of file gcd.hpp.

template<typename T, bool REFCNT, typename T_factory>
bool Arageli::is_coprime ( const vector< T, REFCNT > &  x,
const T_factory &  tfctr 
) [inline]

Returns true if all objects in the vector are coprime.

Definition at line 318 of file gcd.hpp.

template<typename T, bool REFCNT>
bool Arageli::is_coprime ( const vector< T, REFCNT > &  x  )  [inline]

Returns true if all objects in the vector are coprime.

Definition at line 323 of file gcd.hpp.

template<class T>
matrix<T> Arageli::hermite_old ( const matrix< T > &  m_  ) 

The old original function for producing Hermite form.

template<typename MA, typename MH, typename MU>
void Arageli::hermite_upper ( const MA &  A,
MH &  H,
MU &  U 
) [inline]

Produces the upper Hermite form H of an integer matrix A.

Returns H, U: U is unimodular princpal left transform such that H = U * A;

Definition at line 57 of file hermite.hpp.

template<typename MA, typename MH, typename MU>
void Arageli::hermite_lower ( const MA &  A,
MH &  H,
MU &  U 
) [inline]

Produces the lower Hermite form H of an integer matrix A.

Returns H, U: U is unimodular princpal rigth transform such that H = A * U;

Definition at line 86 of file hermite.hpp.

template<typename M>
M Arageli::hermite ( const M &  A  )  [inline]

Produces the upper Hermite form H of an integer matrix A.

Definition at line 106 of file hermite.hpp.

template<typename M>
M Arageli::hermite_transform_matrix ( const M &  A  )  [inline]

Produces the unimodular princpal left transform U such that U*A is a Hermite form of an integer matrix A.

Definition at line 123 of file hermite.hpp.

template<typename T, typename T_factory>
T Arageli::inverse_mod ( const T &  a,
const T &  m,
const T_factory &  tfctr 
) [inline]

Returns inversion of a modulo n.

Requirement: n must be prime.

Definition at line 43 of file intalg.hpp.

template<typename T>
T Arageli::inverse_mod ( const T &  a,
const T &  n 
) [inline]

Returns inversion of a modulo n.

Requirement: n must be prime.

Definition at line 58 of file intalg.hpp.

template<typename T, typename I, typename T_factory>
T Arageli::power_mod ( a,
n,
const T &  m,
const T_factory &  tfctr 
)

Exponentiates a in to power n modulo m via squaring and adding.

Requirements: n and m must be a positive.

template<typename T, typename I>
T Arageli::power_mod ( const T &  a,
const I &  n,
const T &  m 
) [inline]

Exponentiates a in to power n modulo m via squaring and adding.

Requirements: n and m must be a positive.

Definition at line 70 of file intalg.hpp.

template<typename T1, typename T2, typename T3>
T3 Arageli::mod ( const T1 &  a,
const T2 &  b,
const T3 &  d 
)

Definition at line 99 of file intalg.hpp.

template<typename T1, typename T2>
T2 Arageli::mod ( const T1 &  a,
const T2 &  b 
) [inline]

Compute a modulo b.

Definition at line 105 of file intalg.hpp.

template<typename T1, typename T2, typename T3>
T3 Arageli::div_mod ( const T1 &  a,
const T2 &  b,
const T3 &  d 
)

Compute a/b modulo d.

template<typename T1, typename T2, typename T3>
T3 Arageli::rem_mod ( const T1 &  a,
const T2 &  b,
const T3 &  d 
) [inline]

Compute residue of division a by b modulo d.

If d is a prime, the function returns 0.

Definition at line 117 of file intalg.hpp.

template<typename T1, typename T2>
T2 Arageli::ann ( const T1 &  a,
const T2 &  n 
) [inline]

Compute n/gcd(a, n).

Definition at line 123 of file intalg.hpp.

template<typename T1, typename T2, typename T3>
T3 Arageli::quo_mod ( const T1 &  a,
const T2 &  b,
const T3 &  d 
)

template<typename T>
T Arageli::split ( const T &  a,
const T &  d 
)

template<typename T>
T Arageli::stab ( const T &  a,
const T &  b,
const T &  N 
)

template<typename T>
T Arageli::split_stab ( const T &  a,
const T &  b,
const T &  N 
)

template<typename T>
T Arageli::unit ( const T &  a,
const T &  N 
)

template<typename T>
T Arageli::stab ( const T &  a,
const T &  b,
const T &  N,
const T &  d 
) [inline]

Definition at line 154 of file intalg.hpp.

template<typename T>
T Arageli::split_stab ( const T &  a,
const T &  b,
const T &  N,
const T &  d 
) [inline]

Definition at line 160 of file intalg.hpp.

template<typename T>
T Arageli::split_mod ( const T &  a,
const T &  d 
)

template<typename T>
T Arageli::stab_mod ( const T &  a,
const T &  b,
const T &  N 
)

template<typename T>
T Arageli::stab_mod ( const T &  a,
const T &  b,
const T &  N,
const T &  d 
) [inline]

Definition at line 176 of file intalg.hpp.

template<typename T>
bool Arageli::is_invertible_mod ( const T &  a,
const T &  N 
)

Returns true iff a is invertible element modulo N.

template<typename T>
std::size_t Arageli::nbits ( const T &  a  )  [inline]

Compute number of bit in binary notation of a.

Definition at line 187 of file intalg.hpp.

template<typename T, typename T_factory>
std::size_t Arageli::nbits ( a,
const T_factory &  tfctr 
)

Compute number of bit in binary notation of a.

template<typename T, typename T_factory>
T Arageli::factorial_successive_multiplication ( a,
const T_factory &  tfctr 
)

Computes factorial via just successive multiplication (by definition).

Computes a*(a-1)*(a-2)* ... *3*2.

template<typename T>
T Arageli::factorial_successive_multiplication ( const T &  a  )  [inline]

Computes factorial via just successive multiplication (by definition).

Definition at line 203 of file intalg.hpp.

template<typename T, typename T_factory>
T Arageli::factorial_even_odd_multiplication ( a,
const T_factory &  tfctr 
)

Computes factorial via even and odd multiplier separation.

template<typename T>
T Arageli::factorial_even_odd_multiplication ( const T &  a  )  [inline]

Computes factorial via even and odd multiplier separation.

Definition at line 213 of file intalg.hpp.

template<typename T, typename T_factory>
T Arageli::factorial ( const T &  a,
const T_factory &  tfctr 
) [inline]

Computes factorial of a via apropriate algorithm.

Definition at line 219 of file intalg.hpp.

template<typename T>
T Arageli::factorial ( const T &  a  )  [inline]

Computes factorial of a via apropriate algorithm.

Definition at line 224 of file intalg.hpp.

template<typename T, typename T_factory>
int Arageli::jacobi ( a,
n,
const T_factory &  tfctr 
)

Computes the Jacobi symbol (a/n).

Requirements: m > 1, m is odd.

template<typename T>
int Arageli::jacobi ( const T &  a,
const T &  n 
) [inline]

Computes the Jacobi symbol (a/n).

Requirements: m > 1, m is odd.

Definition at line 242 of file intalg.hpp.

template<typename T, typename TT>
T Arageli::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)).

Returns x such that x^2 = a (mod n). Requirement: 0 <= a < n, n is prime and n = 1 (mod 4).

template<typename T>
T Arageli::sqrt_mod_shenks ( const T &  a,
const T &  n 
) [inline]

The Shenks algorithm (square root of a modulo n, for n = 1 (mod 4)).

Returns x such that x^2 = a (mod n). Requirement: 0 <= a < n, n is prime and n = 1 (mod 4).

Definition at line 265 of file intalg.hpp.

template<typename Gen, typename IntGen>
void Arageli::intconvex_simple ( const Gen &  gen,
IntGen &  intgen 
)

A convex hull of integer points of a polyhedron.

This function takes a set of generatrices of the base cone of a polyhedron. And it returns a set of generatrices of the base cone of convex hull of integer pointes of that polyhedron. This function implements a primitive algorithm and finds the convex hull very slow. It's deathly algorithm! Source of the idea: Emelichev V.A., Kovalev M.M., Kravcov M.K. Mnogogranniki, grafy, optimizacija (Nauka, 1981)(Russian), pp. 107--110. System of generatrices in gen is not necessarily minimal; and retrieved system intgen is not necessarily minimal (actually it's very big). WARINING! Type of elements of gen should be integer.

template<typename A, typename T, typename Ctrler>
void Arageli::intcount_barvinok ( const A &  a,
T &  res,
Ctrler  ctrler 
)

Counts all integer points in bodily polytope.

template<typename A, typename T>
void Arageli::intcount_barvinok ( const A &  a,
T &  res 
) [inline]

Counts all integer points in bodily polytope.

Definition at line 56 of file intcount_barvinok.hpp.

template<typename A>
A::element_type Arageli::intcount_barvinok ( const A &  a  )  [inline]

Counts all integer points in bodily polytope.

Definition at line 62 of file intcount_barvinok.hpp.

template<typename T>
interval<T> Arageli::operator+ ( const interval< T > &  a,
const interval< T > &  b 
)

Definition at line 193 of file interval.hpp.

template<typename T>
interval<T> Arageli::operator- ( const interval< T > &  a,
const interval< T > &  b 
)

Definition at line 210 of file interval.hpp.

template<typename T>
interval<T> Arageli::operator * ( const interval< T > &  a,
const interval< T > &  b 
)

Definition at line 227 of file interval.hpp.

template<typename T>
interval<T> Arageli::operator/ ( const interval< T > &  a,
const interval< T > &  b 
)

Definition at line 244 of file interval.hpp.

template<typename T1, typename T2>
bool Arageli::are_overlap_intervals_oooo ( const T1 &  a,
const T2 &  b 
) [inline]

Definition at line 263 of file interval.hpp.

template<typename Seg1, typename Seg2>
bool Arageli::is_overlap_segs ( const Seg1 &  a,
const Seg2 &  b 
) [inline]

Definition at line 281 of file interval.hpp.

template<typename Out, typename T>
Out& Arageli::operator<< ( Out &  out,
const interval< T > &  x 
)

Definition at line 288 of file interval.hpp.

template<typename In, typename T>
In& Arageli::operator>> ( In &  in,
interval< T > &  x 
)

Definition at line 295 of file interval.hpp.

template<typename T1, typename T2>
bool Arageli::are_comparable_oooo ( const interval< T1 > &  a,
const interval< T2 > &  b 
)

Determines if a and b are exactly comparable as two open intervals.

Definition at line 322 of file interval.hpp.

template<typename T1, typename T2>
int Arageli::cmp ( const interval< T1 > &  a,
const interval< T2 > &  b 
)

Semi-lexicographical comparision between two intervals.

An empty interval less than all others.

Definition at line 329 of file interval.hpp.

template<typename T1, typename T2>
bool Arageli::operator< ( const interval< T1 > &  a,
const interval< T2 > &  b 
)

Definition at line 347 of file interval.hpp.

template<typename T1, typename T2>
bool Arageli::operator> ( const interval< T1 > &  a,
const interval< T2 > &  b 
)

Definition at line 355 of file interval.hpp.

template<typename T1, typename T2>
bool Arageli::operator<= ( const interval< T1 > &  a,
const interval< T2 > &  b 
)

Definition at line 363 of file interval.hpp.

template<typename T1, typename T2>
bool Arageli::operator>= ( const interval< T1 > &  a,
const interval< T2 > &  b 
)

Definition at line 371 of file interval.hpp.

template<typename T1, typename T2>
bool Arageli::operator== ( const interval< T1 > &  a,
const interval< T2 > &  b 
)

Definition at line 379 of file interval.hpp.

template<typename T1, typename T2>
bool Arageli::operator!= ( const interval< T1 > &  a,
const interval< T2 > &  b 
) [inline]

Definition at line 387 of file interval.hpp.

template<typename T>
interval<T> Arageli::abs ( const interval< T > &  x  ) 

Definition at line 392 of file interval.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_ostream<Ch, ChT>& Arageli::output_polynom_first_default ( std::basic_ostream< Ch, ChT > &  out,
const T &  x 
) [inline]

Default ouputting method for subexpression as the first coefficient in a polynomial.

Definition at line 29 of file io.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_ostream<Ch, ChT>& Arageli::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>& Arageli::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>& Arageli::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>& Arageli::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>& Arageli::input_pow_default ( std::basic_istream< Ch, ChT > &  in,
T &  x 
) [inline]

Default inutting method for subexpression as a degree of variable in a polynomial.

Definition at line 55 of file io.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_ostream<Ch, ChT>& Arageli::output_polynom_first ( std::basic_ostream< Ch, ChT > &  out,
const T &  x 
) [inline]

Definition at line 61 of file io.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_ostream<Ch, ChT>& Arageli::output_polynom_internal ( std::basic_ostream< Ch, ChT > &  out,
const T &  x 
) [inline]

Definition at line 66 of file io.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_ostream<Ch, ChT>& Arageli::output_pow ( std::basic_ostream< Ch, ChT > &  out,
const T &  x 
) [inline]

Definition at line 71 of file io.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_istream<Ch, ChT>& Arageli::input_polynom_first ( std::basic_istream< Ch, ChT > &  in,
T &  x 
) [inline]

Definition at line 76 of file io.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_istream<Ch, ChT>& Arageli::input_polynom_internal ( std::basic_istream< Ch, ChT > &  in,
T &  x 
) [inline]

Definition at line 81 of file io.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_istream<Ch, ChT>& Arageli::input_pow ( std::basic_istream< Ch, ChT > &  in,
T &  x 
) [inline]

Definition at line 86 of file io.hpp.

template<typename T, typename TB, typename F>
apply_iterator<T, TB, F> Arageli::operator+ ( apply_iterator< T, TB, F >  x,
typename apply_iterator< T, TB, F >::difference_type  n 
)

Definition at line 104 of file iteradapt.hpp.

template<typename T, typename TB, typename F>
apply_iterator<T, TB, F> Arageli::operator- ( apply_iterator< T, TB, F >  x,
typename apply_iterator< T, TB, F >::difference_type  n 
)

Definition at line 110 of file iteradapt.hpp.

template<typename T, typename TB, typename F>
std::iterator_traits<TB>::difference_type Arageli::operator- ( const apply_iterator< T, TB, F > &  a,
const apply_iterator< T, TB, F > &  b 
) [inline]

Definition at line 116 of file iteradapt.hpp.

template<typename T, typename TB, typename F>
bool Arageli::operator== ( const apply_iterator< T, TB, F > &  a,
const apply_iterator< T, TB, F > &  b 
) [inline]

Definition at line 130 of file iteradapt.hpp.

template<typename T, typename TB, typename F>
bool Arageli::operator!= ( const apply_iterator< T, TB, F > &  a,
const apply_iterator< T, TB, F > &  b 
) [inline]

Definition at line 131 of file iteradapt.hpp.

template<typename T, typename TB, typename F>
bool Arageli::operator< ( const apply_iterator< T, TB, F > &  a,
const apply_iterator< T, TB, F > &  b 
) [inline]

Definition at line 132 of file iteradapt.hpp.

template<typename T, typename TB, typename F>
bool Arageli::operator> ( const apply_iterator< T, TB, F > &  a,
const apply_iterator< T, TB, F > &  b 
) [inline]

Definition at line 133 of file iteradapt.hpp.

template<typename T, typename TB, typename F>
bool Arageli::operator<= ( const apply_iterator< T, TB, F > &  a,
const apply_iterator< T, TB, F > &  b 
) [inline]

Definition at line 134 of file iteradapt.hpp.

template<typename T, typename TB, typename F>
bool Arageli::operator>= ( const apply_iterator< T, TB, F > &  a,
const apply_iterator< T, TB, F > &  b 
) [inline]

Definition at line 135 of file iteradapt.hpp.

template<typename T, typename TB1, typename TB2, typename F>
std::iterator_traits<TB1>::difference_type Arageli::operator- ( const Iterpair< T, TB1, TB2, F > &  a,
const Iterpair< T, TB1, TB2, F > &  b 
) [inline]

Definition at line 226 of file iteradapt.hpp.

template<typename T, typename TB1, typename TB2, typename F>
bool Arageli::operator== ( const Iterpair< T, TB1, TB2, F > &  a,
const Iterpair< T, TB1, TB2, F > &  b 
) [inline]

Definition at line 231 of file iteradapt.hpp.

template<typename T, typename TB1, typename TB2, typename F>
bool Arageli::operator!= ( const Iterpair< T, TB1, TB2, F > &  a,
const Iterpair< T, TB1, TB2, F > &  b 
) [inline]

Definition at line 235 of file iteradapt.hpp.

template<typename T, typename TB1, typename TB2, typename F>
bool Arageli::operator< ( const Iterpair< T, TB1, TB2, F > &  a,
const Iterpair< T, TB1, TB2, F > &  b 
) [inline]

Definition at line 239 of file iteradapt.hpp.

template<typename T, typename TB1, typename TB2, typename F>
bool Arageli::operator> ( const Iterpair< T, TB1, TB2, F > &  a,
const Iterpair< T, TB1, TB2, F > &  b 
) [inline]

Definition at line 243 of file iteradapt.hpp.

template<typename T, typename TB1, typename TB2, typename F>
bool Arageli::operator<= ( const Iterpair< T, TB1, TB2, F > &  a,
const Iterpair< T, TB1, TB2, F > &  b 
) [inline]

Definition at line 247 of file iteradapt.hpp.

template<typename T, typename TB1, typename TB2, typename F>
bool Arageli::operator>= ( const Iterpair< T, TB1, TB2, F > &  a,
const Iterpair< T, TB1, TB2, F > &  b 
) [inline]

Definition at line 251 of file iteradapt.hpp.

template<typename B_type, typename H_type>
bool Arageli::lll_reduction ( B_type &  B,
H_type &  H 
)

LLL basis reduction.

Parameters:
B should be a matrix
H should be a matrix

big_int Arageli::entier ( const big_int &  de  ) 

Definition at line 33 of file logarithm.cpp.

big_int Arageli::frac ( const big_int &  de,
std::size_t  kbits 
)

Definition at line 71 of file logarithm.cpp.

std::size_t Arageli::lg10 ( const big_int &  b  ) 

Returns lg (b).

Definition at line 110 of file logarithm.cpp.

std::size_t Arageli::lg10 ( std::size_t  b  ) 

Returns lg (b).

Definition at line 121 of file logarithm.cpp.

big_int Arageli::power_of_ten ( std::size_t  pow  ) 

Returns 10^pow.

Definition at line 133 of file logarithm.cpp.

big_int Arageli::entier_1 ( const big_int &  be  ) 

Definition at line 143 of file logarithm.cpp.

big_int Arageli::frac_1 ( const big_int &  de,
std::size_t  kbits 
)

Returns 10 ^ {de/log2_10} with kbits - 1 precision.

Definition at line 167 of file logarithm.cpp.

void Arageli::do_bin_convert ( const big_int &  dm,
const big_int &  de,
std::size_t  p,
big_int &  bm,
big_int &  be 
)

Definition at line 217 of file logarithm.cpp.

std::size_t Arageli::do_dec_convert ( big_int &  dm,
big_int &  de,
std::size_t  p,
const big_int &  bm,
const big_int &  be 
)

Definition at line 246 of file logarithm.cpp.

template<typename T, bool REFCNT>
matrix<T, true> Arageli::transpose ( const matrix< T, REFCNT > &  a  ) 

Definition at line 2704 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
int Arageli::cmp ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Lexicographical comparision of two matrix.

Each matrix is represented as (rows, cols, elements) and on this form performs lexicographical comparision, where sequences of elements have compared lexicographicaly too. Returns

Definition at line 2726 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool Arageli::operator<= ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2784 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
bool Arageli::operator<= ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 2784 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
bool Arageli::operator<= ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2784 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool Arageli::operator>= ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2785 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
bool Arageli::operator>= ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 2785 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
bool Arageli::operator>= ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2785 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool Arageli::operator< ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2786 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
bool Arageli::operator< ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 2786 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
bool Arageli::operator< ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2786 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool Arageli::operator> ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2787 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
bool Arageli::operator> ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 2787 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
bool Arageli::operator> ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2787 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool Arageli::operator== ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2788 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
bool Arageli::operator== ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 2788 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
bool Arageli::operator== ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2788 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool Arageli::operator!= ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2789 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
bool Arageli::operator!= ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 2789 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
bool Arageli::operator!= ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2789 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_add_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2842 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::add_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2842 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::add_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2842 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_sub_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2843 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::sub_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2843 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::sub_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2843 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_mul_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2844 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::mul_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2844 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::mul_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2844 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_div_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2845 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::div_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2845 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::div_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2845 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_mod_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2846 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::mod_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2846 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::mod_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2846 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_bitand_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2847 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::bitand_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2847 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::bitand_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2847 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_bitor_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2848 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::bitor_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2848 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::bitor_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2848 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_bitxor_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2849 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::bitxor_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2849 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::bitxor_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2849 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_shl_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2850 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::shl_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2850 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::shl_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2850 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::each_shr_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2851 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::shr_matrix_scalar ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2851 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::shr_scalar_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2851 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::mul_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2860 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::div_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2864 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::add_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2868 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::sub_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2869 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::mod_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2870 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::bitand_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2871 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::bitor_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2872 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::bitxor_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2873 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::shl_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2874 of file matrix.hpp.

template<typename T1, typename T2, typename T3>
T3& Arageli::shr_matrix_matrix ( const T1 &  a,
const T2 &  b,
T3 &  res 
)

Definition at line 2875 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator+ ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3027 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator+ ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3027 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator+ ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3027 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator+ ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3027 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator+ ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3027 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator+ ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3027 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator+ ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3027 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator+ ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3027 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator+ ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3027 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator- ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3028 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator- ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3028 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator- ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3028 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator- ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3028 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator- ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3028 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator- ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3028 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator- ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3028 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator- ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3028 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator- ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3028 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator * ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3029 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator * ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3029 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator * ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3029 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator * ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3029 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator * ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3029 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator * ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3029 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator * ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3029 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator * ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3029 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator * ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3029 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator/ ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3030 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator/ ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3030 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator/ ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3030 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator/ ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3030 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator/ ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3030 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator/ ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3030 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator/ ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3030 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator/ ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3030 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator/ ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3030 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator% ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3031 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator% ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3031 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator% ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3031 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator% ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3031 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator% ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3031 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator% ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3031 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator% ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3031 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator% ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3031 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator% ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3031 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator & ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3032 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator & ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3032 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator & ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3032 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator & ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3032 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator & ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3032 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator & ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3032 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator & ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3032 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator & ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3032 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator & ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3032 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator| ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3033 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator| ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3033 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator| ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3033 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator| ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3033 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator| ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3033 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator| ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3033 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator| ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3033 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator| ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3033 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator| ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3033 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator^ ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3034 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator^ ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3034 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator^ ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3034 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator^ ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3034 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator^ ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3034 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator^ ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3034 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator^ ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3034 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator^ ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3034 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator^ ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3034 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator<< ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3035 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator<< ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3035 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator<< ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3035 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator<< ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3035 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator<< ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3035 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator<< ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3035 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator<< ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3035 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator<< ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3035 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator<< ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3035 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
matrix<T1, REFCNT1> Arageli::operator>> ( const matrix< T1, REFCNT1 > &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3036 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2>
matrix<T1, REFCNT1> Arageli::operator>> ( const matrix< T1, REFCNT1 > &  a,
const T2 &  b 
) [inline]

Definition at line 3036 of file matrix.hpp.

template<typename T1, typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator>> ( const T1 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3036 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<T1, REFCNT1> Arageli::operator>> ( const matrix< T1, REFCNT1 > &  a,
const T1 &  b 
) [inline]

Definition at line 3036 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<T2, REFCNT2> Arageli::operator>> ( const T2 &  a,
const matrix< T2, REFCNT2 > &  b 
) [inline]

Definition at line 3036 of file matrix.hpp.

template<typename T1, bool REFCNT1>
matrix<rational<T1>, REFCNT1> Arageli::operator>> ( const matrix< rational< T1 >, REFCNT1 > &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 3036 of file matrix.hpp.

template<typename T2, bool REFCNT2>
matrix<rational<T2>, REFCNT2> Arageli::operator>> ( const rational< T2 > &  a,
const matrix< rational< T2 >, REFCNT2 > &  b 
) [inline]

Definition at line 3036 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator>> ( const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  a,
const sparse_polynom< T1, D1, REFCNT1 > &  b 
) [inline]

Definition at line 3036 of file matrix.hpp.

template<typename T1, typename D1, bool REFCNT1, bool REFCNT2>
matrix<sparse_polynom <T1, D1, REFCNT1>, REFCNT2> Arageli::operator>> ( const sparse_polynom< T1, D1, REFCNT1 > &  a,
const matrix< sparse_polynom< T1, D1, REFCNT1 >, REFCNT2 > &  b 
) [inline]

Definition at line 3036 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
vector<T2, REFCNT2> Arageli::operator * ( const matrix< T1, REFCNT1 > &  m,
const vector< T2, REFCNT2 > &  x 
)

Matrix by vector multiplication.

Regards x as columt-vector and performs standard matrix by vector multiplication.

template<typename T2, bool REFCNT2, typename T1, bool REFCNT1>
vector<T2, REFCNT2> Arageli::operator * ( const vector< T2, REFCNT2 > &  x,
const matrix< T1, REFCNT1 > &  m 
)

Vector by matrix multiplication.

Regards x as row-vector and performs standard matrix by vector multiplication.

template<typename T, bool REFCNT>
std::ostream& Arageli::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.

Parameters:
out an output stream
x the matrix for outputting

template<typename T, bool REFCNT>
std::istream& Arageli::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& Arageli::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& Arageli::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& Arageli::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& Arageli::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.

The matrix m2 is cetral element in the triplet. This matrix is placed in buttom-right corner of a gabarite rectangel. See implementation at matrix.cpp for details.

template<typename T, bool REFCNT>
std::ostream& Arageli::operator<< ( std::ostream &  out,
const matrix< T, REFCNT > &  x 
)

Standard output routine (default type of outputting) for the matrix.

Definition at line 3289 of file matrix.hpp.

template<typename T, bool REFCNT>
std::istream& Arageli::operator>> ( std::istream &  out,
matrix< T, REFCNT > &  x 
)

Standard input routine (default type of inputting) for the matrix.

Definition at line 3294 of file matrix.hpp.

template<typename T, bool REFCNT>
std::ofstream& Arageli::operator<< ( std::ofstream &  out,
const matrix< T, REFCNT > &  x 
)

WARNING! TEMPORARY DEFINITION!!!

Definition at line 3300 of file matrix.hpp.

template<typename T, bool REFCNT>
std::ifstream& Arageli::operator>> ( std::ifstream &  out,
matrix< T, REFCNT > &  x 
)

WARNING! TEMPORARY DEFINITION!!!

Definition at line 3305 of file matrix.hpp.

template<typename T, bool REFCNT>
std::ostream& Arageli::operator<< ( std::ostringstream &  out,
const matrix< T, REFCNT > &  x 
)

Definition at line 3312 of file matrix.hpp.

template<typename T, bool REFCNT>
std::istream& Arageli::operator>> ( std::istringstream &  out,
matrix< T, REFCNT > &  x 
)

Standard input routine (default type of inputting) for the matrix.

Definition at line 3317 of file matrix.hpp.

template<typename T, bool REFCNT>
matrix<T, REFCNT> Arageli::opposite ( const matrix< T, REFCNT > &  x  )  [inline]

Definition at line 3368 of file matrix.hpp.

template<typename T, bool REFCNT>
matrix<T, REFCNT>& Arageli::opposite ( const matrix< T, REFCNT > &  x,
matrix< T, REFCNT > *  y 
) [inline]

Definition at line 3373 of file matrix.hpp.

template<typename T, bool REFCNT>
matrix<T, REFCNT>& Arageli::opposite ( matrix< T, REFCNT > *  x  )  [inline]

Definition at line 3378 of file matrix.hpp.

template<typename T, bool REFCNT>
matrix<T, REFCNT>& Arageli::inverse ( const matrix< T, REFCNT > &  x,
matrix< T, REFCNT > *  y 
) [inline]

Definition at line 3391 of file matrix.hpp.

template<typename T, bool REFCNT>
matrix<T, REFCNT>& Arageli::inverse ( matrix< T, REFCNT > *  x  )  [inline]

Definition at line 3396 of file matrix.hpp.

template<typename T, bool REFCNT>
bool Arageli::is_unit ( const matrix< T, REFCNT > &  x  )  [inline]

Definition at line 3401 of file matrix.hpp.

template<typename T, bool REFCNT>
bool Arageli::is_opposite_unit ( const matrix< T, REFCNT > &  x  )  [inline]

Definition at line 3405 of file matrix.hpp.

template<typename T, bool REFCNT>
bool Arageli::is_null ( const matrix< T, REFCNT > &  x  )  [inline]

Definition at line 3409 of file matrix.hpp.

template<typename T, bool REFCNT>
std::ostream& Arageli::output_polynom_first ( std::ostream &  out,
const matrix< T, REFCNT > &  x 
) [inline]

Definition at line 3471 of file matrix.hpp.

template<typename T, bool REFCNT>
std::ostream& Arageli::output_polynom_internal ( std::ostream &  out,
const matrix< T, REFCNT > &  x 
) [inline]

Definition at line 3476 of file matrix.hpp.

template<typename T, bool REFCNT>
std::ostream& Arageli::output_pow ( std::ostream &  out,
const matrix< T, REFCNT > &  x 
) [inline]

Definition at line 3481 of file matrix.hpp.

template<typename T, bool REFCNT>
std::istream& Arageli::input_polynom_first ( std::istream &  in,
matrix< T, REFCNT > &  x 
) [inline]

Definition at line 3486 of file matrix.hpp.

template<typename T, bool REFCNT>
std::istream& Arageli::input_polynom_internal ( std::istream &  in,
matrix< T, REFCNT > &  x 
)

template<typename T, bool REFCNT>
std::istream& Arageli::input_pow ( std::istream &  in,
matrix< T, REFCNT > &  x 
) [inline]

Definition at line 3495 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
void Arageli::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.

Definition at line 3507 of file matrix.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
void Arageli::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.

Definition at line 3536 of file matrix.hpp.

template<typename T>
T Arageli::safe_reference ( const T &  x  ) 

Makes and returns a temporary copy of the argument.

This function is useful to dealing with our container-liked structures when an element of structure is used in operation with whole its owner. For example, such operations are the dividing a row of a matrix by the element in that row, the dividing a polynomial by the leading coefficient and so on.

Definition at line 36 of file misc.hpp.

template<typename T1, typename T2, typename Outiter>
void Arageli::generate_range_helper ( T1 &  t1,
const T2 &  t2,
Outiter  outiter 
)

Definition at line 40 of file misc.hpp.

template<typename T1, typename T2, typename T3, typename Outiter>
void Arageli::generate_range_helper ( T1 &  t1,
const T2 &  t2,
const T3 &  t3,
Outiter  outiter 
)

Definition at line 56 of file misc.hpp.

template<typename T1, typename T2, typename Outiter>
void Arageli::generate_range_helper_wo_inc ( T1 &  t1,
const T2 &  t2,
Outiter  outiter 
)

Definition at line 66 of file misc.hpp.

template<typename Outiter>
void Arageli::generate_range_helper ( bool &  t1,
bool  t2,
Outiter  outiter 
) [inline]

Definition at line 82 of file misc.hpp.

template<typename Outiter>
void Arageli::generate_range_helper ( float &  t1,
float  t2,
Outiter  outiter 
) [inline]

Definition at line 86 of file misc.hpp.

template<typename Outiter>
void Arageli::generate_range_helper ( double &  t1,
double  t2,
Outiter  outiter 
) [inline]

Definition at line 90 of file misc.hpp.

template<typename Outiter>
void Arageli::generate_range_helper ( long double &  t1,
long double  t2,
Outiter  outiter 
) [inline]

Definition at line 94 of file misc.hpp.

template<typename A, typename F, typename Q, typename E, typename Ctrler>
void Arageli::skeleton_motzkin_burger ( A &  a,
F &  f,
Q &  q,
E &  e,
Ctrler  ctrler 
)

The Motzkin-Burger algorithm without modifications.

Finds extreme rays f and basis e of a cone ax >= 0 returns also an incidence matrix q = f * transpose(a).

template<typename A, typename F, typename Q, typename E>
void Arageli::skeleton_motzkin_burger ( A &  a,
F &  f,
Q &  q,
E &  e 
) [inline]

The Motzkin-Burger algorithm without modifications.

Just calls full version of the function.

Definition at line 107 of file motzkin_burger.hpp.

template<typename A, typename F, typename Q, typename E, typename Ctrler>
void Arageli::skeleton_motzkin_burger_min ( A &  a,
F &  f,
Q &  q,
E &  e,
Ctrler  ctrler 
)

The Motzkin-Burger algorithm with selecting minimum elements.

Finds extreme rays f and basis e of a cone ax >= 0 returns also an incidence matrix q = f * transpose(a).

template<typename A, typename F, typename Q, typename E>
void Arageli::skeleton_motzkin_burger_min ( A &  a,
F &  f,
Q &  q,
E &  e 
) [inline]

The Motzkin-Burger algorithm with selecting minimum elements.

Just calls full version of the function.

Definition at line 133 of file motzkin_burger.hpp.

template<typename A, typename F, typename Q, typename E, typename Ctrler>
void Arageli::skeleton_motzkin_burger_max ( A &  a,
F &  f,
Q &  q,
E &  e,
Ctrler  ctrler 
)

The Motzkin-Burger algorithm with selecting maximum elements.

Finds extreme rays f and basis e of a cone ax >= 0 returns also an incidence matrix q = f * transpose(a).

template<typename A, typename F, typename Q, typename E>
void Arageli::skeleton_motzkin_burger_max ( A &  a,
F &  f,
Q &  q,
E &  e 
) [inline]

The Motzkin-Burger algorithm with selecting maximum elements.

Just calls full version of the function.

Definition at line 159 of file motzkin_burger.hpp.

template<typename A, typename F, typename Q, typename E>
void Arageli::integer_conv_motzkin_burger ( A &  a,
F &  f,
Q &  q,
E &  e 
)

template<typename P1, typename P2, typename PQ, typename PR>
void Arageli::polynom_divide_simple ( const P1 &  p1,
const P2 &  p2,
PQ &  pq,
PR &  pr 
)

Division of two univariate polynomials with quotient and remainder.

Appropriate for polynomials over fields and rings.

Definition at line 44 of file polyalg.hpp.

template<typename P1, typename P2, typename PQ, typename PR, typename T>
void Arageli::polynom_pseudodivide_simple ( const P1 &  p1,
const P2 &  p2,
PQ &  pq,
PR &  pr,
T &  multiplier 
)

Definition at line 80 of file polyalg.hpp.

template<typename P, typename T>
T& Arageli::polynom_rational_to_int_value ( const P &  p,
T &  res 
)

Definition at line 106 of file polyalg.hpp.

template<typename Pr, typename Pi, typename X>
void Arageli::polynom_rational_to_int ( const Pr &  pr,
Pi &  pi,
const X &  x 
)

Definition at line 125 of file polyalg.hpp.

template<typename P1, typename P2, typename PQ, typename PR>
void Arageli::polynom_divide_rational_simple ( P1  p1,
P2  p2,
PQ &  pq,
PR &  pr 
)

Definition at line 152 of file polyalg.hpp.

template<typename P1, typename P2, typename PQ, typename PR>
void Arageli::polynom_divide ( const P1 &  p1,
const P2 &  p2,
PQ &  pq,
PR &  pr,
const type_category::type &   
) [inline]

Definition at line 194 of file polyalg.hpp.

template<typename P1, typename P2, typename PQ, typename PR>
void Arageli::polynom_divide ( const P1 &  p1,
const P2 &  p2,
PQ &  pq,
PR &  pr,
const type_category::rational &   
) [inline]

Definition at line 203 of file polyalg.hpp.

template<typename P1, typename P2, typename PQ, typename PR>
void Arageli::polynom_divide ( const P1 &  p1,
const P2 &  p2,
PQ &  pq,
PR &  pr 
) [inline]

Definition at line 212 of file polyalg.hpp.

template<typename P, typename M>
void Arageli::sparse_polynom_reduction_mod ( P &  p,
const M &  m 
)

Polynom coefficients reduction modulo m.

Definition at line 232 of file polyalg.hpp.

template<typename P>
P::coef_type Arageli::max_abs_coef ( const P &  p  ) 

Computes maximum of absolute values of coefficients of polynom p.

Definition at line 245 of file polyalg.hpp.

template<typename P>
P::coef_type Arageli::max_abs_coef_wo_leading ( const P &  p  ) 

Computes maximum of absolute values of coefficients of polynom p without leading coef.

Definition at line 262 of file polyalg.hpp.

template<typename P>
P::coef_type Arageli::polynom_content ( const P &  x  ) 

Definition at line 282 of file polyalg.hpp.

template<typename P>
P Arageli::polynom_primpart ( const P &  x  )  [inline]

Definition at line 293 of file polyalg.hpp.

template<typename T, typename P>
T Arageli::root_upper_bound_cauchy ( const P &  p  ) 

Definition at line 298 of file polyalg.hpp.

template<typename P, typename V>
V& Arageli::squarefree_factorize_poly_rational ( const P &  h,
V &  res 
)

Definition at line 311 of file polyalg.hpp.

template<typename P>
P Arageli::reciprocal_poly ( const P &  p  ) 

Definition at line 339 of file polyalg.hpp.

template<typename Out, typename T, typename R, typename M, typename CFG>
void Arageli::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 Arageli::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.

This function produces command chain for pstricks package in LaTex that draw given polytope. You should place this chain into environment.

template<typename F, typename FT>
std::ostream& Arageli::operator<< ( std::ostream &  s,
const polynom< F > &  v 
)

Definition at line 413 of file polynom.hpp.

template<typename F, typename FT>
polynom<F> Arageli::abs ( const polynom< F > &  maxVal  ) 

Definition at line 430 of file polynom.hpp.

template<typename F, typename FT>
polynom<F> Arageli::normalize ( const polynom< F > &  val  ) 

Normalize polynom Normalize polynom to ensure that coefficient with high degree equal to identity. The resulting polynom is equal to the given polynom.

Parameters:
value the polynom to normalize
Returns:
normalized polynom equal to the value

Definition at line 445 of file polynom.hpp.

template<typename T, typename I, typename T_factory>
T Arageli::power ( a,
n,
const T_factory &  tfctr 
)

Exponentiates a in to positive integer power n via squaring and adding.

Requirements: n != 0 or a != 0.

template<typename T, typename I>
T Arageli::power ( const T &  a,
const I &  n 
) [inline]

Exponentiates a in to positive integer power n via squaring and adding.

Definition at line 35 of file powerest.hpp.

template<typename T, typename I, typename T_factory>
T Arageli::pow2 ( n,
const T_factory &  tfctr 
) [inline]

Exponentiates 2 in to positive integer power n via left shift operator.

Definition at line 41 of file powerest.hpp.

template<typename T, typename I>
T Arageli::pow2 ( n  )  [inline]

Exponentiates 2 in to positive integer power n via left shift operator.

Definition at line 49 of file powerest.hpp.

template<typename T>
T Arageli::log2 ( x  )  [inline]

Returns the base-2 logarithm of x. The default version.

Definition at line 58 of file powerest.hpp.

template<typename T1, typename T2, typename Q, typename R>
void Arageli::divide ( const T1 &  a,
const T2 &  b,
Q &  q,
R &  r 
) [inline]

Performs division produced quotient and remainder.

Parameters:
a dividend
b divisor
q the resulting quotient
r the resulting remainder

Definition at line 68 of file powerest.hpp.

template<typename T1, typename T2, typename Q, typename R>
void Arageli::prdivide ( const T1 &  a,
const T2 &  b,
Q &  q,
R &  r 
) [inline]

Performs division produced quotient and POSITIVE remainder (pr).

Parameters:
a dividend
b divisor
q the resulting quotient
r the resulting remainder, 0 <= r < |b|

Definition at line 99 of file powerest.hpp.

template<typename T1, typename T2>
T1 Arageli::prquot ( const T1 &  a,
const T2 &  b 
) [inline]

Returns quotient of pr-division of a by b.

Performs division produced quotient and POSITIVE remainder (pr-division).

Parameters:
a dividend

Definition at line 134 of file powerest.hpp.

template<typename T1, typename T2>
T2 Arageli::prrem ( const T1 &  a,
const T2 &  b 
) [inline]

Returns remainder of pr-division of a by b.

Definition at line 149 of file powerest.hpp.

template<typename T>
T Arageli::square ( const T &  a  )  [inline]

Returns square of a.

Definition at line 164 of file powerest.hpp.

int Arageli::pow ( int  x,
int  y 
) [inline]

Definition at line 168 of file powerest.hpp.

template<typename T, typename T_factory>
bool Arageli::is_prime_division ( const T &  x,
const T_factory &  tfctr 
)

Determines if x is prime via consecutive division by sample divisors.

Very simple and slow algorithm for big x.

template<typename T>
bool Arageli::is_prime_division ( const T &  x  )  [inline]

Determines if x is prime via consecutive division by sample divisors.

Very simple and slow algorithm for big x.

Definition at line 39 of file prime.hpp.

template<typename T, typename N, typename T_factory>
bool Arageli::is_pseudoprime_miller_rabin ( const T &  x,
const N &  n,
const T_factory &  tfctr 
)

Determines if x is prime via Miller-Rabin algorithm.

Very fast algorithm for big x. Returns true if x is pseudo-prime to n bases and false if x is composite number.

template<typename T>
bool Arageli::is_prime_AKS_classic ( const T &  n  ) 

Determines if x is prime.

Very slow algorithm for any prime x.

template<typename T>
bool Arageli::is_prime_AKS ( const T &  n  ) 

Determines if x is prime.

Very slow algorithm for any prime x.

template<typename T, typename N>
bool Arageli::is_pseudoprime_miller_rabin ( const T &  x,
const N &  n 
) [inline]

Determines if x is prime via Miller-Rabin algorithm.

Very fast algorithm for big x. Returns true if x is pseudo-prime to n bases and false if x is composite number.

Definition at line 62 of file prime.hpp.

template<typename T, typename N, typename T_factory>
bool Arageli::is_pseudoprime_solovay_strassen ( const T &  x,
const N &  n,
const T_factory &  tfctr 
)

Determines if x is prime via Solovey-Strassen algorithm.

More fast algorithm for big x, than simple division.

template<typename T, typename N>
bool Arageli::is_prime_solovey_strassen ( const T &  x,
const N &  n 
) [inline]

Determines if x is prime via Solovey-Strassen algorithm.

More fast algorithm for big x, than simple division.

Definition at line 73 of file prime.hpp.

template<typename T, typename T_factory>
bool Arageli::is_prime ( const T &  x,
const T_factory &  tfctr 
) [inline]

Determines if x is prime via appropriate algorithm for T.

By default it is just call is_prime_division function.

Definition at line 80 of file prime.hpp.

template<typename T, typename T_factory>
bool Arageli::is_probably_prime ( const T &  x,
const T_factory &  tfctr 
) [inline]

Determines if x is probably prime via appropriate algorithm for T.

By default it is just call is_pseudoprime_solovay_strassen function.

Definition at line 92 of file prime.hpp.

template<typename T>
bool Arageli::is_probably_prime ( const T &  x  )  [inline]

Determines if x is probably prime via appropriate algorithm for T.

Definition at line 98 of file prime.hpp.

template<typename Out, typename T>
Out Arageli::small_primes ( Out  primes,
const T &  N 
)

Fills sequence with first N primes.

Fills sequence that begin on 'primes' with first prime numbers, i.g. 2, 3, ... Number of generated primes is N. The function returns iterator on end of generated sequence.

template<typename T, typename N>
int Arageli::is_prime_small_primes_division ( const T &  n,
const N &  np 
)

Return 1 if n is prime Return 0 if n is composite Return -1 if n has no small factors

template<typename T>
int Arageli::is_prime_small_primes_division ( const T &  n  ) 

Return 1 if n is prime Return 0 if n is composite Return -1 if n has no small factors

Definition at line 122 of file prime.hpp.

template<typename T, typename T_factory>
bool Arageli::is_composite ( const T &  x,
const T_factory &  tfctr 
) [inline]

Determines if x is composite.

Definition at line 127 of file prime.hpp.

template<typename T>
bool Arageli::is_composite ( const T &  x  )  [inline]

Determines if x is composite.

Definition at line 139 of file prime.hpp.

template<typename T1, typename T2, bool REFCNT2, typename T_factory>
vector<T2, REFCNT2>& Arageli::factorize_division ( T1  x,
vector< T2, REFCNT2 > &  res,
const T_factory &  tfctr 
)

Factorizes x into a set of prime factors via consecutive division.

Very simple and slow algorithm for big x. The resulting prime multipliers in res are ascending sorted. Number of copies of each multiplier is equal to its repetition factor, i.e. after the function call the expression (product(res) == x) is true.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::factorize_division ( const T1 &  x,
vector< T2, REFCNT2 > &  res 
) [inline]

Factorizes x into a set of prime factors via consecutive division.

Definition at line 163 of file prime.hpp.

template<typename T, typename T_factory>
vector<T, true> Arageli::factorize_division ( const T &  x,
const T_factory &  tfctr 
) [inline]

Factorizes x into a set of prime factors via consecutive division.

Definition at line 170 of file prime.hpp.

template<typename T>
vector<T, true> Arageli::factorize_division ( const T &  x  )  [inline]

Factorizes x into a set of prime factors via consecutive division.

Definition at line 179 of file prime.hpp.

template<typename T1, typename T2, bool REFCNT2, typename T_factory>
vector<T2, REFCNT2>& Arageli::factorize ( const T1 &  x,
vector< T2, REFCNT2 > &  res,
const T_factory &  tfctr 
) [inline]

Factorizes x into a set of prime factors via appropriate algorithm for T.

By default it is just call factorize_division function.

Definition at line 187 of file prime.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::factorize ( const T1 &  x,
vector< T2, REFCNT2 > &  res 
) [inline]

Factorizes x into a set of prime factors via appropriate algorithm for T.

Definition at line 194 of file prime.hpp.

template<typename T, typename T_factory>
vector<T, true> Arageli::factorize ( const T &  x,
const T_factory &  tfctr 
) [inline]

Factorizes x into a set of prime factors via appropriate algorithm for T.

Definition at line 201 of file prime.hpp.

template<typename T>
vector<T, true> Arageli::factorize ( const T &  x  )  [inline]

Factorizes x into a set of prime factors via appropriate algorithm for T.

Definition at line 210 of file prime.hpp.

template<typename T1, typename T2, bool REFCNT2, typename T3, typename T4>
vector<T2, REFCNT2>& Arageli::partial_factorize_division ( T1  x,
vector< T2, REFCNT2 > &  res,
const T3 &  max,
T4 &  rest 
)

Partialy factorizes x into a set of prime factors via test division.

template<typename T, typename N, typename T_factory>
T Arageli::pollard_pm1 ( const T &  n,
const N &  no_of_iter,
const T_factory &  tfctr 
)

Pollard p-1 method (Simple variant).

Pollard p-1 method (Simple variant)

template<typename T, typename N>
T Arageli::pollard_pm1 ( const T &  n,
const N &  no_of_iter = 10000 
)

Pollard p-1 method (Simple variant).

Pollard p-1 method (Simple variant)

Definition at line 243 of file prime.hpp.

template<typename T, typename T_factory>
T Arageli::rho_pollard ( const T &  n,
const T_factory &  tfctr 
)

Pollard's rho algorithm.

Return a non-trivial factor of n or 1 if the algorithm failed.

template<typename T>
T Arageli::rho_pollard ( const T &  n  ) 

Pollard's rho algorithm.

Return a non-trivial factor of n or 1 if the algorithm failed.

Definition at line 260 of file prime.hpp.

template<typename T, typename N, typename T_factory>
T Arageli::brent ( const T &  n,
no_of_iter,
const T_factory &  tfctr 
)

Pollard's rho algorithm.

Brent's improovement of Pollard's rho algorithm. Return a non-trivial factor of n or 1 if the algorithm failed. This algorithm can fail for composite n.

template<typename T, typename N>
T Arageli::brent ( const T &  n,
no_of_iter 
)

Pollard's rho algorithm.

Brent's improovement of Pollard's rho algorithm. Return a non-trivial factor of n or 1 if the algorithm failed. This algorithm can fail for composite n.

Definition at line 279 of file prime.hpp.

template<typename T, typename T3, typename T4>
vector<T, true> Arageli::partial_factorize_division ( const T &  x,
const T3 &  max,
T4 &  rest 
) [inline]

Partialy factorizes x into a set of prime factors via test division.

Definition at line 285 of file prime.hpp.

template<typename T1, typename TT1, typename T2, bool REFCNT2, typename T3>
vector<T2, REFCNT2>& Arageli::partial_factorize_division ( const T1 &  x,
vector< T2, REFCNT2 > &  res,
const T3 &  max 
) [inline]

Partialy factorizes x into a set of prime factors via test division.

Definition at line 300 of file prime.hpp.

template<typename T, typename T3>
vector<T, true> Arageli::partial_factorize_division ( const T &  x,
const T3 &  max 
) [inline]

Partialy factorizes x into a set of prime factors via test division.

Definition at line 310 of file prime.hpp.

template<typename T1, typename T2, bool REFCNT2, typename T3, typename T4>
vector<T2, REFCNT2>& Arageli::partial_factorize ( const T1 &  x,
vector< T2, REFCNT2 > &  res,
const T3 &  max,
T4 &  rest 
) [inline]

Partialy factorizes x into a set of prime factors via appropriate algorithm for T.

Definition at line 325 of file prime.hpp.

template<typename T, typename T3, typename T4>
vector<T, true> Arageli::partial_factorize ( const T &  x,
const T3 &  max,
T4 &  rest 
) [inline]

Partialy factorizes x into a set of prime factors via appropriate algorithm for T.

Definition at line 332 of file prime.hpp.

template<typename T1, typename TT1, typename T2, bool REFCNT2, typename T3>
vector<T2, REFCNT2>& Arageli::partial_factorize ( const T1 &  x,
vector< T2, REFCNT2 > &  res,
const T3 &  max 
) [inline]

Partialy factorizes x into a set of prime factors via appropriate algorithm for T.

Definition at line 347 of file prime.hpp.

template<typename T, typename T3>
vector<T, true> Arageli::partial_factorize ( const T &  x,
const T3 &  max 
) [inline]

Partialy factorizes x into a set of prime factors via appropriate algorithm for T.

Definition at line 357 of file prime.hpp.

template<typename T1, typename T2, typename T3, typename T4>
const T4& Arageli::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 Arageli::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.

Definition at line 371 of file prime.hpp.

template<typename T1, typename T2>
T1 Arageli::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.

Definition at line 381 of file prime.hpp.

template<typename T>
T Arageli::next_prime_successive_checking ( x  ) 

Finds the next after x prime number via successive test for each number.

Calls is_prime for each number greater then x and returns when is_prime returns true.

template<typename T>
T Arageli::prev_prime_successive_checking ( x  ) 

Finds the previous before x prime number via successive test for each number.

Calls is_prime for each number less then x and returns when is_prime returns true.

template<typename T>
T Arageli::next_prime ( const T &  x  )  [inline]

Finds the next after x prime number via appropriate algorithm.

Definition at line 411 of file prime.hpp.

template<typename T>
T Arageli::prev_prime ( const T &  x  )  [inline]

Finds the previous before x prime number via appropriate algorithm.

Definition at line 417 of file prime.hpp.

template<typename T>
T Arageli::next_probably_prime ( x  )  [inline]

Finds the next after x probably prime number via appropriate algorithm.

template<typename T>
T Arageli::prev_probably_prime ( x  )  [inline]

Finds the previous before x probably prime number via appropriate algorithm.

template<typename T, typename N>
void Arageli::rsa_generate_keys ( l,
T &  c,
T &  public_key,
T &  d 
)

algorithms.

Generate RSA kyes. l is the length of public key

template<typename T>
T Arageli::rsa_encyph ( const T &  x,
const T &  c,
const T &  key 
)

rsa encyphering

template<typename T>
T Arageli::rsa_decyph ( const T &  y,
const T &  d,
const T &  key 
)

rsa decyphering

template<typename T>
bool Arageli::is_mersen_prime_degree ( const T &  n  )  [inline]

Determines if 2^n-1 is Mersenn prime number.

Determination goes by Luka-Lemer criteria (1890, 1930). Be careful: the determination is time expensive for large n.

Definition at line 470 of file prime.hpp.

template<typename T>
T Arageli::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.

Determination by a table with all known at the moment Mersenn numbers. If the next number is unknown, the function throws an exception.

char Arageli::rand ( char  maxVal  )  [inline]

Definition at line 48 of file rand.hpp.

unsigned char Arageli::rand ( unsigned char  maxVal  )  [inline]

Definition at line 49 of file rand.hpp.

short Arageli::rand ( short  maxVal  )  [inline]

Definition at line 50 of file rand.hpp.

unsigned short Arageli::rand ( unsigned short  maxVal  )  [inline]

Definition at line 51 of file rand.hpp.

int Arageli::rand ( int  maxVal  )  [inline]

Definition at line 52 of file rand.hpp.

unsigned int Arageli::rand ( unsigned int  maxVal  )  [inline]

Definition at line 53 of file rand.hpp.

long Arageli::rand ( long  maxVal  )  [inline]

Definition at line 54 of file rand.hpp.

unsigned long Arageli::rand ( unsigned long  maxVal  )  [inline]

Definition at line 55 of file rand.hpp.

big_int Arageli::rand ( big_int  maxVal  )  [inline]

Definition at line 61 of file rand.hpp.

template<typename T>
rational<T> Arageli::rand ( const rational< T > &  maxVal  )  [inline]

Definition at line 64 of file rand.hpp.

template<typename F, typename I>
monom<F, I> Arageli::rand ( const monom< F, I > &  maxVal  )  [inline]

Definition at line 76 of file rand.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT> Arageli::rand ( const sparse_polynom< F, I, REFCNT > &  maxVal  )  [inline]

Definition at line 83 of file rand.hpp.

template<typename T, bool REFCNT>
matrix<T, REFCNT> Arageli::rand ( const matrix< T, REFCNT > &  maxVal  )  [inline]

Definition at line 93 of file rand.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_ostream<Ch, ChT>& Arageli::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 
) [inline]

Definition at line 349 of file rational.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_istream<Ch, ChT>& Arageli::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>& Arageli::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>& Arageli::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>& Arageli::operator<< ( std::basic_ostream< Ch, ChT > &  out,
const rational< T > &  x 
) [inline]

Reads a rational from a string notation.

Format is x or x/x where x is notation for object of type T.

Definition at line 396 of file rational.hpp.

template<typename T, typename Ch, typename ChT>
std::basic_istream<Ch, ChT>& Arageli::operator>> ( std::basic_istream< Ch, ChT > &  in,
rational< T > &  x 
) [inline]

Writes a rational to a string notation.

Format is x or x/x where x is notation for object of type T.

Definition at line 407 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator+ ( const rational< T1 > &  b,
const rational< T2 > &  c 
)

template<typename T1, typename T2>
rational<T1> Arageli::operator- ( const rational< T1 > &  b,
const rational< T2 > &  c 
)

template<typename T1, typename T2>
rational<T1> Arageli::operator * ( const rational< T1 > &  b,
const rational< T2 > &  c 
)

template<typename T1, typename T2>
rational<T1> Arageli::operator/ ( const rational< T1 > &  b,
const rational< T2 > &  c 
)

template<typename T1, typename T2>
rational<T1> Arageli::operator% ( const rational< T1 > &  b,
const rational< T2 > &  c 
) [inline]

Definition at line 435 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator+= ( rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 469 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator+= ( rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 469 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator+ ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 469 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator+ ( const T2 &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 469 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator-= ( rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 470 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator-= ( rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 470 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator- ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 470 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator- ( const T2 &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 470 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator *= ( rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 471 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator *= ( rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 471 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator * ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 471 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator * ( const T2 &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 471 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator/= ( rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 472 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator/= ( rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 472 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator/ ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 472 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator/ ( const T2 &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 472 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator%= ( rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 473 of file rational.hpp.

template<typename T1, typename T2>
rational<T1>& Arageli::operator%= ( rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 473 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator% ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 473 of file rational.hpp.

template<typename T1, typename T2>
rational<T1> Arageli::operator% ( const T2 &  a,
const rational< T1 > &  b 
) [inline]

Definition at line 473 of file rational.hpp.

template<typename T1, typename T2>
int Arageli::cmp ( const rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Comparison of two rationals.

Returns

Definition at line 489 of file rational.hpp.

template<typename T>
int Arageli::sign ( const rational< T > &  x  )  [inline]

Definition at line 497 of file rational.hpp.

template<typename T>
bool Arageli::is_coprime ( const rational< T > &  a,
const rational< T > &  b 
) [inline]

Definition at line 502 of file rational.hpp.

template<typename T>
rational<T> Arageli::gcd ( const rational< T > &  a,
const rational< T > &  b 
) [inline]

Definition at line 507 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator< ( const rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 535 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator< ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 535 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator< ( const T1 &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 535 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator> ( const rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 536 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator> ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 536 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator> ( const T1 &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 536 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator== ( const rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 537 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator== ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 537 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator== ( const T1 &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 537 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator!= ( const rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 538 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator!= ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 538 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator!= ( const T1 &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 538 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator<= ( const rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 539 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator<= ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 539 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator<= ( const T1 &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 539 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator>= ( const rational< T1 > &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 540 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator>= ( const rational< T1 > &  a,
const T2 &  b 
) [inline]

Definition at line 540 of file rational.hpp.

template<typename T1, typename T2>
bool Arageli::operator>= ( const T1 &  a,
const rational< T2 > &  b 
) [inline]

Definition at line 540 of file rational.hpp.

template<typename T>
T Arageli::ifloor ( const rational< T > &  x  ) 

Floor of x.

Returns maximum integer i <= x.

template<typename T>
T Arageli::iceil ( const rational< T > &  x  ) 

Ceiling of x.

Returns minimum integer i >= x.

template<typename T>
rational<T> Arageli::frac ( const rational< T > &  x  )  [inline]

Fractional part of x.

Return x - floor(x).

Definition at line 561 of file rational.hpp.

template<typename T1>
bool Arageli::is_null ( const rational< T1 > &  x  )  [inline]

Definition at line 628 of file rational.hpp.

template<typename T1>
rational<T1> Arageli::opposite ( const rational< T1 > &  x  )  [inline]

Definition at line 632 of file rational.hpp.

template<typename T1>
rational<T1>& Arageli::opposite ( const rational< T1 > &  x,
rational< T1 > *  y 
) [inline]

Definition at line 636 of file rational.hpp.

template<typename T1>
rational<T1>& Arageli::opposite ( rational< T1 > *  x  )  [inline]

Definition at line 640 of file rational.hpp.

template<typename T1>
rational<T1> Arageli::inverse ( const rational< T1 > &  x  )  [inline]

Definition at line 644 of file rational.hpp.

template<typename T1>
rational<T1>& Arageli::inverse ( const rational< T1 > &  x,
rational< T1 > *  y 
) [inline]

Definition at line 651 of file rational.hpp.

template<typename T1>
rational<T1>& Arageli::inverse ( rational< T1 > *  x  )  [inline]

Definition at line 658 of file rational.hpp.

template<typename T1>
std::ostream& Arageli::output_polynom_first ( std::ostream &  out,
const rational< T1 > &  x 
) [inline]

Definition at line 678 of file rational.hpp.

template<typename T1>
std::ostream& Arageli::output_polynom_internal ( std::ostream &  out,
const rational< T1 > &  x 
) [inline]

Definition at line 683 of file rational.hpp.

template<typename T1>
std::ostream& Arageli::output_pow ( std::ostream &  out,
const rational< T1 > &  x 
) [inline]

Definition at line 687 of file rational.hpp.

template<typename T1>
std::istream& Arageli::input_polynom_first ( std::istream &  in,
rational< T1 > &  x 
) [inline]

Definition at line 691 of file rational.hpp.

template<typename T1>
std::istream& Arageli::input_polynom_internal ( std::istream &  in,
rational< T1 > &  x 
) [inline]

Definition at line 696 of file rational.hpp.

template<typename T1>
std::istream& Arageli::input_pow ( std::istream &  in,
rational< T1 > &  x 
) [inline]

Definition at line 700 of file rational.hpp.

template<typename T>
rational<T> Arageli::abs ( const rational< T > &  x  )  [inline]

Absolute value of x.

Definition at line 705 of file rational.hpp.

template<typename T>
rational<T> Arageli::floor ( const rational< T > &  x  )  [inline]

Floor of x.

See Arageli::ifloor.

Definition at line 711 of file rational.hpp.

template<typename T>
rational<T> Arageli::ceil ( const rational< T > &  x  )  [inline]

Ceiling of x.

See Arageli::iceil.

Definition at line 717 of file rational.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue<T1, M1, Config1> Arageli::operator+ ( residue< T1, M1, Config1 >  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 240 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue<T1, M1, Config1> Arageli::operator- ( residue< T1, M1, Config1 >  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 241 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue<T1, M1, Config1> Arageli::operator * ( residue< T1, M1, Config1 >  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 242 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue<T1, M1, Config1> Arageli::operator/ ( residue< T1, M1, Config1 >  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 243 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
residue<T1, M1, Config1> Arageli::operator% ( residue< T1, M1, Config1 >  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 244 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool Arageli::operator== ( const residue< T1, M1, Config1 > &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 278 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2>
bool Arageli::operator== ( const residue< T1, M1, Config1 > &  a,
const T2 &  b 
) [inline]

Definition at line 278 of file residue.hpp.

template<typename T1, typename T2, typename M2, typename Config2>
bool Arageli::operator== ( const T1 &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 278 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool Arageli::operator!= ( const residue< T1, M1, Config1 > &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 279 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2>
bool Arageli::operator!= ( const residue< T1, M1, Config1 > &  a,
const T2 &  b 
) [inline]

Definition at line 279 of file residue.hpp.

template<typename T1, typename T2, typename M2, typename Config2>
bool Arageli::operator!= ( const T1 &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 279 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool Arageli::operator< ( const residue< T1, M1, Config1 > &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 280 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2>
bool Arageli::operator< ( const residue< T1, M1, Config1 > &  a,
const T2 &  b 
) [inline]

Definition at line 280 of file residue.hpp.

template<typename T1, typename T2, typename M2, typename Config2>
bool Arageli::operator< ( const T1 &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 280 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool Arageli::operator<= ( const residue< T1, M1, Config1 > &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 281 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2>
bool Arageli::operator<= ( const residue< T1, M1, Config1 > &  a,
const T2 &  b 
) [inline]

Definition at line 281 of file residue.hpp.

template<typename T1, typename T2, typename M2, typename Config2>
bool Arageli::operator<= ( const T1 &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 281 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool Arageli::operator> ( const residue< T1, M1, Config1 > &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 282 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2>
bool Arageli::operator> ( const residue< T1, M1, Config1 > &  a,
const T2 &  b 
) [inline]

Definition at line 282 of file residue.hpp.

template<typename T1, typename T2, typename M2, typename Config2>
bool Arageli::operator> ( const T1 &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 282 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
bool Arageli::operator>= ( const residue< T1, M1, Config1 > &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 283 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2>
bool Arageli::operator>= ( const residue< T1, M1, Config1 > &  a,
const T2 &  b 
) [inline]

Definition at line 283 of file residue.hpp.

template<typename T1, typename T2, typename M2, typename Config2>
bool Arageli::operator>= ( const T1 &  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 283 of file residue.hpp.

template<typename T1, typename M1, typename Config1, typename T2, typename M2, typename Config2>
int Arageli::cmp ( residue< T1, M1, Config1 >  a,
const residue< T2, M2, Config2 > &  b 
) [inline]

Definition at line 292 of file residue.hpp.

template<typename T, typename M, typename Config>
std::ostream& Arageli::operator<< ( std::ostream &  out,
const residue< T, M, Config > &  x 
) [inline]

Definition at line 297 of file residue.hpp.

template<typename T, typename M, typename Config>
std::istream& Arageli::operator>> ( std::istream &  in,
residue< T, M, Config > &  x 
)

Definition at line 302 of file residue.hpp.

template<typename T, typename M, typename Config>
const residue<T, M, Config>& Arageli::abs ( const residue< T, M, Config > &  x  ) 

Definition at line 366 of file residue.hpp.

template<typename P1, typename P2, typename M>
M& Arageli::sylvester_fill ( const P1 &  p1,
const P2 &  p2,
M &  res 
)

Fills non-zero elements in Sylvester matrix from two polynomials.

If res originaly is zero-matrix, the result is Sylvester matrix for these polynomials. Before filling the function appropriate resize a matrix.

template<typename P1, typename P2, typename M, typename MTFactory>
M& Arageli::sylvester ( const P1 &  p1,
const P2 &  p2,
M &  res,
MTFactory  fctr 
)

Creates Sylvester matrix from two polynomials.

This function resizes appropriatly and fills matrix 'res'. Returns just a reference to those matrix, i.e. a reference to 'res'. Factory 'fctr' should be intended to build objects of type 'res' element.

template<typename P1, typename P2, typename M>
M& Arageli::sylvester ( const P1 &  p1,
const P2 &  p2,
M &  res 
) [inline]

Creates Sylvester matrix from two polynomials.

Definition at line 58 of file resultant.hpp.

template<typename P1, typename P2>
matrix<typename P1::coef_type> Arageli::sylvester ( const P1 &  p1,
const P2 &  p2 
) [inline]

Creates Sylvester matrix from two polynomials.

Definition at line 65 of file resultant.hpp.

template<typename P1, typename P2, typename SRChain, typename PCFactory>
void Arageli::subresultants_nonmodular ( const P1 &  p1,
const P2 &  p2,
SRChain &  s,
PCFactory  fctr 
)

Computes the chain of subresultants of two polynomials.

Unfortunatly, we have a problem with signs of the result subresultants. BE CAREFUL! Use this function in case only if a sign of the result doesn't matter.

Parameters:
s - should be a vector of polynomials compatible with p1 and p2.

template<typename P1, typename P2, typename SRChain>
void Arageli::subresultants_nonmodular ( const P1 &  p1,
const P2 &  p2,
SRChain &  s 
) [inline]

Computes the chain of subresultants of two polynomials.

See the full version of this function.

Definition at line 89 of file resultant.hpp.

template<typename P1, typename P2, typename PCFactory>
P1::coef_type Arageli::resultant_nonmodular ( const P1 &  p1,
const P2 &  p2,
PCFactory  fctr 
)

Computes the resultant of two polynomials.

As we use subresultants_nonmodular in computation we have the same problem --- the problem with sign. See subresultants_nonmodular function for details.

template<typename P1, typename P2>
P1::coef_type Arageli::resultant_nonmodular ( const P1 &  p1,
const P2 &  p2 
) [inline]

Computes the resultant of two polynomials.

See the full version of this function.

Definition at line 109 of file resultant.hpp.

template<typename P1, typename P2, typename PCFactory>
P1::coef_type Arageli::resultant ( const P1 &  p1,
const P2 &  p2,
PCFactory  fctr 
) [inline]

Computes the resultant of two polynomials.

Definition at line 121 of file resultant.hpp.

template<typename P1, typename P2>
P1::coef_type Arageli::resultant ( const P1 &  p1,
const P2 &  p2 
) [inline]

Computes the resultant of two polynomials.

Definition at line 132 of file resultant.hpp.

template<typename A, typename F, typename Q, typename E, typename Ctrler>
void Arageli::skeleton ( A &  a,
F &  f,
Q &  q,
E &  e,
const Ctrler &  ctrler 
) [inline]

The algorithm for double-description of a polyhedal cone.

Finds extreme rays f and basis e of a cone ax >= 0 returns also an incidence matrix q = f * transpose(a).

Definition at line 55 of file skeleton.hpp.

template<typename A, typename F, typename Q, typename E>
void Arageli::skeleton ( A &  a,
F &  f,
Q &  q,
E &  e 
) [inline]

The algorithm for double-description of a polyhedal cone.

Just calls full version of the function.

Definition at line 65 of file skeleton.hpp.

template<typename MA, typename MB, typename MP, typename MQ, typename Rank, typename T_det, typename T_factory, typename Ctrler, typename Norm>
void Arageli::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.

Produces normal diagonal form B of integer matrix A. Returns B, P, Q, rank, det:

template<typename MA, typename MB, typename MP, typename MQ, typename Rank, typename T_det, typename Ctrler>
void Arageli::smith ( const MA &  A,
MB &  B,
MP &  P,
MQ &  Q,
Rank &  rank,
T_det &  det,
Ctrler  ctrler 
) [inline]

Produces normal diagonal form B of integer matrix A.

Definition at line 139 of file smith.hpp.

template<typename MA, typename MB, typename MP, typename MQ, typename Rank, typename T_det>
void Arageli::smith ( const MA &  A,
MB &  B,
MP &  P,
MQ &  Q,
Rank &  rank,
T_det &  det 
) [inline]

Produces normal diagonal form B of integer matrix A.

Definition at line 170 of file smith.hpp.

template<typename M>
M Arageli::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 Arageli::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.

Produces normal diagonal form B of integer matrix A. Returns B, P, Q, rank, det:

template<typename MA, typename MB, typename MP, typename MQ, typename Rank, typename T_det>
void Arageli::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.

Returns B, P, Q, rank, det:

template<typename A, typename B, typename GX, typename Offset>
solve_linsys_result Arageli::solve_linsys ( const A &  a,
const B &  b,
Offset &  offset,
GX &  gx 
)

Solve heterogeneous linear system.

Solve linear system a*x = b. If the system doesn't have a solution, the function returns SLR_EMPTY. If the system have a solution(s), gx is a matrix of generators: any x is uniquely represented as x = offset + sum(a[i]*gx.col(i), i = 0..gx.ncols()-1), where a[i], i = 0..gx.ncols()-1 are some coefficients.

WARNING! It isn't implemented yet.

template<typename A, typename B, typename X>
solve_linsys_result Arageli::solve_linsys ( const A &  a,
const B &  b,
X &  x 
)

Solve a heterogeneous linear system.

Solve linear system a*x = b. If the system have only one point x as a solution, that solution is stored as x argument and the function returns SLR_UNIQUE. If the system doesn't have a solution, x isn't changed and the function returns SLR_EMPTY. If the system have a multiple solution, x is set equal to the one of them and the function returns SLR_MULTIPLE.

WARNING! This function has a slow and temporary limited implementation.

template<typename A, typename B>
B Arageli::solve_linsys ( const A &  a,
const B &  b 
)

Solve a heterogeneous linear system.

Solve linear system a*x = b. If the system have only one point x as a solution, that solution is returned. If the system doesn't have a solution or have a multiple solution, the function throws exception no_unique_solution.

WARNING! This function has a slow and temporary limited implementation.

template<typename A>
A Arageli::solve_linsys ( const A &  a  ) 

Solve a homogeneous linear system.

Solve linear system a*x = 0. Returns matrix of generators. Each x is represented as x = sum(a[i]*gx.col(i), i = 0..gx.ncols()-1) where gx is returned matrix and a[i], i = 0..gx.ncols()-1 are some coefficients.

WARNING! It isn't implemented yet.

template<typename F, typename I>
bool Arageli::is_unit ( const monom< F, I > &  x  )  [inline]

Definition at line 437 of file sparse_polynom.hpp.

template<typename F, typename I>
bool Arageli::is_opposite_unit ( const monom< F, I > &  x  )  [inline]

Definition at line 441 of file sparse_polynom.hpp.

template<typename F, typename I>
bool Arageli::is_null ( const monom< F, I > &  x  )  [inline]

Definition at line 445 of file sparse_polynom.hpp.

template<typename F, typename I>
monom<F, I> Arageli::opposite ( const monom< F, I > &  x  )  [inline]

Definition at line 449 of file sparse_polynom.hpp.

template<typename F, typename I>
monom<F, I>& Arageli::opposite ( const monom< F, I > &  x,
monom< F, I > *  y 
) [inline]

Definition at line 453 of file sparse_polynom.hpp.

template<typename F, typename I>
monom<F, I>& Arageli::opposite ( monom< F, I > *  x  )  [inline]

Definition at line 457 of file sparse_polynom.hpp.

template<typename F, typename I>
monom<F, I> Arageli::inverse ( const monom< F, I > &  x  )  [inline]

Definition at line 461 of file sparse_polynom.hpp.

template<typename F, typename I>
monom<F, I>& Arageli::inverse ( const monom< F, I > &  x,
monom< F, I > *  y 
) [inline]

Definition at line 468 of file sparse_polynom.hpp.

template<typename F, typename I>
monom<F, I>& Arageli::inverse ( monom< F, I > *  x  )  [inline]

Definition at line 477 of file sparse_polynom.hpp.

template<typename F, typename I>
std::ostream& Arageli::output_polynom_first ( std::ostream &  out,
const monom< F, I > &  x 
) [inline]

Definition at line 485 of file sparse_polynom.hpp.

template<typename F, typename I>
std::ostream& Arageli::output_polynom_internal ( std::ostream &  out,
const monom< F, I > &  x 
) [inline]

Definition at line 490 of file sparse_polynom.hpp.

template<typename F, typename I>
std::ostream& Arageli::output_pow ( std::ostream &  out,
const monom< F, I > &  x 
) [inline]

Definition at line 494 of file sparse_polynom.hpp.

template<typename F, typename I>
std::istream& Arageli::input_polynom_first ( std::istream &  in,
monom< F, I > &  x 
)

template<typename F, typename I>
std::istream& Arageli::input_polynom_internal ( std::istream &  in,
monom< F, I > &  x 
)

template<typename F, typename I>
std::istream& Arageli::input_pow ( std::istream &  in,
monom< F, I > &  x 
) [inline]

Definition at line 505 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
int Arageli::cmp ( const monom< F1, I1 > &  m1,
const monom< F2, I2 > &  m2 
) [inline]

Lexicographical comparision of two monoms. Regards each monom as pair (sign of coefficient, degree, coefficient)

Definition at line 523 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
int Arageli::cmp ( const monom< F1, I1 > &  m1,
const F2 &  b 
) [inline]

Definition at line 534 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
int Arageli::cmp ( const F1 &  a,
const monom< F2, I2 > &  m2 
) [inline]

Definition at line 539 of file sparse_polynom.hpp.

template<typename F, typename I, typename Factory_coef>
int Arageli::sign ( const monom< F, I > &  x  )  [inline]

Determines the sign of monom, i.e. sign of the its coefficient.

Factory_coef must have a method to produce null element of F type.

Definition at line 546 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
bool Arageli::operator== ( const monom< F1, I1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 576 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
bool Arageli::operator== ( const monom< F1, I1 > &  a,
const F2 &  b 
) [inline]

Definition at line 576 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
bool Arageli::operator== ( const F1 &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 576 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
bool Arageli::operator!= ( const monom< F1, I1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 577 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
bool Arageli::operator!= ( const monom< F1, I1 > &  a,
const F2 &  b 
) [inline]

Definition at line 577 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
bool Arageli::operator!= ( const F1 &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 577 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
bool Arageli::operator<= ( const monom< F1, I1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 578 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
bool Arageli::operator<= ( const monom< F1, I1 > &  a,
const F2 &  b 
) [inline]

Definition at line 578 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
bool Arageli::operator<= ( const F1 &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 578 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
bool Arageli::operator>= ( const monom< F1, I1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 579 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
bool Arageli::operator>= ( const monom< F1, I1 > &  a,
const F2 &  b 
) [inline]

Definition at line 579 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
bool Arageli::operator>= ( const F1 &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 579 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
bool Arageli::operator< ( const monom< F1, I1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 580 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
bool Arageli::operator< ( const monom< F1, I1 > &  a,
const F2 &  b 
) [inline]

Definition at line 580 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
bool Arageli::operator< ( const F1 &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 580 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
bool Arageli::operator> ( const monom< F1, I1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 581 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
bool Arageli::operator> ( const monom< F1, I1 > &  a,
const F2 &  b 
) [inline]

Definition at line 581 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
bool Arageli::operator> ( const F1 &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 581 of file sparse_polynom.hpp.

template<typename Ch, typename ChT, typename F, typename I>
std::basic_ostream<Ch, ChT>& Arageli::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 
) [inline]

Simple outputting of monom.

Âûâîäèò ìîíîì â ïðîñòîì âèäå "(êîýô, ñòåï)", ãäå ñèìâîëû ðàçäåëèòåëè ìîãóò çàäàâàòüñÿ ïîëüçîâàòåëåì.

Definition at line 631 of file sparse_polynom.hpp.

template<typename Ch, typename ChT, typename F, typename I>
std::basic_ostream<Ch, ChT>& Arageli::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>& Arageli::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>& Arageli::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>& Arageli::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.

Definition at line 702 of file sparse_polynom.hpp.

template<typename Ch, typename ChT, typename F, typename I>
std::basic_ostream<Ch, ChT>& Arageli::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 
) [inline]

Oputputs monom in aligned form. (Restricted implementation.).

The aligned form for monom includes two line of output: on the bottom line coefficient and variable symbol are placed and on the top line degree is placed. WARNING. Temporary this form is equal to output_var.

Definition at line 732 of file sparse_polynom.hpp.

template<typename F, typename I, typename Ch, typename ChT>
std::basic_ostream<Ch, ChT>& Arageli::operator<< ( std::basic_ostream< Ch, ChT > &  out,
const monom< F, I > &  x 
) [inline]

Ñòàíäàðòíûé ñïîñîá âûâîäà ìîíîìà: ñîâïàäàåò ñ output_var.

Definition at line 750 of file sparse_polynom.hpp.

template<typename F, typename I, typename Ch, typename ChT>
std::basic_istream<Ch, ChT>& Arageli::operator>> ( std::basic_istream< Ch, ChT > &  in,
monom< F, I > &  x 
) [inline]

Ñòàíäàðòíûé ñïîñîá ââîäà ìîíîìà: ñîâïàäàåò ñ input_var.

Definition at line 761 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
monom<F1, I1> Arageli::operator+ ( const monom< F1, I1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 807 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
monom<F1, I1> Arageli::operator+ ( const monom< F1, I1 > &  x,
const F2 &  y 
) [inline]

Definition at line 807 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
monom<F2, I2> Arageli::operator+ ( const F1 &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 807 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
monom<F1, I1> Arageli::operator- ( const monom< F1, I1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 808 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
monom<F1, I1> Arageli::operator- ( const monom< F1, I1 > &  x,
const F2 &  y 
) [inline]

Definition at line 808 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
monom<F2, I2> Arageli::operator- ( const F1 &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 808 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
monom<F1, I1> Arageli::operator * ( const monom< F1, I1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 809 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
monom<F1, I1> Arageli::operator * ( const monom< F1, I1 > &  x,
const F2 &  y 
) [inline]

Definition at line 809 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
monom<F2, I2> Arageli::operator * ( const F1 &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 809 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
monom<F1, I1> Arageli::operator/ ( const monom< F1, I1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 810 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
monom<F1, I1> Arageli::operator/ ( const monom< F1, I1 > &  x,
const F2 &  y 
) [inline]

Definition at line 810 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
monom<F2, I2> Arageli::operator/ ( const F1 &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 810 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2>
monom<F1, I1> Arageli::operator% ( const monom< F1, I1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 811 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2>
monom<F1, I1> Arageli::operator% ( const monom< F1, I1 > &  x,
const F2 &  y 
) [inline]

Definition at line 811 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2>
monom<F2, I2> Arageli::operator% ( const F1 &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 811 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT> Arageli::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>& Arageli::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.

Âûâîäèò ïîëèíîì â ïðîñòîì âèäå "(ìîíîì_1, ìîíîì_2, ..., ìîíîì_size)", ãäå ìíîãîòî÷èå íå ÿâëÿåòñÿ ýëåìåíòîì ñèíòàêñèñà è ìîíîìû âûâîäÿòñÿ ñ ïîìîùüþ output_list. Ñèìâîëû- ðàçäåëèòåëè ìîãóò çàäàâàòüñÿ ïîëüçîâàòåëåì. Çàìå÷àíèå. Åñëè âû õîòèòå èçìåíèòü ïàðàìåòðû ïî óìîë÷àíèþ äëÿ ýòîé ôóíêöèè, òî, íå çóáóäüòå ñäåëàòü òî æå ñàìîå è äëÿ êîíñòðóêòîðà sparse_polynom_outputer_simple.

template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_ostream<Ch, ChT>& Arageli::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.

Âûâîäèò ïîëèíîì â ïðèâû÷íîì âèäå, ñ óêàçàíèåì ôîðìàëüíîé ïåðåìåííîé, äëÿ âûâîäà ìîíîìà èñïîëüçóåòñÿ output_var. Çàìå÷àíèå. Åñëè âû õîòèòå èçìåíèòü ïàðàìåòðû ïî óìîë÷àíèþ äëÿ ýòîé ôóíêöèè, òî, íå çóáóäüòå ñäåëàòü òî æå ñàìîå è äëÿ êîíñòðóêòîðà sparse_polynom_outputer_var.

template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_istream<Ch, ChT>& Arageli::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>& Arageli::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>& Arageli::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 
) [inline]

Inputting of a polynomial with variable symbol.

Definition at line 1820 of file sparse_polynom.hpp.

template<typename Ch, typename ChT, typename F, typename I, bool REFCNT>
std::basic_ostream<Ch, ChT>& Arageli::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 
) [inline]

Oputputs polynomial in aligned form. (Restricted implementation.).

The aligned form for polynomial includes two line of output: on the bottom line coefficients and variables symbol are placed and on the top line degrees are placed. WARNING. Temporary this form is equal to output_var.

Definition at line 1849 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_ostream<Ch, ChT>& Arageli::operator<< ( std::basic_ostream< Ch, ChT > &  out,
const sparse_polynom< F, I, REFCNT > &  x 
)

Ñòàíàðòíûé âûâîä ïîëèíîìà. Ñîâïàäàåò ñ sparse_polynom_output_var.

Definition at line 1867 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT, typename Ch, typename ChT>
std::basic_istream<Ch, ChT>& Arageli::operator>> ( std::basic_istream< Ch, ChT > &  in,
sparse_polynom< F, I, REFCNT > &  x 
)

Ñòàíàðòíûé âûâîä ïîëèíîìà. Ñîâïàäàåò ñ sparse_polynom_input_var.

Definition at line 1878 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator+ ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1987 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator+ ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 1987 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator+ ( const monom< F1, I1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1987 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator+ ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const F2 &  y 
) [inline]

Definition at line 1987 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator+ ( const F1 &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1987 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator+ ( const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  x,
const rational< F1 > &  y 
) [inline]

Definition at line 1987 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator+ ( const rational< F1 > &  x,
const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  y 
) [inline]

Definition at line 1987 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator- ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1988 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator- ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 1988 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator- ( const monom< F1, I1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1988 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator- ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const F2 &  y 
) [inline]

Definition at line 1988 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator- ( const F1 &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1988 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator- ( const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  x,
const rational< F1 > &  y 
) [inline]

Definition at line 1988 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator- ( const rational< F1 > &  x,
const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  y 
) [inline]

Definition at line 1988 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator * ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1989 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator * ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 1989 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator * ( const monom< F1, I1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1989 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator * ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const F2 &  y 
) [inline]

Definition at line 1989 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator * ( const F1 &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1989 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator * ( const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  x,
const rational< F1 > &  y 
) [inline]

Definition at line 1989 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator * ( const rational< F1 > &  x,
const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  y 
) [inline]

Definition at line 1989 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator/ ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1990 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator/ ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 1990 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator/ ( const monom< F1, I1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1990 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator/ ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const F2 &  y 
) [inline]

Definition at line 1990 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator/ ( const F1 &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1990 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator/ ( const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  x,
const rational< F1 > &  y 
) [inline]

Definition at line 1990 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator/ ( const rational< F1 > &  x,
const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  y 
) [inline]

Definition at line 1990 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator% ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1991 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator% ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const monom< F2, I2 > &  y 
) [inline]

Definition at line 1991 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator% ( const monom< F1, I1 > &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1991 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
sparse_polynom<F1, I1, REFCNT1> Arageli::operator% ( const sparse_polynom< F1, I1, REFCNT1 > &  x,
const F2 &  y 
) [inline]

Definition at line 1991 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
sparse_polynom<F2, I2, REFCNT2> Arageli::operator% ( const F1 &  x,
const sparse_polynom< F2, I2, REFCNT2 > &  y 
) [inline]

Definition at line 1991 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator% ( const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  x,
const rational< F1 > &  y 
) [inline]

Definition at line 1991 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1>
sparse_polynom<rational<F1>, I1, REFCNT1> Arageli::operator% ( const rational< F1 > &  x,
const sparse_polynom< rational< F1 >, I1, REFCNT1 > &  y 
) [inline]

Definition at line 1991 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
int Arageli::cmp ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Lexicographical comparision of two polynomials.

Regards polynomial as sequence of monoms that begins monom with greatest degree value and compares two sequences of monoms lexicograficaly. Returns

Definition at line 2013 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
bool Arageli::is_primitive ( const sparse_polynom< F, I, REFCNT > &  x  ) 

Definition at line 2068 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator== ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2140 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool Arageli::operator== ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 2140 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator== ( const monom< F1, I1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2140 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
bool Arageli::operator== ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const F2 &  b 
) [inline]

Definition at line 2140 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator== ( const F1 &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2140 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator!= ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2141 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool Arageli::operator!= ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 2141 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator!= ( const monom< F1, I1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2141 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
bool Arageli::operator!= ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const F2 &  b 
) [inline]

Definition at line 2141 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator!= ( const F1 &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2141 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator<= ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2142 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool Arageli::operator<= ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 2142 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator<= ( const monom< F1, I1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2142 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
bool Arageli::operator<= ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const F2 &  b 
) [inline]

Definition at line 2142 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator<= ( const F1 &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2142 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator>= ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2143 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool Arageli::operator>= ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 2143 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator>= ( const monom< F1, I1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2143 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
bool Arageli::operator>= ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const F2 &  b 
) [inline]

Definition at line 2143 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator>= ( const F1 &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2143 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator< ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2144 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool Arageli::operator< ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 2144 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator< ( const monom< F1, I1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2144 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
bool Arageli::operator< ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const F2 &  b 
) [inline]

Definition at line 2144 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator< ( const F1 &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2144 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator> ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2145 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2>
bool Arageli::operator> ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const monom< F2, I2 > &  b 
) [inline]

Definition at line 2145 of file sparse_polynom.hpp.

template<typename F1, typename I1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator> ( const monom< F1, I1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2145 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2>
bool Arageli::operator> ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const F2 &  b 
) [inline]

Definition at line 2145 of file sparse_polynom.hpp.

template<typename F1, typename F2, typename I2, bool REFCNT2>
bool Arageli::operator> ( const F1 &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b 
) [inline]

Definition at line 2145 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
bool Arageli::is_unit ( const sparse_polynom< F, I, REFCNT > &  x  )  [inline]

Definition at line 2267 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
bool Arageli::is_opposite_unit ( const sparse_polynom< F, I, REFCNT > &  x  )  [inline]

Definition at line 2271 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
bool Arageli::is_null ( const sparse_polynom< F, I, REFCNT > &  x  )  [inline]

Definition at line 2275 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT> Arageli::opposite ( const sparse_polynom< F, I, REFCNT > &  x  )  [inline]

Definition at line 2280 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT>& Arageli::opposite ( const sparse_polynom< F, I, REFCNT > &  x,
sparse_polynom< F, I, REFCNT > *  y 
) [inline]

Definition at line 2285 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT>& Arageli::opposite ( sparse_polynom< F, I, REFCNT > *  x  )  [inline]

Definition at line 2290 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT> Arageli::inverse ( const sparse_polynom< F, I, REFCNT > &  x  )  [inline]

Definition at line 2294 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT>& Arageli::inverse ( const sparse_polynom< F, I, REFCNT > &  x,
sparse_polynom< F, I, REFCNT > *  y 
) [inline]

Definition at line 2301 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT>& Arageli::inverse ( sparse_polynom< F, I, REFCNT > *  x  )  [inline]

Definition at line 2308 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
std::ostream& Arageli::output_polynom_first ( std::ostream &  out,
const sparse_polynom< F, I, REFCNT > &  x 
) [inline]

Definition at line 2315 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
std::ostream& Arageli::output_polynom_internal ( std::ostream &  out,
const sparse_polynom< F, I, REFCNT > &  x 
) [inline]

Definition at line 2320 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
std::ostream& Arageli::output_pow ( std::ostream &  out,
const sparse_polynom< F, I, REFCNT > &  x 
) [inline]

Definition at line 2324 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
std::istream& Arageli::input_polynom_first ( std::istream &  in,
sparse_polynom< F, I, REFCNT > &  x 
)

template<typename F, typename I, bool REFCNT>
std::istream& Arageli::input_polynom_internal ( std::istream &  in,
sparse_polynom< F, I, REFCNT > &  x 
)

template<typename F, typename I, bool REFCNT>
std::istream& Arageli::input_pow ( std::istream &  in,
sparse_polynom< F, I, REFCNT > &  x 
) [inline]

Definition at line 2335 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT> Arageli::euclid ( sparse_polynom< F, I, REFCNT >  a,
sparse_polynom< F, I, REFCNT >  b 
)

Specialization of euclid for sparse_polynom.

Definition at line 2443 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
bool Arageli::is_coprime ( const sparse_polynom< F, I, REFCNT > &  a,
const sparse_polynom< F, I, REFCNT > &  b 
) [inline]

Specialization of is_coprime for sparse_polynom.

Definition at line 2465 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename F2, typename I2, bool REFCNT2, typename Q, typename R>
void Arageli::prdivide ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const sparse_polynom< F2, I2, REFCNT2 > &  b,
Q &  q,
R &  r 
) [inline]

Definition at line 2494 of file sparse_polynom.hpp.

template<typename F1, typename I1, bool REFCNT1, typename I2>
sparse_polynom<F1, I1, REFCNT1> Arageli::pow ( const sparse_polynom< F1, I1, REFCNT1 > &  a,
const I2 &  n 
) [inline]

Definition at line 2508 of file sparse_polynom.hpp.

template<typename F, typename I>
monom<F, I> Arageli::abs ( const monom< F, I > &  x  )  [inline]

Absolute value for monom.

It is a monom with the same degree and abs(x.coef()) coefficient.

Definition at line 2519 of file sparse_polynom.hpp.

template<typename F, typename I, bool REFCNT>
sparse_polynom<F, I, REFCNT> Arageli::abs ( const sparse_polynom< F, I, REFCNT > &  x  )  [inline]

Absolute value for polynomial.

It is x if leading coefficient of x is positive and -x if leading coefficient is negative.

Definition at line 2527 of file sparse_polynom.hpp.

template<typename T>
T Arageli::sin ( const T &  x  )  [inline]

Definition at line 15 of file std_import.hpp.

template<typename T>
T Arageli::cos ( const T &  x  )  [inline]

Definition at line 16 of file std_import.hpp.

template<typename T>
T Arageli::tan ( const T &  x  )  [inline]

Definition at line 17 of file std_import.hpp.

template<typename T>
T Arageli::sinh ( const T &  x  )  [inline]

Definition at line 18 of file std_import.hpp.

template<typename T>
T Arageli::cosh ( const T &  x  )  [inline]

Definition at line 19 of file std_import.hpp.

template<typename T>
T Arageli::tanh ( const T &  x  )  [inline]

Definition at line 20 of file std_import.hpp.

template<typename T>
T Arageli::asin ( const T &  x  )  [inline]

Definition at line 21 of file std_import.hpp.

template<typename T>
T Arageli::acos ( const T &  x  )  [inline]

Definition at line 22 of file std_import.hpp.

template<typename T>
T Arageli::atan ( const T &  x  )  [inline]

Definition at line 23 of file std_import.hpp.

template<typename T>
T Arageli::abs ( const T &  x  )  [inline]

Definition at line 24 of file std_import.hpp.

template<typename T>
T Arageli::exp ( const T &  x  )  [inline]

Definition at line 25 of file std_import.hpp.

template<typename T>
T Arageli::floor ( const T &  x  )  [inline]

Definition at line 26 of file std_import.hpp.

template<typename T>
T Arageli::ceil ( const T &  x  )  [inline]

Definition at line 27 of file std_import.hpp.

template<typename T>
T Arageli::log ( const T &  x  )  [inline]

Definition at line 28 of file std_import.hpp.

template<typename T>
T Arageli::log10 ( const T &  x  )  [inline]

Definition at line 29 of file std_import.hpp.

template<typename T>
T Arageli::sqrt ( const T &  x  )  [inline]

Definition at line 30 of file std_import.hpp.

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

Definition at line 33 of file std_import.hpp.

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

Definition at line 37 of file std_import.hpp.

template<typename P, typename SS>
void Arageli::sturm_diff_sys ( const P &  p,
SS &  ss 
)

Builds full Sturm system for polynomial.

After call, ss.front() is equal to p and ss.back() is constant.

template<typename SS, typename T>
SS::size_type Arageli::sturm_sign_changes ( const SS &  ss,
const T &  x,
int  signpx 
)

Number of sign changes for Sturm system in point 'x' with precomputed sign.

The function counts the number of sign changes for given Sturm system. A sign of value obtained after substitution 'x' into a polynomial ss.front() must be already precomputed and passed through 'signpx' parameter. So, the function doesn't compute an expression sign(ss.front().subs(x)) but uses 'signpx' value insted.

template<typename SS, typename T>
SS::size_type Arageli::sturm_sign_changes ( const SS &  ss,
const T &  x 
) [inline]

Number of sign changes for Sturm system in point 'x'.

Definition at line 54 of file sturm.hpp.

template<typename SS, typename Seg>
SS::size_type Arageli::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> Arageli::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 Arageli::sturm ( const P &  p,
LIMS &  lims,
SegBound  bs 
)

Real root location for polynomial by the Sturm algorithm on segment bs.

The function performs a real root loocation over T for nonzero polynomial p. It is looking for only roots in 'bs' segment. The result segments (each of them contains exactly one root) are placed into 'lims' that must be a vector of segments.

template<typename T, typename P, typename LIMS>
void Arageli::sturm ( const P &  p,
LIMS &  lims 
) [inline]

All real root location for polynomial by the Sturm algorithm.

See sturm function with 3 arguments.

Definition at line 87 of file sturm.hpp.

template<typename P, typename Lims>
bool Arageli::interval_root_dichotomy ( const P &  p,
int  lsign,
Lims &  lims 
)

Dichotomy of an interval with one root of a polynomial to double precision.

Returns true if exact root is found, otherwise returns false. 'lsign' should be already precomputed sign of p.subs(lims.first()).

template<typename P, typename Lims, typename T>
bool Arageli::interval_root_precise ( const P &  p,
Lims &  lims,
const T &  e 
)

Fits intervals that located the roots to 'e' precision.

After call, for all i, 0 <= i < lims.size() an expression lims[i].length() <= e is satisfied.

template<typename T, typename P, typename Roots, typename Prec>
void Arageli::roots_poly_real ( const P &  p,
Roots &  roots,
Prec &  prec,
const T &  e = null< T >() 
)

Computes all real roots of polynomial with precision 'e'.

If e is zero, it means that the precision doesn't matter.

template<typename Out, typename T>
void Arageli::output_latex_verb ( Out &  out,
const T &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Verbativ output in LaTeX.

Uses definition.

Definition at line 53 of file texout.hpp.

template<typename Out, typename T>
void Arageli::output_latex ( Out &  out,
const T &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Outputs the object in LaTeX notation. Common case.

Parameters:
out the stream which the function outputs to
x object for outputting
in_math indicates if there is already environment of mathematical formula (have effect on $ placing).
eep an environment, see ex_environ_priority

Definition at line 69 of file texout.hpp.

template<typename Out, typename T>
void Arageli::output_latex_math ( Out &  out,
const T &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Encloses the standard output of x in $ brackets.

Definition at line 81 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const signed int &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 108 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const unsigned int &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 109 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const signed short int &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 110 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const unsigned short int &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 111 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const signed long int &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 112 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const unsigned long int &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 113 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const float &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 114 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const double &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 115 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const long double &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 116 of file texout.hpp.

template<typename Out>
void Arageli::output_latex ( Out &  out,
const big_int &  x,
bool  in_math = false,
ex_environ_priority  eep = eep_alone 
) [inline]

Definition at line 117 of file texout.hpp.

template<typename Out, typename T>
void Arageli::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.

Parameters:
minlensimple a minimum length (in symbols) of notation in LaTeX of numerator and denominator of rational when function produces nate with slash; if lenght is greater then this value then the function used horizontal line.
externsign if this flag is true then the function takes a minus sign (if present) out of fraction; applicable if only function using horizontal line.

template<typename Out, typename T>
void Arageli::output_latex ( Out &  out,
const rational< T > &  x,
bool  in_math,
ex_environ_priority  eep 
) [inline]

Definition at line 155 of file texout.hpp.

template<typename Out, typename T>
void Arageli::output_latex ( Out &  out,
const rational< T > &  x,
bool  in_math 
) [inline]

Definition at line 165 of file texout.hpp.

template<typename Out, typename T>
void Arageli::output_latex ( Out &  out,
const rational< T > &  x 
) [inline]

Definition at line 174 of file texout.hpp.

template<typename Out, typename T, bool REFCNT>
void Arageli::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 Arageli::output_latex ( Out &  out,
const vector< T, REFCNT > &  x,
bool  in_math,
ex_environ_priority  eep 
) [inline]

Definition at line 196 of file texout.hpp.

template<typename Out, typename T, bool REFCNT>
void Arageli::output_latex ( Out &  out,
const vector< T, REFCNT > &  x,
bool  in_math 
) [inline]

Definition at line 209 of file texout.hpp.

template<typename Out, typename T, bool REFCNT>
void Arageli::output_latex ( Out &  out,
const vector< T, REFCNT > &  x 
) [inline]

Definition at line 221 of file texout.hpp.

template<typename Out, typename T, bool REFCNT>
void Arageli::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 Arageli::output_latex ( Out &  out,
const matrix< T, REFCNT > &  x 
) [inline]

Definition at line 246 of file texout.hpp.

template<typename Out, typename T, bool REFCNT>
void Arageli::output_latex ( Out &  out,
const matrix< T, REFCNT > &  x,
bool  in_math 
) [inline]

Definition at line 258 of file texout.hpp.

template<typename Out, typename T, bool REFCNT>
void Arageli::output_latex ( Out &  out,
const matrix< T, REFCNT > &  x,
bool  in_math,
ex_environ_priority  eep 
) [inline]

Definition at line 271 of file texout.hpp.

template<typename Out, typename F, typename I>
void Arageli::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 Arageli::output_latex ( Out &  out,
const monom< F, I > &  x,
bool  in_math,
ex_environ_priority  eep 
) [inline]

Definition at line 297 of file texout.hpp.

template<typename Out, typename F, typename I>
void Arageli::output_latex ( Out &  out,
const monom< F, I > &  x,
bool  in_math 
) [inline]

Definition at line 307 of file texout.hpp.

template<typename Out, typename F, typename I>
void Arageli::output_latex ( Out &  out,
const monom< F, I > &  x 
) [inline]

Definition at line 316 of file texout.hpp.

template<typename Out, typename F, typename I, bool REFCNT>
void Arageli::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 Arageli::output_latex ( Out &  out,
const sparse_polynom< F, I, REFCNT > &  x,
bool  in_math,
ex_environ_priority  eep 
) [inline]

Definition at line 335 of file texout.hpp.

template<typename Out, typename F, typename I, bool REFCNT>
void Arageli::output_latex ( Out &  out,
const sparse_polynom< F, I, REFCNT > &  x,
bool  in_math 
) [inline]

Definition at line 345 of file texout.hpp.

template<typename Out, typename F, typename I, bool REFCNT>
void Arageli::output_latex ( Out &  out,
const sparse_polynom< F, I, REFCNT > &  x 
) [inline]

Definition at line 354 of file texout.hpp.

template<typename In_hor, typename In_ver, typename In_box>
matrix_frames<In_hor, In_ver, In_box> Arageli::make_matrix_frames ( In_hor  hf,
In_hor  hl,
In_ver  vf,
In_ver  vl,
In_box  bf,
In_box  bl 
) [inline]

Helper functions that creates matrix_frames with appropriate parameters.

Definition at line 442 of file texout.hpp.

template<typename In_hor, typename In_ver>
matrix_frames<In_hor, In_ver> Arageli::make_matrix_frames ( In_hor  hf,
In_hor  hl,
In_ver  vf,
In_ver  vl 
) [inline]

Definition at line 452 of file texout.hpp.

template<typename In_hor>
matrix_frames<In_hor> Arageli::make_matrix_frames ( In_hor  hf,
In_hor  hl 
) [inline]

Definition at line 461 of file texout.hpp.

matrix_frames Arageli::make_matrix_frames (  )  [inline]

Definition at line 467 of file texout.hpp.

template<typename In_ver>
matrix_frames<const matrix_line*, In_ver> Arageli::make_matrix_vers ( In_ver  vf,
In_ver  vl 
) [inline]

Definition at line 473 of file texout.hpp.

template<typename In_box>
matrix_frames<const matrix_line*, const matrix_line*, In_box> Arageli::make_matrix_boxes ( In_box  bf,
In_box  bl 
) [inline]

Definition at line 482 of file texout.hpp.

template<typename In_ver, typename In_box>
matrix_frames<const matrix_line*, In_ver, In_box> Arageli::make_matrix_vers_boxes ( In_ver  vf,
In_ver  vl,
In_box  bf,
In_box  bl 
) [inline]

Definition at line 493 of file texout.hpp.

template<typename T, bool REFCNT, typename Ch, typename ChT, typename In_hor, typename In_ver, typename In_box>
void Arageli::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 Arageli::triangulate_simple_1 ( const Q &  q,
const Dim1 &  dim,
TR &  tr,
const Dim2 &  subspdim,
Ctrler  ctrler 
)

Triangulates a cone with structure matrix q.

Triangulates a polyhedral cone. q is matrix of the structure of a cone. In particular this matrix is obtained from Motzkin-Burger algorithm as q-matrix. Values itself in that matrix is not matter, only equality with zero is valuable. Output matrix tr contains dim columns and several rows, number of which is equal to number of simpixes founded in the polyhedral cone. Matrix tr contains indexes of vertexes that include in each simplex according to an order in q matrix. TEMPORARY LIMITATION: All subspace generators should'n be included to q matrix.

template<typename Q, typename Dim1, typename TR, typename Dim2>
void Arageli::triangulate_simple_1 ( const Q &  q,
const Dim1 &  dim,
TR &  tr,
const Dim2 &  subspdim 
) [inline]

Triangulates a cone with the relations matrix q.

See full version of this function.

Definition at line 111 of file triangulation.hpp.

template<typename Q, typename Dim1, typename TR>
void Arageli::triangulate_simple_1 ( const Q &  q,
const Dim1 &  dim,
TR &  tr 
) [inline]

Triangulates a pointed cone with the relations matrix q.

See full version of this function.

Definition at line 123 of file triangulation.hpp.

std::ostream& Arageli::operator<< ( std::ostream &  out,
const true_type &   
) [inline]

Definition at line 62 of file type_opers.hpp.

std::ostream& Arageli::operator<< ( std::ostream &  out,
const false_type &   
) [inline]

Definition at line 65 of file type_opers.hpp.

template<typename Vec, typename Index>
cnc_reference<Vec>::type Arageli::vec_operator_sqbrackets_index_vector ( Vec *  vec,
const Index &  ind,
const type_category::integer &   
) [inline]

Definition at line 86 of file vecalg.hpp.

template<typename Vec, typename Index>
indexed_subvector<Vec, vector<typename Vec::size_type> > Arageli::vec_operator_sqbrackets_index_vector ( Vec *  vec,
const Index &  ind,
const type_category::string &   
) [inline]

Definition at line 93 of file vecalg.hpp.

template<typename Vec, typename Index>
indexed_subvector<Vec, Index> Arageli::vec_operator_sqbrackets_index_vector ( Vec *  vec,
const Index &  ind,
const type_category::type &   
) [inline]

Definition at line 100 of file vecalg.hpp.

template<typename Vec, typename UFunc>
void Arageli::apply1_wores_vec ( Vec &  a,
UFunc  f 
)

Definition at line 108 of file vecalg.hpp.

template<typename Vec1, typename Vec2, typename BinOp>
void Arageli::apply2_wores_vec_by_vec ( Vec1 &  a,
Vec2 &  b,
BinOp  f 
)

Definition at line 118 of file vecalg.hpp.

template<typename Vec, typename Val, typename BinOp>
void Arageli::apply2_wores_vec_by_val ( Vec &  a,
Val &  b,
BinOp  f 
)

Definition at line 131 of file vecalg.hpp.

template<typename Val, typename Vec, typename BinOp>
void Arageli::apply2_wores_val_by_vec ( Val &  a,
Vec &  b,
BinOp  f 
)

Definition at line 142 of file vecalg.hpp.

template<typename Vec1, typename Vec2, typename VecRes, typename Func2>
VecRes& Arageli::apply2_vec_by_vec ( const Vec1 &  a,
const Vec2 &  b,
VecRes &  res,
Func2  f 
)

Definition at line 154 of file vecalg.hpp.

template<typename Vec1, typename Vec2, typename Func2>
Vec1 Arageli::apply2_vec_by_vec ( const Vec1 &  a,
const Vec2 &  b,
Func2  f 
) [inline]

Definition at line 173 of file vecalg.hpp.

template<typename Vec, typename Val, typename VecRes, typename Func2>
VecRes& Arageli::apply2_vec_by_val ( const Vec &  a,
const Val &  b,
VecRes &  res,
Func2  f 
)

Definition at line 183 of file vecalg.hpp.

template<typename Vec, typename Val, typename Func2>
Vec Arageli::apply2_vec_by_val ( const Vec &  a,
const Val &  b,
Func2  f 
) [inline]

Definition at line 199 of file vecalg.hpp.

template<typename Val, typename Vec, typename VecRes, typename Func2>
VecRes& Arageli::apply2_val_by_vec ( const Val &  a,
const Vec &  b,
VecRes &  res,
Func2  f 
)

Definition at line 208 of file vecalg.hpp.

template<typename Val, typename Vec, typename Func2>
Vec Arageli::apply2_val_by_vec ( const Val &  a,
const Vec &  b,
Func2  f 
) [inline]

Definition at line 224 of file vecalg.hpp.

template<typename Vec1, typename Vec2, typename VecRes, typename Func3>
VecRes& Arageli::apply3_vec_by_vec ( const Vec1 &  a,
const Vec2 &  b,
VecRes &  res,
Func3  f 
)

Definition at line 234 of file vecalg.hpp.

template<typename Vec1, typename Vec2, typename Func3>
Vec1 Arageli::apply3_vec_by_vec ( const Vec1 &  a,
const Vec2 &  b,
Func3  f 
) [inline]

Definition at line 253 of file vecalg.hpp.

template<typename Vec, typename Val, typename VecRes, typename Func3>
VecRes& Arageli::apply3_vec_by_val ( const Vec &  a,
const Val &  b,
VecRes &  res,
Func3  f 
)

Definition at line 263 of file vecalg.hpp.

template<typename Vec, typename Val, typename Func3>
Vec Arageli::apply3_vec_by_val ( const Vec &  a,
const Val &  b,
Func3  f 
) [inline]

Definition at line 279 of file vecalg.hpp.

template<typename Val, typename Vec, typename VecRes, typename Func3>
VecRes& Arageli::apply3_val_by_vec ( const Val &  a,
const Vec &  b,
VecRes &  res,
Func3  f 
)

Definition at line 288 of file vecalg.hpp.

template<typename Val, typename Vec, typename Func3>
Vec Arageli::apply3_val_by_vec ( const Val &  a,
const Vec &  b,
Func3  f 
) [inline]

Definition at line 304 of file vecalg.hpp.

template<typename Vec1, typename Vec2, typename Cmp>
int Arageli::cmp_vec_by_vec ( const Vec1 &  a,
const Vec2 &  b,
Cmp  cmp 
)

Definition at line 313 of file vecalg.hpp.

template<typename Vec, typename Val, typename Cmp>
int Arageli::cmp_vec_by_val ( const Vec &  a,
const Val &  val,
Cmp  cmp 
)

Definition at line 337 of file vecalg.hpp.

template<typename Val, typename Vec, typename Cmp>
int Arageli::cmp_val_by_vec ( const Val &  val,
const Vec &  a,
Cmp  cmp 
)

Definition at line 353 of file vecalg.hpp.

template<typename Vec1, typename Vec2>
int Arageli::cmpdef_vec_by_vec ( const Vec1 &  a,
const Vec2 &  b 
)

Definition at line 370 of file vecalg.hpp.

template<typename Vec, typename Val>
int Arageli::cmpdef_vec_by_val ( const Vec &  a,
const Val &  val 
)

Definition at line 375 of file vecalg.hpp.

template<typename Val, typename Vec>
int Arageli::cmpdef_val_by_vec ( const Val &  val,
const Vec &  a 
)

Definition at line 380 of file vecalg.hpp.

template<typename Vec1, typename Vec2, typename Cmp>
bool Arageli::allcmp_vec_by_vec ( const Vec1 &  a,
const Vec2 &  b,
Cmp  cmp 
)

Definition at line 386 of file vecalg.hpp.

template<typename Vec, typename Val, typename Cmp>
bool Arageli::allcmp_vec_by_val ( const Vec &  a,
const Val &  val,
Cmp  cmp 
)

Definition at line 402 of file vecalg.hpp.

template<typename Val, typename Vec, typename Cmp>
bool Arageli::allcmp_val_by_vec ( const Val &  val,
const Vec &  a,
Cmp  cmp 
)

Definition at line 415 of file vecalg.hpp.

template<typename Vec1, typename Vec2, typename Cmp>
Vec1::template other_element_type_refcnt<bool, true>::type Arageli::eachcmp_vec_by_vec ( const Vec1 &  a,
const Vec2 &  b,
Cmp  cmp 
) [inline]

Definition at line 430 of file vecalg.hpp.

template<typename Vec, typename Val, typename Cmp>
Vec::template other_element_type_refcnt<bool, true>::type Arageli::eachcmp_vec_by_val ( const Vec &  a,
const Val &  val,
Cmp  cmp 
) [inline]

Definition at line 439 of file vecalg.hpp.

template<typename Val, typename Vec, typename Cmp>
Vec::template other_element_type_refcnt<bool, true>::type Arageli::eachcmp_val_by_vec ( const Val &  val,
const Vec &  a,
Cmp  cmp 
) [inline]

Definition at line 448 of file vecalg.hpp.

template<typename Vec1, typename Vec2, typename Cmp>
Vec1::template other_element_type_refcnt<int, true>::type Arageli::elwisecmp_vec_by_vec ( const Vec1 &  a,
const Vec2 &  b,
Cmp  cmp 
) [inline]

Definition at line 458 of file vecalg.hpp.

template<typename Vec, typename Val, typename Cmp>
Vec::template other_element_type_refcnt<int, true>::type Arageli::elwisecmp_vec_by_val ( const Vec &  a,
const Val &  val,
Cmp  cmp 
) [inline]

Definition at line 467 of file vecalg.hpp.

template<typename Val, typename Vec, typename Cmp>
Vec::template other_element_type_refcnt<int, true>::type Arageli::elwisecmp_val_by_vec ( const Val &  val,
const Vec &  a,
Cmp  cmp 
) [inline]

Definition at line 476 of file vecalg.hpp.

template<typename Index, typename T>
bool Arageli::all_in_range ( const Index &  ind,
const T &  left,
const T &  right 
)

Definition at line 484 of file vecalg.hpp.

template<typename Out, typename Vec>
Out& Arageli::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>& Arageli::left_assign_plus ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1265 of file vector.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::left_assign_minus ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1266 of file vector.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::left_assign_multiplies ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1267 of file vector.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::left_assign_divides ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1268 of file vector.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::left_assign_modulus ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1269 of file vector.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::left_assign_bitwise_or ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1270 of file vector.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::left_assign_bitwise_and ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1271 of file vector.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::left_assign_bitwise_xor ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1272 of file vector.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::left_assign_shift_left ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1273 of file vector.hpp.

template<typename T1, typename T2, bool REFCNT2>
vector<T2, REFCNT2>& Arageli::left_assign_shift_right ( const T1 &  x,
vector< T2, REFCNT2 > &  y 
) [inline]

Definition at line 1274 of file vector.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T1_factory>
T1 Arageli::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 Arageli::dotprod ( const vector< T1, REFCNT1 > &  a,
const vector< T2, REFCNT2 > &  b 
) [inline]

Dot product (scalar product) of two vectors.

Definition at line 1966 of file vector.hpp.

template<typename T, bool REFCNT, typename T2, typename T2_factory>
T2& Arageli::product ( const vector< T, REFCNT > &  x,
T2 &  res,
const T2_factory &  t2fctr 
)

Multiplies all elements of vector.

Multiplies all elements of x via operator *= applied on res. Returns a reference to res.

template<typename T, bool REFCNT, typename T2, typename T2_factory>
T2& Arageli::sum ( const vector< T, REFCNT > &  x,
T2 &  res,
const T2_factory &  t2fctr 
)

Sums all elements of vector.

Sums all elements of x via operator += applied on res. Returns a reference to res.

template<typename T, bool REFCNT, typename T2>
T2& Arageli::product ( const vector< T, REFCNT > &  x,
T2 &  res 
) [inline]

Multiplies all elements of vector.

Multiplies all elements of x via operator *= applied on res. Returns a reference to res.

Definition at line 1989 of file vector.hpp.

template<typename T, bool REFCNT, typename T2>
T2& Arageli::sum ( const vector< T, REFCNT > &  x,
T2 &  res 
) [inline]

Sums all elements of vector.

Sums all elements of x via operator += applied on res. Returns a reference to res.

Definition at line 1996 of file vector.hpp.

template<typename T, bool REFCNT>
T Arageli::product ( const vector< T, REFCNT > &  x  )  [inline]

Multiplies all elements of vector.

Definition at line 2018 of file vector.hpp.

template<typename T, bool REFCNT>
T Arageli::sum ( const vector< T, REFCNT > &  x  )  [inline]

Sums all elements of vector.

Definition at line 2026 of file vector.hpp.

template<typename Out, typename T, bool REFCNT>
Out& Arageli::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 
) [inline]

Simple output of the vector.

Definition at line 2039 of file vector.hpp.

template<typename In, typename T, bool REFCNT>
In& Arageli::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& Arageli::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& Arageli::vector_output_row ( std::ostream &  out,
const vector< T, REFCNT > &  x 
) [inline]

Prints vector as a row-vector.

Definition at line 2076 of file vector.hpp.

template<typename T, bool REFCNT>
std::ostream& Arageli::vector_output_col ( std::ostream &  out,
const vector< T, REFCNT > &  x 
) [inline]

Prints vector as a column-vector.

Definition at line 2086 of file vector.hpp.

template<typename T, bool REFCNT>
std::ostream& Arageli::operator<< ( std::ostream &  out,
const vector< T, REFCNT > &  x 
) [inline]

Standard output routine (default type of outputting) for the vector.

Definition at line 2095 of file vector.hpp.

template<typename T, bool REFCNT>
std::istream& Arageli::operator>> ( std::istream &  in,
vector< T, REFCNT > &  x 
) [inline]

Standard input routine (default type of inputting) for the vector.

Definition at line 2101 of file vector.hpp.

template<typename T, bool REFCNT>
std::ofstream& Arageli::operator<< ( std::ofstream &  out,
const vector< T, REFCNT > &  x 
) [inline]

WARNING! TEMPORARY!.

Definition at line 2107 of file vector.hpp.

template<typename T, bool REFCNT>
std::ifstream& Arageli::operator>> ( std::ifstream &  in,
vector< T, REFCNT > &  x 
) [inline]

WARNING! TEMPORARY!.

Definition at line 2113 of file vector.hpp.

template<typename T, bool REFCNT>
std::ostringstream& Arageli::operator<< ( std::ostringstream &  out,
const vector< T, REFCNT > &  x 
) [inline]

WARNING! TEMPORARY!.

Definition at line 2119 of file vector.hpp.

template<typename T, bool REFCNT>
std::istringstream& Arageli::operator>> ( std::istringstream &  in,
vector< T, REFCNT > &  x 
) [inline]

WARNING! TEMPORARY!.

Definition at line 2125 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, REFCNT> Arageli::opposite ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2182 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, REFCNT>& Arageli::opposite ( const vector< T, REFCNT > &  x,
vector< T, REFCNT > *  y 
) [inline]

Definition at line 2187 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, REFCNT>& Arageli::opposite ( vector< T, REFCNT > *  x  )  [inline]

Definition at line 2192 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, REFCNT> Arageli::inverse ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2197 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, REFCNT>& Arageli::inverse ( const vector< T, REFCNT > &  x,
vector< T, REFCNT > *  y 
) [inline]

Definition at line 2205 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, REFCNT>& Arageli::inverse ( vector< T, REFCNT > *  x  )  [inline]

Definition at line 2210 of file vector.hpp.

template<typename T, bool REFCNT>
bool Arageli::is_unit ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2215 of file vector.hpp.

template<typename T, bool REFCNT>
bool Arageli::is_opposite_unit ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2219 of file vector.hpp.

template<typename T, bool REFCNT>
bool Arageli::is_null ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2223 of file vector.hpp.

template<typename T, bool REFCNT>
std::ostream& Arageli::output_polynom_first ( std::ostream &  out,
const vector< T, REFCNT > &  x 
) [inline]

Definition at line 2228 of file vector.hpp.

template<typename T, bool REFCNT>
std::ostream& Arageli::output_polynom_internal ( std::ostream &  out,
const vector< T, REFCNT > &  x 
) [inline]

Definition at line 2233 of file vector.hpp.

template<typename T, bool REFCNT>
std::ostream& Arageli::output_pow ( std::ostream &  out,
const vector< T, REFCNT > &  x 
) [inline]

Definition at line 2238 of file vector.hpp.

template<typename T, bool REFCNT>
std::istream& Arageli::input_polynom_first ( std::istream &  in,
vector< T, REFCNT > &  x 
) [inline]

Definition at line 2243 of file vector.hpp.

template<typename T, bool REFCNT>
std::istream& Arageli::input_polynom_internal ( std::istream &  in,
vector< T, REFCNT > &  x 
)

template<typename T, bool REFCNT>
std::istream& Arageli::input_pow ( std::istream &  in,
vector< T, REFCNT > &  x 
) [inline]

Definition at line 2252 of file vector.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
void Arageli::fill_subvector ( const vector< T1, REFCNT1 > &  orig,
const vector< T2, REFCNT2 > &  indexes,
vector< T3, REFCNT3 > &  res 
)

Makes subvector from another vector and index vector.

Definition at line 2266 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::sin ( const Arageli::vector< T, REFCNT > &  x  )  [inline]

Each of this function evaluate specific mathematical function of each element in vector and results store to returned vector.

Definition at line 2370 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::cos ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2371 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::tan ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2372 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::sinh ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2373 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::cosh ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2374 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::tanh ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2375 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::asin ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2376 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::acos ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2377 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::atan ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2378 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::abs ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2379 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::exp ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2380 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::floor ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2381 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::ceil ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2382 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::log ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2383 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::log10 ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2384 of file vector.hpp.

template<typename T, bool REFCNT>
vector<T, true> Arageli::sqrt ( const vector< T, REFCNT > &  x  )  [inline]

Definition at line 2385 of file vector.hpp.

template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
vector<T1, REFCNT1> Arageli::pow ( const vector< T1, REFCNT1 > &  a,
const vector< T2, REFCNT2 > &  b 
) [inline]

Definition at line 2393 of file vector.hpp.

template<typename T1, bool REFCNT1, typename P>
vector<T1, REFCNT1> Arageli::pow ( const vector< T1, REFCNT1 > &  a,
const P &  b 
) [inline]

Definition at line 2405 of file vector.hpp.


Variable Documentation

const int Arageli::EXACT = 1

Rounds to the closest value.

Definition at line 58 of file big_float.hpp.

const int Arageli::ROUND = 2

Uses rules of `'manual'' computations.

Definition at line 59 of file big_float.hpp.

const int Arageli::TO_NEAREST = 3

Rounds towards the nearest number.

Definition at line 60 of file big_float.hpp.

const int Arageli::TO_ZERO = 4

Rounds towards zero.

Definition at line 61 of file big_float.hpp.

const int Arageli::TO_P_INF = 5

Rounds towards +infinity.

Definition at line 62 of file big_float.hpp.

const int Arageli::TO_M_INF = 6

Rounds towards -infinity.

Definition at line 63 of file big_float.hpp.

const int Arageli::TO_INF = 7

Rounds outwards zero.

Definition at line 64 of file big_float.hpp.

const int Arageli::NAN = 1

Definition at line 70 of file big_float.hpp.

const int Arageli::PINF = 2

Definition at line 71 of file big_float.hpp.

const int Arageli::M_INF = 3

Definition at line 72 of file big_float.hpp.

const int Arageli::P_ZERO = 4

Definition at line 73 of file big_float.hpp.

const int Arageli::M_ZERO = 5

Definition at line 74 of file big_float.hpp.

const int Arageli::PREC_MIN = 2

Definition at line 78 of file big_float.hpp.

const unsigned long Arageli::PREC_MAX = _Internal::max_digit

Definition at line 79 of file big_float.hpp.

const unsigned long Arageli::D_PREC_MAX = ( long ) (_Internal::max_digit * log ( 2.0l ) / log ( 10.0l ))

Definition at line 80 of file big_float.hpp.

const fromnull_t Arageli::fromnull = fromnull_t()

Helper constant to create cone as one point (null).

Definition at line 44 of file cone.hpp.

const fromspace_t Arageli::fromspace = fromspace_t()

Helper constant to create cone from dimention.

Definition at line 49 of file cone.hpp.

const fromineq_t Arageli::fromineq = fromineq_t()

Helper constant to create cone from the set of inequalities.

Definition at line 54 of file cone.hpp.

const fromeq_t Arageli::fromeq = fromeq_t()

Helper constant to create cone from the set of equalities.

Definition at line 59 of file cone.hpp.

const fromgen_t Arageli::fromgen = fromgen_t()

Helper constant to create cone from the set of generatrices.

Definition at line 64 of file cone.hpp.

const frombasis_t Arageli::frombasis = frombasis_t()

Helper constant to create cone from the set of basis vectors.

Definition at line 69 of file cone.hpp.

const fromdual_t Arageli::fromdual = fromdual_t()

Definition at line 73 of file cone.hpp.

CCounter Arageli::counter_big_int_sum_GC

CCounter Arageli::counter_big_int_mul_GC

CCounter Arageli::counter_big_int_div_GC

const char* Arageli::matrix_output_list_first_bracket_default = "("

Definition at line 2205 of file matrix.cpp.

const char* Arageli::matrix_output_list_second_bracket_default = ")"

Definition at line 2206 of file matrix.cpp.

const char* Arageli::matrix_output_list_row_separator_default = ", "

Definition at line 2207 of file matrix.cpp.

const char* Arageli::matrix_output_list_first_row_bracket_default = "("

Definition at line 2208 of file matrix.cpp.

const char* Arageli::matrix_output_list_second_row_bracket_default = ")"

Definition at line 2209 of file matrix.cpp.

const char* Arageli::matrix_output_list_col_separator_default = ", "

Definition at line 2210 of file matrix.cpp.

const char* Arageli::matrix_input_list_first_bracket_default = "("

Definition at line 2211 of file matrix.cpp.

const char* Arageli::matrix_input_list_second_bracket_default = ")"

Definition at line 2212 of file matrix.cpp.

const char* Arageli::matrix_input_list_row_separator_default = ","

Definition at line 2213 of file matrix.cpp.

const char* Arageli::matrix_input_list_first_row_bracket_default = "("

Definition at line 2214 of file matrix.cpp.

const char* Arageli::matrix_input_list_second_row_bracket_default = ")"

Definition at line 2215 of file matrix.cpp.

const char* Arageli::matrix_input_list_col_separator_default = ","

Definition at line 2216 of file matrix.cpp.

const char* Arageli::matrix_output_aligned_left_col_default = "||"

Definition at line 2217 of file matrix.cpp.

const char* Arageli::matrix_output_aligned_right_col_default = "||"

Definition at line 2218 of file matrix.cpp.

const char* Arageli::matrix_output_aligned_inter_col_default = " "

Definition at line 2219 of file matrix.cpp.

const colwise_t Arageli::colwise = colwise_t()

Helper object for columnwise filling of the matrix.

See constructors of matrix template class.

Definition at line 70 of file matrix.hpp.

const diag_t Arageli::diag = diag_t()

Helper object for construct a diagonal matrix.

See constructors of matrix template class.

Definition at line 79 of file matrix.hpp.

const eye_t Arageli::eye = eye_t()

Helper object for construct an indentity matrix.

See constructors of matrix template class.

Definition at line 88 of file matrix.hpp.

const frommat_t Arageli::frommat = frommat_t()

Definition at line 92 of file matrix.hpp.

const char* Arageli::matrix_output_list_first_bracket_default

Definition at line 2205 of file matrix.cpp.

const char* Arageli::matrix_output_list_second_bracket_default

Definition at line 2206 of file matrix.cpp.

const char* Arageli::matrix_output_list_row_separator_default

Definition at line 2207 of file matrix.cpp.

const char* Arageli::matrix_output_list_first_row_bracket_default

Definition at line 2208 of file matrix.cpp.

const char* Arageli::matrix_output_list_second_row_bracket_default

Definition at line 2209 of file matrix.cpp.

const char* Arageli::matrix_output_list_col_separator_default

Definition at line 2210 of file matrix.cpp.

const char* Arageli::matrix_input_list_first_bracket_default

Definition at line 2211 of file matrix.cpp.

const char* Arageli::matrix_input_list_second_bracket_default

Definition at line 2212 of file matrix.cpp.

const char* Arageli::matrix_input_list_row_separator_default

Definition at line 2213 of file matrix.cpp.

const char* Arageli::matrix_input_list_first_row_bracket_default

Definition at line 2214 of file matrix.cpp.

const char* Arageli::matrix_input_list_second_row_bracket_default

Definition at line 2215 of file matrix.cpp.

const char* Arageli::matrix_input_list_col_separator_default

Definition at line 2216 of file matrix.cpp.

const char* Arageli::matrix_output_aligned_left_col_default

Definition at line 2217 of file matrix.cpp.

const char* Arageli::matrix_output_aligned_right_col_default

Definition at line 2218 of file matrix.cpp.

const char* Arageli::matrix_output_aligned_inter_col_default

Definition at line 2219 of file matrix.cpp.

const fromempty_t Arageli::fromempty = fromempty_t()

Definition at line 39 of file polyhedron.hpp.

const fromivert_t Arageli::fromivert = fromivert_t()

Definition at line 42 of file polyhedron.hpp.

const fromvert_t Arageli::fromvert = fromvert_t()

Definition at line 45 of file polyhedron.hpp.

const char* Arageli::rational_output_list_first_bracket_default = "("

Definition at line 339 of file rational.cpp.

const char* Arageli::rational_output_list_second_bracket_default = ")"

Definition at line 340 of file rational.cpp.

const char* Arageli::rational_output_list_separator_default = ", "

Definition at line 341 of file rational.cpp.

const char* Arageli::rational_input_list_first_bracket_default = "("

Definition at line 342 of file rational.cpp.

const char* Arageli::rational_input_list_second_bracket_default = ")"

Definition at line 343 of file rational.cpp.

const char* Arageli::rational_input_list_separator_default = ","

Definition at line 344 of file rational.cpp.

const char* Arageli::rational_output_default_oblique_default = "/"

Definition at line 345 of file rational.cpp.

const char* Arageli::rational_input_default_oblique_default = "/"

Definition at line 346 of file rational.cpp.

const char* Arageli::rational_output_list_first_bracket_default

Definition at line 339 of file rational.cpp.

const char* Arageli::rational_output_list_second_bracket_default

Definition at line 340 of file rational.cpp.

const char* Arageli::rational_output_list_separator_default

Definition at line 341 of file rational.cpp.

const char* Arageli::rational_input_list_first_bracket_default

Definition at line 342 of file rational.cpp.

const char* Arageli::rational_input_list_second_bracket_default

Definition at line 343 of file rational.cpp.

const char* Arageli::rational_input_list_separator_default

Definition at line 344 of file rational.cpp.

const char* Arageli::rational_output_default_oblique_default

Definition at line 345 of file rational.cpp.

const char* Arageli::rational_input_default_oblique_default

Definition at line 346 of file rational.cpp.

const char* Arageli::monom_input_list_first_bracket_default = "("

Definition at line 1619 of file sparse_polynom.cpp.

const char* Arageli::monom_output_list_first_bracket_default = "("

Definition at line 1620 of file sparse_polynom.cpp.

const char* Arageli::monom_input_list_second_bracket_default = ")"

Definition at line 1621 of file sparse_polynom.cpp.

const char* Arageli::monom_output_list_second_bracket_default = ")"

Definition at line 1622 of file sparse_polynom.cpp.

const char* Arageli::monom_input_list_separator_default = ","

Definition at line 1623 of file sparse_polynom.cpp.

const char* Arageli::monom_output_list_separator_default = ", "

Definition at line 1624 of file sparse_polynom.cpp.

const char* Arageli::monom_input_var_mul_default = "*"

Definition at line 1625 of file sparse_polynom.cpp.

const char* Arageli::monom_output_var_mul_default = "*"

Definition at line 1626 of file sparse_polynom.cpp.

const char* Arageli::monom_input_var_var_default = "x"

Definition at line 1627 of file sparse_polynom.cpp.

const char* Arageli::monom_output_var_var_default = "x"

Definition at line 1628 of file sparse_polynom.cpp.

const char* Arageli::monom_input_var_pow_default = "^"

Definition at line 1629 of file sparse_polynom.cpp.

const char* Arageli::monom_output_var_pow_default = "^"

Definition at line 1630 of file sparse_polynom.cpp.

const char* Arageli::monom_input_list_first_bracket_default

Definition at line 1619 of file sparse_polynom.cpp.

const char* Arageli::monom_output_list_first_bracket_default

Definition at line 1620 of file sparse_polynom.cpp.

const char* Arageli::monom_input_list_second_bracket_default

Definition at line 1621 of file sparse_polynom.cpp.

const char* Arageli::monom_output_list_second_bracket_default

Definition at line 1622 of file sparse_polynom.cpp.

const char* Arageli::monom_input_list_separator_default

Definition at line 1623 of file sparse_polynom.cpp.

const char* Arageli::monom_output_list_separator_default

Definition at line 1624 of file sparse_polynom.cpp.

const char* Arageli::monom_input_var_mul_default

Definition at line 1625 of file sparse_polynom.cpp.

const char* Arageli::monom_output_var_mul_default

Definition at line 1626 of file sparse_polynom.cpp.

const char* Arageli::monom_input_var_var_default

Definition at line 1627 of file sparse_polynom.cpp.

const char* Arageli::monom_output_var_var_default

Definition at line 1628 of file sparse_polynom.cpp.

const char* Arageli::monom_input_var_pow_default

Definition at line 1629 of file sparse_polynom.cpp.

const char* Arageli::monom_output_var_pow_default

Definition at line 1630 of file sparse_polynom.cpp.

const norm_monom_seq_t Arageli::norm_monom_seq = norm_monom_seq_t() [static]

Helper object for choosing method that gives sorted monom sequence.

See constructors and relative methods of sparse_polynom template class.

Definition at line 858 of file sparse_polynom.hpp.

const any_monom_seq_t Arageli::any_monom_seq = any_monom_seq_t() [static]

Helper object for choosing method that gives unsorted monom sequence.

See constructors and relative methods of sparse_polynom template class.

Definition at line 867 of file sparse_polynom.hpp.

const char* Arageli::vector_output_list_first_bracket_default = "("

Definition at line 61 of file vecalg.cpp.

const char* Arageli::vector_output_list_second_bracket_default = ")"

Definition at line 62 of file vecalg.cpp.

const char* Arageli::vector_output_list_separator_default = ", "

Definition at line 63 of file vecalg.cpp.

const char* Arageli::vector_input_list_first_bracket_default = "("

Definition at line 64 of file vecalg.cpp.

const char* Arageli::vector_input_list_second_bracket_default = ")"

Definition at line 65 of file vecalg.cpp.

const char* Arageli::vector_input_list_separator_default = ","

Definition at line 66 of file vecalg.cpp.

const char* Arageli::vector_input_list_range_default = ":"

Definition at line 67 of file vecalg.cpp.

const char* Arageli::vector_output_aligned_left_col_default = "||"

Definition at line 68 of file vecalg.cpp.

const char* Arageli::vector_output_aligned_right_col_default = "||"

Definition at line 69 of file vecalg.cpp.

const char* Arageli::vector_output_list_first_bracket_default

Definition at line 61 of file vecalg.cpp.

const char* Arageli::vector_output_list_second_bracket_default

Definition at line 62 of file vecalg.cpp.

const char* Arageli::vector_output_list_separator_default

Definition at line 63 of file vecalg.cpp.

const char* Arageli::vector_input_list_first_bracket_default

Definition at line 64 of file vecalg.cpp.

const char* Arageli::vector_input_list_second_bracket_default

Definition at line 65 of file vecalg.cpp.

const char* Arageli::vector_input_list_separator_default

Definition at line 66 of file vecalg.cpp.

const char* Arageli::vector_input_list_range_default

Definition at line 67 of file vecalg.cpp.

const char* Arageli::vector_output_aligned_left_col_default

Definition at line 68 of file vecalg.cpp.

const char* Arageli::vector_output_aligned_right_col_default

Definition at line 69 of file vecalg.cpp.

const fromseq_t Arageli::fromseq = fromseq_t()

Definition at line 68 of file vector.hpp.

const fromval_t Arageli::fromval = fromval_t()

Definition at line 71 of file vector.hpp.

const fromvec_t Arageli::fromvec = fromvec_t()

Definition at line 74 of file vector.hpp.

const fromsize_t Arageli::fromsize = fromsize_t()

Definition at line 77 of file vector.hpp.

const fromstr_t Arageli::fromstr = fromstr_t()

Definition at line 80 of file vector.hpp.


Generated on Thu Aug 31 17:38:22 2006 for Arageli by  doxygen 1.4.7