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

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

Namespaces

namespace  MatrixHom
 Limited doc so far. Used in RationalSolver.
namespace  IndexedTags
 limited doc so far
namespace  Protected
 This is the namespace all LinBox internal code is in.
namespace  TraceTags
 undocumented
namespace  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  BlasMatrixDomainSubin
 C -= A. More...
class  BlasMatrixDomainAddin
 C += A. More...
class  BlasMatrixDomain
 Interface for all functionnalities provided for BlasMatrix. 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  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  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...
struct  LinBoxTag
 Structure for tags. 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...
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, WanTraits >
 solver using a hybrid Numeric/Symbolic computation. More...
class  RNS
 RNS. More...
class  SigmaBasis
 implementation of $\sigma$-basis (minimal basis). More...
class  SmithFormBinary
 Compute Smith form. More...
class  SmithFormIliopoulos
 This is Iliopoulos' algorithm do 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  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  BlackboxInterface
 This blackbox base class exists solely to aid documentation organization. More...
class  BlasBlackbox
 Dense matrix representation for BLAS based elimination. More...
class  Butterfly
 Switching Network based BlackBox Matrix. 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  Compose< _Blackbox, _Blackbox >
 specialization for _Blackbox1 = _Blackbox2 More...
class  ComposeTraits
 used in ..., for example More...
class  ComposeTraits< BlasBlackbox< Field > >
 used in smith-binary, for example More...
class  ComposeOwner
 Blackbox of a product: $C = AB$, i.e $Cx \gets A(Bx)$. 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  Permutation
 size is n. 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  ZOQuad
 A class of striped or block-decomposed zero-one matrices. More...
class  ScalarMatrix
 Blackbox for aI. More...
class  SparseMatrix
 vector of sparse rows. More...
class  SparseMatrixFactory
 Sparse matrix factory This class inherits BlackboxFactory and provides a method for using a SparseMatrixBase object with integer or rational data type as input to the high-level integer and rational solutions functions. 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  SubmatrixOwner< Blackbox, VectorCategories::DenseVectorTag >
 Specialization for dense vectors. 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 _PField::CoeffField, _PField >
 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  TriplesBB
 wrapper for NAG Sparse Matrix format. More...
class  ZeroOne
 Time and space efficient representation of sparse {0,1}-matrices. More...
struct  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  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  BlockRing
 Elements are wrapped BlasMatrix objects. More...
class  FieldEnvelope
 Derived class used to implement the field archetype
  Helps to minimize

code bloat. More...

class  FieldInterface
 This field base class exists solely to aid documentation organization. More...
class  RingCategories
 some basic information about each field or ring. More...
struct  GivaroField< LinBox::GF2 >
 give LinBox fields an allure of Givaro FieldsThis class adds the necessary requirements allowing the construction of an extension of a LinBox field. More...
class  GivaroExtension
 This template class is defined to be in phase with the LinBox archetype. More...
class  GivaroExtension< GivaroGfq >
 This template class is define just to be in phase with the LinBox archetype. More...
class  Hom< BaseField, GivaroExtension< BaseField > >
 NO DOC. More...
struct  GivaroField
 give LinBox fields an allure of Givaro FieldsThis class adds the necessary requirements allowing the construction of an extension of a LinBox field or a givaro polynomial of a LinBox field ... More...
class  GivaroGfq
 Wrapper of Givaro's GFqDom<int32_t> class. More...
class  GivaroMontg
 wrapper of Givaro's Givaro::Montgomery< Givaro::Std32>. More...
class  GivaroZpz
 wrapper of Givaro's ZpzDom. 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  LidiaGfq
 defines the Galois Field GF(pk). More...
struct  Local2_32
 Fast arithmetic mod 2^32, including gcd. More...
class  ModularBalanced< double >
 Centered representation of $\mathbf{Z}/m\mathbf{Z}$. More...
class  FieldAXPY< ModularBalanced< double > >
 Specialization of FieldAXPY. More...
class  DotProductDomain< ModularBalanced< double > >
 Specialization of DotProductDomain. More...
class  Modular< int8_t >
 Specialization of Modular to signed 8 bit element type with efficient dot product. More...
class  Modular< double >
 Standard representation of $\mathbf{Z}/m\mathbf{Z}$. More...
class  Modular< int32_t >
 Specialization of Modular to int32_t element type with efficient dot product. More...
class  Modular< int64_t >
 Specialization of Modular to int64_t element type with efficient dot product. More...
class  Modular< int16_t >
 Specialization of Modular to short element type with efficient dot product. More...
