Main Page | Modules | Namespace List | Class Hierarchy | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages

LinBox Namespace Reference


Data Structures

class  FactorMult
class  FieldFactorMult
class  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. More...

class  BlackboxBlockContainerBase::const_iterator
class  BlackboxBlockContainer
class  BlackboxBlockContainerRecord
class  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. More...

class  BlackboxContainerBase::const_iterator
class  BlackboxContainerSymmetric
 See base class for doc. More...

class  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> // ================================================================ #. More...

class  BlackboxContainer
 Limited doc so far. More...

class  BlasMatrixDomainMulAdd
class  BlasMatrixDomainMul
class  BlasMatrixDomainMulin
class  BlasMatrixDomainInv
class  BlasMatrixDomainRank
class  BlasMatrixDomainDet
class  BlasMatrixDomainLeftSolve
class  BlasMatrixDomainRightSolve
class  BlasMatrixDomainMinpoly
class  BlasMatrixDomainCharpoly
class  BlasMatrixDomain
class  BlockLanczosSolver
class  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. More...

class  BlockWiedemannSolver
struct  LazyProduct
struct  ChineseRemainder
class  CRA
class  DenseContainer
 Limited doc so far. More...

class  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. More...

class  Eliminator
class  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. More...

class  LABlockLanczosSolver
class  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. More...

class  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. More...

class  LiftingContainer
class  LiftingContainerBase
class  LiftingContainerBase::const_iterator
class  DixonLiftingContainer
class  WiedemannLiftingContainer
class  BlockWiedemannLiftingContainer
class  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.
More...

struct  MatrixHomTrait
struct  MatrixHomTrait< DenseMatrixBase< typename Ring::Element >, Field >
struct  MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparseSeq >, Field >
struct  MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparsePar >, Field >
struct  MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparseMap >, Field >
struct  MatrixHomTrait< DenseMatrix< Ring >, Field >
struct  MatrixHomTrait< BlasBlackbox< Ring >, Field >
class  MatrixInverse
class  MatrixRank
class  MGBlockLanczosSolver
 Block Lanczos iteration. More...

class  MinPoly
class  MinPolyBlas
class  OneInvariantFactor
 Limited doc so far. More...

class  RationalReconstruction
 Limited doc so far. Used, for instance, after LiftingContainer. More...

class  RationalSolverAdaptive
class  RationalSolver
 interface for the different specialization of p-adic lifting based solvers. More...

class  RationalSolver< Ring, Field, RandomPrime, WiedemannTraits >
 partial specialization of p-adic based solver with Wiedemann algorithm More...

class  RationalSolver< Ring, Field, RandomPrime, BlockWiedemannTraits >
 partial specialization of p-adic based solver with block Wiedemann algorithm More...

class  RationalSolver< Ring, Field, RandomPrime, DixonTraits >
 partial specialization of p-adic based solver with Dixon algorithm More...

class  RationalSolver< Ring, Field, RandomPrime, NumericalTraits >
 partial specialization of p-adic based solver with a hybrid Numeric/Symbolic computation More...

class  Signature
class  Signature::BLAS_LPM_Method
class  Signature::Minpoly_Method
class  SmithFormAdaptive
class  SmithFormBinary
 Compute Smith form. More...

class  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. More...

class  SmithFormLocal
 Smith normal form (invariant factors) of a matrix over a local ring. More...

class  SmithFormLocal< Local2_32 >
class  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. More...

class  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). More...

class  BlasApply
class  MatrixApplyDomain
 blackbox apply optimizations More...

class  BlasMatrixApplyDomain
class  MatrixApplyDomain< Domain, BlasMatrix< typename Domain::Element > >
class  MatrixApplyDomain< Domain, DenseMatrix< Domain > >
class  MatrixApplyDomain< Domain, BlasBlackbox< Domain > >
class  BlackboxArchetype
 showing the member functions provided by all blackbox matrix classes. More...

class  BlackboxInterface
 This blackbox base class exists solely to aid documentation organization. More...

class  Thread
struct  BBBase
class  LessTypeInfo
class  BBThread
class  BlasBlackbox
 template <class> More...

struct  BlasBlackbox::rebind
struct  MatrixTraits< BlasBlackbox< Field > >
struct  MatrixTraits< const BlasBlackbox< Field > >
class  MatrixContainerTrait< BlasBlackbox< Field > >
class  MatrixContainerTrait< const BlasBlackbox< Field > >
class  Butterfly
 Switching Network based BlackBox Matrix. A good preconditioner. More...

struct  Butterfly::rebind
struct  Companion
 Companion matrix of a monic polynomial. More...

struct  Companion::rebind
class  Compose
 General case. More...

struct  Compose::rebind
class  Compose< _Blackbox, _Blackbox >
 specialization for _Blackbox1 = _Blackbox2 More...

struct  Compose< _Blackbox, _Blackbox >::rebind
class  ComposeTraits
 used in ..., for example More...

class  ComposeTraits< DenseMatrix< Field > >
 used in smith-binary, for example More...

class  DenseMatrix
 Blackbox interface to dense matrix representation. More...

struct  DenseMatrix::rebind
struct  MatrixTraits< DenseMatrix< Field > >
struct  MatrixTraits< const DenseMatrix< Field > >
class  DenseMatrixFactory
class  Diagonal
 General diagonal, not be implemented. More...

class  Diagonal< _Field, VectorCategories::DenseVectorTag >
 Specialization of Diagonal for application to dense vectors. More...

struct  Diagonal< _Field, VectorCategories::DenseVectorTag >::rebind
class  Diagonal< Field, VectorCategories::SparseSequenceVectorTag >
 Specialization of Diagonal for application to sparse sequence vectors. More...

struct  Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::rebind
class  Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >
 Specialization of Diagonal for application to sparse associative vectors. More...

struct  Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::rebind
class  Dif
 Blackbox of a difference: C := A - B, i.e. Cx = Ax - Bx. More...

struct  Dif::rebind
class  DirectSum
 If C = DirectSum(A, B) and y = xA and z = wB, then (y,z) = (x,w)C. More...

struct  DirectSum::rebind
class  DirectSum< Blackbox, Blackbox >
struct  DirectSum< Blackbox, Blackbox >::rebind
class  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. More...

class  Frobenius
 template <class> More...

struct  Frobenius::rebind
class  Hilbert
 Example of a blackbox that is space efficient, though not time efficient. More...

struct  Hilbert::rebind
class  Hilbert< _Field, VectorCategories::DenseVectorTag >
class  Hilbert< _Field, VectorCategories::SparseSequenceVectorTag >
class  Hilbert< _Field, VectorCategories::SparseAssociativeVectorTag >
class  Inverse
 A Blackbox for the inverse. Not efficient if many applications are used. More...

struct  Inverse::rebind
class  MoorePenrose
 Generalized inverse of a blackbox. Efficiency concerns when many applications are used. More...

struct  MoorePenrose::rebind
class  Hankel
 template <class> More...

struct  Hankel::rebind
class  Sylvester
 template <class> More...

struct  Sylvester::rebind
class  Toeplitz
 This is the blackbox representation of a Toeplitz matrix. More...

struct  Toeplitz::rebind
class  NullMatrix
 This is a representation of the 0 by 0 empty matrix which does not occupy memory. It has it's uses! More...

struct  NullMatrix::rebind
class  Permutation
 size is n. More...

struct  Permutation::rebind
class  PolynomialBB
 represent the matrix P(A) where A is a blackbox and P a polynomial More...

struct  PolynomialBB::rebind
class  RandomMatrixTraits
class  RandomMatrix
struct  RandomMatrix::rebind
class  ScalarMatrix
 Blackbox for aI. Use particularly for representing 0 and I. More...

struct  ScalarMatrix::rebind
class  SCompose
class  SparseMatrix
 vector of sparse rows. More...

struct  SparseMatrix::rebind
class  SparseMatrixFactory
struct  MatrixTraits< SparseMatrix< Field, _Row > >
struct  MatrixTraits< const SparseMatrix< Field, _Row > >
class  SubMatrixTraits< DenseMatrix< Field > >
class  SubMatrixTraits< Submatrix< DenseMatrix< Field > > >
class  Submatrix
class  Submatrix< Blackbox, VectorCategories::DenseVectorTag >
struct  Submatrix< Blackbox, VectorCategories::DenseVectorTag >::rebind
class  Submatrix< DenseMatrix< _Field >, VectorCategories::DenseVectorTag >
struct  Submatrix< DenseMatrix< _Field >, VectorCategories::DenseVectorTag >::rebind
class  SubRowMatrix< Matrix, MatrixCategories::RowMatrixTag >
struct  SubRowMatrix< Matrix, MatrixCategories::RowMatrixTag >::rebind
class  Sum
 blackbox of a matrix sum without copying. More...

struct  Sum::rebind
class  Transpose
 transpose matrix without copying. More...

struct  Transpose::rebind
class  TriplesBB
 wrapper for NAG Sparse Matrix format. More...

struct  TriplesBB::rebind
class  ZeroOne
 Time and space efficient representation of sparse {0,1}-matrices. More...

struct  ZeroOne::rebind
class  ElementAbstract
 Abstract element base class, a technicality. More...

class  ElementArchetype
 Field and Ring element interface specification and archetypical instance class. More...

class  ElementEnvelope
 Adaptor from archetypical interface to abstract interface, a technicality. More...

class  GivPolynomial
 Polynomials over a domain. More...

struct  GivPolynomial::rebind
class  GMPRationalElement
 elements of GMP_Rationals. More...

class  FFLAS
 BLAS for matrices over finite fields. More...

class  FFPACK
 Set of elimination based routines for dense linear algebra with matrices over finite prime field of characteristic less than 2^26. More...

class  FieldAbstract
 field base class. More...

class  FieldArchetype
 field specification and archetypical instance. More...

class  FieldEnvelope
 Derived class used to implement the field archetype. More...

class  FieldInterface
 This field base class exists solely to aid documentation organization. More...

class  RingCategories
struct  RingCategories::GenericTag
struct  RingCategories::ModularTag
struct  RingCategories::IntegerTag
struct  RingCategories::RationalTag
struct  ClassifyRing
struct  FieldTraits
struct  ClassifyRing< GF2 >
class  GF2
struct  ClassifyRing< GivaroExtension< BaseField > >
struct  FieldTraits< GivaroExtension< BaseField > >
struct  GivaroField
 give LinBox fields an allure of Givaro Fields More...

class  GivaroExtension
class  GivaroExtension< GivaroGfq >
class  Hom< BaseField, GivaroExtension< BaseField > >
struct  ClassifyRing< GivaroGfq >
class  GivaroGfq
struct  ClassifyRing< GivaroMontg >
class  GivaroMontg
 wrapper of Givaro's Montgomery<Std32>. More...

