Classes | |
| class | AccurateFloat |
| minimalistic wrapper for MPFR numbers More... | |
| class | Array |
| Container class with constant time random access. More... | |
| class | Bitset |
| Container class for dense sets of integers. More... | |
| class | color_error |
| An exception of this type is thrown by an attempt to assign a wrong value to some color component. More... | |
| class | RGB |
| Color description in RGB space: Red-Green-Blue additive color model. More... | |
| class | HSV |
| Color description in HSV space. More... | |
| class | EquivalenceRelation |
| An equivalence relation on the integers `0,..,n-1` for a given size `n`. More... | |
| class | FaceMap |
| class | FacetList |
| class | GenericGraph |
| Generic type for all graph classes. More... | |
| class | Complement |
| Complement as GenericSet. More... | |
| class | SingleElementSet |
| singleton as GenericSet More... | |
| class | GenericVector |
| class | FixedVector |
| Built-in array decorated as a vector. More... | |
| class | Heap |
| struct | HeapConstructor |
| Metaconstructor for this heap implementation. More... | |
| class | IncidenceMatrix |
| 0/1 incidence matrix. More... | |
| class | Integer |
| Wrapper class for GMP's mpz_t type. More... | |
| class | no_match |
| struct | conv |
| struct | conv< T, T > |
| Trivial conversion of a type to itself. More... | |
| class | ptr_wrapper |
| struct | unlimited |
| struct | nothing |
| Structure denoting the absence of data. More... | |
| struct | ignore |
| Masquerade class for suppressing I/O and conversion. More... | |
| class | shared_object |
| class | shared_pointer |
| class | shared_array |
| struct | if_else |
| struct | function_argument |
| struct | attrib |
| struct | size_discriminant |
| derivation and conversion tests due to Andrei Alexandrescu More... | |
| struct | list_search |
| struct | list_search_all |
| struct | merge_list |
| class | Map |
| Associative array based on AVL::tree. More... | |
| class | Matrix |
| Matrix type class which holds the elements in a contiguous array More... | |
| class | permutation_iterator< permutations_heap > |
| Implementation of the Heap's algorithm by R. Sedgewick. More... | |
| class | UniformlyRandom< Rational > |
| class | UniformlyRandom< Bitset > |
| Generator of random Bitset of a given maximal cardinality. More... | |
| class | UniformlyRandom< AccurateFloat > |
| Generator of random AccurateFloat numbers from [0, 1). More... | |
| class | RandomSpherePoints |
| Generator of uniformly distributed random points on the unit sphere in R^d. More... | |
| class | Rational |
| A class for rational numbers. More... | |
| class | output_predicate_selector |
| class | GenericSet |
| Generic type for ordered sets More... | |
| class | GenericMutableSet |
| Generic type for ordered mutable sets More... | |
| class | Set |
An associative container based on a balanced binary search (AVL) tree. Comparator is a functor defining a total ordering on the element value domain. In the most cases, the default choice (lexicographical order) will suffice for your needs. More... | |
| class | SparseMatrixStatistics |
| sparse matrix statistics collection More... | |
| class | SparseVector |
| class | iterator_product |
| class | Vector |
| Vector type class which holds the elements in a contiguous array More... | |
Namespaces | |
| namespace | AVL |
| traits classes and such related to balanced trees | |
Enumerations | |
| enum | heap_element_state { heap_element_unvisited = -2, heap_element_removed = -1, heap_element_active = 1 } |
Functions | |
| int | incl (const Bitset &s1, const Bitset &s2) |
| See incl(GenericSet,GenericSet). | |
| template<typename Matrix1, typename Matrix2> | |
| RowChain< ColChain< const typename Unwary< Matrix1 > ::type &, SameElementIncidenceMatrix < true > >, ColChain < SameElementIncidenceMatrix < true >, const typename Unwary< Matrix2 >::type & > > | diag_1 (const GenericIncidenceMatrix< Matrix1 > &m1, const GenericIncidenceMatrix< Matrix2 > &m2) |
| the same, but with corner blocks filled with 1 | |
| template<typename TargetType, typename _Matrix> | |
| const LazyMatrix1< const _Matrix &, conv< typename _Matrix::element_type, TargetType > > | convert_to (const GenericMatrix< _Matrix > &m) |
| explicit conversion of matrix elements to another type | |
| template<typename _Set1, typename _Set2, typename E1, typename E2, class Comparator> | |
| int | incl (const GenericSet< _Set1, E1, Comparator > &s1, const GenericSet< _Set2, E2, Comparator > &s2) |
| template<typename TargetType, typename Vector> | |
| const LazyVector1< const Vector &, conv< typename Vector::element_type, TargetType > > | convert_to (const GenericVector< Vector > &V) |
| explicit conversion of vector elements to another type | |
| graph::Graph | complete_graph (int n_nodes) |
| create complete graph on given number of nodes | |
| template<typename Matrix1, typename Matrix2> | |
| IncidenceMatrix | convolute (const GenericIncidenceMatrix< Matrix1 > &m1, const GenericIncidenceMatrix< Matrix2 > &m2) |
| Convolution of two incidence relations. | |
| template<typename E> | |
| disable_if< E, std::numeric_limits< E > ::is_integer >::type | det (Matrix< E > M) |
| determinant of a matrix | |
| template<typename E> | |
| disable_if< Matrix< E > , std::numeric_limits< E > ::is_integer >::type | inv (Matrix< E > M) |
| matrix inversion | |
| template<typename E> | |
| disable_if< Vector< E > , std::numeric_limits< E > ::is_integer >::type | lin_solve (Matrix< E > A, Vector< E > B) |
| solving systems of linear equations | |
| void | gcd_ext (long a, long b, long &g, long &p, long &q) |
| g=gcd(a,b) && g==p*a+q*b | |
| template<typename _Matrix, typename _Vector, typename E> | |
| bool | has_solution (const GenericMatrix< _Matrix, E > &A, const GenericVector< _Vector, E > &B) |
| template<typename Iterator> | |
| void | normalize (Iterator dst) |
| Divide each vector in a sequence thru its length (L2-norm). | |
| template<typename _Matrix> | |
| disable_if< typename _Matrix::element_type, std::numeric_limits< typename _Matrix::element_type > ::is_integer >::type | det (const GenericMatrix< _Matrix > &m) |
| Compute the determinant of a matrix using the Gauss elimination method. | |
| template<typename _Matrix, typename _Vector, typename E> | |
| disable_if< typename _Vector::persistent_type, std::numeric_limits< E > ::is_integer >::type | reduce (const GenericMatrix< _Matrix, E > &A, const GenericVector< _Vector, E > &V) |
| Reduce a vector with a given matrix using the Gauss elimination method. | |
| template<typename _Matrix> | |
| disable_if< typename _Matrix::persistent_type, std::numeric_limits< typename _Matrix::element_type > ::is_integer >::type | inv (const GenericMatrix< _Matrix > &m) |
| template<typename _Matrix, typename _Vector, typename E> | |
| disable_if< Vector< E > , std::numeric_limits< E > ::is_integer >::type | lin_solve (const GenericMatrix< _Matrix, E > &A, const GenericVector< _Vector, E > &B) |
| template<typename VectorIterator, typename RowBasisOutputIterator, typename ColBasisOutputIterator, typename E> | |
| void | null_space (VectorIterator v, RowBasisOutputIterator row_basis_consumer, ColBasisOutputIterator col_basis_consumer, ListMatrix< SparseVector< E > > &H, bool simplify=false) |
| template<typename _Vector, typename E> | |
| ListMatrix< SparseVector< E > > | null_space_oriented (const GenericVector< _Vector, E > &V, int req_sign) |
| template<typename _Matrix, typename E> | |
| std::pair< Set< int >, Set< int > > | basis_affine (const GenericMatrix< _Matrix, E > &M) |
| The same as basis(), but ignoring the first column of the matrix. | |
| template<typename E, typename _Vector1, typename _Vector2> | |
| _Vector2::persistent_type | proj (const GenericVector< _Vector1, E > &u, const GenericVector< _Vector2, E > &v) |
| Project u to v. | |
| template<typename Vector> | |
| GenericVector< Vector > ::persistent_type | dehomogenize (const GenericVector< Vector > &V) |
| Divide by the first element and strip it off. | |
| template<typename Vector> | |
| GenericVector< Vector > ::persistent_type | dehomogenize_trop (const GenericVector< Vector > &V) |
| Subtract the first element and strip it off. | |
| template<typename VectorIterator> | |
| void | orthogonalize (VectorIterator v) |
| Apply the Gram-Schmidt orthogonalization to the vector sequence. | |
| template<typename VectorIterator> | |
| void | orthogonalize_affine (VectorIterator v) |
| template<typename _Matrix> | |
| Set< int > | far_points (const GenericMatrix< _Matrix > &M) |
| Find row indices of all far points (that is, having zero in the first column). | |
| template<typename E, typename _Matrix, typename _Vector> | |
| Set< int > | orthogonal_rows (const GenericMatrix< _Matrix, E > &M, const GenericVector< _Vector, E > &v) |
| Find indices of rows orthogonal to the given vector. | |
The most common classes/functions/... are exported to the namespace polymake. Use this for your client code.
| bool pm::has_solution | ( | const GenericMatrix< _Matrix, E > & | A, | |
| const GenericVector< _Vector, E > & | B | |||
| ) | [inline] |
Solve the linear system A*x==B
| degenerate_matrix | if det(A) == 0 | |
| infeasible | if rank(A) != rank(A|B) |
| int pm::incl | ( | const GenericSet< _Set1, E1, Comparator > & | s1, | |
| const GenericSet< _Set2, E2, Comparator > & | s2 | |||
| ) | [inline] |
Analyze the inclusion relation of two sets. 0 $s1$ and $s2$ are equal -1 $s1$ is included in $s2$ 1 $s2$ is included in $s1$ 2 $s1$ and $s2$ are independent
| enable_if< typename GenericMatrix< _Matrix, Rational >::persistent_type, std::numeric_limits< typename _Matrix::element_type >::is_integer >::type pm::inv | ( | const GenericMatrix< _Matrix > & | m | ) | [inline] |
Compute the inverse matrix $A^-1$ using the Gauss elimination method.
| degenerate_matrix | if det(A)==0 |
| enable_if< Vector< Rational >, std::numeric_limits< E >::is_integer >::type pm::lin_solve | ( | const GenericMatrix< _Matrix, E > & | A, | |
| const GenericVector< _Vector, E > & | B | |||
| ) | [inline] |
Solve the linear system A*x==B
| degenerate_matrix | if det(A) == 0 | |
| infeasible | if rank(A) != rank(A|B) |
| void pm::null_space | ( | VectorIterator | v, | |
| RowBasisOutputIterator | row_basis_consumer, | |||
| ColBasisOutputIterator | col_basis_consumer, | |||
| ListMatrix< SparseVector< E > > & | H, | |||
| bool | simplify = false | |||
| ) | [inline] |
Compute the basis of the subspaces spanned by a sequence of vectors and orthogonal one.
| v | input iterator over the vectors | |
| row_basis_consumer | output iterator consuming the indices of basis rows (=vectors) | |
| col_basis_consumer | output iterator consuming the indices of basis columns (=coordinates) |
| ListMatrix< SparseVector<E> > pm::null_space_oriented | ( | const GenericVector< _Vector, E > & | V, | |
| int | req_sign | |||
| ) | [inline] |
| req_sign | expected sign of det( null_space(V) / V ) |
| void pm::orthogonalize_affine | ( | VectorIterator | v | ) | [inline] |
The same as orthogonalize(.), but making the affine parts of the resulting vectors (without 0-th coordinate) orthogonal
1.5.6