linbox
|
Namespace in which all linbox code resides. More...
Namespaces | |
GetEntryTags | |
limited doc so far. | |
IndexedTags | |
limited doc so far | |
MatrixHom | |
Limited doc so far. Used in RationalSolver. | |
Protected | |
This is the namespace all LinBox internal code is in. | |
RingCategories | |
some basic information about each field or ring. | |
TraceTags | |
undocumented | |
VectorWrapper | |
limited doc so far. | |
Data Structures | |
class | algoException |
Algorithmic exception. More... | |
class | BadInputException |
The input is not as expected. More... | |
class | BitVector |
Binary constant defined both for 32 and 64 bits. More... | |
class | BlackboxArchetype |
showing the member functions provided by all blackbox matrix classes. More... | |
class | BlackboxBlockContainer |
no doc. More... | |
class | BlackboxBlockContainerBase |
A base class for BlackboxBlockContainer. More... | |
class | BlackboxBlockContainerRecord |
no doc. More... | |
class | BlackboxContainer |
Limited doc so far. 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 | BlackboxFactory |
A tool for computations with integer and rational matrices. More... | |
struct | BlackboxSpecifier |
BlackboxSpecifier. More... | |
class | BlasMatrix |
Dense matrix representation. More... | |
class | BlasMatrix< MultiModDouble > |
No Doc. More... | |
class | BlasMatrixDomain |
Interface for all functionnalities provided for BlasMatrix. More... | |
class | BlasMatrixDomainAddin |
C += A. More... | |
class | BlasMatrixDomainInv< MultiModDouble, BlasMatrix< MultiModDouble > > |
specialisation for MultiModDouble. More... | |
class | BlasMatrixDomainSubin |
C -= A. More... | |
class | BlasPermutation |
Lapack-style permutation. More... | |
class | BlasSubmatrix |
Dense Submatrix representation. More... | |
class | BlockHankelLiftingContainer |
Block Hankel LiftingContianer. More... | |
class | BlockLanczosSolver |
Block Lanczos iteration. More... | |
class | BlockMasseyDomain |
Compute the linear generator of a sequence of matrices. More... | |
class | BlockRing |
Elements are wrapped BlasMatrix objects. More... | |
class | BlockWiedemannLiftingContainer |
Block Wiedemann LiftingContianer. More... | |
class | BooleanSwitch |
Boolean switch object. More... | |
class | BooleanSwitchFactory |
Boolean switch factory. More... | |
class | Butterfly |
Switching Network based BlackBox Matrix. More... | |
class | CekstvSwitch |
Butterfly switch object from preconditioner paper. More... | |
class | CekstvSwitchFactory |
Cekstv switch factory. More... | |
struct | ChineseRemainder |
Wrapper around OMP/SEQ version of ChineseRemainderXXX<CRABase>. More... | |
struct | ChineseRemainderSeq |
No doc. More... | |
struct | ClassifyRing |
Default ring category. More... | |
class | Commentator |
Give information to user during runtime. More... | |
struct | Companion |
Companion matrix of a monic polynomial. More... | |
class | Compose |
Blackbox of a product: ![]() ![]() | |
class | Compose< _Blackbox, _Blackbox > |
specialization for _Blackbox1 = _Blackbox2 More... | |
class | ComposeOwner |
Blackbox of a product: ![]() ![]() | |
class | ComposeTraits |
used in ..., for example More... | |
class | ComposeTraits< BlasMatrix< Field > > |
used in smith-binary, for example More... | |
class | ConstantVectorStream |
Constant vector factory. More... | |
struct | CRASpecifier |
CRASpecifier. More... | |
struct | CRATraits |
Solve using CRA (iterations uses SolveMethod) More... | |
class | DenseContainer |
Limited doc so far. More... | |
class | DenseRowsMatrix |
Dense row-wise matrix container. 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::SparseAssociativeVectorTag > |
Specialization of Diagonal for application to sparse associative vectors. More... | |
class | Diagonal< _Field, VectorCategories::SparseSequenceVectorTag > |
Specialization of Diagonal for application to sparse sequence vectors. More... | |
class | Dif |
Blackbox of a difference: C := A - B , i.e Cx = Ax - Bx . More... | |
class | DiophantineSolver |
DiophantineSolver<QSolver> creates a diophantine solver using a QSolver to generate rational solutions. More... | |
class | DirectSum |
If C = DirectSum(A, B) and y = xA and z = wB, then (y,z) = (x,w)C. More... | |
class | DixonLiftingContainer |
Dixon Lifting Container. More... | |
class | DotProductDomain< Modular< uint16_t > > |
Specialization of DotProductDomain for unsigned short modular field. More... | |
class | DotProductDomain< Modular< uint32_t > > |
Specialization of DotProductDomain for uint32_t modular field. More... | |
class | DotProductDomain< Modular< uint8_t > > |
Specialization of DotProductDomain for unsigned short modular field. More... | |
class | DotProductDomain< ModularBalanced< double > > |
Specialization of DotProductDomain. More... | |
struct | EarlyMultipCRA |
NO DOC. More... | |
struct | EarlySingleCRA |
NO DOC. More... | |
class | EchelonFormDomain |
Echelon form domain. 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... | |
struct | EliminationSpecifier |
EliminationSpecifier. More... | |
class | Eliminator |
Elimination system. More... | |
class | Exception |
This is the exception class in LinBox. More... | |
class | FieldAbstract |
field base class. More... | |
class | FieldArchetype |
field specification and archetypical instance. More... | |
class | FieldAXPY |
FieldAXPY object. More... | |
class | FieldAXPY< Modular< _Element > > |
Specialization of FieldAXPY for parameterized modular field. More... | |
class | FieldAXPY< Modular< uint16_t > > |
Specialization of FieldAXPY for uint16_t modular field. More... | |
class | FieldAXPY< Modular< uint32_t > > |
Specialization of FieldAXPY for unsigned short modular field. More... | |
class | FieldAXPY< Modular< uint8_t > > |
Specialization of FieldAXPY for uint8_t modular field. More... | |
class | FieldAXPY< ModularBalanced< double > > |
Specialization of FieldAXPY. More... | |
class | FieldAXPY< UnparametricField< integer > > |
NO DOc. More... | |
class | FieldEnvelope |
Derived class used to implement the field archetypeHelps to minimize code bloat. More... | |
class | FieldInterface |
This field base class exists solely to aid documentation organization. More... | |
class | FieldIO |
Dummy field for conceptually unclear io. More... | |
struct | FieldTraits |
FieldTrait. More... | |
struct | FullMultipBlasMatCRA |
NO DOC. More... | |
struct | FullMultipCRA |
NO DOC... More... | |
struct | FullMultipFixedCRA |
Chinese Remaindering Algorithm for multiple residues. More... | |
class | GaussDomain |
Repository of functions for rank by elimination on sparse matrices. More... | |
class | GivaroExtension |
This template class is defined to be in phase with the LinBox archetype. More... | |
class | GivaroExtension< LinBox::GivaroGfq > |
This template class is define just to be in phase with the LinBox archetype. 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... | |
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 | GivaroGfq |
Wrapper of Givaro's GFqDom<int32_t> class. More... | |
class | GivaroMontg |
wrapper of Givaro's Givaro::Montgomery< Givaro::Std32>. More... | |
struct | GivaroRnsFixedCRA |
NO DOC... More... | |
class | GivaroZpz |
wrapper of Givaro's ZpzDom. More... | |
class | GivPolynomialRing |
Polynomials. More... | |
class | GmpRandomPrime |
generating random prime integers, using the gmp library. More... | |
class | GMPRationalElement |
elements of GMP_Rationals. More... | |
class | Hilbert |
Example of a blackbox that is space efficient, though not time efficient. More... | |
class | Hilbert_JIT_Entry |
The object needed to build a Hilbert matrix as a JIT matrix. 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 | Hom< BaseField, GivaroExtension< BaseField > > |
NO DOC. More... | |
struct | HybridSpecifier |
HybridSpecifier. More... | |
struct | IMLTraits |
IML wrapper. More... | |
class | InconsistentSystem |
Exception thrown when the system to be solved is inconsistent. More... | |
class | indexDomain |
Class used for permuting indices. More... | |
class | InvalidMatrixInput |
Exception class for invalid matrix input. More... | |
class | Inverse |
A Blackbox for the inverse. More... | |
class | IrrecuperableException |
Something bad an unexpected happened. More... | |
class | JIT_Matrix |
Example of a blackbox that is space efficient, though not time efficient. More... | |
class | LABlockLanczosSolver |
Biorthogonalising block Lanczos iteration. More... | |
class | LanczosSolver |
Solve a linear system using the conjugate Lanczos iteration. More... | |
class | LargeDouble |
NO DOC. More... | |
class | LastInvariantFactor |
This is used in a Smith Form algorithm. More... | |
class | latticeMethod |
NTL methods. More... | |
class | LidiaGfq |
defines the Galois Field GF(pk). More... | |
class | LinboxError |
base class for execption handling in LinBox More... | |
struct | LinBoxTag |
Structure for tags. More... | |
struct | Local2_32 |
Fast arithmetic mod 2^32, including gcd. More... | |
class | LQUPMatrix |
LQUP factorisation. More... | |
class | MasseyDomain |
Berlekamp/Massey algorithm. More... | |
class | MatrixArchetype |
Directly-represented matrix archetype. More... | |
class | MatrixBlackbox |
Matrix black box. More... | |
struct | MatrixCategories |
For specializing matrix arithmetic. More... | |
class | MatrixDomain |
Class of matrix arithmetic functions. More... | |
class | MatrixDomain< GF2 > |
Specialization of MatrixDomain for GF2. More... | |
class | MatrixPermutation |
Permutation classique. More... | |
class | MatrixRank |
Compute the rank of an integer matrix in place over a finite field by Gaussian elimination. More... | |
class | MatrixStream |
MatrixStream. More... | |
class | MatrixStreamReader |
An abstract base class to represent readers for specific formats. More... | |
struct | Method |
Method specifiers for controlling algorithm choice. More... | |
class | MGBlockLanczosSolver |
Block Lanczos iteration. More... | |
class | Modular |
Prime fields of positive characteristic implemented directly in LinBox. More... | |
class | Modular< double > |
Standard representation of ![]() | |
class | Modular< int16_t > |
Specialization of Modular to short element type with efficient dot product. 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< int8_t > |
Specialization of Modular to signed 8 bit element type with efficient dot product. More... | |
class | Modular< uint16_t > |
Specialization of class Modular for uint16_t element type. More... | |
class | Modular< uint32_t > |
Specialization of class Modular for uint32_t element type. More... | |
class | Modular< uint8_t > |
Allows compact storage when the modulus is less than 2^8. More... | |
class | ModularBalanced< double > |
Centered representation of ![]() | |
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 | MoorePenrose |
Generalized inverse of a blackbox. More... | |
class | MVProductDomain |
Helper class to allow specializations of certain matrix-vector products. More... | |
class | MVProductDomain< Modular< uint16_t > > |
Specialization of MVProductDomain for uint16_t modular field. More... | |
class | MVProductDomain< Modular< uint32_t > > |
Specialization of MVProductDomain for uint32_t modular field. More... | |
class | MVProductDomain< Modular< uint8_t > > |
Specialization of MVProductDomain for uint8_t modular field. More... | |
class | NoHomError |
Error object for attempt to establish a Hom that cannot exist. More... | |
class | NonzeroRandIter |
Random iterator for nonzero random numbers. More... | |
class | NotImplementedYetException |
Not implemented yet. More... | |
struct | NTL_PID_zz_p |
extend Wrapper of zz_p from NTL. More... | |
class | NTL_ZZ |
the integer ring. More... | |
struct | NTL_zz_p |
long ints modulo a positive integer. More... | |
struct | NTL_ZZ_p |
Wrapper of zz_p from NTL. More... | |
class | NTL_zz_pE |
zz_pE Define a parameterized class to easily handle UnparametricField<NTL::zz_pE> field 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_pE_Initialiser |
use ZZ_pEBak mechanism too ? 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_pX |
Ring (in fact, a unique factorization domain) of polynomial with coefficients in class NTL_ZZ_p (integers mod a wordsize prime). More... | |
class | NullMatrix |
This is a representation of the 0 by 0 empty matrix which does not occupy memory. More... | |
class | OneInvariantFactor |
Limited doc so far. More... | |
class | ParamFuzzy |
Abstract parameterized field of "fuzzy" doubles. More... | |
class | Permutation |
size is n. More... | |
class | PID_double |
NO DOC. More... | |
class | PID_integer |
Domain for integer operations. More... | |
class | PIR_ntl_ZZ_p |
extend Wrapper of ZZ_p from NTL. More... | |
class | PlotData |
The raw data to plot. More... | |
class | PlotGraph |
The graph. More... | |
class | PlotStyle |
Represents a table of values to plot. 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 | 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 | PowerOfTwoModular |
Ring of elements modulo some power of two. More... | |
class | PreconditionFailed |
A precondition failed. More... | |
class | PrimeStream |
Prime number stream. 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 | RandomDenseMatrix |
Random Dense Matrix builder. 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 | RandomIntegerIter |
Random Integer Iterator. More... | |
class | RandomIntegerIterator |
Random Prime Generator. More... | |
class | RandomPrimeIter |
Random Prime Iterator. More... | |
class | RandomPrimeIterator |
Random Prime Generator. 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::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 | RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseSequenceVectorTag > |
Specialization of RandomSparseStream for sparse sequence vectors. More... | |
struct | RankBuilder |
random method for constructing rank More... | |
class | RationalReconstruction |
Limited doc so far. More... | |
struct | RationalRemainder |
Chinese remainder of rationals. More... | |
struct | RationalRemainder2 |
Chinese remainder of rationals. More... | |
class | RationalSolver |
Interface for the different specialization of p-adic lifting based solvers. More... | |
class | RationalSolver< Ring, Field, RandomPrime, BlockHankelTraits > |
Block Hankel. 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, SparseEliminationTraits > |
Sparse LU. More... | |
class | RationalSolver< Ring, Field, RandomPrime, WanTraits > |
solver using a hybrid Numeric/Symbolic computation. More... | |
class | RationalSolver< Ring, Field, RandomPrime, WiedemannTraits > |
Partial specialization of p-adic based solver with Wiedemann algorithm. More... | |
struct | RawVector |
Canonical vector types. More... | |
struct | Rebind |
used in support of Hom, MatrixHom More... | |
struct | Rebind< std::vector< T >, U > |
Rebind. More... | |
class | ReverseVector |
Reverse vector class This class wraps an existing vector type and reverses its direction. 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 | RingInterface |
This ring base class exists solely to aid documentation organization. More... | |
class | RNS |
RNS. More... | |
class | ScalarMatrix |
Blackbox for aI . More... | |
class | SigmaBasis |
implementation of ![]() | |
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 | 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... | |
struct | SolverTraits |
Solver traits. More... | |
class | Sparse_Vector |
vector< Pair<T,I> > and actualsize More... | |
class | SparseLULiftingContainer |
SparseLULiftingContainer. More... | |
class | SparseMatrix |
vector of sparse rows. More... | |
class | SparseMatrixBase |
Sparse matrix container This class acts as a generic row-wise container for sparse matrices. 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 | StandardBasisStream |
Stream for ![]() | |
class | StandardBasisStream< Field, _Vector, VectorCategories::DenseVectorTag > |
Specialization of standard basis stream for dense 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 | StandardBasisStream< Field, _Vector, VectorCategories::SparseSequenceVectorTag > |
Specialization of standard basis stream for sparse sequence vectors. More... | |
class | Subiterator |
Subvector iterator class provides striding iterators. 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 | Subvector |
Dense subvectorThis class provides a statically sized subvector of a random access container (such as std::vector, deque). More... | |
class | Sum |
blackbox of a matrix sum without copying. More... | |
class | SumOwner |
blackbox of a matrix sum without copying. More... | |
class | Sylvester |
This is a representation of the Sylvester matrix of two polynomials. More... | |
class | TernaryLattice |
NO DOC. 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 | TransposedBlasMatrix |
TransposedBlasMatrix. More... | |
class | TransposedBlasMatrix< TransposedBlasMatrix< Matrix > > |
TransposedBlasMatrix. More... | |
class | TransposeMatrix |
Matrix transpose. More... | |
class | TransposeOwner |
transpose matrix without copying. More... | |
class | TriangularBlasMatrix |
Triangular BLAS matrix. More... | |
class | TriplesBB |
wrapper for NAG Sparse Matrix format. More... | |
class | UnparametricRandIter |
Unparameterized random field element generator template. More... | |
class | UnparametricRandIter< NTL::ZZ_p > |
Constructor for random field element generator. More... | |
struct | Vector |
Vector ?? More... | |
struct | VectorCategories |
List of vector categories. More... | |
class | VectorFraction |
VectorFraction<Domain> is a vector of rational elements with common reduced denominator. More... | |
class | VectorStream |
Vector factory. More... | |
struct | VectorTraits |
Vector traits template structure. More... | |
class | WiedemannLiftingContainer |
Wiedemann LiftingContianer. More... | |
class | WiedemannSolver |
Linear system solvers based on Wiedemann's method. More... | |
class | ZeroOne |
Time and space efficient representation of sparse {0,1}-matrices. More... | |
class | ZeroOne< GF2 > |
Time and space efficient representation of sparse matrices over GF2. More... | |
class | ZOQuad |
A class of striped or block-decomposed zero-one matrices. More... | |
Typedefs | |
typedef Givaro::Integer | integer |
Integers in LinBox. More... | |
Enumerations |
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 > | |
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. More... | |
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. More... | |
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. More... | |
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. 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 | 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 . More... | |
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. More... | |
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. More... | |
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 . More... | |
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. More... | |
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... | |
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... | |
double | naturallog (const Givaro::Integer &a) |
Natural logarithm (ln). More... | |
template<class T > | |
std::ostream & | operator<< (std::ostream &o, const BlasMatrix< T > &Mat) |
Write a matrix to a stream. More... | |
template<class T > | |
std::ostream & | operator<< (std::ostream &o, const BlasSubmatrix< T > &Mat) |
Write a matrix to a stream. More... | |
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 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::BlasElimination &M) |
Compute the characteristic polynomial over ![]() | |
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 ![]() | |
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 Blackbox , class MyMethod > | |
bool | isPositiveDefinite (const Blackbox &A, const MyMethod &M) |
Compute the isPositiveDefinite of A. More... | |
template<class Blackbox , class MyMethod > | |
bool | isPositiveSemiDefinite (const Blackbox &A, const MyMethod &M) |
Compute the isPositiveSemiDefinite of A. More... | |
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 Matrix > | |
unsigned long & | rankin (unsigned long &r, Matrix &A) |
Rank of A . 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 & | 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 ![]() | |
unsigned long & | rankin (unsigned long &r, GaussDomain< GF2 >::Matrix &A, const RingCategories::ModularTag &, const Method::SparseElimination &M) |
specialization to ![]() | |
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 > | |
Vector & | solve (Vector &x, const Blackbox &A, const Vector &b, const SolveMethod &M) |
Solve Ax = b, for x. More... | |
template<class Vector , class Blackbox > | |
Vector & | solve (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 , 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... | |
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 > | |
Vector & | solve (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 > | |
Vector & | solve (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 > | |
Vector & | solve (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 > | |
Vector & | solve (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, typename Vector< Ring >::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 > | |
Vector & | solve (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, 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) | |
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.
enum SolveResult |
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.
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.
A | Black box matrix of the system |
x | Place to store solution vector |
b | Right-hand side |
u | Vector in which to store certificate of inconsistency, if required |
F | Field over which to perform computations |
traits | SolverTraits structure with user-specified parameters |
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.
A | Black box matrix of the system |
x | Place to store solution vector |
b | Right-hand side |
F | Field over which to perform computations |
traits | SolverTraits structure with user-specified parameters |
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.
A | Black box matrix of the system |
x | Place to store solution vector |
b | Right-hand side |
F | Field over which to perform computations |
traits | SolverTraits structure with user-specified parameters |
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.
A | Black box matrix of the system |
x | Place to store solution vector |
b | Right-hand side |
F | Field over which to perform computations |
traits | SolverTraits structure with user-specified parameters |
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.
A | Black box matrix of the system |
x | Place to store solution vector |
b | Right-hand side |
u | Place to store certificate of inconsistency |
F | Field over which to perform computations |
traits | SolverTraits structure with user-specified parameters |
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.
F | Field |
Side | left or right from LinBox::SideTag |
m | rows |
n | cols |
A | input matrix |
lda | leading dimension of A |
Ker | Kernel. NULL if kerdim==0 |
ldk | leading dimension of the kernel. |
kerdim | dimension of the kernel. |
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.
F | field | |
Side | SideTag::Left or SideTag::Right nullspace. | |
[in,out] | A | Input matrix |
[out] | Ker | Nullspace of the matrix (Allocated in the routine) |
[out] | kerdim | rank of the kernel |
kerdim
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.
F | field | |
Side | SideTag::Left or SideTag::Right nullspace. | |
[in] | A | Input matrix |
[out] | Ker | Nullspace of the matrix (Allocated in the routine) |
[out] | kerdim | rank of the kernel |
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 | ||
) |
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
.
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.
F | the field in which A lives |
A | is a matrix whose nullspace we look for. |
M | number of lines in A |
N | number of column of A |
lda | the leading dimension of matrix A |
ker_dim | the dimension of the kernel |
Field | - |
NULL
(and not 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')
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]
|
inline |
NO DOC !
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
|
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.
x | vector of booleans marking elements to switch into contiguous block |
j | offset of contiguous block |
|
inline |
Natural logarithm (ln).
log(2) being close to 0.69314718055994531
a | integer. |
|
inline |
Positiveness of an integer.
Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.
x | integer |
true
iff x>=0
.
|
inline |
Positiveness of an integer.
Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.
x | integer |
true
iff x>=0
.
|
inline |
Positiveness of an integer.
Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.
x | integer |
true
iff x>=0
.
|
inline |
Positiveness of an integer.
Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.
x | integer |
true
iff x>=0
.
|
inline |
Positiveness of an integer.
Essentially usefull in debug mode to avoid compiler warnings about comparison always true for some unsigned type.
x | integer |
true
iff x>=0
. std::ostream& LinBox::operator<< | ( | std::ostream & | o, |
const BlasMatrix< T > & | Mat | ||
) |
Write a matrix to a stream.
The C++
way using operator<<
o | output stream |
Mat | matrix to write. |
std::ostream& LinBox::operator<< | ( | std::ostream & | o, |
const BlasSubmatrix< T > & | Mat | ||
) |
Write a matrix to a stream.
The C++ way using operator<<
o | output stream |
Mat | matrix to write. |
void RandomBlasPermutation | ( | BlasPermutation< size_t > & | P | ) |
Polynomial& LinBox::charpoly | ( | Polynomial & | P, |
const Blackbox & | A, | ||
const MyMethod & | M | ||
) |
...using an optional Method parameter
P | - the output characteristic polynomial. If the polynomial is of degree d, this random access container has size d+1, the 0-th entry is the constant coefficient and the d-th is 1 since the charpoly is monic. |
A | - a blackbox matrix Optional |
M | - the method object. Generally, the default object suffices and the algorithm used is determined by the class of M. Basic methods are Method::Blackbox, Method::Elimination, and Method::Hybrid (the default). See methods.h for more options. |
Polynomial& LinBox::charpoly | ( | Polynomial & | P, |
const Blackbox & | A, | ||
const RingCategories::ModularTag & | tag, | ||
const Method::BlasElimination & | M | ||
) |
Compute the characteristic polynomial over .
Compute the characteristic polynomial of a matrix using dense elimination methods
P | Polynomial where to store the result |
A | Blackbox 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 .
Compute the characteristic polynomial of a matrix, represented via a blackBox.
P | Polynomial where to store the result |
A | Blackbox 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.
A | Black box of which to compute the isPositiveDefinite |
M | may 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.
A | Black box of which to compute the isPositiveSemiDefinite |
M | may be a Method::Hybrid (SemiDefault), Method::Blackbox, Method::Elimination, or of other method type. |
|
inline |
Rank of A
.
A
may be modified
A | matrix |
r | rank |
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.
[out] | x | solution |
[in] | A | matrix |
[in] | b | target |
[in] | M | method to use ( |
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 | ||
) |
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).
|
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.
F | Field in which arithmetic is done |
n | integer number of elements in vector |
r | Random field element generator |