struct  ClassifyRing< GivaroRational >
class  GivaroRational
struct  ClassifyRing< GivaroZpz< Tag > >
class  GivaroZpz
 wrapper of Givaro's ZpzDom. More...

class  FieldAXPY< GivaroZpz< Std32 > >
class  FieldAXPY< GivaroZpz< Std16 > >
class  DotProductDomain< GivaroZpz< Std32 > >
class  DotProductDomain< GivaroZpz< Std16 > >
struct  ClassifyRing< GMP_Integers >
struct  ClassifyRing< GMPRationalField >
class  GMPRationalField
class  NoHomError
 Error object for attempt to establish a Hom that cannot exist. More...

class  Hom
 map element of source ring(field) to target ring More...

class  Hom< Source, Source >
struct  ClassifyRing< LidiaGfq >
class  LidiaGfq
 defines the Galois Field GF(pk). More...

struct  ClassifyRing< Local2_32 >
struct  Local2_32
 Fast arithmetic mod 2^32, including gcd. More...

struct  ClassifyRing< Modular< int > >
class  Modular< int >
 template <> More...

class  FieldAXPY< Modular< int > >
class  DotProductDomain< Modular< int > >
struct  ClassifyRing< Modular< int32 > >
class  Modular< int32 >
 template <> More...

class  FieldAXPY< Modular< int32 > >
class  DotProductDomain< Modular< int32 > >
struct  ClassifyRing< Modular< int8 > >
class  Modular< int8 >
 Specialization of Modular to signed 8 bit element type with efficient dot product. More...

class  FieldAXPY< Modular< int8 > >
class  DotProductDomain< Modular< int8 > >
class  MVProductDomain< Modular< int8 > >
struct  ClassifyRing< Modular< double > >
class  Modular< double >
 template <> More...

class  FieldAXPY< Modular< double > >
class  DotProductDomain< Modular< double > >
class  MVProductDomain< Modular< int32 > >
struct  ClassifyRing< Modular< short > >
class  Modular< int16 >
 Specialization of Modular to short element type with efficient dot product. More...

class  FieldAXPY< Modular< int16 > >
class  DotProductDomain< Modular< int16 > >
class  MVProductDomain< Modular< int16 > >
struct  ClassifyRing< Modular< Element > >
class  ModularBase
class  Modular
 Prime fields of positive characteristic implemented directly in LinBox. More...

class  Modular< uint8 >
 Allows compact storage when the modulus is less than 2^8. More...

class  Modular< uint16 >
 Specialization of class Modular for uint16 element type. More...

class  Modular< uint32 >
 Specialization of class Modular for uint32 element type. More...

class  FieldAXPY< Modular< _Element > >
class  FieldAXPY< Modular< uint8 > >
class  FieldAXPY< Modular< uint16 > >
class  FieldAXPY< Modular< uint32 > >
class  DotProductDomain< Modular< uint8 > >
class  DotProductDomain< Modular< uint16 > >
class  DotProductDomain< Modular< uint32 > >
class  MVProductDomain< Modular< uint8 > >
class  MVProductDomain< Modular< uint16 > >
class  MVProductDomain< Modular< uint32 > >
struct  ClassifyRing< UnparametricRandIter< NTL::GF2E > >
class  UnparametricRandIter< NTL::GF2E >
 template<> More...

class  NTL_GF2E
struct  ClassifyRing< NTL_zz_p >
struct  NTL_zz_p
struct  ClassifyRing< UnparametricRandIter< NTL::zz_pE > >
class  UnparametricRandIter< NTL::zz_pE >
struct  ClassifyRing< NTL_PID_zz_p >
struct  NTL_PID_zz_p
 extend Wrapper of zz_p from NTL. Add PID functions More...

struct  ClassifyRing< UnparametricField< NTL::RR > >
struct  ClassifyRing< NTL_ZZ >
class  FieldAXPY< NTL_ZZ >
struct  ClassifyRing< UnparametricField< NTL::ZZ_p > >
struct  NTL_ZZ_p
struct  ClassifyRing< UnparametricRandIter< NTL::ZZ_pE > >
class  UnparametricRandIter< NTL::ZZ_pE >
class  NTL_ZZ_pE
class  ParamFuzzy
struct  ClassifyRing< PID_integer >
struct  ClassifyRIng< PIRModular< int > >
class  PIRModular< int >
 template <> More...

class  FieldAXPY< PIRModular< int > >
class  DotProductDomain< PIRModular< int > >
class  MVProductDomain< PIRModular< int32 > >
struct  ClassifyRIng< PIRModular< int32 > >
class  PIRModular< int32 >
 template <> More...

class  FieldAXPY< PIRModular< int32 > >
class  DotProductDomain< PIRModular< int32 > >
struct  ClassifyRIng< PIR_ntl_ZZ_p >
class  PIR_ntl_ZZ_p
 extend Wrapper of ZZ_p from NTL. Add PIR functions More...

class  FieldAXPY< PIR_ntl_ZZ_p >
class  DotProductDomain< PIR_ntl_ZZ_p >
class  MVProductDomain< PIR_ntl_ZZ_p >
struct  Rebind
 used in support of Hom, MatrixHom More...

struct  ClassifyRing< UnparametricField< K > >
class  UnparametricField
class  FieldAXPY< UnparametricField< integer > >
class  BlackboxSymmetrizeIterator
class  MatrixArchetype
struct  MatrixTraits< MatrixArchetype< Element > >
class  MatrixContainerTrait< BlasMatrix< typename Field::Element > >
class  MatrixContainerTrait< const BlasMatrix< typename Field::Element > >
class  BlasMatrix
 Limited docs so far. More...

class  BlasTag
class  TriangularBlasMatrix
struct  MatrixTraits< BlasMatrix< Element > >
struct  MatrixTraits< const BlasMatrix< Element > >
class  indexDomain
class  BlasPermutation
class  TransposedBlasMatrix
class  TransposedBlasMatrix< TransposedBlasMatrix< Matrix > >
class  DenseRowsMatrix
struct  MatrixTraits< DenseRowsMatrix< Row > >
class  DenseSubmatrix
struct  DenseSubmatrix::rebind
struct  MatrixTraits< DenseSubmatrix< Element > >
class  DenseMatrixBase
struct  DenseMatrixBase::rebind
struct  MatrixTraits< DenseMatrixBase< Element > >
struct  MatrixTraits< const DenseMatrixBase< Element > >
class  FactorizedMatrixLeftSolve
class  FactorizedMatrixRightSolve
class  FactorizedMatrixLeftLSolve
class  FactorizedMatrixRightLSolve
class  FactorizedMatrixLeftUSolve
class  FactorizedMatrixRightUSolve
class  LQUPMatrix
struct  MatrixContainerCategory
struct  MatrixContainerCategory::BlasContainer
struct  MatrixContainerCategory::Container
struct  MatrixContainerCategory::Blackbox
class  MatrixContainerTrait
class  MatrixContainerTrait< DenseMatrixBase< typename Field::Element > >
class  MatrixContainerTrait< SparseMatrixBase< typename Field::Element > >
class  MatrixContainerTrait< DenseMatrix< Field > >
class  MatrixContainerTrait< SparseMatrix< Field > >
struct  MatrixCategories
 For specializing matrix arithmetic. More...

struct  MatrixCategories::BlackboxTag
struct  MatrixCategories::RowMatrixTag
struct  MatrixCategories::ColMatrixTag
struct  MatrixCategories::RowColMatrixTag
struct  MatrixTraits
class  MVProductDomain
 Helper class to allow specializations of certain matrix-vector products. More...

class  MatrixDomain
 Class of matrix arithmetic functions. More...

class  InvalidMatrixInput
class  FieldIO
 Dummy field for conceptually unclear io. More...

class  SparseMatrixWriteHelper
class  SparseMatrixWriteHelper::NoField
class  SparseMatrixReadWriteHelper
class  SparseMatrixWriteHelper< _Element, Row, VectorCategories::SparseParallelVectorTag >
class  SparseMatrixWriteHelper< _Element, Row, VectorCategories::SparseParallelVectorTag >::NoField
class  SparseMatrixBase
struct  SparseMatrixBase::rebind
class  SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >
struct  SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >::rebind
class  SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >::_RawIterator
class  SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >::_RawIndexedIterator
class  SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >
struct  SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >::rebind
class  SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >::_RawIterator
class  SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >::_RawIndexedIterator
class  SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >
struct  SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >::rebind
class  SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >::_RawIterator
class  SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >::_RawIndexedIterator
struct  MatrixTraits< SparseMatrixBase< Element, Row, Trait > >
struct  MatrixTraits< const SparseMatrixBase< Element, Row, Trait > >
class  TransposeMatrix
class  TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag >
class  TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag >
class  TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag >
struct  MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > >
struct  MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > >
struct  MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > >
struct  MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > >
struct  MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > >
struct  MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > >
class  RandIterAbstract
class  RandIterArchetype
class  RandIterEnvelope
class  GenericRandIter
class  GF2RandIter
class  GmpRandomPrime
 generating random prime integers, using the gmp library. More...

class  GMPRationalRandIter
class  LidiaGfqRandIter
class  MersenneTwister
class  ModularRandIter
class  ModularBase::RandIter
class  NonzeroRandIter
class  NTL_ZZRandIter
class  ParamFuzzyRandIter
class  RandomPrime
class  UnparametricRandIter
class  RingAbstract
 Abstract ring base class. More...

class  RingArchetype
 specification and archetypic instance for the ring interface More...

class  RingEnvelope
 implement the ring archetype to minimize code bloat. More...

class  GivPolynomialRing
 polynomials with coefficients modulo some power of two More...

class  PowerOfTwoModular
 Ring of elements modulo some power of two. More...

struct  PowerOfTwoModular::RandIter
class  RingInterface
 This ring base class exists solely to aid documentation organization. More...

struct  IntegerModularDet
struct  Specifier
struct  HybridSpecifier
struct  BlackboxSpecifier
struct  EliminationSpecifier
struct  WiedemannTraits
struct  LanczosTraits
struct  BlockLanczosTraits
struct  SparseEliminationTraits
struct  DixonTraits
struct  BlockWiedemannTraits
struct  NumericalTraits
struct  BlasEliminationTraits
struct  NonBlasEliminationTraits
struct  Method
 Method specifiers for controlling algorithm choice. More...

struct  SolverTraits
class  SolveFailed
class  InconsistentSystem
struct  IntegerModularMinpoly
class  SolverConcept
 showing functions expected of solver objects More...

class  Valence
class  Wiedemann
 solutions all based on Wiedemann's algorithm. More...

class  BooleanSwitch
class  BooleanSwitchFactory
class  CekstvSwitch
class  CekstvSwitchFactory
struct  LessThanString
class  ActivityState
 used by commentator More...

class  Commentator
 give information to user during runtime More...