class  Modular< uint8_t >
 Allows compact storage when the modulus is less than 2^8. More...
class  FieldAXPY< Modular< uint8_t > >
 Specialization of FieldAXPY for uint8_t modular field. More...
class  DotProductDomain< Modular< uint8_t > >
 Specialization of DotProductDomain for unsigned short modular field. More...
class  MVProductDomain< Modular< uint8_t > >
 Specialization of MVProductDomain for uint8_t modular field. More...
class  Modular< uint16_t >
 Specialization of class Modular for uint16_t element type. More...
class  FieldAXPY< Modular< uint16_t > >
 Specialization of FieldAXPY for uint16_t modular field. More...
class  DotProductDomain< Modular< uint16_t > >
 Specialization of DotProductDomain for unsigned short modular field. More...
class  MVProductDomain< Modular< uint16_t > >
 Specialization of MVProductDomain for uint16_t modular field. More...
class  Modular< uint32_t >
 Specialization of class Modular for uint32_t element type. More...
class  FieldAXPY< Modular< uint32_t > >
 Specialization of FieldAXPY for unsigned short modular field. More...
class  DotProductDomain< Modular< uint32_t > >
 Specialization of DotProductDomain for uint32_t modular field. More...
class  MVProductDomain< Modular< uint32_t > >
 Specialization of MVProductDomain for uint32_t modular field. More...
class  Modular
 Prime fields of positive characteristic implemented directly in LinBox. More...
class  FieldAXPY< Modular< _Element > >
 Specialization of FieldAXPY for parameterized modular field. More...
struct  NTL_zz_p
 long ints modulo a positive integer. More...
class  NTL_zz_pE
 zz_pE Define a parameterized class to easily handle UnparametricField<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...
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 UnparametricField<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...
class  ParamFuzzy
 Abstract parameterized field of "fuzzy" doubles. More...
class  PID_double
 NO DOC. More...
class  PID_integer
 Domain for integer operations. 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...
struct  Rebind
 used in support of Hom, MatrixHom More...
class  FieldAXPY< UnparametricField< integer > >
 NO DOc. More...
class  MatrixArchetype
 Directly-represented matrix archetype. More...
class  BlasMatrix
 Dense matrix representation. More...
class  BlasSubmatrix
 Dense Submatrix representation. More...
class  TriangularBlasMatrix
 Triangular BLAS matrix. More...
class  indexDomain
 Class used for permuting indices. More...
class  TransposedBlasMatrix
 TransposedBlasMatrix. More...
class  TransposedBlasMatrix< TransposedBlasMatrix< Matrix > >
 TransposedBlasMatrix. More...
class  DenseRowsMatrix
 Dense row-wise matrix container. 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...
class  MatrixDomain
 Class of matrix arithmetic functions. More...
class  BlasPermutation
 Lapack-style permutation. More...
class  MatrixPermutation
 Permutation classique. More...
struct  RankBuilder
 random method for constructing rank More...
class  RandomDenseMatrix
 Random Dense Matrix builder. More...
class  InvalidMatrixInput
 Exception class for invalid matrix input. More...
class  FieldIO
 Dummy field for conceptually unclear io. More...
class  SparseMatrixBase
 Sparse matrix container This class acts as a generic row-wise container for sparse matrices. More...
class  TransposeMatrix
 Matrix transpose. More...
class  RandIterAbstract
 Random field element generator. More...
class  RandIterArchetype
 Random field element generator archetype. More...
class  RandIterEnvelope
 Random field base element generator. More...
class  GmpRandomPrime
 generating random prime integers, using the gmp library. More...
class  ModularBalancedRandIter
 Random field base element generator. More...
class  ModularCrookedRandIter
 Random field base element generator. More...
class  ModularRandIter
 Random field base element generator. More...
class  NonzeroRandIter
 Random iterator for nonzero random numbers. 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  UnparametricRandIter
 Unparameterized random field element generator template. 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  RingEnvelope
 implement the ring archetype to minimize code bloat. More...
class  GivPolynomialRing
 Polynomials. More...
class  PowerOfTwoModular
 Ring of elements modulo some power of two. More...
class  RingInterface
 This ring base class exists solely to aid documentation organization. More...
struct  HybridSpecifier
 HybridSpecifier. More...
struct  BlackboxSpecifier
 BlackboxSpecifier. More...
struct  EliminationSpecifier
 EliminationSpecifier. More...
struct  Method
 Method specifiers for controlling algorithm choice. 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...
class  BooleanSwitch
 Boolean switch object. More...
