| ActivityState | Used by commentator |
| Argument | |
| BaseTimer | Base for class RealTimer; class SysTimer; class UserTimer; |
| BB_Symmetric_Container | |
| BBBase | |
| BBThread | |
| BitVector | |
| BlackboxArchetype | Showing the member functions provided by all blackbox matrix classes |
| BlackboxBlockContainer | |
| BlackboxBlockContainerBase | A base class for BlackboxBlockContainer. The primary member function is begin(). It returns an iterator which after i increments (++) dereferences to $U A^i V$, for $U$ and $V$ determined by the init function. It is designed to be used with implementations of Block Berlekamp-Massey such as BlockMasseyDomain |
| BlackboxBlockContainerBase::const_iterator | |
| BlackboxBlockContainerRecord | |
| BlackboxContainer | Limited doc so far |
| BlackboxContainerBase | A base class for BlackboxContainer. The primary member function is begin(). It returns an iterator which after i increments (++) dereferences to $v^T A^i u$, for $v$ and $u$ determined by the form of construction. It is designed to be used with implementations of Berlekamp-Massey such as MasseyDom |
| BlackboxContainerBase::const_iterator | |
| BlackboxContainerSymmetric | See base class for doc |
| BlackboxContainerSymmetrize | Symmetrizing iterator (for rank computations). # //================================================================ // LinBox Project 1999 // Symmetrizing iterator (for rank computations) // Same left and right vector // A is supposed to have tranpose-vector product // the sequence is this->u^t this->u, (A this->u)^t (A this->u) = this->u^t (A^t A) this->u, // (A^t (A this->u))^t (A^t (A this->u)) = this->u^t (A^t A)^2 this->u , etc. // Time-stamp: <13 Jun 02 18:16:43 Jean-Guillaume.Dumas@imag.fr> // ================================================================ # |
| BlackboxFactory | A tool for computations with integer and rational matrices. The blackbox factory provides a facility for performing integer or rational computations by reducing modulo one or more primes and recovering the solution with Chinese Remaindering, lifting, or rational reconstruction. It is an interface that provides one method which, given a field, produces a black box representing a particular matrix over that field. The factory object may be passed to various procedures, such as rank, det, and solve, which will perform the required modular reductions to find integer or rational solutions |
| BlackboxInterface | This blackbox base class exists solely to aid documentation organization |
| BlackboxSpecifier | |
| BlackboxSymmetrizeIterator | |
| BlasApply | |
| BlasBlackbox | Template <class> |
| BlasBlackbox::rebind | |
| BlasEliminationTraits | |
| BlasMatrix | Limited docs so far |
| BlasMatrixApplyDomain | |
| BlasMatrixDomain | |
| BlasMatrixDomainCharpoly | |
| BlasMatrixDomainDet | |
| BlasMatrixDomainInv | |
| BlasMatrixDomainLeftSolve | |
| BlasMatrixDomainMinpoly | |
| BlasMatrixDomainMul | |
| BlasMatrixDomainMulAdd | |
| BlasMatrixDomainMulin | |
| BlasMatrixDomainRank | |
| BlasMatrixDomainRightSolve | |
| BlasPermutation | |
| BlasTag | |
| BlockLanczosSolver | |
| BlockLanczosTraits | |
| BlockMasseyDomain | Compute the linear generator of a sequence of matrices Giorgi, Jeannerod Villard algorithm from ISSAC'03 This class encapsulates the functionality required for computing the block minimal polynomial of a matrix |
| BlockWiedemannLiftingContainer | |
| BlockWiedemannSolver | |
| BlockWiedemannTraits | |
| BooleanSwitch | |
| BooleanSwitchFactory | |
| Butterfly | Switching Network based BlackBox Matrix. A good preconditioner |
| Butterfly::rebind | |
| CekstvSwitch | |
| CekstvSwitchFactory | |
| ChineseRemainder | |
| ClassifyRing | |
| ClassifyRing< GF2 > | |
| ClassifyRing< GivaroExtension< BaseField > > | |
| ClassifyRing< GivaroGfq > | |
| ClassifyRing< GivaroMontg > | |
| ClassifyRing< GivaroRational > | |
| ClassifyRing< GivaroZpz< Tag > > | |
| ClassifyRing< GMP_Integers > | |
| ClassifyRing< GMPRationalField > | |
| ClassifyRing< LidiaGfq > | |
| ClassifyRing< Local2_32 > | |
| ClassifyRing< Modular< double > > | |
| ClassifyRing< Modular< Element > > | |
| ClassifyRing< Modular< int > > | |
| ClassifyRing< Modular< int32 > > | |
| ClassifyRing< Modular< int8 > > | |
| ClassifyRing< Modular< short > > | |
| ClassifyRing< NTL_PID_zz_p > | |
| ClassifyRing< NTL_ZZ > | |
| ClassifyRing< NTL_zz_p > | |
| ClassifyRing< PID_integer > | |
| ClassifyRIng< PIR_ntl_ZZ_p > | |
| ClassifyRIng< PIRModular< int > > | |
| ClassifyRIng< PIRModular< int32 > > | |
| ClassifyRing< UnparametricField< K > > | |
| ClassifyRing< UnparametricField< NTL::RR > > | |
| ClassifyRing< UnparametricField< NTL::ZZ_p > > | |
| ClassifyRing< UnparametricRandIter< NTL::GF2E > > | |
| ClassifyRing< UnparametricRandIter< NTL::zz_pE > > | |
| ClassifyRing< UnparametricRandIter< NTL::ZZ_pE > > | |
| Commentator | Give information to user during runtime |
| Commentator::Activity | |
| Commentator::StepsAndTime | |
| Companion | Companion matrix of a monic polynomial |
| Companion::rebind | |
| CompareSparseEntries | |
| Compose | General case |
| Compose::rebind | |
| Compose< _Blackbox, _Blackbox > | Specialization for _Blackbox1 = _Blackbox2 |
| Compose< _Blackbox, _Blackbox >::rebind | |
| ComposeTraits | Used in ..., for example |
| ComposeTraits< DenseMatrix< Field > > | Used in smith-binary, for example |
| ConstantVectorStream | |
| CRA | |
| DenseContainer | Limited doc so far |
| DenseMatrix | Blackbox interface to dense matrix representation |
| DenseMatrix::rebind | |
| DenseMatrixBase | |
| DenseMatrixBase::rebind | |
| DenseMatrixFactory | |
| DenseReader | |
| DenseRowsMatrix | |
| DenseSubmatrix | |
| DenseSubmatrix::rebind | |
| Diagonal | General diagonal, not be implemented |
| Diagonal< _Field, VectorCategories::DenseVectorTag > | Specialization of Diagonal for application to dense vectors |
| Diagonal< _Field, VectorCategories::DenseVectorTag >::rebind | |
| Diagonal< Field, VectorCategories::SparseAssociativeVectorTag > | Specialization of Diagonal for application to sparse associative vectors |
| Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::rebind | |
| Diagonal< Field, VectorCategories::SparseSequenceVectorTag > | Specialization of Diagonal for application to sparse sequence vectors |
| Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::rebind | |
| Dif | Blackbox of a difference: C := A - B, i.e. Cx = Ax - Bx |
| Dif::rebind | |
| DiophantineSolver | DiophantineSolver<QSolver> creates a diophantine solver using a QSolver to generate rational solutions Methods solve, randomSolve just expose functions from underlying rational solver. Method diophantineSolve creates a solution with minimal denominator, and can also create a certificate of minimality (described in 'Certified Dense Linear System Solving' by Mulders+Storjohann) which will be left in the public field lastCertificate |
| DirectSum | If C = DirectSum(A, B) and y = xA and z = wB, then (y,z) = (x,w)C |
| DirectSum::rebind | |
| DirectSum< Blackbox, Blackbox > | |
| DirectSum< Blackbox, Blackbox >::rebind | |
| DixonLiftingContainer | |
| DixonTraits | |
| DotProductDomain | |
| DotProductDomain< GivaroZpz< Std16 > > | |
| DotProductDomain< GivaroZpz< Std32 > > | |
| DotProductDomain< Modular< double > > | |
| DotProductDomain< Modular< int > > | |
| DotProductDomain< Modular< int16 > > | |
| DotProductDomain< Modular< int32 > > | |
| DotProductDomain< Modular< int8 > > | |
| DotProductDomain< Modular< uint16 > > | |
| DotProductDomain< Modular< uint32 > > | |
| DotProductDomain< Modular< uint8 > > | |
| DotProductDomain< PIR_ntl_ZZ_p > | |
| DotProductDomain< PIRModular< int > > | |
| DotProductDomain< PIRModular< int32 > > | |
| ElementAbstract | Abstract element base class, a technicality |
| ElementArchetype | Field and Ring element interface specification and archetypical instance class |
| ElementEnvelope | Adaptor from archetypical interface to abstract interface, a technicality |
| EliminationSpecifier | |
| Eliminator | |
| FactorizedMatrixLeftLSolve | |
| FactorizedMatrixLeftSolve | |
| FactorizedMatrixLeftUSolve | |
| FactorizedMatrixRightLSolve | |
| FactorizedMatrixRightSolve | |
| FactorizedMatrixRightUSolve | |
| FactorMult | |
| FFLAS | BLAS for matrices over finite fields |
| FFPACK | Set of elimination based routines for dense linear algebra with matrices over finite prime field of characteristic less than 2^26 |
| FieldAbstract | Field base class |
| FieldArchetype | Field specification and archetypical instance |
| FieldAXPY | |
| FieldAXPY< GivaroZpz< Std16 > > | |
| FieldAXPY< GivaroZpz< Std32 > > | |
| FieldAXPY< Modular< _Element > > | |
| FieldAXPY< Modular< double > > | |
| FieldAXPY< Modular< int > > | |
| FieldAXPY< Modular< int16 > > | |
| FieldAXPY< Modular< int32 > > | |
| FieldAXPY< Modular< int8 > > | |
| FieldAXPY< Modular< uint16 > > | |
| FieldAXPY< Modular< uint32 > > | |
| FieldAXPY< Modular< uint8 > > | |
| FieldAXPY< NTL_ZZ > | |
| FieldAXPY< PIR_ntl_ZZ_p > | |
| FieldAXPY< PIRModular< int > > | |
| FieldAXPY< PIRModular< int32 > > | |
| FieldAXPY< UnparametricField< integer > > | |
| FieldEnvelope | Derived class used to implement the field archetype |
| FieldFactorMult | |
| FieldInterface | This field base class exists solely to aid documentation organization |
| FieldIO | Dummy field for conceptually unclear io |
| FieldTraits | |
| FieldTraits< GivaroExtension< BaseField > > | |
| Frobenius | Template <class> |
| Frobenius::rebind | |
| GaussDomain | Repository of functions for rank by elimination on sparse matrices. Several versions allow for adjustment of the pivoting strategy and for choosing in-place elimination or for not modifying the input matrix. Also an LU interface is offered |
| GenericRandIter | |
| GF2 | |
| GF2RandIter | |
| GivaroExtension | |
| GivaroExtension< GivaroGfq > | |
| GivaroField | Give LinBox fields an allure of Givaro Fields |
| GivaroGfq | |
| GivaroMontg | Wrapper of Givaro's Montgomery<Std32> |
| GivaroRational | |
| GivaroZpz | Wrapper of Givaro's ZpzDom |
| GivPolynomial | Polynomials over a domain |
| GivPolynomial::rebind | |
| GivPolynomialRing | Polynomials with coefficients modulo some power of two |
| GmpRandomPrime | Generating random prime integers, using the gmp library |
| GMPRationalElement | Elements of GMP_Rationals |
| GMPRationalField | |
| GMPRationalRandIter | |
| Hankel | Template <class> |
| Hankel::rebind | |
| Hilbert | Example of a blackbox that is space efficient, though not time efficient |
| Hilbert::rebind | |
| Hilbert< _Field, VectorCategories::DenseVectorTag > | |
| Hilbert< _Field, VectorCategories::SparseAssociativeVectorTag > | |
| Hilbert< _Field, VectorCategories::SparseSequenceVectorTag > | |
| Hom | Map element of source ring(field) to target ring |
| Hom< BaseField, GivaroExtension< BaseField > > | |
| Hom< Source, Source > | |
| HybridSpecifier | |
| InconsistentSystem | |
| indexDomain | |
| IntegerModularDet | |
| IntegerModularMinpoly | |
| InvalidMatrixInput | |
| Inverse | A Blackbox for the inverse. Not efficient if many applications are used |
| Inverse::rebind | |
| LABlockLanczosSolver | |
| LanczosSolver | Solve a linear system using the conjugate Lanczos iteration. Lanczos system solver class. This class encapsulates the functionality required for solving a linear system through the conjugate Lanczos iteration |
| LanczosTraits | |
| LastInvariantFactor | This is used in a Smith Form algorithm. This computes the last invariant factor of an integer matrix, whether zero or not, by rational solving |
| LazyProduct | |
| LessThanString | |
| LessTypeInfo | |
| LidiaGfq | Defines the Galois Field GF(pk) |
| LidiaGfqRandIter | |
| LiftingContainer | |
| LiftingContainerBase | |
| LiftingContainerBase::const_iterator | |
| LinboxBadFormat | |
| LinboxError | |
| LinboxMathDivZero | |
| LinboxMathError | |
| Local2_32 | Fast arithmetic mod 2^32, including gcd |
| LQUPMatrix | |
| MapleDense1Reader | |
| MapleSparse1Reader | |
| MasseyDomain | Berlekamp/Massey algorithm. Domain Massey
- Computation is stopped when the polynomials remain the same for more than EARLY_TERM_THRESOLD
- When minimal polynomial equals characteristic polynomial, 2 additional iterations are needed to compute it (parameter DEFAULT_ADDITIONAL_ITERATION), but those iterations are not needed for the rank
|
| MatrixApplyDomain | Blackbox apply optimizations |
| MatrixApplyDomain< Domain, BlasBlackbox< Domain > > | |
| MatrixApplyDomain< Domain, BlasMatrix< typename Domain::Element > > | |
| MatrixApplyDomain< Domain, DenseMatrix< Domain > > | |
| MatrixArchetype | |
| MatrixCategories | For specializing matrix arithmetic |
| MatrixCategories::BlackboxTag | |
| MatrixCategories::ColMatrixTag | |
| MatrixCategories::RowColMatrixTag | |
| MatrixCategories::RowMatrixTag | |
| MatrixContainerCategory | |
| MatrixContainerCategory::Blackbox | |
| MatrixContainerCategory::BlasContainer | |
| MatrixContainerCategory::Container | |
| MatrixContainerTrait | |
| MatrixContainerTrait< BlasBlackbox< Field > > | |
| MatrixContainerTrait< BlasMatrix< typename Field::Element > > | |
| MatrixContainerTrait< const BlasBlackbox< Field > > | |
| MatrixContainerTrait< const BlasMatrix< typename Field::Element > > | |
| MatrixContainerTrait< DenseMatrix< Field > > | |
| MatrixContainerTrait< DenseMatrixBase< typename Field::Element > > | |
| MatrixContainerTrait< SparseMatrix< Field > > | |
| MatrixContainerTrait< SparseMatrixBase< typename Field::Element > > | |
| MatrixDomain | Class of matrix arithmetic functions |
| MatrixHomTrait | |
| MatrixHomTrait< BlasBlackbox< Ring >, Field > | |
| MatrixHomTrait< DenseMatrix< Ring >, Field > | |
| MatrixHomTrait< DenseMatrixBase< typename Ring::Element >, Field > | |
| MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparseMap >, Field > | |
| MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparsePar >, Field > | |
| MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparseSeq >, Field > | |
| MatrixInverse | |
| MatrixMarketReader | |
| MatrixRank | |
| MatrixStream | |
| MatrixStreamReader | |
| MatrixTraits | |
| MatrixTraits< BlasBlackbox< Field > > | |
| MatrixTraits< BlasMatrix< Element > > | |
| MatrixTraits< const BlasBlackbox< Field > > | |
| MatrixTraits< const BlasMatrix< Element > > | |
| MatrixTraits< const DenseMatrix< Field > > | |
| MatrixTraits< const DenseMatrixBase< Element > > | |
| MatrixTraits< const SparseMatrix< Field, _Row > > | |
| MatrixTraits< const SparseMatrixBase< Element, Row, Trait > > | |
| MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > > | |
| MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > > | |
| MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > > | |
| MatrixTraits< DenseMatrix< Field > > | |
| MatrixTraits< DenseMatrixBase< Element > > | |
| MatrixTraits< DenseRowsMatrix< Row > > | |
| MatrixTraits< DenseSubmatrix< Element > > | |
| MatrixTraits< MatrixArchetype< Element > > | |
| MatrixTraits< SparseMatrix< Field, _Row > > | |
| MatrixTraits< SparseMatrixBase< Element, Row, Trait > > | |
| MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > > | |
| MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > > | |
| MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > > | |
| MersenneTwister | |
| MessageClass | |
| Method | Method specifiers for controlling algorithm choice |
| MGBlockLanczosSolver | Block Lanczos iteration |
| MinPoly | |
| MinPolyBlas | |
| Modular | Prime fields of positive characteristic implemented directly in LinBox |
| Modular< double > | Template <> |
| Modular< int > | Template <> |
| Modular< int16 > | Specialization of Modular to short element type with efficient dot product |
| Modular< int32 > | Template <> |
| Modular< int8 > | Specialization of Modular to signed 8 bit element type with efficient dot product |
| Modular< uint16 > | Specialization of class Modular for uint16 element type |
| Modular< uint32 > | Specialization of class Modular for uint32 element type |
| Modular< uint8 > | Allows compact storage when the modulus is less than 2^8 |
| ModularBase | |
| ModularBase::RandIter | |
| ModularRandIter | |
| MoorePenrose | Generalized inverse of a blackbox. Efficiency concerns when many applications are used |
| MoorePenrose::rebind | |
| MVProductDomain | Helper class to allow specializations of certain matrix-vector products |
| MVProductDomain< Modular< int16 > > | |
| MVProductDomain< Modular< int32 > > | |
| MVProductDomain< Modular< int8 > > | |
| MVProductDomain< Modular< uint16 > > | |
| MVProductDomain< Modular< uint32 > > | |
| MVProductDomain< Modular< uint8 > > | |
| MVProductDomain< PIR_ntl_ZZ_p > | |
| MVProductDomain< PIRModular< int32 > > | |
| NoHomError | Error object for attempt to establish a Hom that cannot exist |
| NonBlasEliminationTraits | |
| NonzeroRandIter | |
| NTL_GF2E | |
| NTL_PID_zz_p | Extend Wrapper of zz_p from NTL. Add PID functions |
| NTL_ZZ_p | |
| NTL_zz_p | |
| NTL_ZZ_pE | |
| NTL_ZZRandIter | |
| NullMatrix | This is a representation of the 0 by 0 empty matrix which does not occupy memory. It has it's uses! |
| NullMatrix::rebind | |
| NumericalTraits | |
| OneInvariantFactor | Limited doc so far |
| Pair | Pair of I and T : struct { column index, value } |
| ParamFuzzy | |
| ParamFuzzyRandIter | |
| Permutation | Size is n |
| Permutation::rebind | |
| PIR_ntl_ZZ_p | Extend Wrapper of ZZ_p from NTL. Add PIR functions |
| PIRModular< int > | Template <> |
| PIRModular< int32 > | Template <> |
| PolynomialBB | Represent the matrix P(A) where A is a blackbox and P a polynomial |
| PolynomialBB::rebind | |
| PowerOfTwoModular | Ring of elements modulo some power of two |
| PowerOfTwoModular::RandIter | |
| PreconditionFailed | |
| PrimeStream | |
| RandIterAbstract | |
| RandIterArchetype | |
| RandIterEnvelope | |
| RandomDenseStream | |
| RandomDenseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag > | |
| RandomMatrix | |
| RandomMatrix::rebind | |
| RandomMatrixTraits | |
| RandomPrime | |
| RandomSparseStream | |
| RandomSparseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag > | |
| RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseAssociativeVectorTag > | |
| RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseParallelVectorTag > | |
| RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseSequenceVectorTag > | |
| RationalReconstruction | Limited doc so far. Used, for instance, after LiftingContainer |
| RationalSolver | Interface for the different specialization of p-adic lifting based solvers |
| RationalSolver< Ring, Field, RandomPrime, BlockWiedemannTraits > | Partial specialization of p-adic based solver with block Wiedemann algorithm |
| RationalSolver< Ring, Field, RandomPrime, DixonTraits > | Partial specialization of p-adic based solver with Dixon algorithm |
| RationalSolver< Ring, Field, RandomPrime, NumericalTraits > | Partial specialization of p-adic based solver with a hybrid Numeric/Symbolic computation |
| RationalSolver< Ring, Field, RandomPrime, WiedemannTraits > | Partial specialization of p-adic based solver with Wiedemann algorithm |
| RationalSolverAdaptive | |
| RawVector | |
| RealTimer | |
| Rebind | Used in support of Hom, MatrixHom |
| Rebind< std::map< size_t, T >, U > | |
| Rebind< std::pair< std::vector< size_t >, std::vector< T > >, U > | |
| Rebind< std::vector< std::pair< size_t, T > >, U > | |
| Rebind< std::vector< T >, U > | |
| ReverseVector | |
| RingAbstract | Abstract ring base class |
| RingArchetype | Specification and archetypic instance for the ring interface |
| RingCategories | |
| RingCategories::GenericTag | |
| RingCategories::IntegerTag | |
| RingCategories::ModularTag | |
| RingCategories::RationalTag | |
| RingEnvelope | Implement the ring archetype to minimize code bloat |
| RingInterface | This ring base class exists solely to aid documentation organization |
| ScalarMatrix | Blackbox for aI. Use particularly for representing 0 and I |
| ScalarMatrix::rebind | |
| SCompose | |
| Signature | |
| Signature::BLAS_LPM_Method | |
| Signature::Minpoly_Method | |
| SmithFormAdaptive | |
| SmithFormBinary | Compute Smith form |
| SmithFormIliopoulos | This is Iliopoulos' algorithm do diagonalize. Compute Smith Form by elimination modulo m, for some modulus m such as S(n), the last invariant factor. The elimination method is originally described in "Worst Case Complexity Bounds on Algorithms for computing the Canonical Structure of Finite Abelian Groups and the Hermite and Smith Normal Forms of an Integer Matrix", by Costas Iliopoulos |
| SmithFormLocal | Smith normal form (invariant factors) of a matrix over a local ring |
| SmithFormLocal< Local2_32 > | |
| SMSReader | |
| SolveFailed | |
| SolverConcept | Showing functions expected of solver objects |
| SolverTraits | |
| Sparse_Vector | Vector< Pair<T> > and actualsize |
| SparseBlackBoxDom | |
| SparseBlackBoxDom::rebind | |
| SparseEliminationTraits | |
| SparseMatrix | Vector of sparse rows |
| SparseMatrix::rebind | |
| SparseMatrixBase | |
| SparseMatrixBase::rebind | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag > | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >::_RawIndexedIterator | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >::_RawIterator | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >::rebind | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag > | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >::_RawIndexedIterator | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >::_RawIterator | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >::rebind | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag > | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >::_RawIndexedIterator | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >::_RawIterator | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >::rebind | |
| SparseMatrixFactory | |
| SparseMatrixReadWriteHelper | |
| SparseMatrixWriteHelper | |
| SparseMatrixWriteHelper::NoField | |
| SparseMatrixWriteHelper< _Element, Row, VectorCategories::SparseParallelVectorTag > | |
| SparseMatrixWriteHelper< _Element, Row, VectorCategories::SparseParallelVectorTag >::NoField | |
| SparseRowReader | |
| SparseSequenceVectorPairLessThan | |
| Specifier | |
| StandardBasisStream | |
| StandardBasisStream< Field, _Vector, VectorCategories::DenseVectorTag > | |
| StandardBasisStream< Field, _Vector, VectorCategories::SparseAssociativeVectorTag > | |
| StandardBasisStream< Field, _Vector, VectorCategories::SparseParallelVectorTag > | |
| StandardBasisStream< Field, _Vector, VectorCategories::SparseSequenceVectorTag > | |
| Subiterator | Subvector iterator class provides striding iterators |
| Submatrix | |
| Submatrix< Blackbox, VectorCategories::DenseVectorTag > | |
| Submatrix< Blackbox, VectorCategories::DenseVectorTag >::rebind | |
| Submatrix< DenseMatrix< _Field >, VectorCategories::DenseVectorTag > | |
| Submatrix< DenseMatrix< _Field >, VectorCategories::DenseVectorTag >::rebind | |
| SubMatrixTraits< DenseMatrix< Field > > | |
| SubMatrixTraits< Submatrix< DenseMatrix< Field > > > | |
| SubRowMatrix< Matrix, MatrixCategories::RowMatrixTag > | |
| SubRowMatrix< Matrix, MatrixCategories::RowMatrixTag >::rebind | |
| Subvector | Dense subvector |
| Sum | Blackbox of a matrix sum without copying |
| Sum::rebind | |
| Sylvester | Template <class> |
| Sylvester::rebind | |
| SysTimer | |
| Thread | |
| Timer | |
| Toeplitz | This is the blackbox representation of a Toeplitz matrix |
| Toeplitz::rebind | |
| Transpose | Transpose matrix without copying |
| Transpose::rebind | |
| TransposedBlasMatrix | |
| TransposedBlasMatrix< TransposedBlasMatrix< Matrix > > | |
| TransposeMatrix | |
| TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > | |
| TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > | |
| TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > | |
| TriangularBlasMatrix | |
| TriplesBB | Wrapper for NAG Sparse Matrix format |
| TriplesBB::rebind | |
| UnparametricField | |
| UnparametricRandIter | |
| UnparametricRandIter< NTL::GF2E > | Template<> |
| UnparametricRandIter< NTL::ZZ_pE > | |
| UnparametricRandIter< NTL::zz_pE > | |
| UserTimer | |
| Valence | |
| Vector | |
| Vector::rebind | |
| VectorCategories | List of vector categories |
| VectorCategories::DenseVectorTag | |
| VectorCategories::DenseZeroOneVectorTag | |
| VectorCategories::GenericVectorTag | |
| VectorCategories::SparseAssociativeVectorTag | |
| VectorCategories::SparseParallelVectorTag | |
| VectorCategories::SparseSequenceVectorTag | |
| VectorCategories::SparseZeroOneVectorTag | |
| VectorDomain | |
| VectorDomainBase | |
| VectorFraction | VectorFraction<Domain> is a vector of rational elements with common reduced denominator. Here Domain is a ring supporting the gcd, eg NTL_ZZ or PID_integer For compatability with the return type of rationalSolver, it allows conversion from/to std::vector<std::pair<Domain::Element> >. All functions will return the fraction in reduced form, calling reduce() if necessary |
| VectorStream | Vector factory |
| VectorTraits | |
| VectorTraits< BitVector > | |
| VectorTraits< ReverseVector< Vector > > | |
| VectorTraits< std::deque< std::pair< size_t, Element > > > | |
| VectorTraits< std::list< std::pair< size_t, Element > > > | |
| VectorTraits< std::map< size_t, Element > > | |
| VectorTraits< std::pair< std::vector< size_t >, std::vector< Element > > > | |
| VectorTraits< std::vector< Element > > | |
| VectorTraits< std::vector< std::pair< size_t, Element > > > | |
| VectorTraits< Subvector< Iterator, ConstIterator > > | |
| Wiedemann | Solutions all based on Wiedemann's algorithm |
| WiedemannLiftingContainer | |
| WiedemannSolver | Linear system solvers based on Wiedemann's method. This class encapsulates all of the functionality for linear system solving with Wiedemann's algorithm. It includes the random solution and random nullspace element of Kaltofen and Saunders (1991), as well as the certificate of inconsistency of Giesbrecht, Lobo, and Saunders (1998) |
| WiedemannTraits | |
| ZeroOne | Time and space efficient representation of sparse {0,1}-matrices |
| ZeroOne::rebind | |
| ZpzDom | |