struct  Commentator::StepsAndTime
struct  Commentator::Activity
class  MessageClass
class  PreconditionFailed
class  LinboxError
class  LinboxMathError
class  LinboxMathDivZero
class  LinboxBadFormat
class  FieldAXPY
class  DenseReader
class  MapleDense1Reader
class  MapleSparse1Reader
class  MatrixMarketReader
class  SMSReader
class  SparseRowReader
class  MatrixStreamReader
class  MatrixStream
class  PrimeStream
class  BaseTimer
 base for class RealTimer; class SysTimer; class UserTimer; More...

class  RealTimer
class  UserTimer
class  SysTimer
class  Timer
class  BitVector
struct  VectorTraits< BitVector >
class  ReverseVector
struct  VectorTraits< ReverseVector< Vector > >
class  Sparse_Vector
 vector< Pair<T> > and actualsize More...

class  VectorStream
 Vector factory. More...

class  ConstantVectorStream
class  RandomDenseStream
class  RandomDenseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag >
class  RandomSparseStream
class  RandomSparseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag >
class  RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseSequenceVectorTag >
class  RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseAssociativeVectorTag >
class  RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseParallelVectorTag >
class  StandardBasisStream
class  StandardBasisStream< Field, _Vector, VectorCategories::DenseVectorTag >
class  StandardBasisStream< Field, _Vector, VectorCategories::SparseSequenceVectorTag >
class  StandardBasisStream< Field, _Vector, VectorCategories::SparseAssociativeVectorTag >
class  StandardBasisStream< Field, _Vector, VectorCategories::SparseParallelVectorTag >
class  Subiterator
 Subvector iterator class provides striding iterators. More...

class  Subvector
 Dense subvector. More...

struct  VectorTraits< Subvector< Iterator, ConstIterator > >
class  VectorDomainBase
class  DotProductDomain
class  VectorDomain
struct  VectorCategories
 List of vector categories. More...

struct  VectorCategories::GenericVectorTag
struct  VectorCategories::DenseZeroOneVectorTag
struct  VectorCategories::SparseZeroOneVectorTag
struct  VectorCategories::DenseVectorTag
struct  VectorCategories::SparseSequenceVectorTag
struct  VectorCategories::SparseAssociativeVectorTag
struct  VectorCategories::SparseParallelVectorTag
struct  SparseSequenceVectorPairLessThan
struct  VectorTraits
struct  VectorTraits< std::vector< Element > >
struct  VectorTraits< std::vector< std::pair< size_t, Element > > >
struct  VectorTraits< std::list< std::pair< size_t, Element > > >
struct  VectorTraits< std::deque< std::pair< size_t, Element > > >
struct  VectorTraits< std::map< size_t, Element > >
struct  VectorTraits< std::pair< std::vector< size_t >, std::vector< Element > > >
class  RawVector
struct  Vector
struct  Vector::rebind
struct  Rebind< std::vector< T >, U >
struct  Rebind< std::pair< std::vector< size_t >, std::vector< T > >, U >
struct  Rebind< std::vector< std::pair< size_t, T > >, U >
struct  Rebind< std::map< size_t, T >, U >

int32

This is a representation of 32 bit ints, usually equivalent to `int'. The use of `int32' ensures you are working with 32 bit signed ints, [-2^31..2^31). Similarly, int8, int16, and int64 are defined.

typedef signed __LINBOX_INT32 int32
typedef signed __LINBOX_INT64 int64
typedef unsigned __LINBOX_INT8 uint8
typedef unsigned __LINBOX_INT16 uint16

uint32

This is a representation of 32 bit unsigned ints, usually equivalent to `unsigned int'. The use of `uint32' ensures you are working with 32 bit unsigned ints, [0..2^32). Similarly, uint8, uint16, and uint64 are defined.

typedef unsigned __LINBOX_INT32 uint32
typedef unsigned __LINBOX_INT64 uint64
template<class T> T abs (const T &a)

Butterfly

Butterfly preconditioner and supporting function

std::vector< bool > setButterfly (const std::vector< bool > &x, size_t j=0)

[NOHEADER]

template<class Field>  Diagonal< Field, VectorCategories::DenseVectorTag >::Diagonal (const Field F, const std::vector< typename Field::Element > &v)
template<class _Field>  Diagonal< _Field, VectorCategories::DenseVectorTag >::Diagonal (const Field F, const size_t n)
template<class Field>  Diagonal< Field, VectorCategories::DenseVectorTag >::Diagonal (const Field F, const size_t n, typename Field::RandIter &iter)
template<class OutVector, class InVector> OutVector & Diagonal< Field, VectorCategories::DenseVectorTag >::apply (OutVector &y, const InVector &x) const
template<class Field>  Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::Diagonal (const Field F, const std::vector< typename Field::Element > &v)
template<class OutVector, class InVector> OutVector & Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::apply (OutVector &y, const InVector &x) const
template<class Field>  Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::Diagonal (const Field F, const std::vector< typename Field::Element > &v)
template<class OutVector, class InVector> OutVector & Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::apply (OutVector &y, const InVector &x) const

NTL_zz_p

long ints modulo a positive integer.

While NTL allows any int to serve as the modulus, only prime moduli yield fields. The primality of the modulus will not be checked, so it is the programmer's responsibility to supply a prime modulus if a field is wanted. These specializations allow the {UnparametricField} template class to be used to wrap NTL's { zz} class as a LinBox field. Uses nice trick for mod p via floating point.

template<>  UnparametricField< NTL::zz_p >::UnparametricField (integer q, size_t e)
template<> NTL::zz_p & UnparametricField< NTL::zz_p >::init (NTL::zz_p &x, const integer &y) const
template<> integerUnparametricField< NTL::zz_p >::convert (integer &x, const NTL::zz_p &y) const
template<> integerUnparametricField< NTL::zz_p >::cardinality (integer &c) const
template<> integerUnparametricField< NTL::zz_p >::characteristic (integer &c) const
template<> NTL::zz_p & UnparametricField< NTL::zz_p >::inv (NTL::zz_p &x, const NTL::zz_p &y) const
template<> bool UnparametricField< NTL::zz_p >::isZero (const NTL::zz_p &x) const
template<> bool UnparametricField< NTL::zz_p >::isOne (const NTL::zz_p &x) const
template<> NTL::zz_p & UnparametricField< NTL::zz_p >::invin (NTL::zz_p &x) const
template<> std::ostream & UnparametricField< NTL::zz_p >::write (std::ostream &os) const
template<>  UnparametricRandIter< NTL::zz_p >::UnparametricRandIter (const UnparametricField< NTL::zz_p > &F, const integer &size, const integer &seed)
 Constructor for random field element generator.

template<> NTL::zz_p & UnparametricRandIter< NTL::zz_p >::random (NTL::zz_p &x) const
 Random field element creator.


class RR.

Rational number field. This field is provided as a convenience in a few places. Use with caution because expression swell.

This specialization allows the {UnparametricField} template class to be used to wrap NTL's RR class as a LinBox field.

template<> NTL::RR & UnparametricField< NTL::RR >::init (NTL::RR &x, const integer &y) const
template<> integerUnparametricField< NTL::RR >::convert (integer &x, const NTL::RR &y) const
template<> NTL::RR & UnparametricField< NTL::RR >::inv (NTL::RR &x, const NTL::RR &y) const
template<> bool UnparametricField< NTL::RR >::isZero (const NTL::RR &x) const
template<> bool UnparametricField< NTL::RR >::isOne (const NTL::RR &x) const
template<> NTL::RR & UnparametricField< NTL::RR >::invin (NTL::RR &x) const
template<> std::ostream & UnparametricField< NTL::RR >::write (std::ostream &os) const
template<> NTL::RR & UnparametricRandIter< NTL::RR >::random (NTL::RR &elt) const

NTL_ZZ_p

Arbitrary precision integers modulus a positive integer.

While NTL allows any integer to serve as the modulus, only prime moduli yield fields. Therefore, while arthmetic operations may be valid for any modulus, only prime moduli are supported in this implementation. The primality of the modulus will not be checked, so it is the programmer's responsibility to supply a prime modulus. These specializations allow the {UnparametricField} template class to be used to wrap NTL's { ZZ} class as a LinBox field.

template<>  UnparametricField< NTL::ZZ_p >::UnparametricField (integer q, size_t e)
template<> integerUnparametricField< NTL::ZZ_p >::convert (integer &x, const NTL::ZZ_p &y) const
template<> double & UnparametricField< NTL::ZZ_p >::convert (double &x, const NTL::ZZ_p &y) const
template<> integerUnparametricField< NTL::ZZ_p >::cardinality (integer &c) const
template<> integerUnparametricField< NTL::ZZ_p >::characteristic (integer &c) const
template<> NTL::ZZ_p & UnparametricField< NTL::ZZ_p >::inv (NTL::ZZ_p &x, const NTL::ZZ_p &y) const
template<> bool UnparametricField< NTL::ZZ_p >::isZero (const NTL::ZZ_p &x) const
template<> bool UnparametricField< NTL::ZZ_p >::isOne (const NTL::ZZ_p &x) const
template<> NTL::ZZ_p & UnparametricField< NTL::ZZ_p >::invin (NTL::ZZ_p &x) const
template<> std::ostream & UnparametricField< NTL::ZZ_p >::write (std::ostream &os) const
template<>  UnparametricRandIter< NTL::ZZ_p >::UnparametricRandIter (const UnparametricField< NTL::ZZ_p > &F, const integer &size, const integer &seed)
 Constructor for random field element generator.

template<> NTL::ZZ_p & UnparametricRandIter< NTL::ZZ_p >::random (NTL::ZZ_p &x) const
 Random field element creator.


Typedefs

