linbox
Namespaces | Data Structures | Typedefs | Enumerations | Functions | Variables
LinBox Namespace Reference

Namespace in which all linbox code resides. More...

Namespaces

 Protected
 This is the namespace all LinBox internal code is in.
 
 MatrixHom
 Limited doc so far. Used in RationalSolver.
 
 RingCategories
 some basic information about each field or ring.
 
 Tag
 Structure for tags.
 
 IndexedTags
 limited doc so far
 
 Exceptions
 Exception class for invalid matrix input.
 
 SparseMatrixFormat
 Sparse matrix format (memory storage)
 
 SparseFileFormat
 Sparse matrix format (file storage)
 
 VectorWrapper
 limited doc so far.
 

Data Structures

class  BlackboxBlockContainerBase
 A base class for BlackboxBlockContainer. More...
 
class  BlackboxBlockContainer
 no doc. More...
 
class  BlackboxBlockContainerRecord
 no doc. More...
 
class  BlackboxContainerBase
 A base class for BlackboxContainer. More...
 
class  BlackboxContainerSymmetric
 See base class for doc. More...
 
class  BlackboxContainerSymmetrize
 Symmetrizing iterator (for rank computations). More...
 
class  BlackboxContainer
 Limited doc so far. More...
 
class  BlasMatrixDomainInv< MultiModDouble, BlasMatrix< MultiModDouble > >
 specialisation for MultiModDouble. More...
 
class  BlockCoppersmithDomain
 Compute the linear generator of a sequence of matrices. More...
 
class  BlockLanczosSolver
 Block Lanczos iteration. More...
 
class  BlockMasseyDomain
 Compute the linear generator of a sequence of matrices. More...
 
struct  ChineseRemainderSeq
 No doc. More...
 
struct  ChineseRemainder
 Wrapper around OMP/SEQ version of ChineseRemainderXXX<CRABase>. More...
 
struct  EarlyMultipCRA
 NO DOC. More...
 
struct  EarlySingleCRA
 NO DOC. More...
 
struct  FullMultipFixedCRA
 Chinese Remaindering Algorithm for multiple residues. More...
 
struct  FullMultipBlasMatCRA
 NO DOC. More...
 
struct  FullMultipCRA
 NO DOC... More...
 
struct  GivaroRnsFixedCRA
 NO DOC... More...
 
class  DenseContainer
 Limited doc so far. More...
 
class  DiophantineSolver
 DiophantineSolver<QSolver> creates a diophantine solver using a QSolver to generate rational solutions. More...
 
class  EchelonFormDomain
 Echelon form domain. More...
 
class  Eliminator
 Elimination system. More...
 
class  GaussDomain
 Repository of functions for rank by elimination on sparse matrices. More...
 
class  LABlockLanczosSolver
 Biorthogonalising block Lanczos iteration. More...
 
class  LanczosSolver
 Solve a linear system using the conjugate Lanczos iteration. More...
 
class  LastInvariantFactor
 This is used in a Smith Form algorithm. More...
 
class  latticeMethod
 NTL methods. More...
 
class  DixonLiftingContainer
 Dixon Lifting Container. More...
 
class  WiedemannLiftingContainer
 Wiedemann LiftingContianer. More...
 
class  BlockWiedemannLiftingContainer
 Block Wiedemann LiftingContianer. More...
 
class  BlockHankelLiftingContainer
 Block Hankel LiftingContianer. More...
 
class  SparseLULiftingContainer
 SparseLULiftingContainer. More...
 
class  MasseyDomain
 Berlekamp/Massey algorithm. More...
 
class  MatrixRank
 Compute the rank of an integer matrix in place over a finite field by Gaussian elimination. More...
 
class  MGBlockLanczosSolver
 Block Lanczos iteration. More...
 
class  OneInvariantFactor
 Limited doc so far. More...
 
class  OpenCLEnviron
 Container for all pertenant information needed to use an OpenCL device, compile kernels for the device, track resource usage, and gain exclusive access to the device. More...
 
struct  RationalRemainder
 Chinese remainder of rationals. More...
 
struct  RationalRemainder2
 Chinese remainder of rationals. More...
 
class  RationalReconstruction
 Limited doc so far. More...
 
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, BlockHankelTraits >
 Block Hankel. More...
 
class  RationalSolver< Ring, Field, RandomPrime, SparseEliminationTraits >
 Sparse LU. More...
 
class  RationalSolver< Ring, Field, RandomPrime, NumSymNormTraits >
 solver using a hybrid Numeric/Symbolic computation. More...
 
class  RNS
 RNS. More...
 
class  TernaryLattice
 NO DOC. More...
 
class  LargeDouble
 NO DOC. More...
 
class  SigmaBasis
 implementation of $\sigma$-basis (minimal basis). More...
 
class  SmithFormBinary
 Compute Smith form. More...
 
class  SmithFormIliopoulos
 This is Iliopoulos' algorithm to diagonalize. More...
 
class  SmithFormLocal
 Smith normal form (invariant factors) of a matrix over a local ring. More...
 
class  PowerGaussDomain
 Repository of functions for rank modulo a prime power by elimination on sparse matrices. More...
 
class  PowerGaussDomainPowerOfTwo
 Repository of functions for rank modulo a prime power by elimination on sparse matrices. More...
 
class  VectorFraction
 VectorFraction<Domain> is a vector of rational elements with common reduced denominator. More...
 
class  WiedemannSolver
 Linear system solvers based on Wiedemann's method. More...
 
class  BlackboxArchetype
 showing the member functions provided by all blackbox matrix classes. More...
 
class  Thread
 built on posix threadsThis is a thread interface, built on posix threads. More...
 
class  CekstvSwitch
 The default butterfly switch object. More...
 
class  Butterfly
 Switching Network based BlackBox Matrix. More...
 
class  BooleanSwitch
 Boolean switch object. More...
 
struct  Companion
 Companion matrix of a monic polynomial. More...
 
class  Compose
 Blackbox of a product: $C = AB$, i.e $Cx \gets A(Bx)$. More...
 
class  ComposeOwner
 Blackbox of a product: $C = AB$, i.e $Cx \gets A(Bx)$. More...
 
class  Compose< _Blackbox, _Blackbox >
 specialization for _Blackbox1 = _Blackbox2 More...
 
class  ComposeTraits
 used in ..., for example More...
 
class  BlasMatrix
 Dense matrix representation. More...
 
class  ComposeTraits< BlasMatrix< Field, Rep > >
 used in smith-binary, for example More...
 
class  CSF
 Space efficient representation of sparse matrices. More...
 
class  Diagonal
 Random diagonal matrices are used heavily as preconditioners. More...
 
class  Diagonal< _Field, VectorCategories::DenseVectorTag >
 Specialization of Diagonal for application to dense vectors. More...
 
class  Diagonal< _Field, VectorCategories::SparseSequenceVectorTag >
 Specialization of Diagonal for application to sparse sequence vectors. More...
 
class  Diagonal< _Field, VectorCategories::SparseAssociativeVectorTag >
 Specialization of Diagonal for application to sparse associative vectors. More...
 
class  Dif
 Blackbox of a difference: C := A - B, i.e Cx = Ax - Bx. More...
 
class  DirectSum
 If C = DirectSum(A, B) and y = xA and z = wB, then (y,z) = (x,w)C. More...
 
class  BlackboxFactory
 A tool for computations with integer and rational matrices. More...
 
class  Hilbert_JIT_Entry
 The object needed to build a Hilbert matrix as a JIT matrix. More...
 
class  Hilbert
 Example of a blackbox that is space efficient, though not time efficient. More...
 
class  Inverse
 A Blackbox for the inverse. More...
 
class  JIT_Matrix
 example of a blackbox that is space efficient, though not time efficient. More...
 
class  MatrixBlackbox
 Matrix black box. More...
 
class  MoorePenrose
 Generalized inverse of a blackbox. More...
 
class  Sylvester
 This is a representation of the Sylvester matrix of two polynomials. More...
 
class  NullMatrix
 This is a representation of the 0 by 0 empty matrix which does not occupy memory. More...
 
class  PolynomialBB
 represent the matrix P(A) where A is a blackbox and P a polynomial More...
 
class  PolynomialBBOwner
 represent the matrix P(A) where A is a blackbox and P a polynomial More...
 
class  ZeroOne
 Time and space efficient representation of sparse {0,1}-matrices. More...
 
class  ScalarMatrix
 Blackbox for aI. More...
 
class  ZOQuad
 A class of striped or block-decomposed zero-one matrices. More...
 
class  Squarize
 transpose matrix without copying. More...
 
class  Submatrix
 leading principal minor of existing matrix without copying. More...
 
