linbox
|
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 | GetEntryTags |
limited doc so far. | |
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 ![]() | |
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: ![]() ![]() | |
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: ![]() ![]() | |
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 archetypeHelps 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 ![]() | |
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 ![]() | |
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 ![]() | |
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<> | |
integer & | Caster (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 ![]() | |
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. | |
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 ![]() | |
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, 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<> | |
integer & | Caster (integer &x, const NTL::RR &y) |
Conversion of field element to an integer. | |
template<> | |
integer & | Caster (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. |
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]
bool LinBox::checkBlasPrime | ( | const Prime | p | ) | [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
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.
x | vector of booleans marking elements to switch into contiguous block |
j | offset 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.
x | field element to contain output (reference returned). |
y | integer. |
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.
x | reference to integer to contain output (reference returned). |
y | constant 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.
x | field element to contain output (reference returned). |
y | integer. |
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.
x | field element to contain output (reference returned). |
y | integer. |
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.
x | field element to contain output (reference returned). |
y | integer. |
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.
x | field element to contain output (reference returned). |
y | integer. |
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.
x | reference to integer to contain output (reference returned). |
y | constant 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.
x | reference to integer to contain output (reference returned). |
y | constant 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.
x | reference to integer to contain output (reference returned). |
y | constant 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.
x | reference to integer to contain output (reference returned). |
y | constant 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.
x | reference to integer to contain output (reference returned). |
y | constant 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.
x | reference to integer to contain output (reference returned). |
y | constant 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.
x | reference to integer to contain output (reference returned). |
y | constant 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<<
o | output stream |
M | 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 |
M | 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. |
Polynomial& LinBox::minpoly | ( | Polynomial & | P, |
const Blackbox & | A, | ||
const MyMethod & | M | ||
) |
...using an optional Method parameter
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. |
unsigned long& LinBox::rankin | ( | unsigned long & | r, |
Matrix & | A | ||
) | [inline] |
Vector& LinBox::solve | ( | Vector & | x, |
const BB & | A, | ||
const Vector & | b, | ||
const Method::Elimination & | 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).
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.
F | Field in which arithmetic is done |
n | integer number of elements in vector |
r | Random field element generator |