typedef std::vector< BBBase * > BB_list
typedef std::map< const std::type_info *,
BB_list, LessTypeInfo
BB_list_list
typedef UnparametricField<
integer
GMP_Integers
typedef NTL_ZZRandIter RandIter
 the integer ring. class NTL_ZZ {

typedef NTL::ZZ Element
typedef ParamFuzzy DoubleRealApproximation
typedef Integer integer
 This is a representation of arbitrary integers.

typedef signed __LINBOX_INT8 int8
typedef signed __LINBOX_INT16 int16

Enumerations

enum  SolverReturnStatus {
  SS_OK, SS_FAILED, SS_SINGULAR, SS_INCONSISTENT,
  SS_BAD_PRECONDITIONER
}
 define the different return status of the p-adic based solver's computation. More...

enum  SolverLevel { SL_MONTECARLO, SL_LASVEGAS, SL_CERTIFIED }
 define the different strategy which can be used in the p-adic based solver. More...

enum  FileFormatTag {
  FORMAT_DETECT, FORMAT_GUILLAUME, FORMAT_TURNER, FORMAT_MATLAB,
  FORMAT_MAPLE, FORMAT_PRETTY, FORMAT_MAGMACPT
}
 tags for SparseMatrixBase::read() and write() More...

enum  MatrixStreamError {
  AMBIGUOUS_FORMAT = -1, GOOD, END_OF_MATRIX, END_OF_FILE,
  BAD_FORMAT, NO_FORMAT
}

Functions

template<class Blackbox, class Polynomial, class Categorytag> Polynomialblackboxcharpoly (Polynomial &P, const Blackbox &A, const Categorytag &tag)
template<class Blackbox> GivPolynomial< typename Blackbox::Field::Element > & blackboxcharpoly (GivPolynomial< typename Blackbox::Field::Element > &P, const Blackbox &A, const RingCategories::IntegerTag &tag)
template<class Blackbox> GivPolynomial< typename Blackbox::Field::Element > & blackboxcharpoly (GivPolynomial< typename Blackbox::Field::Element > &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
template<class Polynomial> int updateFactorsMult (FieldFactorMult< Polynomial > *ffm, const size_t n, int *goal)
template<class FieldPoly, class IntPoly> void trials (list< vector< FactorMult< FieldPoly, IntPoly > > > &sols, const int goal, vector< FactorMult< FieldPoly, IntPoly > > &ufv, const int i0)
template<class Polynomial> void trials (list< vector< FieldFactorMult< Polynomial > > > &sols, const int goal, vector< FieldFactorMult< Polynomial > > &ufv, const int i0)
template<class Iterator, class Comparator> void bitonicSort (Iterator begin, Iterator end, const Comparator &comparator=Comparator())
template<class Iterator, class Comparator> void bitonicMerge (Iterator begin, Iterator end, const Comparator &comparator=Comparator())
template<class Polynomial, class Blackbox> Polynomialcia (Polynomial &P, const Blackbox &A, const Method::BlasElimination &M)
template<class Vector> long density (const Vector &v)
 Estimate nonzero entries in a vector, used in parallel elimination.

template<class Vector, class VectorCategory> long density (const Vector &, VectorCategory)
template<class Vector> long density (const Vector &v, VectorCategories::DenseVectorTag)
template<class Vector> long density (const Vector &v, VectorCategories::SparseSequenceVectorTag)
template<class Vector> long density (const Vector &v, VectorCategories::SparseAssociativeVectorTag)
template<class Vector> long density (const Vector &v, VectorCategories::SparseParallelVectorTag)
template<class Ring, class ItMatrix> void SpecialBound (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const ItMatrix &A)
template<class Ring> void BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const DenseMatrixBase< typename Ring::Element > &A)
template<class Ring> void BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const DenseSubmatrix< typename Ring::Element > &A)
template<class Ring> void BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const SparseMatrix< Ring > &A)
template<class Ring, class Matrix1, class Matrix2> void BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const Compose< Matrix1, Matrix2 > &A)
template<class Ring, class Matrix> void BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const Transpose< Matrix > &A)
template<class Ring, class ItMatrix> void ApplyBound (const Ring &R, typename Ring::Element &bound_A, const ItMatrix &A)
int rational_reconstruction (integer &a, integer &b, const integer &n0, const integer &d0, const integer &B)
template<class Domain> void reduceIn (Domain &D, std::pair< typename Domain::Element, typename Domain::Element > &frac)
template<class Domain, class Vector> void vectorGcdIn (typename Domain::Element &result, Domain &D, Vector &v)
template<class Domain, class Vector> Domain::Element vectorGcd (Domain &D, Vector &v)
template<class OutV, class Matrix, class InV> OutV & apply (OutV &y, const Matrix &A, const InV &x)
template<class OutV, class Matrix, class InV> OutV & applyTranspose (OutV &y, const Matrix &A, const InV &x)
template<class Domain, class IMatrix> void create_padic_chunk (const Domain &D, const IMatrix &M, double *chunks, size_t num_chunks)
 split an integer matrix into a padic chunk representation

void * runThread (void *arg)
template<class Matrix, class Out, class In> BBThread< Matrix, Out, In > * createBBThread (const Matrix *m, Out *out, const In *in)
template<class Field> bool checkBlasApply (const Field &F, size_t n)
template<class Field>  Hilbert< Field, VectorCategories::DenseVectorTag >::Hilbert (Field F, size_t n)
template<class OutVector, class InVector> OutVector & Hilbert< Field, VectorCategories::DenseVectorTag >::apply (OutVector &y, const InVector &x) const
template<class Field>  Hilbert< Field, VectorCategories::SparseSequenceVectorTag >::Hilbert (Field F, size_t n)
template<class OutVector, class InVector> OutVector & Hilbert< Field, VectorCategories::SparseSequenceVectorTag >::apply (OutVector &y, const InVector &x) const
template<class Field>  Hilbert< Field, VectorCategories::SparseAssociativeVectorTag >::Hilbert (Field F, size_t n)
template<class OutVector, class InVector> OutVector & Hilbert< Field, VectorCategories::SparseAssociativeVectorTag >::apply (OutVector &y, const InVector &x) const
std::ostream & operator<< (std::ostream &os, GMPRationalElement &elt)
std::istream & operator>> (std::istream &is, GMPRationalElement &elt)
template<> NTL::GF2E & UnparametricField< NTL::GF2E >::init (NTL::GF2E &x, const integer &y) const
template<> integerUnparametricField< NTL::GF2E >::convert (integer &x, const NTL::GF2E &y) const
template<> bool UnparametricField< NTL::GF2E >::isZero (const NTL::GF2E &a) const
template<> bool UnparametricField< NTL::GF2E >::isOne (const NTL::GF2E &a) const
template<> integerUnparametricField< NTL::GF2E >::characteristic (integer &c) const
template<> integerUnparametricField< NTL::GF2E >::cardinality (integer &c) const
template<> NTL::GF2E & UnparametricField< NTL::GF2E >::inv (NTL::GF2E &x, const NTL::GF2E &y) const
template<> NTL::GF2E & UnparametricField< NTL::GF2E >::invin (NTL::GF2E &x) const
template<> std::istream & UnparametricField< NTL::GF2E >::read (std::istream &is, NTL::GF2E &x) const
template<> NTL::zz_pE & UnparametricField< NTL::zz_pE >::init (NTL::zz_pE &x, const integer &y) const
template<> integerUnparametricField< NTL::zz_pE >::convert (integer &x, const NTL::zz_pE &y) const
template<> bool UnparametricField< NTL::zz_pE >::isZero (const NTL::zz_pE &a) const
template<> bool UnparametricField< NTL::zz_pE >::isOne (const NTL::zz_pE &a) const
template<> integerUnparametricField< NTL::zz_pE >::characteristic (integer &c) const
template<> integerUnparametricField< NTL::zz_pE >::cardinality (integer &c) const
template<> NTL::zz_pE & UnparametricField< NTL::zz_pE >::inv (NTL::zz_pE &x, const NTL::zz_pE &y) const
template<> NTL::zz_pE & UnparametricField< NTL::zz_pE >::invin (NTL::zz_pE &x) const
template<> std::istream & UnparametricField< NTL::zz_pE >::read (std::istream &is, NTL::zz_pE &x) const
 NTL_ZZ (int p=0, int exp=1)
integercardinality (integer &c) const
integercharacteristic (integer &c) const
std::ostream & write (std::ostream &out) const
std::istream & read (std::istream &in) const
template<class Element2> Elementinit (Element &x, const Element2 &y) const
 Init x from y.

Elementinit (Element &x, const Element &y) const
 Init from a NTL::ZZ.

Elementinit (Element &x, const int64 &y) const
 Init from an int64.

Elementinit (Element &x, const uint64 &y) const
 Init from a uint64.

Elementinit (Element &x, const integer &y) const
 I don't know how to init from integer efficiently.

integerconvert (integer &x, const Element &y)
 Convert y to an Element.

double & convert (double &x, const Element &y)
Elementassign (Element &x, const Element &y) const
 x = y.

bool areEqual (const Element &x, const Element &y) const
 Test if x == y.

bool isZero (const Element &x) const
 Test if x == 0.

bool isOne (const Element &x) const
 Test if x == 1.

Elementadd (Element &x, const Element &y, const Element &z) const
 return x = y + z

Elementsub (Element &x, const Element &y, const Element &z) const
 return x = y - z

template<class Int> Elementmul (Element &x, const Element &y, const Int &z) const
 return x = y * z

Elementdiv (Element &x, const Element &y, const Element &z) const
 If z divides y, return x = y / z, otherwise, throw an exception.

Elementinv (Element &x, const Element &y) const
 If y is a unit, return x = 1 / y, otherwsie, throw an exception.

Elementneg (Element &x, const Element &y) const
 return x = -y;

template<class Int> Elementaxpy (Element &r, const Element &a, const Int &x, const Element &y) const
 return r = a x + y

Elementaddin (Element &x, const Element &y) const
 return x += y;

Elementsubin (Element &x, const Element &y) const
 return x -= y;

template<class Int> Elementmulin (Element &x, const Int &y) const
 return x *= y;

Elementdivin (Element &x, const Element &y) const
 If y divides x, return x /= y, otherwise throw an exception.

Elementinvin (Element &x)
 If x is a unit, x = 1 / x, otherwise, throw an exception.

Elementnegin (Element &x) const
 return x = -x;

template<class Int> Elementaxpyin (Element &r, const Element &a, const Int &x) const
 return r += a x

std::ostream & write (std::ostream &out, const Element &y) const
 out << y;

std::istream & read (std::istream &in, Element &x) const
 read x from istream in

bool isUnit (const Element &x) const
 Test if x is a unit.

Elementgcd (Element &g, const Element &a, const Element &b) const
 return g = gcd (a, b)

Elementgcdin (Element &g, const Element &b) const
 return g = gcd (g, b)

Elementxgcd (Element &g, Element &s, Element &t, const Element &a, const Element &b) const
 g = gcd(a, b) = a*s + b*t. The coefficients s and t are defined according to the standard Euclidean algorithm applied to |a| and |b|, with the signs then adjusted according to the signs of a and b.

Elementlcm (Element &c, const Element &a, const Element &b) const
 c = lcm (a, b)

Elementlcmin (Element &l, const Element &b) const
 l = lcm (l, b)

Elementsqrt (Element &x, const Element &y) const
 x = floor ( sqrt(y)).

long reconstructRational (Element &a, Element &b, const Element &x, const Element &m, const Element &a_bound, const Element &b_bound) const
 Requires 0 <= x < m, m > 2 * a_bound * b_bound, a_bound >= 0, b_bound > 0 This routine either returns 0, leaving a and b unchanged, or returns 1 and sets a and b so that (1) a = b x (mod m), (2) |a| <= a_bound, 0 < b <= b_bound, and (3) gcd(m, b) = gcd(a, b).