class  BooleanSwitchFactory
 Boolean switch factory. More...
class  CekstvSwitch
 Butterfly switch object from preconditioner paper. More...
class  CekstvSwitchFactory
 Cekstv switch factory. More...
class  Commentator
 Give information to user during runtime. More...
class  PreconditionFailed
 A precondtion failed. More...
class  LinboxError
 base class for execption handling in Givaro. More...
class  FieldAXPY
 FieldAXPY object. More...
class  MatrixStreamReader
 An abstract base class to represent readers for specific formats. More...
class  MatrixStream
 MatrixStream. More...
class  PrimeStream
 Prime number stream. More...
class  BitVector
 Binary constant defined both for 32 and 64 bits. More...
class  ReverseVector
 Reverse vector class This class wraps an existing vector type and reverses its direction. 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...

Typedefs

typedef Givaro::Integer integer
 Integers in LinBox.

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...
enum  FileFormatTag
 tags for SparseMatrixBase::read() and write()

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.
template<class Field , class Vector , class Blackbox >
Vector & 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.
template<class Field , class Vector , class Blackbox >
Vector & 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.
template<class Field , class Vector , class Blackbox >
Vector & 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.
template<class Field , class Matrix , class Vector >
Vector & solve (const Matrix &A, Vector &x, const Vector &b, const Field &F, const BlasEliminationTraits &traits)
 Solve Ax=b over field F using Gaussian elimination.
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.
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.
template<class Field >
size_t NullSpaceBasis (const Field &F, const LinBoxTag::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.
template<class Field >
size_t & NullSpaceBasis (const Field &F, const LinBoxTag::Side Side, BlasMatrix< typename Field::Element > &A, BlasMatrix< typename Field::Element > &Ker, size_t &kerdim)
 Nullspace of a dense matrix on a finite field.
template<class Field >
size_t & NullSpaceBasis (const Field &F, const LinBoxTag::Side Side, const BlasMatrix< typename Field::Element > &A, BlasMatrix< typename Field::Element > &Ker, size_t &kerdim)
 Nullspace of a dense matrix on a finite field.
template<class Field >
void Zero (const Field &F, typename Field::Element *Z, const size_t ldZ, const size_t lig1, const size_t col1, const size_t lig2, const size_t col2)
template<class Field >
void Identity (const Field &F, typename Field::Element *Id, const size_t ldI, const size_t lig1, const size_t col1, const size_t lig2, const size_t col2)
 Creates identity matrix in F of size dim1 x dim2.
template<class Field >
Field::Element * RightNullspaceDirect (const Field &F, typename Field::Element *A, const size_t &M, const size_t &N, const size_t &lda, size_t &ker_dim)
 The right or left nullspace (kernel or cokernel) of a matrix A We use the LU decomposition.
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.
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.
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.
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.
template<class Ring , class ItMatrix >
void ApplyBound (const Ring &R, typename Ring::Element &bound_A, const ItMatrix &A)
 ApplyBound.
template<class Prime >
bool checkBlasPrime (const Prime p)
 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
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
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
template<>
NTL::zz_p & Caster (NTL::zz_p &x, const integer &y)
 Initialization of field element from an integer.
template<>
integerCaster (integer &x, const NTL::zz_p &y)
 Conversion of field element to an integer.
template<class T >
std::ostream & operator<< (std::ostream &o, const BlasMatrix< T > &Mat)
 Write a matrix to a stream.
template<class T >
std::ostream & operator<< (std::ostream &o, const BlasSubmatrix< T > &Mat)
 Write a matrix to a stream.
void RandomBlasPermutation (BlasPermutation< size_t > &P)
template<class Blackbox , class Polynomial , class MyMethod >
Polynomial & charpoly (Polynomial &P, const Blackbox &A, const MyMethod &M)
 ...using an optional Method parameter
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::BlasElimination &M)
 Compute the characteristic polynomial over $\mathbf{Z}_p$.
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$.
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.
template<class Field >
Field::Element & detin (typename Field::Element &d, BlasBlackbox< Field > &A)
 Rank of Blackbox A.
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 Blackbox , class MyMethod >
bool isPositiveDefinite (const Blackbox &A, const MyMethod &M)
 Compute the isPositiveDefinite of A.
template<class Blackbox , class MyMethod >
bool isPositiveSemiDefinite (const Blackbox &A, const MyMethod &M)
 Compute the isPositiveSemiDefinite of A.