class  Submatrix< Blackbox, VectorCategories::DenseVectorTag >
 Specialization for dense vectors. More...
 
class  Submatrix< Blackbox, VectorCategories::DenseZeroOneVectorTag >
 Specialization for dense ZeroOne vectors. More...
 
class  Submatrix< BlasMatrix< _Field >, VectorCategories::DenseVectorTag >
 Specialization for BlasMatrix. More...
 
class  SubmatrixOwner< Blackbox, VectorCategories::DenseVectorTag >
 Specialization for dense vectors. More...
 
class  SubRowMatrix< Matrix, MatrixCategories::RowMatrixTag >
 submatrix consisting contiguous rows of a row based matrix. More...
 
class  Sum
 blackbox of a matrix sum without copying. More...
 
class  SumOwner
 blackbox of a matrix sum without copying. More...
 
class  Toeplitz
 This is the blackbox representation of a Toeplitz matrix. More...
 
class  Toeplitz< typename _PRing::CoeffField, _PRing >
 Specialization for when the field of matrix elements is the same as the coefficient field of the polynomial field. More...
 
class  Transpose
 transpose matrix without copying. More...
 
class  TransposeOwner
 transpose matrix without copying. More...
 
class  ZeroOne< GF2 >
 Time and space efficient representation of sparse matrices over GF2. More...
 
class  ElementAbstract
 Abstract element base class, a technicality. More...
 
class  ElementArchetype
 Field and Ring element interface specification and archetypical instance class. More...
 
class  RingEnvelope
 implement the ring archetype to minimize code bloat. More...
 
class  FieldEnvelope
 Derived class used to implement the field archetypeHelps to minimize code bloat. More...
 
class  RandIterEnvelope
 Random field base element generator. More...
 
class  ElementEnvelope
 Adaptor from archetypical interface to abstract interface, a technicality. More...
 
class  GMPRationalElement
 elements of GMP_Rationals. More...
 
class  FieldAbstract
 field base class. More...
 
class  FieldArchetype
 field specification and archetypical instance. More...
 
class  FieldInterface
 This field base class exists solely to aid documentation organization. More...
 
struct  ClassifyRing
 Default ring category. More...
 
struct  FieldTraits
 FieldTrait. More...
 
class  NoHomError
 Error object for attempt to establish a Hom that cannot exist. More...
 
class  Hom
 map element of source ring(field) to target ringAn instance of Hom is a homomorphism from a ring of type Source to a ring (usually field) of type Target. More...
 
class  ImageField
 ImageFields are fields which are targets of a ring homomorphism from a source ring. More...
 
class  ParamFuzzy
 Abstract parameterized field of "fuzzy" doubles. More...
 
struct  Rebind
 used in support of Hom, MatrixHom More...
 
class  indexDomain
 Class used for permuting indices. More...
 
struct  ContainerCategories
 used to separate BLAS2 and BLAS3 operations More...
 
struct  ContainerTraits
 Trait for the Category. More...
 
class  MatrixArchetype
 Directly-represented matrix archetype. More...
 
class  BlasSubmatrix
 Dense Submatrix representation. More...
 
class  TriangularBlasMatrix
 Triangular BLAS matrix. More...
 
struct  IndexedCategory< BlasMatrix< Field, _Rep > >
 
class  BlasMatrix< MultiModDouble >
 No Doc. More...
 
class  MatrixDomain
 Class of matrix arithmetic functions. More...
 
class  TransposedBlasMatrix
 TransposedBlasMatrix. More...
 
class  TransposedBlasMatrix< TransposedBlasMatrix< Matrix > >
 TransposedBlasMatrix. More...
 
class  LQUPMatrix
 LQUP factorisation. More...
 
struct  MatrixCategories
 For specializing matrix arithmetic. More...
 
class  MVProductDomain
 Helper class to allow specializations of certain matrix-vector products. More...
 
struct  MatrixTraits
 NO DOC. More...
 
class  MatrixContainerTrait
 NODOC. More...
 
struct  MatrixHomTrait
 try to map a blackbox over a homorphic ring The most suitable type More...
 
struct  IndexedCategory
 Trait to show whether or not the BB class has a Indexed iterator. More...
 
class  BlasMatrixDomainSubin
 C -= A. More...
 
class  BlasMatrixDomainAddin
 C += A. More...
 
class  BlasMatrixDomain
 Interface for all functionnalities provided for BlasMatrix. More...
 
class  BlasMatrixDomainMulAdd< BlasVector< Field >, BlasMatrix< Field, _Rep >, BlasVector< Field > >
 what about subvector/submatrices ? More...
 
class  MatrixDomain< GF2 >
 Specialization of MatrixDomain for GF2. More...
 
class  SubmatrixAdapter
 Generic submatrix view adapter used internally in the OpenCLMatrixDomain. More...
 
class  OpenCLMatrixDomain
 Interface for all functionnalities provided for BlasMatrix using GPUs. More...
 
class  MatrixPermutation
 Permutation classique. More...
 
class  BlasPermutation
 Lapack-style permutation. More...
 
class  PlainSubmatrix
 to be used in reference matrix domain (PlainDomain). More...
 
struct  RankBuilder
 random method for constructing rank More...
 
class  RandomDenseMatrix
 Random Dense Matrix builder. More...
 
class  DenseMat
 to be used in standard matrix domain More...
 
class  Sliced
 The Sliced Matrix class _Domain must be a GF(3) rep, BaseT must be an unsigned int type. More...
 
class  SlicedPolynomialMatrixAddin
 C += A. More...
 
class  SlicedPolynomialMatrixSubin
 C -= A. More...
 
class  SparseMatrixWriteHelper
 Write helper. More...
 
class  SparseMatrixReadHelper
 Read helper. More...
 
class  SparseMatrix< _Field, SparseMatrixFormat::COO::implicit >
 Sparse matrix, Coordinate storage. More...
 
class  SparseMatrix< _Field, SparseMatrixFormat::COO >
 Sparse matrix, Coordinate storage. More...
 
class  SparseMatrix< _Field, SparseMatrixFormat::CSR >
 Sparse matrix, Coordinate storage. More...
 
class  SparseMatrix< _Field, SparseMatrixFormat::ELL >
 Sparse matrix, Coordinate storage. More...
 
class  SparseMatrix< _Field, SparseMatrixFormat::ELL_R >
 Sparse matrix, Coordinate storage. More...
 
class  SparseMatrix< _Field, SparseMatrixFormat::HYB >
 Sparse matrix, Coordinate storage. More...
 
class  SparseMatrix< Field_, SparseMatrixFormat::TPL_omp >
 Sparse matrix representation which stores nonzero entries by i,j,value triples. More...
 
class  SparseMatrix< Field_, SparseMatrixFormat::TPL >
 Sparse Matrix in Triples storage. More...
 
class  TransposeMatrix
 Matrix transpose. More...
 
class  RandIterAbstract
 Random field element generator. More...
 
class  RandIterArchetype
 Random field element generator archetype. More...
 
class  GenericRandIter
 Random field base element generator. More...
 
class  GmpRandomPrime
 generating random prime integers, using the gmp library. More...
 
class  ModularCrookedRandIter
 Random field base element generator. More...
 
class  RandomIntegerIterator
 Random Prime Generator. More...
 
class  RandomIntegerIter
 Random Integer Iterator. More...
 
class  RandomPrimeIterator
 Random Prime Generator. More...
 
class  RandomPrimeIter
 Random Prime Iterator. More...
 
class  RingAbstract
 Abstract ring base class. More...
 
class  RingArchetype
 specification and archetypic instance for the ring interfaceThe RingArchetype and its encapsulated element class contain pointers to the RingAbstract and its encapsulated ring element, respectively. More...
 
class  GivPolynomialRing
 Polynomials. More...
 
struct  Local2_32
 Fast arithmetic mod 2^32, including gcd. More...
 
class  FieldAXPY< Givaro::ModularBalanced< double > >
 Specialization of FieldAXPY. More...
 
class  DotProductDomain< Givaro::ModularBalanced< double > >
 Specialization of DotProductDomain. More...
 
class  FieldAXPY
 FieldAXPY object. More...
 
class  FieldAXPY< Givaro::Modular< uint8_t > >
 Specialization of FieldAXPY for uint8_t modular field. More...
 
class  DotProductDomain< Givaro::Modular< uint8_t > >
 Specialization of DotProductDomain for unsigned short modular field. More...
 
class  MVProductDomain< Givaro::Modular< uint8_t > >
 Specialization of MVProductDomain for uint8_t modular field. More...
 
class  FieldAXPY< Givaro::Modular< uint16_t > >
 Specialization of FieldAXPY for uint16_t modular field. More...
 