Elementquo (Element &q, const Element &a, const Element &b) const
 q = floor (x/y);

Elementrem (Element &r, const Element &a, const Element &b) const
 r = remindar of a / b

Elementquoin (Element &a, const Element &b) const
 a = quotient (a, b)

Elementremin (Element &x, const Element &y) const
 a = quotient (a, b)

void quoRem (Element &q, Element &r, const Element &a, const Element &b) const
 q = [a/b], r = a - b*q |r| < |b|, and if r != 0, sign(r) = sign(b)

bool isDivisor (const Element &a, const Element &b) const
 Test if b | a.

long compare (const Element &a, const Element &b) const
Elementabs (Element &x, const Element &a) const
int getMaxModulus ()
template<> NTL::ZZ_p & UnparametricField< NTL::ZZ_p >::init (NTL::ZZ_p &x, const integer &y) const
 Initialization of field element from an integer. Behaves like C++ allocator construct. This function assumes the output field element x has already been constructed, but that it is not already initialized. This done by converting to a std::string : inefficient but correct.

template<> NTL::ZZ_pE & UnparametricField< NTL::ZZ_pE >::init (NTL::ZZ_pE &x, const integer &y) const
template<> bool UnparametricField< NTL::ZZ_pE >::isZero (const NTL::ZZ_pE &a) const
template<> bool UnparametricField< NTL::ZZ_pE >::isOne (const NTL::ZZ_pE &a) const
template<> integerUnparametricField< NTL::ZZ_pE >::convert (integer &c, const NTL::ZZ_pE &e) const
template<> integerUnparametricField< NTL::ZZ_pE >::characteristic (integer &c) const
template<> integerUnparametricField< NTL::ZZ_pE >::cardinality (integer &c) const
template<> NTL::ZZ_pE & UnparametricField< NTL::ZZ_pE >::inv (NTL::ZZ_pE &x, const NTL::ZZ_pE &y) const
template<> NTL::ZZ_pE & UnparametricField< NTL::ZZ_pE >::invin (NTL::ZZ_pE &x) const
template<> std::istream & UnparametricField< NTL::ZZ_pE >::read (std::istream &is, NTL::ZZ_pE &x) const
template<class Element, class Row> std::ostream & operator<< (std::ostream &os, const SparseMatrixBase< Element, Row > &A)
template<class Element, class Row> std::istream & operator>> (std::istream &is, SparseMatrixBase< Element, Row > &A)
uint32 hiBit (uint32 u)
uint32 loBit (uint32 u)
uint32 loBits (uint32 u)
uint32 mixBits (uint32 u, uint32 v)
template<class Blackbox, class Polynomial, class MyMethod, class DomainCategory> Polynomialcharpoly (Polynomial &P, const Blackbox &A, const DomainCategory &tag, const MyMethod &M)
template<class Blackbox, class Polynomial, class MyMethod> Polynomialcharpoly (Polynomial &P, const Blackbox &A, const MyMethod &M)
 ...using an optional Method parameter

template<class Blackbox, class Polynomial> Polynomialcharpoly (Polynomial &P, const Blackbox &A)
 ...using default method

template<class Polynomial, class Blackbox, class DomainCategory> Polynomialcharpoly (Polynomial &P, const Blackbox &A, const DomainCategory &tag, const Method::Hybrid &M)
template<class Polynomial, class Field, class DomainCategory> Polynomialcharpoly (Polynomial &P, const DenseMatrix< Field > &A, const DomainCategory &tag, const Method::Hybrid &M)
template<class Polynomial, class Blackbox, class DomainCategory> Polynomialcharpoly (Polynomial &P, const Blackbox &A, const DomainCategory &tag, const Method::Elimination &M)
template<class Polynomial, class Blackbox> Polynomialcharpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
 Compute the characteristic polynomial over { Z_p}.

template<class Polynomial, class Blackbox> Polynomialcharpoly (Polynomial &P, const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::BlasElimination &M)
 Compute the characteristic polynomial over { Z}.

template<class Polynomial, class Blackbox, class Categorytag> Polynomialcharpoly (Polynomial &P, const Blackbox &A, const Categorytag &tag, const Method::Blackbox &M)
template<class Blackbox, class DetMethod, class DomainCategory> Blackbox::Field::Elementdet (typename Blackbox::Field::Element &d, const Blackbox &A, const DomainCategory &tag, const DetMethod &M)
template<class Blackbox, class MyMethod> Blackbox::Field::Elementdet (typename Blackbox::Field::Element &d, const Blackbox &A, const MyMethod &M)
 Compute the determinant of A.

template<class Blackbox> Blackbox::Field::Elementdet (typename Blackbox::Field::Element &d, const Blackbox &A)
template<class Blackbox> Blackbox::Field::Elementdet (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Field> Field::Elementdet (typename Field::Element &d, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Blackbox> Blackbox::Field::Elementdet (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &M)
template<class Blackbox> Blackbox::Field::Elementdet (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
template<class Blackbox> Blackbox::Field::Elementdet (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Wiedemann &M)
template<class Blackbox> Blackbox::Field::Elementdet (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
template<class Field> Field::Elementdetin (typename Field::Element &d, BlasBlackbox< Field > &A)
 A will be modified.

template<class Blackbox, class MyMethod> Blackbox::Field::Elementdet (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class BB> BB::Field::ElementgetEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j)
 Getting the i,j entry of the blackbox.

template<class BB> BB::Field::ElementgetEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j, const Method::Hybrid &m)
 our best guess

template<class Field> Field::ElementgetEntry (typename Field::Element &x, const DenseMatrix< Field > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class Field> Field::ElementgetEntry (typename Field::Element &x, const SparseMatrix< Field > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class Field> Field::ElementgetEntry (typename Field::Element &x, const ScalarMatrix< Field > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class Field, class Trait> Field::ElementgetEntry (typename Field::Element &x, const Diagonal< Field, Trait > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class BB> BB::Field::ElementgetEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j, const Method::Elimination &m)
 our elimination (a fake in this case)

template<class Blackbox> Blackbox::Field::ElementgetEntry (typename Blackbox::Field::Element &res, const Blackbox &A, const size_t i, const size_t j, const Method::Blackbox &m)
template<class Field, class Trait, class BlackBox> Field::ElementgetEntry (typename Field::Element &t, const Compose< Diagonal< Field, Trait >, BlackBox > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class BlackBox, class Field, class Trait> Field::ElementgetEntry (typename Field::Element &t, const Compose< BlackBox, Diagonal< Field, Trait > > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class Field, class T1, class T2> Field::ElementgetEntry (typename Field::Element &t, const Compose< Diagonal< Field, T1 >, Diagonal< Field, T2 > > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class Blackbox, class isPositiveDefiniteMethod, class DomainCategory> bool isPositiveDefinite (const Blackbox &A, const DomainCategory &tag, const isPositiveDefiniteMethod &M)
template<class Blackbox, class MyMethod> bool isPositiveDefinite (const Blackbox &A, const MyMethod &M)
template<class Blackbox> bool isPositiveDefinite (const Blackbox &A)
template<class Blackbox, class MyMethod> bool isPositiveDefinite (const Blackbox &A, const RingCategories::ModularTag &tag, const MyMethod &M)
template<class Blackbox> bool isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Hybrid &M)
template<class Blackbox> bool isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Elimination &M)
template<class Blackbox> bool isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Blackbox &M)
template<class Blackbox> bool isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Wiedemann &M)
template<class Blackbox> bool isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::BlasElimination &M)
template<class Ring> bool isPositiveDefinite (const DenseMatrix< Ring > &A, const RingCategories::IntegerTag &tag, const Method::BlasElimination &M)
template<class Blackbox, class isPositiveSemiDefiniteMethod, class DomainCategory> bool isPositiveSemiDefinite (const Blackbox &A, const DomainCategory &tag, const isPositiveSemiDefiniteMethod &M)
template<class Blackbox, class MyMethod> bool isPositiveSemiDefinite (const Blackbox &A, const MyMethod &M)
template<class Blackbox> bool isPositiveSemiDefinite (const Blackbox &A)
template<class Blackbox, class MyMethod> bool isPositiveSemiDefinite (const Blackbox &A, const RingCategories::ModularTag &tag, const MyMethod &M)
template<class Blackbox> bool isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Hybrid &M)
template<class Blackbox> bool isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Elimination &M)
template<class Blackbox> bool isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Blackbox &M)
template<class Blackbox> bool isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Wiedemann &M)
template<class Blackbox> bool isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::BlasElimination &M)
template<class Ring> bool isPositiveSemiDefinite (const DenseMatrix< Ring > &A, const RingCategories::IntegerTag &tag, const Method::BlasElimination &M)
template<class Field> void LU (DenseMatrix< Field > &M)
template<class Field> void LU (Submatrix< DenseMatrix< Field > > &M)
template<class Matrix> void LL_MULIN (Matrix &M, const Matrix &L)
template<class Matrix> void RU_MULIN (Matrix &R, const Matrix &U)
template<class Matrix> void AXMYIN (Matrix &, const Matrix &, const Matrix &)
template<class BB> bool useBB (const BB &A)
template<class Field> bool useBB (const DenseMatrix< Field > &A)
template<class Blackbox, class Polynomial, class DomainCategory, class MyMethod> Polynomialminpoly (Polynomial &P, const Blackbox &A, const DomainCategory &tag, const MyMethod &M)
template<class Blackbox, class Polynomial, class MyMethod> Polynomialminpoly (Polynomial &P, const Blackbox &A, const MyMethod &M)
 ...using an optional Method parameter

template<class Polynomial, class Blackbox> Polynomialminpoly (Polynomial &P, const Blackbox &A)
 ...using default Method

template<class Polynomial, class Blackbox> Polynomialminpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Polynomial, class Field> Polynomialminpoly (Polynomial &P, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Polynomial, class Blackbox> Polynomialminpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &M)
template<class Polynomial, class Blackbox> Polynomialminpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
template<class Polynomial, class Blackbox> Polynomialminpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
template<class Polynomial, class Blackbox> Polynomialminpoly (Polynomial &P, const Blackbox &A, RingCategories::ModularTag tag, const Method::Wiedemann &M=Method::Wiedemann())
template<class Polynomial, class Blackbox, class MyMethod> Polynomialminpoly (Polynomial &P, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class Blackbox> unsigned long & rank (unsigned long &r, const Blackbox &A)
template<class Matrix> unsigned long & rankin (unsigned long &r, Matrix &A)
template<class Blackbox> unsigned long & rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Hybrid &m)
template<class Blackbox> unsigned long & rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &m)
template<class Field, class Vector> unsigned long & rank (unsigned long &r, const SparseMatrix< Field, Vector > &A, const RingCategories::ModularTag &tag, const Method::Elimination &m)
template<class Blackbox> unsigned long & rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::NonBlasElimination &m)
template<class Blackbox> unsigned long & rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &m)
template<class Blackbox, class Method> unsigned long & rank (unsigned long &r, const Blackbox &A, const Method &M)
template<class Blackbox> unsigned long & rank (unsigned long &res, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Wiedemann &M)
 M may be Method::Wiedemann().

