| ActivityState | Used by commentator This stores a snapshot of the state of the commentator's activity stack, so it may be restored after an exception is thrown |
| Algorithm | |
| Argument | |
| BaseTimer | |
| BasicReader | |
| BB_Symmetric_Container | |
| BBBase | |
| BBThread | |
| BitVector | |
| const_iterator | |
| const_reference | |
| iterator | |
| reference | |
| BlackboxArchetype | Showing the member functions provided by all blackbox matrix classes |
| BlackboxBlockContainer | |
| BlackboxBlockContainerBase | A base class for BlackboxBlockContainer. The primary member function is begin(). @doc 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 |
| const_iterator | |
| BlackboxBlockContainerRecord | |
| BlackboxContainer | Limited doc so far |
| BlackboxContainerBase | A base class for BlackboxContainer. The primary member function is begin(). @doc 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 |
| const_iterator | |
| BlackboxContainerSymmetric | See base class for doc |
| BlackboxContainerSymmetrize | Symmetrizing iterator (for rank computations). @doc # //================================================================ // LinBox Project 1999 // Symmetrizing iterator (for rank computations) // Same left and right vector // A is supposed to have tranpose-vector product // the sequence is u^t u, (A u)^t (A u) = u^t (A^t A) u, // (A^t (A u))^t (A^t (A u)) = u^t (A^t A)^2 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. @doc 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 | |
| BlackboxSpecifier | |
| BlackboxSymmetrizeIterator | |
| BlasApply | |
| BlasBlackbox | Template <class _Field> |
| rebind | |
| BlasEliminationTraits | |
| BlasMatrix | @memo Limited docs so far |
| BlasMatrixApplyDomain | |
| BlasMatrixDomain | |
| BlasMatrixDomainCharpoly | |
| BlasMatrixDomainCharpoly< Field, Polynomial, Container, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainDet | |
| BlasMatrixDomainDet< Field, BlasBlackbox< Field > > | |
| BlasMatrixDomainDet< Field, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainInv | |
| BlasMatrixDomainInv< Field, BlasBlackbox< Field > > | |
| BlasMatrixDomainInv< Field, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainLeftSolve | |
| BlasMatrixDomainLeftSolve< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainLeftSolve< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainLeftSolve< Field, std::vector< typename Field::Element >, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainLeftSolve< Field, std::vector< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMinpoly | |
| BlasMatrixDomainMinpoly< Field, Polynomial, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMul | |
| BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element >, BlasPermutation > | |
| BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element >, TransposedBlasMatrix< BlasPermutation > > | |
| BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasPermutation, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasPermutation, TriangularBlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, TransposedBlasMatrix< BlasPermutation >, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element >, BlasPermutation > | |
| BlasMatrixDomainMul< Field, std::vector< typename Field::Element >, BlasPermutation, std::vector< typename Field::Element > > | |
| BlasMatrixDomainMul< Field, std::vector< typename Field::Element >, std::vector< typename Field::Element >, BlasPermutation > | |
| BlasMatrixDomainMul< Field, std::vector< typename Field::Element >, std::vector< typename Field::Element >, TransposedBlasMatrix< BlasPermutation > > | |
| BlasMatrixDomainMul< Field, std::vector< typename Field::Element >, TransposedBlasMatrix< BlasPermutation >, std::vector< typename Field::Element > > | |
| BlasMatrixDomainMulAdd | |
| BlasMatrixDomainMulAdd< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMulAdd< Field, std::vector< typename Field::Element >, BlasMatrix< typename Field::Element >, std::vector< typename Field::Element > > | |
| BlasMatrixDomainMulAdd< Field, std::vector< typename Field::Element >, std::vector< typename Field::Element >, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMulin | |
| BlasMatrixDomainMulin< Field, BlasMatrix< typename Field::Element >, BlasPermutation > | |
| BlasMatrixDomainMulin< Field, BlasMatrix< typename Field::Element >, TransposedBlasMatrix< BlasPermutation > > | |
| BlasMatrixDomainMulin< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainMulin< Field, std::vector< typename Field::Element >, BlasPermutation > | |
| BlasMatrixDomainMulin< Field, std::vector< typename Field::Element >, TransposedBlasMatrix< BlasPermutation > > | |
| BlasMatrixDomainRank | |
| BlasMatrixDomainRank< Field, BlasBlackbox< Field > > | |
| BlasMatrixDomainRank< Field, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainRightSolve | |
| BlasMatrixDomainRightSolve< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainRightSolve< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainRightSolve< Field, std::vector< typename Field::Element >, BlasMatrix< typename Field::Element > > | |
| BlasMatrixDomainRightSolve< Field, std::vector< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > > | |
| BlasPermutation | |
| BlasTag | |
| BlockLanczosSolver | |
| BlockLanczosTraits | |
| BlockMasseyDomain | Compute the linear generator of a sequence of matrices @doc 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 | Butterfly Switching Network based BlackBox Matrix. A good preconditioner. @doc Implements butterfly switching network on a LinBox vector as a black box matrix through the use of a switch object |
| rebind | |
| CekstvSwitch | |
| CekstvSwitchFactory | |
| ChineseRemainder | |
| ClassifyRing | |
| ClassifyRing< DoubelFMod > | |
| 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 > > | |
| Command | |
| Companion | Companion matrix of a monic polynomial |
| rebind | |
| Comparator | |
| CompareSparseEntries | |
| Compose | General case |
| rebind | |
| Compose< _Blackbox, _Blackbox > | Specialization for _Blackbox1 = _Blackbox2 |
| rebind | |
| ComposeTraits | |
| ComposeTraits< DenseMatrix< Field > > | |
| ConstantVectorStream | |
| CRA | |
| DataNode | |
| DenseContainer | Limited doc so far |
| DenseIntegerMatrix | |
| DenseIntegerVector | |
| DenseMatrix | Blackbox interface to dense matrix representation |
| rebind | |
| DenseMatrixBase | |
| ColIterator | |
| ConstColIterator | |
| ConstRawIndexedIterator | |
| ConstRowIterator | |
| RawIndexedIterator | |
| rebind | |
| RowIterator | |
| DenseMatrixFactory | |
| DenseReader | |
| DenseRowsMatrix | |
| DenseSubmatrix | |
| ConstRawIterator | |
| RawIterator | |
| rebind | |
| Diagonal | General diagonal, not be implemented |
| Diagonal< _Field, VectorCategories::DenseVectorTag > | Specialization of Diagonal for application to dense vectors |
| rebind | |
| Diagonal< Field, VectorCategories::SparseAssociativeVectorTag > | Specialization of Diagonal for application to sparse associative vectors |
| rebind | |
| Diagonal< Field, VectorCategories::SparseSequenceVectorTag > | Specialization of Diagonal for application to sparse sequence vectors |
| rebind | |
| Diagonal< GF2, VectorTraits< Vector< GF2 >::Dense >::VectorCategory > | |
| Dif | Blackbox of a difference: C := A - B, i.e. Cx = Ax - Bx |
| rebind | |
| DiophantineSolver | DiophantineSolver<QSolver> creates a diophantine solver using a QSolver to generate rational solutions @doc 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 |
| rebind | |
| DirectSum< Blackbox, Blackbox > | |
| rebind | |
| DixonLiftingContainer | |
| DixonTraits | |
| DotProductDomain | |
| DotProductDomain< DoubleFmod > | |
| DotProductDomain< GF2 > | |
| 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 > > | |
| DoubleFmod | |
| ElementAbstract | Abstract element base class, a technicality |
| ElementArchetype | This is the Field and Ring element interface specification and archetypical instance class. @doc Element classes must contain public default constructor, copy constructor, assignment operator, and destructor. Note that primitive types such as int and double meet this specification |
| ElementEnvelope | Adaptor from archetypical interface to abstract interface, a technicality |
| EliminationSpecifier | |
| Eliminator | |
| Error | |
| FactorizedMatrixLeftLSolve | |
| FactorizedMatrixLeftLSolve< Field, BlasMatrix< typename Field::Element > > | |
| FactorizedMatrixLeftLSolve< Field, std::vector< typename Field::Element > > | |
| FactorizedMatrixLeftSolve | |
| FactorizedMatrixLeftSolve< Field, BlasMatrix< typename Field::Element > > | |
| FactorizedMatrixLeftSolve< Field, std::vector< typename Field::Element > > | |
| FactorizedMatrixLeftUSolve | |
| FactorizedMatrixLeftUSolve< Field, BlasMatrix< typename Field::Element > > | |
| FactorizedMatrixLeftUSolve< Field, std::vector< typename Field::Element > > | |
| FactorizedMatrixRightLSolve | |
| FactorizedMatrixRightLSolve< Field, BlasMatrix< typename Field::Element > > | |
| FactorizedMatrixRightLSolve< Field, std::vector< typename Field::Element > > | |
| FactorizedMatrixRightSolve | |
| FactorizedMatrixRightSolve< Field, BlasMatrix< typename Field::Element > > | |
| FactorizedMatrixRightSolve< Field, std::vector< typename Field::Element > > | |
| FactorizedMatrixRightUSolve | |
| FactorizedMatrixRightUSolve< Field, BlasMatrix< typename Field::Element > > | |
| FactorizedMatrixRightUSolve< Field, std::vector< typename Field::Element > > | |
| FFLAS | BLAS for matrices over finite fields |
| FFPACK | Set of elimination based routines for dense linear algebra with matrices over finite field |
| FieldAbstract | |
| FieldArchetype | |
| FieldAXPY | |
| FieldAXPY< DoubleFmod > | |
| 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 | |
| FieldInterface | This field base class exists solely to aid documentation organization. @doc For the general field member function documentation consult the FieldArchetype. For specific properties of individual representations consult the specific field classes |
| FieldIO | Dummy field for conceptually unclear io |
| FieldReaderAnalyzer | |
| FieldTraits | |
| FieldTraits< GivaroExtension< BaseField > > | |
| foobar | |
| foobar< LinBox::Local2_32 > | |
| Frobenius | Template <class _Field> |
| rebind | |
| GaussDomain | Repository of functions for rank by elimination on sparse matrices. @doc 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 | |
| GenericVector | |
| GF2 | |
| GF2RandIter | |
| GivaroExtension | |
| GivaroGfq | |
| GivaroMontg | |
| GivaroRational | |
| GivaroZpz | |
| GivPolynomialRing | |
| GmpRandomPrime | Generating random prime integers, using the gmp library |
| GMPRationalElement | |
| GMPRationalField | |
| GMPRationalRandIter | |
| Hankel | Template <class _Field> |
| rebind | |
| Hilbert | Example of a blackbox that is space efficient, though not time efficient |
| rebind | |
| Hilbert< _Field, VectorCategories::DenseVectorTag > | |
| Hilbert< _Field, VectorCategories::SparseAssociativeVectorTag > | |
| Hilbert< _Field, VectorCategories::SparseSequenceVectorTag > | |
| Hom | |
| Hom< Source, Source > | |
| HybridSpecifier | |
| IliopoulosElimination | This is Iliopoulos' algorithm do diagonalize. @doc 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 |
| ImageField | |
| InconsistentSystem | |
| indexDomain | |
| InputStorage | |
| Integer | |
| IntegerMatrix | |
| IntegerModularDet | |
| IntegerModularMinpoly | |
| IntegerModularSOLUTION | |
| IntegerVector | |
| InvalidMatrixInput | |
| Inverse | A Blackbox for the inverse. Not efficient if many applications are used |
| rebind | |
| iterator_traits< LinBox::BitVector::const_iterator > | |
| iterator_traits< LinBox::BitVector::iterator > | |
| LABlockLanczosSolver | |
| LanczosSolver | Solve a linear system using the conjugate Lanczos iteration. @doc 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. @doc This computes the last invariant factor of an integer matrix, whether zero or not, by rational solving |
| LazyProduct | |
| LessThanString | |
| LessTypeInfo | |
| LidiaGfq | |
| LidiaGfqRandIter | |
| LiftingContainer | |
| LiftingContainerBase | |
| const_iterator | |
| LinboxBadFormat | |
| LinboxError | |
| LinboxMathDivZero | |
| LinboxMathError | |
| Local2_32 | |
| LocalSmith | Smith normal form (invariant factors) of a matrix over a local ring |
| LocalSmith< Local2_32 > | |
| LPM_Method | |
| LQUPMatrix | |
| MapleDense1Reader | |
| MapleSparse1Reader | |
| MasseyDomain | Berlekamp/Massey algorithm. @doc 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 | |
| MatrixApplyDomain< Domain, BlasBlackbox< Domain > > | |
| MatrixApplyDomain< Domain, BlasMatrix< typename Domain::Element > > | |
| MatrixApplyDomain< Domain, DenseMatrix< Domain > > | |
| MatrixArchetype | |
| MatrixCategories | For specializing matrix arithmetic |
| BlackboxTag | |
| ColMatrixTag | |
| RowColMatrixTag | |
| RowMatrixTag | |
| MatrixContainerCategory | |
| Blackbox | |
| BlasContainer | |
| 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 |
| MatrixDomain< GF2 > | |
| 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 | |
| Method | Method specifiers for controlling algorithm choice |
| MGBlockLanczosSolver | Block Lanczos iteration |
| MinPoly | |
| MinPolyBlas | |
| MinpolyMethod | |
| Modular | Prime fields of positive characteristic implemented directly in LinBox. @doc This parameterized field can be used to construct prime fields. Typical use would be Modular<integer> for integers modulo a large prime, Modular<uint32>, modular<int>, or modular<double> for integers modulo a wordsize * prime. Each of those has specialized performance features suitable to certain applications |
| Modular< double > | |
| Modular< int > | Specialization of Modular to int element type with efficient dot product. @doc Efficient element operations for dot product, mul, axpy, by using floating point inverse of modulus (borrowed from NTL) and some use of non-normalized intermediate values |
| Modular< int16 > | Specialization of Modular to short element type with efficient dot product. @doc Efficient element operations for dot product, mul, axpy, by using floating point inverse of modulus (borrowed from NTL) and some use of non-normalized intermediate values |
| Modular< int32 > | Specialization of Modular to int32 element type with efficient dot product. @doc Efficient element operations for dot product, mul, axpy, by using floating point inverse of modulus (borrowed from NTL) and some use of non-normalized intermediate values |
| Modular< int8 > | Specialization of Modular to signed 8 bit element type with efficient dot product. @doc Efficient element operations for dot product, mul, axpy, by using floating point inverse of modulus (borrowed from NTL) and some use of non-normalized intermediate values |
| 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. @doc Requires 1 < the modulus < 2^8, normally prime. See FieldArchetype for member specifications |
| ModularBase | |
| ModularRandIter | |
| MoorePenrose | Generalized inverse of a blackbox. Efficiency concerns when many applications are used |
| 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 > > | |
| MyRandom | |
| MyRank | |
| node | |
| NoFiniteExtendedInLinBox | |
| NoHomError | Error object for attempt to establish a Hom that cannot exist |
| NonBlasEliminationTraits | |
| NonzeroRandIter | |
| NoTableFiniteInLinBox | |
| NTL_GF2E | |
| NTL_PID_zz_p | Extend Wrapper of zz_p from NTL. Add PID functions |
| NTL_ZZ | |
| NTL_ZZ_p | |
| NTL_zz_p | |
| NTL_ZZ_pE | |
| 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! |
| rebind | |
| NumericalTraits | |
| OneInvariantFactor | Limited doc so far |
| Pair | Pair of I and T : struct { column index, value } |
| ParamFuzzy | |
| ParamFuzzyRandIter | |
| Permutation | Size is n |
| rebind | |
| PID_double | |
| PID_integer | |
| PIR_ntl_ZZ_p | Extend Wrapper of ZZ_p from NTL. Add PIR functions |
| PIRModular< int > | |
| PIRModular< int32 > | |
| PolynomialBB | Represent the matrix P(A) where A is a blackbox and P a polynomial |
| rebind | |
| PowerOfTwoModular | |
| RandIter | |
| pplt | |
| pplt< LinBox::NTL_PID_zz_p > | |
| PreconditionFailed | |
| PrimeStream | |
| PromiseNode | |
| pwrlist | |
| RandIter | |
| RandIterAbstract | |
| RandIterArchetype | |
| RandIterEnvelope | |
| RandomDenseStream | |
| RandomDenseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag > | |
| RandomDenseStreamGF2 | |
| 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 > | |
| RandomSparseStreamGF2 | |
| RationalReconstruction | Limited doc so far. Used, for instance, after LiftingContainer |
| RationalSolver | |
| RationalSolver< Ring, Field, RandomPrime, BlockWiedemannTraits > | |
| RationalSolver< Ring, Field, RandomPrime, DixonTraits > | |
| RationalSolver< Ring, Field, RandomPrime, NumericalTraits > | |
| RationalSolver< Ring, Field, RandomPrime, WiedemannTraits > | |
| RationalSolverAdaptive | |
| RawVector | |
| RawVector< bool > | |
| Reader | |
| ReaderBlackBoxFactory | |
| ReaderIterator | |
| ReaderNotAField | |
| RealTimer | |
| Rebind | |
| 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 | |
| RingArchetype | |
| RingBase | |
| RingCategories | |
| GenericTag | |
| IntegerTag | |
| ModularTag | |
| RationalTag | |
| RingEnvelope | |
| RingInterface | |
| RingSpecific | |
| RingVector | |
| RingVectorBase | |
| ScalarMatrix | Blackbox for aI. Use particularly for representing 0 and I |
| rebind | |
| SCompose | |
| Signature | |
| BLAS_LPM_Method | |
| Minpoly_Method | |
| SingularMatrix | |
| SmithForm | Compute Smith form |
| SmithFormAdaptive | |
| SMSReader | |
| SolveFailed | |
| SolverTraits | |
| Sparse_Vector | Sparse Vector : vector< Pair<T> > and actualsize |
| SparseBlackBoxDom | |
| rebind | |
| SparseEliminationTraits | |
| SparseIntegerMatrix | |
| SparseIntegerVector | |
| SparseMatrix | Vector of sparse rows |
| rebind | |
| SparseMatrixBase | |
| rebind | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag > | |
| _RawIndexedIterator | |
| _RawIterator | |
| rebind | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag > | |
| _RawIndexedIterator | |
| _RawIterator | |
| rebind | |
| SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag > | |
| _RawIndexedIterator | |
| _RawIterator | |
| rebind | |
| SparseMatrixBase< UnparametricField< Ring >::Element, pair< vector< size_t >, vector< Ring > >> | |
| SparseMatrixFactory | |
| SparseMatrixReadWriteHelper | |
| SparseMatrixWriteHelper | |
| NoField | |
| 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 | |
| Submatrix | |
| Submatrix< Blackbox, VectorCategories::DenseVectorTag > | |
| rebind | |
| Submatrix< DenseMatrix< _Field >, VectorCategories::DenseVectorTag > | |
| rebind | |
| SubMatrixTraits< DenseMatrix< Field > > | |
| SubMatrixTraits< Submatrix< DenseMatrix< Field > > > | |
| SubRowMatrix< Matrix, MatrixCategories::RowMatrixTag > | |
| rebind | |
| Subvector | |
| Sum | Blackbox of a matrix sum without copying |
| rebind | |
| Sylvester | |
| rebind | |
| SysTimer | |
| TagNode | |
| TagTreeFrame | |
| Thread | |
| Timer | |
| Toeplitz | This is the blackbox representation of a Toeplitz matrix |
| rebind | |
| Transpose | Transpose matrix without copying |
| 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 |
| rebind | |
| UnparametricField | |
| UnparametricRandIter | |
| UnparametricRandIter< NTL::GF2E > | |
| UnparametricRandIter< NTL::zz_pE > | |
| UnparametricRandIter< NTL::ZZ_pE > | |
| UnSupportedMatrixType | |
| UserTimer | |
| Valence | |
| vector | |
| Vector | |
| rebind | |
| vector< pair< vector< size_t >, RingVector< Ring > >> | |
| VectorBase | |
| VectorCategories | |
| DenseVectorTag | |
| DenseZeroOneVectorTag | |
| GenericVectorTag | |
| SparseAssociativeVectorTag | |
| SparseParallelVectorTag | |
| SparseSequenceVectorTag | |
| SparseZeroOneVectorTag | |
| VectorDomain | |
| VectorDomain< GF2 > | |
| VectorDomainBase | |
| VectorFraction | VectorFraction<Domain> is a vector of rational elements with common reduced denominator. @doc 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 | |
| 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 > > | |
| VectorVector | |
| VectorVectorBase | |
| WiedemannLiftingContainer | |
| WiedemannSolver | Linear system solvers based on Wiedemann's method. @doc 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 | |
| Writer | |
| WriterFrame | |
| XMLTree | |
| ZeroOne | Time and space efficient representation of sparse {0,1}-matrices |
| RawIndexIterator | |
| RawIterator | |
| rebind | |
| ZpzDom | |