class  DotProductDomain< Givaro::Modular< uint16_t > >
 Specialization of DotProductDomain for unsigned short modular field. More...
 
class  MVProductDomain< Givaro::Modular< uint16_t > >
 Specialization of MVProductDomain for uint16_t modular field. More...
 
class  FieldAXPY< Givaro::Modular< uint32_t > >
 Specialization of FieldAXPY for unsigned short modular field. More...
 
class  DotProductDomain< Givaro::Modular< uint32_t > >
 Specialization of DotProductDomain for uint32_t modular field. More...
 
class  MVProductDomain< Givaro::Modular< uint32_t > >
 Specialization of MVProductDomain for uint32_t modular field. More...
 
class  FieldAXPY< Givaro::Modular< uint64_t > >
 Specialization of FieldAXPY for unsigned short modular field. More...
 
class  DotProductDomain< Givaro::Modular< uint64_t > >
 Specialization of DotProductDomain for uint64_t modular field. More...
 
class  MVProductDomain< Givaro::Modular< uint64_t > >
 Specialization of MVProductDomain for uint64_t modular field. More...
 
class  FieldAXPY< Givaro::Modular< _Element > >
 Specialization of FieldAXPY for parameterized modular field. More...
 
class  FieldAXPY< Givaro::Modular< double, double > >
 Specialization of FieldAXPY for modular double. More...
 
class  FieldAXPY< Givaro::Modular< float, float > >
 Specialization of FieldAXPY for modular float. More...
 
struct  NTL_zz_p
 long ints modulo a positive integer. More...
 
class  NTL_zz_pE_Initialiser
 use ZZ_pEBak mechanism too ? More...
 
class  NTL_zz_pE
 zz_pE Define a parameterized class to easily handle Givaro::ZRing<NTL::zz_pE> field More...
 
class  NTL_zz_pEX
 Ring (in fact, a unique factorization domain) of polynomial with coefficients in class NTL_zz_p (integers mod a wordsize prime). More...
 
class  NTL_zz_pX
 Ring (in fact, a unique factorization domain) of polynomial with coefficients in class NTL_zz_p (integers mod a wordsize prime). More...
 
class  NTL_ZZ
 the integer ring. More...
 
struct  NTL_ZZ_p
 Wrapper of zz_p from NTL. More...
 
class  UnparametricRandIter< NTL::ZZ_p >
 Constructor for random field element generator. More...
 
class  NTL_ZZ_pE
 Wrapper of ZZ_pE from NTL Define a parameterized class to handle easily Givaro::ZRing<NTL::ZZ_pE> field. More...
 
class  NTL_ZZ_pX
 Ring (in fact, a unique factorization domain) of polynomial with coefficients in class NTL_ZZ_p (integers mod a wordsize prime). More...
 
struct  NTL_PID_zz_p
 extend Wrapper of zz_p from NTL. More...
 
class  PIR_ntl_ZZ_p
 extend Wrapper of ZZ_p from NTL. More...
 
class  RingInterface
 This ring base class exists solely to aid documentation organization. More...
 
struct  GetEntryCategory
 GetEntryCategory is specialized for BB classes that offer a local getEntry. More...
 
struct  HybridSpecifier
 HybridSpecifier. More...
 
struct  BlackboxSpecifier
 BlackboxSpecifier. More...
 
struct  EliminationSpecifier
 EliminationSpecifier. More...
 
struct  CRASpecifier
 CRASpecifier. More...
 
struct  BlockWiedemannTraits
 To select algorithms that use Giorgi' algorithms/block-massey-domain.h. More...
 
struct  CoppersmithTraits
 To select algorithms that use Yuhasz' algorithms/coppersmith.h. More...
 
struct  IMLTraits
 IML wrapper. More...
 
struct  Method
 Method specifiers for controlling algorithm choice. More...
 
struct  CRATraits
 Solve using CRA (iterations uses SolveMethod) More...
 
struct  SolverTraits
 Solver traits. More...
 
class  SolveFailed
 Exception thrown when the computed solution vector is not a true solution to the system, but none of the problems cited below exist. More...
 
class  InconsistentSystem
 Exception thrown when the system to be solved is inconsistent. More...
 
struct  TraceCategory
 Trait to show whether or not the BB class has a local trace function. More...
 
class  Commentator
 Give information to user during runtime. More...
 
class  PreconditionFailed
 A precondition failed. More...
 
class  Exception
 This is the exception class in LinBox. More...
 
class  algoException
 Algorithmic exception. More...
 
class  NotImplementedYetException
 Not implemented yet. More...
 
class  IrrecuperableException
 Something bad an unexpected happened. More...
 
class  BadInputException
 The input is not as expected. More...
 
class  LinboxError
 base class for execption handling in LinBox More...
 
class  MatrixStream
 MatrixStream. More...
 
class  MatrixStreamReader
 An abstract base class to represent readers for specific formats. More...
 
class  PrimeStream
 Prime number stream. More...
 
class  BitVector
 Binary constant defined both for 32 and 64 bits. More...
 
struct  ContainerTraits< std::vector< _Rep > >
 
class  ReverseVector
 Reverse vector class This class wraps an existing vector type and reverses its direction. More...
 
class  SlicedPolynomialVectorAddin
 C += A. More...
 
class  SlicedPolynomialVectorSubin
 C -= A. More...
 
class  Sparse_Vector
 vector< Pair<T,I> > and actualsize More...
 
class  VectorStream
 Vector factory. More...
 
class  ConstantVectorStream
 Constant vector factory. More...
 
class  RandomDenseStream
 Random dense vector stream. More...
 
class  RandomDenseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag >
 Specialization of random dense stream for dense vectors. More...
 
class  RandomSparseStream
 Random sparse vector stream. More...
 
class  RandomSparseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag >
 Specialization of RandomSparseStream for dense vectors. More...
 
class  RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseSequenceVectorTag >
 Specialization of RandomSparseStream for sparse sequence vectors. More...
 
class  RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseAssociativeVectorTag >
 Specialization of RandomSparseStream for sparse associative vectors. More...
 
class  RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseParallelVectorTag >
 Specialization of RandomSparseStream for sparse parallel vectors. More...
 
class  StandardBasisStream
 Stream for $e_1,\cdots,e_n$. More...
 
class  StandardBasisStream< Field, _Vector, VectorCategories::DenseVectorTag >
 Specialization of standard basis stream for dense vectors. More...
 
class  StandardBasisStream< Field, _Vector, VectorCategories::SparseSequenceVectorTag >
 Specialization of standard basis stream for sparse sequence vectors. More...
 
class  StandardBasisStream< Field, _Vector, VectorCategories::SparseAssociativeVectorTag >
 Specialization of standard basis stream for sparse associative vectors. More...
 
class  StandardBasisStream< Field, _Vector, VectorCategories::SparseParallelVectorTag >
 Specialization of standard basis stream for sparse parallel vectors. More...
 
class  Subiterator
 Subvector iterator class provides striding iterators. More...
 
class  Subvector
 Dense subvectorThis class provides a statically sized subvector of a random access container (such as std::vector, deque). More...
 
struct  VectorCategories
 List of vector categories. More...
 
struct  VectorTraits
 Vector traits template structure. More...
 
struct  RawVector
 Canonical vector types. More...
 
struct  Vector
 Vector ?? More...
 
struct  Rebind< std::vector< T >, U >
 Rebind. More...
 
class  MetaData
 This is the general metadata class. More...
 
class  FieldMetaData
 Field metadata. More...
 
class  MatrixMetaData
 Matrix metadata. More...
 
class  EnvironmentMetaData
 Environment metadata;. More...
 
class  BenchmarkMetaData
 Benchmark metadata;. More...
 
class  AlgorithmMetaData
 Algorithm metadata;. More...
 
class  GeneratorMetaData
 Generator metadata;. More...
 
class  StorageMetaData
 Storage metadata;. More...
 
class  showProgression
 Show progression on the terminal (helper) More...
 
class  TimeWatcher
 Helper. More...
 
struct  DataSeries
 this structure holds a bunch of timings. More...
 
class  PlotStyle
 Represents a table of values to plot (2D). More...
 
class  PlotData
 The raw data to plot. More...
 
class  PlotGraph
 The graph (2D). More...
 

Typedefs

typedef Givaro::Integer integer
 Integers in LinBox. More...
 
typedef std::vector< double > dvector_t
 vector of double
 
typedef std::vector< dvector_tdmatrix_t
 matrix of double
 

Enumerations

enum  SolveResult
 Enumeration for results of next solver. More...
 
enum  SNSolverReturnStatus
 define the possible return status of the solver's computation.
 