template<class Field> unsigned long & rank (unsigned long &r, const SparseMatrix< Field, typename LinBox::Vector< Field >::SparseSeq > &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
 M may be Method::SparseElimination().

template<class Field> unsigned long & rankin (unsigned long &r, SparseMatrix< Field, typename LinBox::Vector< Field >::SparseSeq > &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
 M may be Method::SparseElimination().

template<class Blackbox> unsigned long & rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
 Change of representation to be able to call the sparse elimination.

template<class Blackbox> unsigned long & rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
 M may be Method::BlasElimination().

template<class Matrix> unsigned long & rankin (unsigned long &r, Matrix &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
 A is modified.

template<class Field> unsigned long & rankin (unsigned long &r, BlasBlackbox< Field > &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
 A is modified.

template<class Blackbox, class MyMethod> unsigned long & rank (unsigned long &r, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class I1, class Lp> void distinct (I1 a, I1 b, Lp &c)
template<class Output, class Blackbox, class SmithMethod, class DomainCategory> Output & smithForm (Output &S, const Blackbox &A, const DomainCategory &tag, const SmithMethod &M)
template<class Output, class Blackbox, class MyMethod> Output & smithForm (Output &S, const Blackbox &A, const MyMethod &M)
template<class Output, class Blackbox> Output & smithForm (Output &S, const Blackbox &A)
template<> list< pair< integer, size_t > > & smithForm (list< pair< integer, size_t > > &S, const DenseMatrix< NTL_ZZ > &A, const RingCategories::IntegerTag &tag, const Method::Hybrid &M)
template<class Vector, class Blackbox, class SolveMethod, class DomainCategory> Vectorsolve (Vector &x, const Blackbox &A, const Vector &b, const DomainCategory &tag, const SolveMethod &M)
template<class Vector, class Blackbox, class SolveMethod> Vectorsolve (Vector &x, const Blackbox &A, const Vector &b, const SolveMethod &M)
 Solve Ax = b, for x.

template<class Vector, class Blackbox> Vectorsolve (Vector &x, const Blackbox &A, const Vector &b)
template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const Method::Hybrid &m)
template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const Method::Blackbox &m)
template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const Method::Elimination &m)
template<class Vector, class Field> Vectorsolve (Vector &x, const SparseMatrix< Field > &A, const Vector &b, const Method::Elimination &m)
template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlasElimination &m)
template<class Vector, class Field> Vectorsolve (Vector &x, const BlasBlackbox< Field > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlasElimination &m)
template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::BlasElimination &m)
template<class Vector, class Field> Vectorsolve (Vector &x, const BlasBlackbox< Field > &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::BlasElimination &m)
template<class Vector, class Field> Vectorsolve (Vector &x, const DenseMatrix< Field > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlasElimination &m)
template<class Vector, class Ring> Vectorsolve (Vector &x, const BlasBlackbox< Ring > &A, const Vector &b, const RingCategories::IntegerTag tag, const Method::Dixon &m)
 solver specialization with DixonTraits over integer (no copying)

template<class Vector, class Ring> Vectorsolve (Vector &x, const DenseMatrix< Ring > &A, const Vector &b, const RingCategories::IntegerTag tag, const Method::Dixon &m)
 solver specialization with DixonTraits over integer (no copying)

template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::NonBlasElimination &m)
template<class Vector, class Field> Vectorsolve (Vector &x, const DenseMatrix< Field > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::NonBlasElimination &m)
template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlockLanczos &m)
template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::BlockLanczos &m)
template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::Wiedemann &m)
template<class Vector, class BB> Vectorsolve (Vector &x, const BB &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Wiedemann &m)
template<class BB> BB::Field::Elementtrace (typename BB::Field::Element &t, const BB &A)
 sum of eigenvalues

template<class BB> BB::Field::Elementtrace (typename BB::Field::Element &t, const BB &A, const Method::Hybrid &m)
 our best guess

template<class Field> Field::Elementtrace (typename Field::Element &t, const DenseMatrix< Field > &A, const Method::Hybrid &m)
template<class Field, class Row> Field::Elementtrace (typename Field::Element &t, const SparseMatrix< Field, Row > &A, const Method::Hybrid &m)
template<class Field, class Trait> Field::Elementtrace (typename Field::Element &t, const Diagonal< Field, Trait > &A, const Method::Hybrid &m)
template<class Field> Field::Elementtrace (typename Field::Element &t, const ScalarMatrix< Field > &A, const Method::Hybrid &m)
template<class BB> BB::Field::Elementtrace (typename BB::Field::Element &t, const BB &A, const Method::Elimination &m)
 our elimination (a fake in this case)

template<class Blackbox> Blackbox::Field::Elementtrace (typename Blackbox::Field::Element &res, const Blackbox &A, const Method::Blackbox &m)
template<class Field, class Trait, class BlackBox> Field::Elementtrace (typename Field::Element &t, const Compose< Diagonal< Field, Trait >, BlackBox > &A, const Method::Hybrid &m)
template<class BlackBox, class Field, class Trait> Field::Elementtrace (typename Field::Element &t, const Compose< BlackBox, Diagonal< Field, Trait > > &A, const Method::Hybrid &m)
template<class Field, class T1, class T2> Field::Elementtrace (typename Field::Element &t, const Compose< Diagonal< Field, T1 >, Diagonal< Field, T2 > > &A, const Method::Hybrid &m)
double nroot (double a, long r, double precision)
long isnpower (long &l, long a)
std::ostream & operator<< (std::ostream &o, const LinboxError &E)
bool equalCaseInsensitive (const std::string s1, const char *s2)
std::ostream & operator<< (std::ostream &o, const BaseTimer &BT)
std::ostream & operator<< (std::ostream &o, const Timer &T)
template<class Field, class Vector> Vector randomVector (Field &F, size_t n, typename Field::RandIter &r)
template<class Field, class Vector, class VectorTrait> Vector randomVector (Field &F, size_t n, typename Field::RandIter &r, VectorCategories::DenseVectorTag< VectorTrait > tag)
template<class Field, class Vector, class VectorTrait> Vector randomVector (Field &F, size_t n, typename Field::RandIter &r, VectorCategories::SparseSequenceVectorTag< VectorTrait > tag)
template<class Field, class Vector, class VectorTrait> Vector randomVector (Field &F, size_t n, typename Field::RandIter &r, VectorCategories::SparseAssociativeVectorTag< VectorTrait > tag)
template<class Element> Elementnoop (Element &a, const Element &b)
template<class Field> void fieldTest (const Field &f, double *array, long iter=1000000)
int64 getOps (int &a, float &b)
template<class Field> bool LU_MUL_TEST (const DenseMatrix< Field > &M, const DenseMatrix< Field > &L, const DenseMatrix< Field > &U)

Variables

const int DEFAULTLIFTHRESHOLD = 5
const int DEFAULTOIFTHRESHOLD = 30
const double CROSSOVER = 0.6
const char * solverReturnString [] = {"OK", "FAILED", "SINGULAR", "INCONSISTENT", "BAD_PRECONDITIONER", "BAD_PRIME"}
const long _DEGINFTY_ = -1
Out &BlackboxParallel(Out
&out, const Matrix &m, const
In &in, BBBase::BBType type)
Out 
BlackboxParallel )(Out &out, const Matrix &cm, const In &in, BBBase::BBType type)
 This is a matrix representation supporting a parallel matrix vector product.

const double doubleTransform = 2.3283064365386962890625e-10
const int N = 624
const int M = 397
const uint32 K = 0x9908B0DFU
unsigned int degree
const int BlasBound = 1 << 26
Commentator commentator


Typedef Documentation

typedef std::vector<BBBase*> BB_list
 

typedef std::map<const std::type_info*, BB_list, LessTypeInfo> BB_list_list
 

typedef NTL::ZZ Element
 

typedef ParamFuzzy DoubleRealApproximation
 

typedef signed __LINBOX_INT8 int8
 

typedef signed __LINBOX_INT16 int16
 

typedef signed __LINBOX_INT32 int32
 

typedef signed __LINBOX_INT64 int64
 

typedef unsigned __LINBOX_INT8 uint8
 

typedef unsigned __LINBOX_INT16 uint16
 

typedef unsigned __LINBOX_INT32 uint32
 

typedef unsigned __LINBOX_INT64 uint64
 


Enumeration Type Documentation

enum FileFormatTag
 

tags for SparseMatrixBase::read() and write()

Enumeration values:
FORMAT_DETECT 
FORMAT_GUILLAUME 
FORMAT_TURNER 
FORMAT_MATLAB 
FORMAT_MAPLE 
FORMAT_PRETTY 
FORMAT_MAGMACPT 

enum MatrixStreamError
 

Enumeration values:
AMBIGUOUS_FORMAT 
GOOD 
END_OF_MATRIX 
END_OF_FILE 
BAD_FORMAT 
NO_FORMAT 


Function Documentation

Polynomial& blackboxcharpoly Polynomial P,
const Blackbox &  A,
const Categorytag &  tag
 

GivPolynomial<typename Blackbox::Field::Element>& blackboxcharpoly GivPolynomial< typename Blackbox::Field::Element > &  P,
const Blackbox &  A,
const RingCategories::IntegerTag &  tag
 

GivPolynomial<typename Blackbox::Field::Element>& blackboxcharpoly GivPolynomial< typename Blackbox::Field::Element > &  P,
const Blackbox &  A,
const RingCategories::ModularTag &  tag,
const Method::Blackbox &  M
 

int updateFactorsMult FieldFactorMult< Polynomial > *  ffm,
const size_t  n,
int *  goal
 

void trials list< vector< FactorMult< FieldPoly, IntPoly > > > &  sols,
const int  goal,
vector< FactorMult< FieldPoly, IntPoly > > &  ufv,
const int  i0
 

void trials list< vector< FieldFactorMult< Polynomial > > > &  sols,
const int  goal,
vector< FieldFactorMult< Polynomial > > &  ufv,
const int  i0
 

void bitonicSort Iterator  begin,
Iterator  end,
const Comparator &  comparator = Comparator()
 

void bitonicMerge Iterator  begin,
Iterator  end,
const Comparator &  comparator = Comparator()
 

Polynomial& cia Polynomial P,
const Blackbox &  A,
const Method::BlasElimination &  M
 

long density const Vector v  )  [inline]
 

Estimate nonzero entries in a vector, used in parallel elimination.

long density const Vector ,
VectorCategory 
[inline]
 