template<class Blackbox , class Polynomial , class MyMethod >
Polynomial & minpoly (Polynomial &P, const Blackbox &A, const MyMethod &M)
 ...using an optional Method parameter
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.
template<class Blackbox >
unsigned long & rank (unsigned long &r, const Blackbox &A)
 Compute the rank of a linear transform A over a field.
template<class Matrix >
unsigned long & rankin (unsigned long &r, Matrix &A)
 Rank of A.
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.
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().
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, BlasBlackbox< 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.
template<class Vector , class Blackbox , class SolveMethod >
Vector & solve (Vector &x, const Blackbox &A, const Vector &b, const SolveMethod &M)
 Solve Ax = b, for x.
template<class Vector , class BB >
Vector & solve (Vector &x, const BB &A, const Vector &b, const Method::Elimination &m)
template<class Vector , class Ring >
Vector & solve (Vector &x, typename Ring::Element &d, const BlasBlackbox< 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, typename Vector< Ring >::SparseSeq > &A, const Vect &b, const RingCategories::IntegerTag tag, Method::Dixon &m)
 solver specialization with the 2nd API and DixonTraits over integer (no copying)
template<class BB >
BB::Field::Element & trace (typename BB::Field::Element &t, const BB &A)
 Sum of the eigenvalues.
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.
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.
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.
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 & Caster (NTL::RR &x, const integer &y)
 Initialization of field element from an integer.
template<>
NTL::RR & Caster (NTL::RR &x, const double &y)
 Initialization of field element from an integer.
template<>
NTL::RR & Caster (NTL::RR &x, const int &y)
 Initialization of field element from an integer.
template<>
NTL::RR & Caster (NTL::RR &x, const long int &y)
 Initialization of field element from an integer.
template<>
integerCaster (integer &x, const NTL::RR &y)
 Conversion of field element to an integer.
template<>
integerCaster (integer &x, const NTL::ZZ_p &y)
 Conversion of field element to an integer.
template<>
double & Caster (double &x, const NTL::ZZ_p &y)
 Conversion of field element to an integer.
template<>
NTL::ZZ_p & Caster (NTL::ZZ_p &x, const integer &y)
 Initialization of field element from an integer.
template<>
NTL::ZZ_p & Caster (NTL::ZZ_p &x, const double &y)
 Conversion of field element to an integer.
template<>
NTL::ZZ_p & Caster (NTL::ZZ_p &x, const int &y)
 Conversion of field element to an integer.
template<>
NTL::ZZ_p & Caster (NTL::ZZ_p &x, const unsigned long &y)
 Conversion of field element to an integer.
template<>
NTL::ZZ_p & Caster (NTL::ZZ_p &x, const unsigned int &y)
 Conversion of field element to an integer.

Detailed Description