enum  SolverReturnStatus
 define the different return status of the p-adic based solver's computation.
 
enum  SolverLevel
 Define the different strategy which can be used in the p-adic based solver. More...
 

Functions

template<class Field , class Vector , class Blackbox >
WiedemannSolver< Field >
::ReturnStatus 
solve (const Blackbox &A, Vector &x, const Vector &b, Vector &u, const Field &F, const WiedemannTraits &traits=WiedemannTraits())
 Solve Ax=b over field F using Wiedemann's method, with inconsistency certificate. More...
 
template<class Field , class Vector , class Blackbox >
Vectorsolve (const Blackbox &A, Vector &x, const Vector &b, const Field &F, const WiedemannTraits &traits=WiedemannTraits())
 Solve Ax=b over field F using the Wiedemann method. More...
 
template<class Field , class Vector , class Blackbox >
Vectorsolve (const Blackbox &A, Vector &x, const Vector &b, const Field &F, const LanczosTraits &traits)
 Solve Ax=b over field F using the Lanczos method. More...
 
template<class Field , class Vector , class Blackbox >
Vectorsolve (const Blackbox &A, Vector &x, const Vector &b, const Field &F, const BlockLanczosTraits &traits)
 Solve Ax=b over field F using the block Lanczos method. More...
 
template<class Field , class Matrix , class Vector >
Vectorsolve (const Matrix &A, Vector &x, const Vector &b, const Field &F, const BlasEliminationTraits &traits)
 Solve Ax=b over field F using Gaussian elimination. More...
 
template<class Field , class Blackbox , class Vector , class MethodTraits >
SolveResult solve (const Blackbox &A, Vector &x, const Vector &b, const Field &F, Vector &u, const MethodTraits &traits=MethodTraits())
 Solve Ax=b over field F, returning consistency indicator. More...
 
template<class Polynomial , class Blackbox >
Polynomial & cia (Polynomial &P, const Blackbox &A, const Method::BlasElimination &M)
 Algorithm computing the integer characteristic polynomial of a dense matrix. More...
 
template<class Field >
size_t & NullSpaceBasisIn (const LINBOX_enum(Tag::Side) Side, BlasMatrix< Field > &A, BlasMatrix< Field > &Ker, size_t &kerdim)
 Nullspace of a dense matrix on a finite field. More...
 
template<class DenseMat >
size_t & NullSpaceBasisIn (const LINBOX_enum(Tag::Side) Side, BlasSubmatrix< DenseMat > &A, BlasMatrix< typename DenseMat::Field > &Ker, size_t &kerdim)
 
template<class Field >
size_t & NullSpaceBasis (const LINBOX_enum(Tag::Side) Side, const BlasMatrix< Field > &A, BlasMatrix< Field > &Ker, size_t &kerdim)
 Nullspace of a dense matrix on a finite field. More...
 
template<class Field >
size_t NullSpaceBasisIn (const Field &F, const LINBOX_enum(Tag::Side) Side, const size_t &m, const size_t &n, typename Field::Element *A, const size_t &lda, typename Field::Element *&Ker, size_t &ldk, size_t &kerdim)
 Computes the kernel of a dense matrix using LQUP. More...
 
template<class Vector >
long density (const Vector &v)
 Estimate nonzero entries in a vector, used in parallel elimination.
 
template<class Ring >
int dyadicToRational (const Ring &Z, typename Ring::Element &a, typename Ring::Element &b, const typename Ring::Element &n, const typename Ring::Element &d, const typename Ring::Element &B)
 Rational reconstruction of a/b from n/d with denominator bound B. More...
 
template<class Ring >
bool partial_hegcd (Ring &Z, typename Ring::Element &e, typename Ring::Element &b, const typename Ring::Element &n, const typename Ring::Element &d, const typename Ring::Element &denBound)
 partial_hegcd() sets e, b from the remainder sequence of n,d. More...
 
template<class Blackbox , class MyMethod >
Blackbox::Field::Element & lif_cra_det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
 Compute the determinant of A over the integers. More...
 
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)
 BoundBlackbox. More...
 
template<class Ring , class ItMatrix >
void ApplyBound (const Ring &R, typename Ring::Element &bound_A, const ItMatrix &A)
 ApplyBound. More...
 
std::vector< cl_platform_id > enumPlatforms ()
 Enumerate all of the platforms currently available on the system.
 
std::string getPlatformName (cl_platform_id platform)
 Get the platform name associated with the platform.
 
double getPlatformVersion (cl_platform_id platform)
 Get the platform version associated with the platform.
 
std::vector< std::string > getPlatformExtensions (cl_platform_id platform)
 Get the platform extensions associated with the platform.
 
std::vector< cl_device_id > enumDevices (cl_platform_id platform)
 Enumerate all of the devices currently available on the platform.
 
cl_context createContext (cl_platform_id platform, cl_device_id device)
 Create an OpenCL context from a platfrom and device.
 
template<class Prime >
bool checkBlasPrime (const Prime p)
 NO DOC ! More...
 
int large_double_division (integer &x, const integer &y, const integer &z)
 NO DOC.
 
template<class Domain >
void reduceIn (Domain &D, std::pair< typename Domain::Element, typename Domain::Element > &frac)
 utility function to reduce a rational pair to lowest form
 
template<class Domain , class Vector >
void vectorGcdIn (typename Domain::Element &result, Domain &D, Vector &v)
 utility function to gcd-in a vector of elements over a domain
 
template<class Domain , class Vector >
Domain::Element vectorGcd (Domain &D, Vector &v)
 utility function, returns gcd of a vector of elements over a domain
 
template<class Domain , class IMatrix >
void create_MatrixQadic (const Domain &D, const IMatrix &Mat, double *chunks, size_t num_chunks, const integer shift)
 split an integer matrix into a padic chunk representation More...
 
template<class Domain , class Vector >
void create_VectorQadic (const Domain &D, const Vector &V, double *chunks, size_t num_chunks)
 split an integer vector into a padic chunk representation More...
 
template<class Domain , class Vector >
void create_VectorQadic_32 (const Domain &D, const Vector &V, double *chunks, size_t num_chunks)
 split an integer vector into a padic chunk representation More...
 
template<class Field >
DenseMatrix< Field > & genericNullspaceRandomRight (DenseMatrix< Field > &N, const FIBB< Field > &A)
 N: AN = 0, each col random.
 
template<class Field >
DenseMatrix< Field > & genericNullspaceRandomLeft (DenseMatrix< Field > &N, const FIBB< Field > &A)
 N: NA = 0, each row random.
 
double naturallog (const Givaro::Integer &a)
 Natural logarithm (ln). More...
 
template<>
bool IsNegative (const uint8_t &p)
 
template<class _Field , class _Storage >
std::ostream & operator<< (std::ostream &os, const BlasMatrix< _Field, _Storage > &Mat)
 Write a matrix to a stream. More...
 
void resize (Index m, Index n)
 resize to m by n. More...
 
void RandomBlasPermutation (BlasPermutation< size_t > &P)
 
template<class T >
std::ostream & operator<< (std::ostream &o, const DenseMat< T > &Mat)
 Write a matrix to a stream. More...
 
template<class Field , class Vector >
Vectorprepare (const Field &F, Vector &y, const typename Field::Element &a)
 y <- ay. More...
 
template<class Blackbox , class Polynomial , class MyMethod >
Polynomial & charpoly (Polynomial &P, const Blackbox &A, const MyMethod &M)
 ...using an optional Method parameter More...
 
template<class Blackbox , class Polynomial >
Polynomial & charpoly (Polynomial &P, const Blackbox &A)
 ...using default method
 
template<class Polynomial , class Blackbox >
Polynomial & charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
 