long density const Vector v,
VectorCategories::DenseVectorTag 
[inline]
 

long density const Vector v,
VectorCategories::SparseSequenceVectorTag 
[inline]
 

long density const Vector v,
VectorCategories::SparseAssociativeVectorTag 
[inline]
 

long density const Vector v,
VectorCategories::SparseParallelVectorTag 
[inline]
 

void SpecialBound const Ring &  R,
typename Ring::Element H_col_sqr,
typename Ring::Element short_col_sqr,
const ItMatrix &  A
 

BoundBlackbox: Sets H_col_sqr <- H_col(A)^2, short_col_sqr <- short_col(A)^2 where H_col(A) is prod_j sqrt(sum_i a_ij^2) ('Hadamard column bound') short_col(A) is min_j sqrt(sum_i a_ij^2) ('shortest column')

note: H_col is not actually a norm! but it is what we need for lifting bound computation

void BoundBlackbox const Ring &  R,
typename Ring::Element H_col_sqr,
typename Ring::Element short_col_sqr,
const DenseMatrixBase< typename Ring::Element > &  A
 

void BoundBlackbox const Ring &  R,
typename Ring::Element H_col_sqr,
typename Ring::Element short_col_sqr,
const DenseSubmatrix< typename Ring::Element > &  A
 

void BoundBlackbox const Ring &  R,
typename Ring::Element H_col_sqr,
typename Ring::Element short_col_sqr,
const SparseMatrix< Ring > &  A
 

void BoundBlackbox const Ring &  R,
typename Ring::Element H_col_sqr,
typename Ring::Element short_col_sqr,
const Compose< Matrix1, Matrix2 > &  A
 

void BoundBlackbox const Ring &  R,
typename Ring::Element H_col_sqr,
typename Ring::Element short_col_sqr,
const Transpose< Matrix > &  A
 

void ApplyBound const Ring &  R,
typename Ring::Element bound_A,
const ItMatrix &  A
 

ApplyBound: computes bound_A <- max_i(max(sum_{j|a_ij > 0} a_ij, sum_{j|a_ij < 0} |a_ij|)) this is useful because for all u, v >= 0: [b has all entries in -u..v] => [each entry of A.b is at most (u+v)*bound_A in absolute value]

int rational_reconstruction integer a,
integer b,
const integer n0,
const integer d0,
const integer B
 

void reduceIn Domain &  D,
std::pair< typename Domain::Element, typename Domain::Element > &  frac
 

utility function to reduce a rational pair to lowest form

void vectorGcdIn typename Domain::Element result,
Domain &  D,
Vector v
 

utility function to gcd-in a vector of elements over a domain

Domain::Element vectorGcd Domain &  D,
Vector v
 

utility function, returns gcd of a vector of elements over a domain

OutV& apply OutV &  y,
const Matrix A,
const InV &  x
[inline]
 

OutV& applyTranspose OutV &  y,
const Matrix A,
const InV &  x
[inline]
 

void create_padic_chunk const Domain &  D,
const IMatrix &  M,
double *  chunks,
size_t  num_chunks
 

split an integer matrix into a padic chunk representation

void* runThread void *  arg  ) 
 

BBThread<Matrix, Out, In>* createBBThread const Matrix m,
Out *  out,
const In *  in
 

bool checkBlasApply const Field F,
size_t  n
 

std::vector<bool> setButterfly const std::vector< bool > &  x,
size_t  j = 0
 

A function used with Butterfly Blackbox Matrices. This function takes an STL vector x of booleans, and returns a vector y of booleans such that setting the switches marked by true flags in y to be on (or to swap elements) the true elements x will be switched to a given contiguous block through the use of a Butterfly switching network. The integer parameter j marks where this block is to begin. If x has r true elements, the Butterfly switching network will place these elements in a contiguous block starting at j and ending at j + r - 1. Wrap around shall be considered to preserve contiguity. The value of j is defaulted to be zero, and it is only allowed to be non-zero is the size of x is a power of 2.

Returns:
vector of booleans for setting switches
Parameters:
x vector of booleans marking elements to switch into contiguous block
j offset of contiguous block
log reference to ostream for logging

Diagonal< Field, VectorCategories::DenseVectorTag >::Diagonal const Field  F,
const std::vector< typename Field::Element > &  v
[inline]
 

Diagonal< _Field, VectorCategories::DenseVectorTag >::Diagonal const Field  F,
const size_t  n
[inline]
 

Diagonal< Field, VectorCategories::DenseVectorTag >::Diagonal const Field  F,
const size_t  n,
typename Field::RandIter iter
[inline]
 

OutVector& Diagonal< Field, VectorCategories::DenseVectorTag >::apply OutVector &  y,
const InVector &  x
const [inline]
 

Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::Diagonal const Field  F,
const std::vector< typename Field::Element > &  v
[inline]
 

OutVector& Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::apply OutVector &  y,
const InVector &  x
const [inline]
 

Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::Diagonal const Field  F,
const std::vector< typename Field::Element > &  v
[inline]
 

OutVector& Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::apply OutVector &  y,
const InVector &  x
const [inline]
 

Hilbert< Field, VectorCategories::DenseVectorTag >::Hilbert Field  F,
size_t  n
[inline]
 

OutVector& Hilbert< Field, VectorCategories::DenseVectorTag >::apply OutVector &  y,
const InVector &  x
const [inline]
 

Hilbert< Field, VectorCategories::SparseSequenceVectorTag >::Hilbert Field  F,
size_t  n
[inline]
 

OutVector& Hilbert< Field, VectorCategories::SparseSequenceVectorTag >::apply OutVector &  y,
const InVector &  x
const [inline]
 

Hilbert< Field, VectorCategories::SparseAssociativeVectorTag >::Hilbert Field  F,
size_t  n
[inline]
 

OutVector& Hilbert< Field, VectorCategories::SparseAssociativeVectorTag >::apply OutVector &  y,
const InVector &  x
const [inline]
 

std::ostream& operator<< std::ostream &  os,
GMPRationalElement &  elt
 

std::istream& operator>> std::istream &  is,
GMPRationalElement &  elt
 

NTL::GF2E& UnparametricField< NTL::GF2E >::init NTL::GF2E &  x,
const integer y
const
 

integer& UnparametricField< NTL::GF2E >::convert integer x,
const NTL::GF2E &  y
const
 

bool UnparametricField< NTL::GF2E >::isZero const NTL::GF2E &  a  )  const
 

bool UnparametricField< NTL::GF2E >::isOne const NTL::GF2E &  a  )  const
 

integer& UnparametricField< NTL::GF2E >::characteristic integer c  )  const
 

integer& UnparametricField< NTL::GF2E >::cardinality integer c  )  const
 

NTL::GF2E& UnparametricField< NTL::GF2E >::inv NTL::GF2E &  x,
const NTL::GF2E &  y
const
 

NTL::GF2E& UnparametricField< NTL::GF2E >::invin NTL::GF2E &  x  )  const
 

std::istream& UnparametricField< NTL::GF2E >::read std::istream &  is,
NTL::GF2E &  x
const
 

UnparametricField< NTL::zz_p >::UnparametricField integer  q,
size_t  e
 

NTL::zz_p& UnparametricField< NTL::zz_p >::init NTL::zz_p &  x,
const integer y
const
 

Initialization of field element from an integer. This Uses NTL's { to} function.

Returns:
reference to field element.
Parameters:
x field element to contain output (reference returned).
y integer.

integer& UnparametricField< NTL::zz_p >::convert integer x,
const NTL::zz_p &  y
const
 

Conversion of field element to an integer. This function assumes the output field element x has already been constructed, but that it is not already initialized. For now, this is done by converting the element type to a C++ long and then to the integer type through the use of static cast and NTL's to_long function. This, of course, assumes such static casts are possible. This function should be changed in the future to avoid using long.

Returns:
reference to integer.
Parameters:
x reference to integer to contain output (reference returned).
y constant reference to field element.

integer& UnparametricField< NTL::zz_p >::cardinality integer c  )  const
 

Cardinality. Return integer representing cardinality of the field. Returns the modulus of the field, which should be prime.

Returns:
integer representing cardinality of the field

integer& UnparametricField< NTL::zz_p >::characteristic integer c  )  const
 

Characteristic. Return integer representing characteristic of the field. Returns the modulus of the field, which should be prime.

Returns:
integer representing characteristic of the field.

NTL::zz_p& UnparametricField< NTL::zz_p >::inv NTL::zz_p &  x,
const NTL::zz_p &  y
const
 

Multiplicative Inverse. x = 1 / y This function assumes both field elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
x field element (reference returned).
y field element.

bool UnparametricField< NTL::zz_p >::isZero const NTL::zz_p &  x  )  const
 

Zero equality. Test if field element is equal to zero. This function assumes the field element has already been constructed and initialized. In this specialization, NTL's IsZero function is called.

Returns:
boolean true if equals zero, false if not.
Parameters:
x field element.

bool UnparametricField< NTL::zz_p >::isOne const NTL::zz_p &  x  )  const
 

One equality. Test if field element is equal to one. This function assumes the field element has already been constructed and initialized. In this specialization, NTL's IsOne function is called.

Returns:
boolean true if equals one, false if not.
Parameters:
x field element.

NTL::zz_p& UnparametricField< NTL::zz_p >::invin NTL::zz_p &  x  )  const
 

Inplace Multiplicative Inverse. x = 1 / x This function assumes both field elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
x field element (reference returned).

std::ostream& UnparametricField< NTL::zz_p >::write std::ostream &  os  )  const
 

Print field.

Returns:
output stream to which field is written.
Parameters:
os output stream to which field is written.

UnparametricRandIter< NTL::zz_p >::UnparametricRandIter const UnparametricField< NTL::zz_p > &  F,
const integer size,
const integer seed
 

Constructor for random field element generator.

NTL::zz_p& UnparametricRandIter< NTL::zz_p >::random NTL::zz_p &  x  )  const
 

Random field element creator.

NTL::zz_pE& UnparametricField< NTL::zz_pE >::init NTL::zz_pE &  x,
const integer y
const
 

integer& UnparametricField< NTL::zz_pE >::convert integer x,
const NTL::zz_pE &  y
const
 

bool UnparametricField< NTL::zz_pE >::isZero const NTL::zz_pE &  a  )  const
 

bool UnparametricField< NTL::zz_pE >::isOne const NTL::zz_pE &  a  )  const
 

integer& UnparametricField< NTL::zz_pE >::characteristic integer c  )  const
 

integer& UnparametricField< NTL::zz_pE >::cardinality integer c  )  const
 

NTL::zz_pE& UnparametricField< NTL::zz_pE >::inv NTL::zz_pE &  x,
const NTL::zz_pE &  y
const
 

NTL::zz_pE& UnparametricField< NTL::zz_pE >::invin NTL::zz_pE &  x  )  const
 

