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