template<class Polynomial , class Domain >
Polynomial & charpoly (Polynomial &P, const SparseMatrix< Domain > &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
 
template<class Polynomial , class Domain >
Polynomial & charpoly (Polynomial &P, const BlasMatrix< Domain > &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
 
template<class Polynomial , class Blackbox >
BlasVector< typename
Blackbox::Field, Polynomial > & 
charpoly (BlasVector< typename Blackbox::Field, Polynomial > &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
 Compute the characteristic polynomial over $\mathbf{Z}_p$. More...
 
template<class Polynomial , class Blackbox >
Polynomial & charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
 Compute the characteristic polynomial over $\mathbf{Z}_p$. More...
 
template<class Blackbox , class DetMethod , class DomainCategory >
Blackbox::Field::Element & det (typename Blackbox::Field::Element &d, const Blackbox &A, const DomainCategory &tag, const DetMethod &Meth)
 Compute the determinant of A. More...
 
template<class Field >
Field::Element & detin (typename Field::Element &d, BlasMatrix< Field > &A)
 Rank of Blackbox A. More...
 
template<class BB >
BB::Field::Element & getEntry (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 , class Method >
BB::Field::Element & getEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j, Method &m)
 To ignore methods.
 
template<class I1 , class Lp >
void distinct (I1 a, I1 b, Lp &c)
 no doc. More...
 
template<class VecPoly , class Blackbox >
vector< Poly< Field > > & invariants (VecPol &S, const Blackbox< Field > &A, Method &M=Method::Hybrid)
 Compute the Frobenius form invariant factors of A. More...
 
template<class Blackbox , class MyMethod >
bool isPositiveDefinite (const Blackbox &A, const MyMethod &M)
 Compute the isPositiveDefinite of A. More...
 
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::BlasElimination &M)
 
template<class Blackbox , class MyMethod >
bool isPositiveSemiDefinite (const Blackbox &A, const MyMethod &M)
 Determine if A is positive semidefinite. More...
 
template<class Blackbox >
bool isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::BlasElimination &M)
 
template<class Polynomial , class Blackbox >
Polynomial & minpoly (Polynomial &P, const Blackbox &A)
 ...using default Method
 
template<class Blackbox , class Method , class DomainCategory >
unsigned long & rank (unsigned long &r, const Blackbox &A, const DomainCategory &tag, const Method &M)
 Compute the rank of a linear transform A over a field by selected method. More...
 
template<class Blackbox >
unsigned long & rank (unsigned long &r, const Blackbox &A)
 Compute the rank of a linear transform A over a field. More...
 
template<class Blackbox , class Method >
unsigned long & rank (unsigned long &r, const Blackbox &A, const Method &M)
 Compute the rank of a linear transform A over a field. More...
 
template<class Blackbox >
unsigned long & rankin (unsigned long &r, Blackbox &A)
 Rank of A. More...
 
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 &res, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Wiedemann &M)
 M may be Method::Wiedemann(). More...
 
template<class Field >
unsigned long & rank (unsigned long &r, const SparseMatrix< Field, SparseMatrixFormat::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)
 
unsigned long & rankin (unsigned long &r, GaussDomain< GF2 >::Matrix &A, const Method::SparseElimination &)
 specialization to $ \mathbf{F}_2 $
 
unsigned long & rankin (unsigned long &r, GaussDomain< GF2 >::Matrix &A, const RingCategories::ModularTag &, const Method::SparseElimination &M)
 specialization to $ \mathbf{F}_2 $
 