std::istream& UnparametricField< NTL::zz_pE >::read std::istream &  is,
NTL::zz_pE &  x
const
 

NTL_ZZ int  p = 0,
int  exp = 1
 

integer& cardinality integer c  )  const [inline]
 

integer& characteristic integer c  )  const [inline]
 

std::ostream& write std::ostream &  out  )  const
 

std::istream& read std::istream &  in  )  const
 

Element& init Element x,
const Element2 &  y
const [inline]
 

Init x from y.

Element& init Element x,
const Element y
const [inline]
 

Init from a NTL::ZZ.

Element& init Element x,
const int64 &  y
const [inline]
 

Init from an int64.

Element& init Element x,
const uint64 &  y
const [inline]
 

Init from a uint64.

Element& init Element x,
const integer y
const [inline]
 

I don't know how to init from integer efficiently.

integer& convert integer x,
const Element y
[inline, static]
 

Convert y to an Element.

double& convert double &  x,
const Element y
[inline, static]
 

Element& assign Element x,
const Element y
const [inline]
 

x = y.

bool areEqual const Element x,
const Element y
const [inline]
 

Test if x == y.

bool isZero const Element x  )  const [inline]
 

Test if x == 0.

bool isOne const Element x  )  const [inline]
 

Test if x == 1.

Element& add Element x,
const Element y,
const Element z
const [inline]
 

return x = y + z

Element& sub Element x,
const Element y,
const Element z
const [inline]
 

return x = y - z

Element& mul Element x,
const Element y,
const Int &  z
const [inline]
 

return x = y * z

Element& div Element x,
const Element y,
const Element z
const [inline]
 

If z divides y, return x = y / z, otherwise, throw an exception.

Element& inv Element x,
const Element y
const [inline]
 

If y is a unit, return x = 1 / y, otherwsie, throw an exception.

Element& neg Element x,
const Element y
const [inline]
 

return x = -y;

Element& axpy Element r,
const Element a,
const Int &  x,
const Element y
const [inline]
 

return r = a x + y

Element& addin Element x,
const Element y
const [inline]
 

return x += y;

Element& subin Element x,
const Element y
const [inline]
 

return x -= y;

Element& mulin Element x,
const Int &  y
const [inline]
 

return x *= y;

Element& divin Element x,
const Element y
const [inline]
 

If y divides x, return x /= y, otherwise throw an exception.

Element& invin Element x  )  [inline]
 

If x is a unit, x = 1 / x, otherwise, throw an exception.

Element& negin Element x  )  const [inline]
 

return x = -x;

Element& axpyin Element r,
const Element a,
const Int &  x
const [inline]
 

return r += a x

std::ostream& write std::ostream &  out,
const Element y
const
 

out << y;

std::istream& read std::istream &  in,
Element x
const
 

read x from istream in

bool isUnit const Element x  )  const [inline]
 

Test if x is a unit.

Element& gcd Element g,
const Element a,
const Element b
const [inline]
 

return g = gcd (a, b)

Element& gcdin Element g,
const Element b
const [inline]
 

return g = gcd (g, b)

Element& xgcd Element g,
Element s,
Element t,
const Element a,
const Element b
const [inline]
 

g = gcd(a, b) = a*s + b*t. The coefficients s and t are defined according to the standard Euclidean algorithm applied to |a| and |b|, with the signs then adjusted according to the signs of a and b.

Element& lcm Element c,
const Element a,
const Element b
const [inline]
 

c = lcm (a, b)

Element& lcmin Element l,
const Element b
const [inline]
 

l = lcm (l, b)

Element& sqrt Element x,
const Element y
const [inline]
 

x = floor ( sqrt(y)).

long reconstructRational Element a,
Element b,
const Element x,
const Element m,
const Element a_bound,
const Element b_bound
const [inline]
 

Requires 0 <= x < m, m > 2 * a_bound * b_bound, a_bound >= 0, b_bound > 0 This routine either returns 0, leaving a and b unchanged, or returns 1 and sets a and b so that (1) a = b x (mod m), (2) |a| <= a_bound, 0 < b <= b_bound, and (3) gcd(m, b) = gcd(a, b).

Element& quo Element q,
const Element a,
const Element b
const [inline]
 

q = floor (x/y);

Element& rem Element r,
const Element a,
const Element b
const [inline]
 

r = remindar of a / b

Element& quoin Element a,
const Element b
const [inline]
 

a = quotient (a, b)

Element& remin Element x,
const Element y
const [inline]
 

a = quotient (a, b)

void quoRem Element q,
Element r,
const Element a,
const Element b
const [inline]
 

q = [a/b], r = a - b*q |r| < |b|, and if r != 0, sign(r) = sign(b)

bool isDivisor const Element a,
const Element b
const [inline]
 

Test if b | a.

long compare const Element a,
const Element b
const [inline]
 

compare two elements, a and b return 1, if a > b return 0, if a = b; return -1. if a < b

Element& abs Element x,
const Element a
const [inline]
 

return the absolute value x = abs (a);

int getMaxModulus  )  [inline, static]
 

UnparametricField< NTL::ZZ_p >::UnparametricField integer  q,
size_t  e
 

integer& UnparametricField< NTL::ZZ_p >::convert integer x,
const NTL::ZZ_p &  y
const
 

Conversion of field element to an integer. This function assumes the output field element x has already been constructed, but that it is not already initialized. This done by converting to a std::string : inefficient but correct.

Returns:
reference to integer.
Parameters:
x reference to integer to contain output (reference returned).
y constant reference to field element.

double& UnparametricField< NTL::ZZ_p >::convert double &  x,
const NTL::ZZ_p &  y
const
 

integer& UnparametricField< NTL::ZZ_p >::cardinality integer c  )  const
 

Cardinality. Return integer representing cardinality of the field. Returns the modulus of the field, which should be prime.

Returns:
integer representing cardinality of the field

integer& UnparametricField< NTL::ZZ_p >::characteristic integer c  )  const
 

Characteristic. Return integer representing characteristic of the field. Returns the modulus of the field, which should be prime.

Returns:
integer representing characteristic of the field.

NTL::ZZ_p& UnparametricField< NTL::ZZ_p >::inv NTL::ZZ_p &  x,
const NTL::ZZ_p &  y
const
 

Multiplicative Inverse. x = 1 / y This function assumes both field elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
x field element (reference returned).
y field element.

bool UnparametricField< NTL::ZZ_p >::isZero const NTL::ZZ_p &  x  )  const
 

Zero equality. Test if field element is equal to zero. This function assumes the field element has already been constructed and initialized. In this specialization, NTL's IsZero function is called.

Returns:
boolean true if equals zero, false if not.
Parameters:
x field element.

bool UnparametricField< NTL::ZZ_p >::isOne const NTL::ZZ_p &  x  )  const
 

One equality. Test if field element is equal to one. This function assumes the field element has already been constructed and initialized. In this specialization, NTL's IsOne function is called.

Returns:
boolean true if equals one, false if not.
Parameters:
x field element.

NTL::ZZ_p& UnparametricField< NTL::ZZ_p >::invin NTL::ZZ_p &  x  )  const
 

Inplace Multiplicative Inverse. x = 1 / x This function assumes both field elements have already been constructed and initialized.

Returns:
reference to x.
Parameters:
x field element (reference returned).

std::ostream& UnparametricField< NTL::ZZ_p >::write std::ostream &  os  )  const
 

Print field.

Returns:
output stream to which field is written.
Parameters:
os output stream to which field is written.

UnparametricRandIter< NTL::ZZ_p >::UnparametricRandIter const UnparametricField< NTL::ZZ_p > &  F,
const integer size,
const integer seed
 

Constructor for random field element generator.

NTL::ZZ_p& UnparametricRandIter< NTL::ZZ_p >::random NTL::ZZ_p &  x  )  const
 

Random field element creator.

NTL::ZZ_pE& UnparametricField< NTL::ZZ_pE >::init NTL::ZZ_pE &  x,
const integer y
const
 

bool UnparametricField< NTL::ZZ_pE >::isZero const NTL::ZZ_pE &  a  )  const
 

bool UnparametricField< NTL::ZZ_pE >::isOne const NTL::ZZ_pE &  a  )  const
 

integer& UnparametricField< NTL::ZZ_pE >::convert integer c,
const NTL::ZZ_pE &  e
const
 

integer& UnparametricField< NTL::ZZ_pE >::characteristic integer c  )  const
 

integer& UnparametricField< NTL::ZZ_pE >::cardinality integer c  )  const
 

NTL::ZZ_pE& UnparametricField< NTL::ZZ_pE >::inv NTL::ZZ_pE &  x,
const NTL::ZZ_pE &  y
const
 

NTL::ZZ_pE& UnparametricField< NTL::ZZ_pE >::invin NTL::ZZ_pE &  x  )  const
 

std::istream& UnparametricField< NTL::ZZ_pE >::read std::istream &  is,
NTL::ZZ_pE &  x
const
 

T abs const T &  a  ) 
 

std::ostream& operator<< std::ostream &  os,
const SparseMatrixBase< Element, Row > &  A
 

std::istream& operator>> std::istream &  is,
SparseMatrixBase< Element, Row > &  A
 

uint32 hiBit uint32  u  )  [inline, static]
 

uint32 loBit uint32  u  )  [inline, static]
 

uint32 loBits uint32  u  )  [inline, static]
 

uint32 mixBits uint32  u,
uint32  v
[inline, static]
 

Polynomial& charpoly Polynomial P,
const Blackbox &  A,
const DomainCategory &  tag,
const MyMethod &  M
 

Polynomial& charpoly Polynomial P,
const Blackbox &  A,
const MyMethod &  M
 

...using an optional Method parameter

P - the output characteristic polynomial. If the polynomial is of degree d, this random access container has size d+1, the 0-th entry is the constant coefficient and the d-th is 1 since the charpoly is monic. A - a blackbox matrix Optional M - the method object. Generally, the default object suffices and the algorithm used is determined by the class of M. Basic methods are Method::Blackbox, Method::Elimination, and Method::Hybrid (the default). See methods.h for more options.

Returns:
a reference to P.

Polynomial& charpoly Polynomial P,
const Blackbox &  A
 

...using default method

Polynomial& charpoly Polynomial P,
const Blackbox &  A,
const DomainCategory &  tag,
const Method::Hybrid &  M
 

Polynomial& charpoly Polynomial P,
const DenseMatrix< Field > &  A,
const DomainCategory &  tag,
const Method::Hybrid &  M
 

Polynomial& charpoly Polynomial P,
const Blackbox &  A,
const DomainCategory &  tag,
const Method::Elimination &  M
 

Polynomial& charpoly Polynomial P,
const Blackbox &  A,
const RingCategories::ModularTag &  tag,
const Method::BlasElimination &  M