Namespace in which all linbox code resides.

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.

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 NullSpaceBasis ( const Field F,
const LinBoxTag::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.
size_t & NullSpaceBasis ( const Field F,
const LinBoxTag::Side  Side,
BlasMatrix< typename Field::Element > &  A,
BlasMatrix< typename Field::Element > &  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:
this is slow : use a constructor from Ker ?
Todo:
this is slow : use a constructor from Ker ?
size_t& LinBox::NullSpaceBasis ( const Field F,
const LinBoxTag::Side  Side,
const BlasMatrix< typename Field::Element > &  A,
BlasMatrix< typename Field::Element > &  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
void LinBox::Zero ( const Field F,
typename Field::Element *  Z,
const size_t  ldZ,
const size_t  lig1,
const size_t  col1,
const size_t  lig2,
const size_t  col2 
)
Parameters:
F
Z
ldZ
lig1
col1
lig2
col2
void LinBox::Identity ( const Field F,
typename Field::Element *  Id,
const size_t  ldI,
const size_t  lig1,
const size_t  col1,
const size_t  lig2,
const size_t  col2 
)

Creates identity matrix in F of size dim1 x dim2.

Warning:
diag_num peut ĂȘtre < 0 !
Bug:
long et size_t ne cohabitent pas bien.
Field::Element* LinBox::RightNullspaceDirect ( const Field F,
typename Field::Element *  A,
const size_t &  M,
const size_t &  N,
const size_t &  lda,
size_t &  ker_dim 
)

The right or left nullspace (kernel or cokernel) of a matrix A We use the LU decomposition.

Parameters:
Fthe field in which A lives
Ais a matrix whose nullspace we look for.
Mnumber of lines in A
Nnumber of column of A
ldathe leading dimension of matrix A
ker_dimthe dimension of the kernel
Template Parameters:
Field-
Returns:
a matrix of leading dimension ker_dim whose column vectors span the nullspace of A. Returns NULL (and not $\mathbf{0}$) if ker_dim == 0 .
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> LinBox::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
NTL::zz_p& LinBox::Caster ( NTL::zz_p &  x,
const integer &  y 
)

Initialization of field element from an integer.

This Uses NTL's to_zz_p function.

Returns:
reference to field element.
Parameters:
xfield element to contain output (reference returned).
yinteger.
integer& LinBox::Caster ( integer &  x,
const NTL::zz_p &  y 
)

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:
xreference to integer to contain output (reference returned).
yconstant reference to field element.
NTL::RR& LinBox::Caster ( NTL::RR &  x,
const integer &  y 
)

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. For now, this is done by converting the integer type to a C++ long and then to the element type through the use of static cast and NTL's to_RR 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 field element.
Parameters:
xfield element to contain output (reference returned).
yinteger.
NTL::RR& LinBox::Caster ( NTL::RR &  x,
const double &  y 
)

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. For now, this is done by converting the integer type to a C++ long and then to the element type through the use of static cast and NTL's to_RR 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 field element.
Parameters:
xfield element to contain output (reference returned).
yinteger.
NTL::RR& LinBox::Caster ( NTL::RR &  x,
const int &  y 
)

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. For now, this is done by converting the integer type to a C++ long and then to the element type through the use of static cast and NTL's to_RR 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 field element.
Parameters:
xfield element to contain output (reference returned).
yinteger.
NTL::RR& LinBox::Caster ( NTL::RR &  x,
const long int &  y 
)

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. For now, this is done by converting the integer type to a C++ long and then to the element type through the use of static cast and NTL's to_RR 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 field element.
Parameters:
xfield element to contain output (reference returned).
yinteger.
integer& LinBox::Caster ( integer &  x,
const NTL::RR &  y 
)

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:
xreference to integer to contain output (reference returned).
yconstant reference to field element.
integer& LinBox::Caster ( integer &  x,
const NTL::ZZ_p &  y 
)

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:
xreference to integer to contain output (reference returned).
yconstant reference to field element.
double& LinBox::Caster ( double &  x,
const NTL::ZZ_p &  y 
)

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:
xreference to integer to contain output (reference returned).
yconstant reference to field element.
NTL::ZZ_p& LinBox::Caster ( NTL::ZZ_p &  x,
const double &  y 
)

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:
xreference to integer to contain output (reference returned).
yconstant reference to field element.
NTL::ZZ_p& LinBox::Caster ( NTL::ZZ_p &  x,
const int &  y 
)

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:
xreference to integer to contain output (reference returned).
yconstant reference to field element.
NTL::ZZ_p& LinBox::Caster ( NTL::ZZ_p &  x,
const unsigned long &  y 
)

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:
xreference to integer to contain output (reference returned).
yconstant reference to field element.
NTL::ZZ_p& LinBox::Caster ( NTL::ZZ_p &  x,
const unsigned int &  y 
)

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:
xreference to integer to contain output (reference returned).
yconstant reference to field element.
std::ostream& LinBox::operator<< ( std::ostream &  o,
const BlasMatrix< T > &  Mat 
)

Write a matrix to a stream.

The C++ way using operator<<

Parameters:
ooutput stream
Mmatrix to write.
std::ostream& LinBox::operator<< ( std::ostream &  o,
const BlasSubmatrix< T > &  Mat 
)

Write a matrix to a stream.

The C++ way using operator<<

Parameters:
ooutput stream
Mmatrix to write.
void RandomBlasPermutation ( BlasPermutation< size_t > &  P)
Todo:
To be factorized.
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::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
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::isPositiveSemiDefinite ( const Blackbox &  A,
const MyMethod &  M 
)

Compute the isPositiveSemiDefinite of A.

The isPositiveSemiDefinite 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 isPositiveSemiDefinite
Mmay be a Method::Hybrid (SemiDefault), Method::Blackbox, Method::Elimination, or of other method type.
Polynomial& LinBox::minpoly ( Polynomial &  P,
const Blackbox &  A,
const MyMethod &  M 
)

...using an optional Method parameter

Parameters:
P- the output minimal 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 minpoly 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.
unsigned long& LinBox::rankin ( unsigned long &  r,
Matrix A 
) [inline]

Rank of A.

A may be modified

Parameters:
Amatrix
rrank
Examples:
examples/smithvalence.C.
Vector& LinBox::solve ( Vector &  x,
const BB &  A,
const Vector &  b,
const Method::Elimination &  m 
)
Todo:
temporary - fix this
BB::Field::Element& LinBox::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