template<class Field >
unsigned long & rankin (unsigned long &r, BlasMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
 A is modified.
 
template<class Output , class Blackbox , class MyMethod >
Output & smithForm (Output &S, const Blackbox &A, const MyMethod &M)
 Compute the Smith form of A. More...
 
template<class Vector , class Blackbox , class SolveMethod >
Vectorsolve (Vector &x, const Blackbox &A, const Vector &b, const SolveMethod &M)
 Solve Ax = b, for x. More...
 
template<class Vector , class Blackbox >
Vectorsolve (Vector &x, const Blackbox &A, const Vector &b)
 the solve with default method.
 
template<class BB >
BB::Field::Element & trace (typename BB::Field::Element &t, const BB &A)
 Sum of the eigenvalues. More...
 
template<class Blackbox , class MyMethod >
Blackbox::Field::Element & valence (typename Blackbox::Field::Element &v, const Blackbox &A, const MyMethod &M)
 Compute the valence of A. More...
 
template<class Field >
std::ostream & writeMMComment (std::ostream &os, Field &F, std::string name, std::string comment)
 Write second line and comment part of matrix market header.
 
template<class BB >
std::ostream & writeMMCoordHeader (std::ostream &os, BB &A, size_t nnz, std::string name, std::string comment="")
 Write matrix market header (up to the i,j,val lines) for a sparse or structured matrix.
 
template<class BB >
std::ostream & writeMMPatternHeader (std::ostream &os, BB &A, size_t nnz, std::string name, std::string comment="")
 Write matrix market header (up to the i,j lines) for a {0,1} sparse or structured matrix.
 
template<class BB >
std::ostream & writeMMArrayHeader (std::ostream &os, BB &A, std::string name, std::string comment="")
 Write matrix market header (up to the entry lines) for a dense matrix.
 
template<class Mat >
std::ostream & writeMMArray (std::ostream &os, Mat &A, std::string name, std::string comment="")
 Generic dense matrix writer to matrix market array format (col major).
 
std::string eltype (float x)
 eltype(x) returns a string containing the name of the type of field or ring element x.
 
template<class Field , class Vector >
Vector randomVector (Field &F, size_t n, typename Field::RandIter &r)
 Random vector generator This templated function takes a field and a random field element generator and returns a vector of random field elements. More...
 
template<class Ring , class Matrix >
MatrixrandomAns (const Ring &R, Matrix &Mat, size_t n, size_t epr)
 
size_t & RandIntInInt (const size_t &s, size_t &RIII, const int &seed=0)
 gives a random number such that $0 \leq RIII < s$. More...
 
void RandomPermutation (size_t *P, const size_t &len)
 Creates a random Lapack style Permutation P of size len.
 
template<class Field >
bool CheckRank (const Field &F, const typename Field::Element *A, const size_t &m, const size_t &n, const size_t &lda, const size_t &alledged_rank)
 Checks we got the right rank. More...
 
template<class Field >
void RandomMatrixWithRank (const Field &F, typename Field::Element *A, const size_t &m, const size_t &n, const size_t &lda, const size_t &rank)
 Builds a m x n random matrix of rank rank over field F.
 
template<class Field >
void RandomMatrixWithDet (const Field &F, typename Field::Element *A, const size_t &m, const size_t &lda, const typename Field::Element &det)
 Builds a m x m random matrix of determinant det over field F. More...
 
void showAdvanceLinear (index_t curr, index_t min, index_t max)
 show the advancement (on the terminal) suppose linear advancement More...
 
void showFinish (index_t curr, index_t all)
 tells the current series of measure has completed (on the terminal) More...
 
void showSkip (index_t curr, index_t all)
 tells the current series of measure was skipped (on the terminal) More...
 
double computeMFLOPS (const double &tim, const double mflo, const index_t rpt=1)
 computes the number of megaflops. More...
 
double computeMFLOPS (const dvector_t &tim, const double mflo, LINBOX_enum(Tag::TimeSelect) ts=Tag::TimeSelect::bestThree)
 computes the number of megaflops. More...
 
bool isDigit (const std::string &s)
 Check if a string is actually a double. More...
 
bool fortifiedString (const std::string &s)
 Tells is a string has double quotes around. More...
 
std::string unfortifyString (const std::string &s)
 removes the surrounding quotes. More...
 
std::string fortifyString (const std::string &s)
 adds surrounding quotes. More...
 
std::string getDateTime (const std::string &sep)
 get ISO time and date More...
 
smatrix_t getMachineInformation ()
 get some machine information (not cpu yet)
 
template<class T >
std::string toString (T &nam)
 Converts anything to a string. More...
 
bool findKeyword (index_t &i, const svector_t::const_iterator &begin, const svector_t::const_iterator &end, const std::string &keyword)
 finds keyword betwen begin and end, return true if found and i is the index where it is (possibly correspondig to end)
 
double fit2 (const dvector_t &X, const dvector_t &Y, int n, double x)
 fit X[n-1,n],Y[n-1,n] and return evaluation at x.
 
double fit3 (const dvector_t &X, const dvector_t &Y, int n, double x)
 fit X[n-2,n],Y[n-2,n] and return evaluation at x.
 
Butterfly

Butterfly preconditioner and supporting function

std::vector< bool > setButterfly (const std::vector< bool > &x, size_t j=0)
 A function used with Butterfly Blackbox Matrices. More...
 
template<class T >
bool isPositive (const T &x)
 Positiveness of an integer. More...
 
template<>
bool isPositive (const uint8_t &)
 Positiveness of an integer. More...
 
template<>
bool isPositive (const uint16_t &)
 Positiveness of an integer. More...
 
template<>
bool isPositive (const uint32_t &)
 Positiveness of an integer. More...
 
template<>
bool isPositive (const uint64_t &)
 Positiveness of an integer. More...
 
template<class Vector , class BB >
Vectorsolve (Vector &x, typename BB::Field::Element &d, const BB &A, const Vector &b)
 2nd integer solver API : solution is a formed by a common denominator and a vector of integer numerator solution is num/d BB: why not a struct RatVector2 { IntVector _n ; Int _d } ; ?
 
template<class Vector , class BB , class MethodTraits >
Vectorsolve (Vector &x, typename BB::Field::Element &d, const BB &A, const Vector &b, const MethodTraits &m)
 2nd integer solver API : solution is a formed by a common denominator and a vector of integer numerator solution is num/d BB: why not a struct RatVector2 { IntVector _n ; Int _d } ; ?
 
template<class Vector , class BB >
Vectorsolve (Vector &x, typename BB::Field::Element &d, const BB &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::BlasElimination &m)
 2nd integer solver API : solution is a formed by a common denominator and a vector of integer numerator solution is num/d BB: why not a struct RatVector2 { IntVector _n ; Int _d } ; ?
 
template<class Vector , class Ring >
Vectorsolve (Vector &x, typename Ring::Element &d, const BlasMatrix< Ring > &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::BlasElimination &m)
 
template<class Vect , class Ring >
Vect & solve (Vect &x, typename Ring::Element &d, const SparseMatrix< Ring, SparseMatrixFormat::SparseSeq > &A, const Vect &b, const RingCategories::IntegerTag &tag, const Method::SparseElimination &m)
 2nd integer solver API : solution is a formed by a common denominator and a vector of integer numerator solution is num/d BB: why not a struct RatVector2 { IntVector _n ; Int _d } ; ?
 
template<class Vector , class Ring >
Vectorsolve (Vector &x, typename Ring::Element &d, const BlasMatrix< Ring > &A, const Vector &b, const RingCategories::IntegerTag tag, Method::Dixon &m)
 solver specialization with the 2nd API and DixonTraits over integer (no copying)
 
template<class Vect , class Ring >
Vect & solve (Vect &x, typename Ring::Element &d, const SparseMatrix< Ring, SparseMatrixFormat::SparseSeq > &A, const Vect &b, const RingCategories::IntegerTag tag, Method::Dixon &m)
 solver specialization with the 2nd API and DixonTraits over integer (no copying)
 

Variables

template<class Out , class Matrix , class In >
Out &BlackboxParallel(Out &out,
const Matrix &m, const In &in,
BBBase::BBType type) typedef
Out::iterator 
OutIterator
 This is a matrix representation supporting a parallel matrix vector product.
 

Detailed Description

Namespace in which all linbox code resides.

The matrix class Sliced is defined.

Bug:
it is dangerous to include matrices defs that include hom for their rebind...

The subdirectories of linbox/ contain the template source code for all the LinBox functionality. See the Modules list for the documentation of the main parts of linbox.

Warning
The timer comes from Givaro and lives in its anonymous namespace.
Bug:
those are not just traits:
Bug:
this does not belong here.
Bug:
those are not just traits:
Bug:
those are not just traits:

It adheres to the LinBox dense matrix interface.

It depends on SlicedBase, also defined here, which packs GF(3) elements into a pair of ints. The int type is a template parameter.

Enumeration Type Documentation

Enumeration for results of next solver.

SOLVE_SUCCESSFUL - System solution was succesful, x holds the solution vector SOLVE_INCONSISTENT - System was inconsistent, u holds the certificate of inconsistency and x is untouched SOLVE_FAILED - Neither a system solution nor a certificate of inconsistency could be obtained before the maximum number of trials elapsed. Both x and u are untouched.

Function Documentation

WiedemannSolver<Field>::ReturnStatus LinBox::solve ( const Blackbox &  A,
Vector &  x,
const Vector &  b,
Vector &  u,
const Field &  F,
const WiedemannTraits &  traits = WiedemannTraits () 
)

Solve Ax=b over field F using Wiedemann's method, with inconsistency certificate.

This is a general interface for the linear system solving capabilities of LinBox. If the system is nonsingular, it returns the unique solution, storing it in the vector x. If the system is consistent and singular, it returns a random solution. Repeated calls to this function can give a complete description of the solution manifold. If the system is inconsistent and the SolverTraits structure supplied requests certification of inconsistency, it fills in the certificate of inconsistency. Otherwise, it runs through the number of iterations specified in traits and throws a SolveFailed exception if it cannot find a solution.

This specialization uses Wiedemann's algorithm and is the default.

Parameters
ABlack box matrix of the system
xPlace to store solution vector
bRight-hand side
uVector in which to store certificate of inconsistency, if required
FField over which to perform computations
traitsSolverTraits structure with user-specified parameters
Returns
Reference to solution vector
Examples:
examples/checksolve.C, and examples/solve.C.
Vector& LinBox::solve ( const Blackbox &  A,
Vector &  x,
const Vector &  b,
const Field &  F,
const WiedemannTraits &  traits = WiedemannTraits () 
)

Solve Ax=b over field F using the Wiedemann method.

This version differs from the one above in that there is no extra parameter for the certificate of inconsistency, and it throws exceptions if the solution fails. It also returns a reference to the solution vector.

Vector& LinBox::solve ( const Blackbox &  A,
Vector &  x,
const Vector &  b,
const Field &  F,
const LanczosTraits &  traits 
)

Solve Ax=b over field F using the Lanczos method.

This is a general interface for the linear system solving capabilities of LinBox. If the system is nonsingular, it returns the unique solution, storing it in the vector x. If the system is consistent and singular, it returns a random solution. Repeated calls to this function can give a complete description of the solution manifold. If the system is inconsistent and the SolverTraits structure has result checking turned on, it runs through the number of iterations specified in traits and throws a SolveFailed exception if it cannot find a solution.

This specialization uses the Lanczos algorithm.

Parameters
ABlack box matrix of the system
xPlace to store solution vector
bRight-hand side
FField over which to perform computations
traitsSolverTraits structure with user-specified parameters
Returns
Reference to solution vector
Vector& LinBox::solve ( const Blackbox &  A,
Vector &  x,
const Vector &  b,
const Field &  F,
const BlockLanczosTraits &  traits 
)

Solve Ax=b over field F using the block Lanczos method.

This is a general interface for the linear system solving capabilities of LinBox. If the system is nonsingular, it returns the unique solution, storing it in the vector x. If the system is consistent and singular, it returns a random solution. Repeated calls to this function can give a complete description of the solution manifold. If the system is inconsistent and the SolverTraits structure has result checking turned on, it runs through the number of iterations specified in traits and throws a SolveFailed exception if it cannot find a solution.

This specialization uses the block Lanczos algorithm.

Parameters
ABlack box matrix of the system
xPlace to store solution vector
bRight-hand side
FField over which to perform computations
traitsSolverTraits structure with user-specified parameters
Returns
Reference to solution vector
Vector& LinBox::solve ( const Matrix A,
Vector &  x,
const Vector &  b,
const Field &  F,
const BlasEliminationTraits &  traits 
)

Solve Ax=b over field F using Gaussian elimination.

This is a general interface for the linear system solving capabilities of LinBox. If the system is nonsingular, it returns the unique solution, storing it in the vector x. If the system is consistent and singular, it returns a random solution. Repeated calls to this function can give a complete description of the solution manifold. If the system is inconsistent and the SolverTraits structure supplied requests certification of inconsistency, it throws an InconsistentSystem exception, which includes a certificate of inconsistency. Otherwise, it runs through the number of iterations specified in traits and throws a SolveFailed exception if it cannot find a solution.

Parameters
ABlack box matrix of the system
xPlace to store solution vector
bRight-hand side
FField over which to perform computations
traitsSolverTraits structure with user-specified parameters
Returns
Reference to solution vector
SolveResult LinBox::solve ( const Blackbox &  A,
Vector &  x,
const Vector &  b,
const Field &  F,
Vector &  u,
const MethodTraits &  traits = MethodTraits () 
)

Solve Ax=b over field F, returning consistency indicator.

This is a variant of solve that does not throw any exceptions unless the user makes an error. It returns a SolveResult enum indicating whether the solve operation was successful, the system was inconsistent, or the solve operation failed. The certificate of inconsistency, if requested, is stored in a reference parameter supplied to this variant.

Parameters
ABlack box matrix of the system
xPlace to store solution vector
bRight-hand side
uPlace to store certificate of inconsistency
FField over which to perform computations
traitsSolverTraits structure with user-specified parameters
Returns
SolveResult indicating whether the solve operation was successful
size_t & NullSpaceBasisIn ( const LINBOX_enum(Tag::Side)  Side,
BlasMatrix< Field > &  A,
BlasMatrix< Field > &  Ker,
size_t &  kerdim 
)

Nullspace of a dense matrix on a finite field.

A is modified.

Parameters
Ffield
SideSideTag::Left or SideTag::Right nullspace.
[in,out]AInput matrix
[out]KerNullspace of the matrix (Allocated in the routine)
[out]kerdimrank of the kernel
Returns
kerdim
Todo:
make it work for BlasSubmatrix too
size_t & NullSpaceBasisIn ( const LINBOX_enum(Tag::Side)  Side,
BlasSubmatrix< DenseMat > &  A,
BlasMatrix< typename DenseMat::Field > &  Ker,
size_t &  kerdim 
)
Todo:
uses too much memory
Todo:
use copy
Todo:
use copy
size_t & NullSpaceBasis ( const LINBOX_enum(Tag::Side)  Side,
const BlasMatrix< Field > &  A,
BlasMatrix< Field > &  Ker,
size_t &  kerdim 
)

Nullspace of a dense matrix on a finite field.

A is preserved.

Parameters
Ffield
SideSideTag::Left or SideTag::Right nullspace.
[in]AInput matrix
[out]KerNullspace of the matrix (Allocated in the routine)
[out]kerdimrank of the kernel
Returns
kerdim
Todo:
make it work for BlasSubmatrix too
size_t LinBox::NullSpaceBasisIn ( const Field &  F,
const LINBOX_enum(Tag::Side)  Side,
const size_t &  m,
const size_t &  n,
typename Field::Element *  A,
const size_t &  lda,
typename Field::Element *&  Ker,
size_t &  ldk,
size_t &  kerdim 
)

Computes the kernel of a dense matrix using LQUP.

Acccording to the dimensions of the input matrix, we chose different methods.

Warning
timings may vary and these choices were made on an experimental basis.
Parameters
FField
Sideleft or right from LinBox::SideTag
mrows
ncols
Ainput matrix
ldaleading dimension of A
KerKernel. NULL if kerdim==0
ldkleading dimension of the kernel.
kerdimdimension of the kernel.
Returns
dimension of the kernel.
Warning
A is modified.
int LinBox::dyadicToRational ( const Ring &  Z,
typename Ring::Element &  a,
typename Ring::Element &  b,
const typename Ring::Element &  n,
const typename Ring::Element &  d,
const typename Ring::Element &  B 
)

Rational reconstruction of a/b from n/d with denominator bound B.

We give a/b, the continued fraction approximant of n/d that satisfies |a/b - n/d| < 1/2d (well approximated) and 0 < b <= B. Return value is 0, if no such approximant exists. Return value is 1, if either (i) a second well approximated rational with denominator bounded by B may exist, or (ii) the well approximated condition is not met for a/b. In these cases, a/b may be used speculatively. Return value is 2, if the approximant is guaranteed (because bB <= d).

If no fraction is well approximated the last b <= B in the remainder sequence of n,d is given.

If d = 2^k and n = sum_i=l to k n_i 2^i, then * n/d = sum_{i=l down to 0} n_i/2^{k-i} is a {dyadic rational}. Numbers of this form are produced for example by numeric-symbolic iterations.

If it is known that n/d is the most accurate approximation with denominator d to a/b, and that the denominator b is bounded by B, i.e. b <= B, then such a/b is uniquely determined, provided d >= bB. ...in that case, such a/b is returned by dyadicToRational(). This follows from two facts: First, by definition, n/d is an accurate approximation to a/b with b <= d when |n/d - a/b| < 1/2d. Otherwise (n-1)/d or (n+1)/d would be a better approximation. Second, if a/b and a'/b' are distinct rationals, then |a/b - a'/b'| >= 1/bb'. Thus if a'/b' is another rational accurately approximated by n/d, we have 1/bb' <= |a/b - a'/b'| <= |a/b - n/d| + |n/d - a'/b'| <= 1/2d + 1/2d = 1/d. So bb' > d >= bB, thus b' > B.

In summary: If it exists, the unique a/b is given such that n/d approximates a/b to within 1/2d and b <= B. Otherwise a plausible a/b is given or failure is signaled.

"Symbolic-Numeric Exact Rational Linear System Solver" by Saunders, Wood, Youse. describes the construction.

bool LinBox::partial_hegcd ( Ring &  Z,
typename Ring::Element &  e,
typename Ring::Element &  b,
const typename Ring::Element &  n,
const typename Ring::Element &  d,
const typename Ring::Element &  denBound 
)

partial_hegcd() sets e, b from the remainder sequence of n,d.

It requires positive n and d. It sets e to the first r_i (remainder) and b to the corresponding q_i (coefficient of n) such that 2r_i < |q_i| and |q_i| <= B (the given denominator bound). True is returned iff such e, b exist.

If not, b is the largest q_i such that |q_i| <= B, and e is the corresponding remainder. In this case b is the denominator of a plausibly approximated but not well approximated rational. It can be used speculatively.

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

BoundBlackbox.

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 LinBox::ApplyBound ( const Ring &  R,
typename Ring::Element &  bound_A,
const ItMatrix &  A 
)

ApplyBound.

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]

bool LinBox::checkBlasPrime ( const Prime  p)
inline

NO DOC !

Bug:
why is this hard coded ?
void create_MatrixQadic ( const Domain D,
const IMatrix &  Mat,
double *  chunks,
size_t  num_chunks,
const integer  shift 
)

split an integer matrix into a padic chunk representation

void LinBox::create_VectorQadic ( const Domain D,
const Vector &  V,
double *  chunks,
size_t  num_chunks 
)

split an integer vector into a padic chunk representation

void LinBox::create_VectorQadic_32 ( const Domain D,
const Vector &  V,
double *  chunks,
size_t  num_chunks 
)

split an integer vector into a padic chunk representation

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

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
xvector of booleans marking elements to switch into contiguous block
joffset of contiguous block
double LinBox::naturallog ( const Givaro::Integer &  a)
inline

Natural logarithm (ln).

log(2) being close to 0.69314718055994531

Parameters
ainteger.
Returns
ln(a).
bool LinBox::isPositive ( const T &  x)
inline

Positiveness of an integer.

Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.

Parameters
xinteger
Returns
true iff x>=0.
bool LinBox::isPositive ( const uint8_t &  )
inline

Positiveness of an integer.

Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.

Parameters
xinteger
Returns
true iff x>=0.
bool LinBox::isPositive ( const uint16_t &  )
inline

Positiveness of an integer.

Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.

Parameters
xinteger
Returns
true iff x>=0.
bool LinBox::isPositive ( const uint32_t &  )
inline

Positiveness of an integer.

Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.

Parameters
xinteger
Returns
true iff x>=0.
bool LinBox::isPositive ( const uint64_t &  )
inline

Positiveness of an integer.

Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.

Parameters
xinteger
Returns
true iff x>=0.
bool LinBox::IsNegative ( const uint8_t &  p)
inline
Todo:
or use integer_traits<T>::is_unsigned ??
std::ostream & operator<< ( std::ostream &  os,
const BlasMatrix< _Field, _Storage > &  Mat 
)

Write a matrix to a stream.

The C++ way using operator<<

Parameters
ooutput stream
Matmatrix to write.
void LinBox::resize ( Index  m,
Index  n 
)

resize to m by n.

If this is allocating, any existing submatrices are invalidated.

Examples:
examples/smith.C.
void RandomBlasPermutation ( BlasPermutation< size_t > &  P)
Todo:
To be factorized.
std::ostream& LinBox::operator<< ( std::ostream &  o,
const DenseMat< T > &  Mat 
)

Write a matrix to a stream.

The C++ way using operator<<

Parameters
ooutput stream
Matmatrix to write.
Vector& LinBox::prepare ( const Field &  F,
Vector &  y,
const typename Field::Element &  a 
)

y <- ay.

Todo:
Vector knows Field
Polynomial& LinBox::charpoly ( Polynomial &  P,
const Blackbox &  A,
const MyMethod &  M 
)

...using an optional Method parameter

Parameters
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& LinBox::charpoly ( Polynomial &  P,
const Blackbox &  A,
const RingCategories::ModularTag &  tag,
const Method::Hybrid &  M 
)
Bug:
not Hybrid at all
Polynomial& LinBox::charpoly ( Polynomial &  P,
const SparseMatrix< Domain > &  A,
const RingCategories::ModularTag &  tag,
const Method::Hybrid &  M 
)
Bug:
not Hybrid at all
Polynomial& LinBox::charpoly ( Polynomial &  P,
const BlasMatrix< Domain > &  A,
const RingCategories::ModularTag &  tag,
const Method::Hybrid &  M 
)
Bug:
not Hybrid at all
BlasVector<typename Blackbox::Field,Polynomial >& LinBox::charpoly ( BlasVector< typename Blackbox::Field, Polynomial > &  P,
const Blackbox &  A,
const RingCategories::ModularTag &  tag,
const Method::BlasElimination &  M 
)

Compute the characteristic polynomial over $\mathbf{Z}_p$.

Compute the characteristic polynomial of a matrix using dense elimination methods

Parameters
PPolynomial where to store the result
ABlackbox representing the matrix
tag
M
Polynomial& LinBox::charpoly ( Polynomial &  P,
const Blackbox &  A,
const RingCategories::ModularTag &  tag,
const Method::Blackbox &  M 
)

Compute the characteristic polynomial over $\mathbf{Z}_p$.

Compute the characteristic polynomial of a matrix, represented via a blackBox.

Parameters
PPolynomial where to store the result
ABlackbox representing the matrix
tag
M
void distinct ( I1  a,
I1  b,
Lp &  c 
)

no doc.

end krat ////////////////////////////

Bug:
this already exists elsewhere
bool LinBox::isPositiveDefinite ( const Blackbox &  A,
const MyMethod &  M 
)

Compute the isPositiveDefinite of A.

The isPositiveDefinite of a linear operator A, represented as a black box, is computed over the ring or field of A.

Parameters
ABlack box of which to compute the isPositiveDefinite
Mmay be a Method::Hybrid (default), Method::Blackbox, Method::Elimination, or of other method type.
bool LinBox::isPositiveDefinite ( const Blackbox &  A,
const RingCategories::IntegerTag &  tag,
const Method::Hybrid &  M 
)
Bug:
should try a modular minpoly and decide on the degree of that...
Bug:
this crude size check can be refined
bool LinBox::isPositiveDefinite ( const Blackbox &  A,
const RingCategories::IntegerTag &  tag,
const Method::BlasElimination &  M 
)
Bug:
why map (same field)? This is a copy.
bool LinBox::isPositiveSemiDefinite ( const Blackbox &  A,
const MyMethod &  M 
)

Determine if A is positive semidefinite.

The positive semidefiniteness of a linear operator A, represented as a black box, is computed over the ring or field (characteristic 0) of A.

Parameters
ABlack box of which to compute the isPositiveSemiDefinite
Mmay be a Method::Hybrid (SemiDefault), Method::Blackbox, Method::Elimination, or of other method type.
bool LinBox::isPositiveSemiDefinite ( const Blackbox &  A,
const RingCategories::IntegerTag &  tag,
const Method::BlasElimination &  M 
)
Warning
this is a copy
unsigned long& LinBox::rankin ( unsigned long &  r,
Blackbox &  A 
)
inline

Rank of A.

A may be modified

Parameters
Amatrix
rrank
Bug:
there is no Elimination() method there.
unsigned long& LinBox::rank ( unsigned long &  r,
const Blackbox &  A,
const RingCategories::ModularTag &  tag,
const Method::Hybrid &  m 
)
inline
Bug:
choose (benchmark) better cuttoff (size, nbnz, sparse rep)
unsigned long& LinBox::rank ( unsigned long &  res,
const Blackbox &  A,
const RingCategories::ModularTag &  tag,
const Method::Wiedemann &  M 
)
inline

M may be Method::Wiedemann().

Bug:
This is too much for solutions. It belongs in algorithms
unsigned long& LinBox::rank ( unsigned long &  r,
const Blackbox &  A,
const RingCategories::ModularTag &  tag,
const Method::SparseElimination &  M 
)
inline
Bug:
choose (benchmark) best representation for Sparse Elimination
Vector& LinBox::solve ( Vector &  x,
const Blackbox &  A,
const Vector &  b,
const SolveMethod &  M 
)

Solve Ax = b, for x.

Vector x such that Ax = b is returned. In the case of a singular matrix A, if the system is consistent, a random solution is returned by default. The method parameter may contain an indication that an arbitrary element of the solution space is acceptable, which can be faster to compute. If the system is inconsistent the zero vector is returned.

Warning
no doc for when using what method
Parameters
[out]xsolution
[in]Amatrix
[in]btarget
[in]Mmethod to use (
See Also
solutions/method.h)
Returns
reference to x
Vector& LinBox::solve ( Vector &  x,
typename Ring::Element &  d,
const BlasMatrix< Ring > &  A,
const Vector &  b,
const RingCategories::IntegerTag &  tag,
const Method::BlasElimination &  m 
)
Bug:
check we don't copy
BB::Field::Element & trace ( typename BB::Field::Element &  t,
const BB &  A 
)

Sum of the eigenvalues.

Also it is the sum of the diagonal entries.

Runtime on n by n matrix is n times the cost of getEntry(). This is linear in n for those classes where getEntry is constant time (eg DenseMatrix and SparseMatrix). Trace is constant time when the diagonal is necessarily constant, eg. for ScalarMatrix and Toeplitz. Worst case time is cost of n blackbox applies (matrix vector products), and apply cost typically ranges between O(n) and O(n^2).

Vector LinBox::randomVector ( Field &  F,
size_t  n,
typename Field::RandIter &  r 
)
inline

Random vector generator This templated function takes a field and a random field element generator and returns a vector of random field elements.

The vector is dense in the field elements, even if the vector is a sparse LinBox vector. The funtion is templatized by the field and the vector types being used. This function calls another function by the same name with an additional parameter of the vector category of the vector it is called with. This mechanism is used because functions cannot have partial template specializations like classes can. This new, extended function can be specialized for specific fields and vectors to allow for better performance.

Returns
v vector of random field elements
Parameters
FField in which arithmetic is done
ninteger number of elements in vector
rRandom field element generator
Matrix& LinBox::randomAns ( const Ring &  R,
Matrix Mat,
size_t  n,
size_t  epr 
)
Bug:
use BlasVector.
size_t& LinBox::RandIntInInt ( const size_t &  s,
size_t &  RIII,
const int &  seed = 0 
)

gives a random number such that $0 \leq RIII < s$.

basic..

Parameters
[in]ssup
[in]seedseed. If 0 (default) we create a new one.
[out]RIIIrandom integer in the interval $[[0, s-1]]$.
Returns
a reference to RIII
bool LinBox::CheckRank ( const Field &  F,
const typename Field::Element *  A,
const size_t &  m,
const size_t &  n,
const size_t &  lda,
const size_t &  alledged_rank 
)

Checks we got the right rank.

Parameters
Ffield
Amatrix
mrows
ncols
ldaleadin dimmension
alledged_ranksupposedly correct rank.
Returns
alledged_rank==rank(A)
Parameters
alledged_rank
Bug:
not used
void LinBox::RandomMatrixWithDet ( const Field &  F,
typename Field::Element *  A,
const size_t &  m,
const size_t &  lda,
const typename Field::Element &  det 
)

Builds a m x m random matrix of determinant det over field F.

Parameters
det
Bug:
not used
void showAdvanceLinear ( index_t  curr,
index_t  min,
index_t  max 
)

show the advancement (on the terminal) suppose linear advancement

Parameters
currcurrent iteration
minstarting iteration
maxterminal iteration
void showFinish ( index_t  curr,
index_t  all 
)

tells the current series of measure has completed (on the terminal)

Parameters
currcurrent iteration
allnumber of iterations
void showSkip ( index_t  curr,
index_t  all 
)

tells the current series of measure was skipped (on the terminal)

Parameters
currcurrent iteration
allnumber of iterations
double computeMFLOPS ( const double &  tim,
const double  mflo,
const index_t  rpt = 1 
)

computes the number of megaflops.

Parameters
timtimer (seconds)
mflonumber of operations (1e6 operations)
rptnumber of experiences
Returns
mflo/(tim*rpt)
double computeMFLOPS ( const dvector_t &  tim,
const double  mflo,
LINBOX_enum(Tag::TimeSelect)  ts = Tag::TimeSelect::bestThree 
)

computes the number of megaflops.

Parameters
timtimer (seconds)
mflonumber of operations (1e6 operations)
tsnumber of experiences to select.
See Also
TimeSelect. Default to the best three
Returns
mflo/(tim*rpt)
bool isDigit ( const std::string &  s)

Check if a string is actually a double.

Parameters
sstring to check
Returns
true/false
bool fortifiedString ( const std::string &  s)

Tells is a string has double quotes around.

Parameters
sstring to test
Returns
true if s[0] == s[last] == '"'
std::string unfortifyString ( const std::string &  s)

removes the surrounding quotes.

Parameters
sremoves quotes around if necessary
Returns
s without surrounding double quotes if necessary
std::string fortifyString ( const std::string &  s)

adds surrounding quotes.

Parameters
sadd quotes around if necessary
Returns
s with surrounding double quotes if necessary
std::string getDateTime ( const std::string &  sep = " ")

get ISO time and date

get ISO time and date year-time YYYY-MM-DD 'sep' HH:MM:SS 'sep' (GMT)

Parameters
sepseparation between
std::string LinBox::toString ( T &  nam)

Converts anything to a string.

Parameters
namto be put in a string.