LinBox Namespace Reference

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

Namespaces
namespace	BLAS2
namespace	BLAS3
namespace	Exceptions
	Exception class for invalid matrix input.
namespace	FFT_utils
namespace	IndexedTags
	limited doc so far
namespace	IteratorCategories
	Information about the type of Prime Iterator.
namespace	MatrixHom
	Limited doc so far. Used in DixonSolver.
namespace	Protected
	This is the namespace all LinBox internal code is in.
namespace	Rank
	Rank of the system, if known.
namespace	RingCategories
	some basic information about each field or ring.
namespace	Shape
	Flags decribing the shape of the matrix.
namespace	SolutionTags
namespace	SparseFileFormat
	Sparse matrix format (file storage)
namespace	SparseMatrixFormat
	Sparse matrix format (memory storage)
namespace	Tag
	Structure for tags.
namespace	VectorWrapper
	limited doc so far.

Data Structures
struct	_LU_
struct	_Rank_update_
class	AbnormalHelper
class	AbnormalHelper< Givaro::Modular< double > >
class	AbnormalHelper< Givaro::Modular< uint64_t > >
class	AbnormalMatrix
class	ActivityState
	used by commentator More...
class	algoException
	Algorithmic exception. More...
class	AlgorithmMetaData
	Algorithm metadata;. More...
class	AltBlackboxBlockContainer
class	BadInputException
	The input is not as expected. More...
struct	BB
class	BBcharpoly
	BlackBox Characteristic Polynomial. More...
class	BenchmarkFile
class	BenchmarkMetaData
	Benchmark metadata;. 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
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...
class	BlackboxInterface
	This blackbox base class exists solely to aid documentation organization. More...
class	BlackboxSymmetrizeIterator
class	BlasApply
class	BlasMatrix
	Dense matrix representation. More...
class	BlasMatrixApplyDomain
class	BlasMatrixDomain
	Interface for all functionnalities provided for BlasMatrix. More...
class	BlasMatrixDomainAdd
class	BlasMatrixDomainAddin
	C += A. More...
class	BlasMatrixDomainCharpoly
class	BlasMatrixDomainCopy
class	BlasMatrixDomainDet
class	BlasMatrixDomainDet< TriangularBlasMatrix< Matrix > >
class	BlasMatrixDomainInv
class	BlasMatrixDomainLeftSolve
class	BlasMatrixDomainLeftSolve< BlasSubvector< Vect >, TriangularBlasMatrix< Matrix > >
class	BlasMatrixDomainLeftSolve< BlasVector< typename Matrix::Field >, TriangularBlasMatrix< Matrix > >
class	BlasMatrixDomainLeftSolve< Matrix1, TriangularBlasMatrix< Matrix2 >, Matrix3 >
class	BlasMatrixDomainMinpoly
class	BlasMatrixDomainMul
class	BlasMatrixDomainMul< Matrix1, BlasPermutation< size_t >, Matrix2 >
class	BlasMatrixDomainMul< Matrix1, BlasPermutation< size_t >, TriangularBlasMatrix< Matrix2 > >
class	BlasMatrixDomainMul< Matrix1, Matrix2, BlasPermutation< size_t > >
class	BlasMatrixDomainMul< Matrix1, Matrix2, TransposedBlasMatrix< BlasPermutation< size_t > > >
class	BlasMatrixDomainMul< Matrix1, Matrix2, TriangularBlasMatrix< Matrix3 > >
class	BlasMatrixDomainMul< Matrix1, TransposedBlasMatrix< BlasPermutation< size_t > >, Matrix2 >
class	BlasMatrixDomainMul< Matrix1, TriangularBlasMatrix< Matrix2 >, BlasPermutation< size_t > >
class	BlasMatrixDomainMul< Matrix1, TriangularBlasMatrix< Matrix2 >, TriangularBlasMatrix< Matrix3 > >
class	BlasMatrixDomainMul< Matrix1, TriangularBlasMatrix< Matrix3 >, Matrix2 >
class	BlasMatrixDomainMulAdd
struct	BlasMatrixDomainMulAdd_specialized
struct	BlasMatrixDomainMulAdd_specialized< Matrix1, Matrix2, Matrix3, Matrix4, ContainerCategories::Matrix, ContainerCategories::Matrix >
struct	BlasMatrixDomainMulAdd_specialized< Vector1, Vector2, Matrix, Vector3, ContainerCategories::Matrix, ContainerCategories::Vector >
struct	BlasMatrixDomainMulAdd_specialized< Vector1, Vector2, Vector3, Matrix, ContainerCategories::Vector, ContainerCategories::Matrix >
class	BlasMatrixDomainMulin
class	BlasMatrixDomainMulin< BlasVector< Field >, BlasPermutation< size_t > >
class	BlasMatrixDomainMulin< BlasVector< Field >, TransposedBlasMatrix< BlasPermutation< size_t > > >
class	BlasMatrixDomainMulin< Matrix, BlasPermutation< size_t > >
class	BlasMatrixDomainMulin< Matrix, TransposedBlasMatrix< BlasPermutation< size_t > > >
class	BlasMatrixDomainMulin< Matrix1, TransposedBlasMatrix< TriangularBlasMatrix< Matrix2 > > >
class	BlasMatrixDomainMulin< Matrix1, TriangularBlasMatrix< Matrix2 > >
class	BlasMatrixDomainRank
class	BlasMatrixDomainRightSolve
class	BlasMatrixDomainRightSolve< BlasSubvector< Vect >, TriangularBlasMatrix< Matrix > >
class	BlasMatrixDomainRightSolve< BlasVector< typename Matrix::Field >, TriangularBlasMatrix< Matrix > >
class	BlasMatrixDomainRightSolve< Matrix1, TriangularBlasMatrix< Matrix3 >, Matrix2 >
class	BlasMatrixDomainSub
class	BlasMatrixDomainSubin
	C -= A. More...
class	BlasMatrixIndexedIterator
class	BlasMatrixIterator
class	BlasMatrixtoSlicedPolynomialMatrix
class	BlasPermutation
	Lapack-style permutation. More...
class	BlasSubmatrix
class	BlasSubvector
class	BlasVector
class	BlockBB
	converts a black box into a block black box More...
class	BlockCompose
	Blackbox of a product: \(C = AB\), i.e \(Cx \gets A(Bx)\). More...
class	BlockCoppersmithDomain
	Compute the linear generator of a sequence of matrices. More...
class	BlockHankel
class	BlockHankelInverse
class	BlockHankelLiftingContainer
	Block Hankel LiftingContianer. More...
class	BlockHankelTag
class	BlockLanczosSolver
	Block Lanczos iteration. More...
class	BlockMasseyDomain
	Compute the linear generator of a sequence of matrices. More...
class	BlockToeplitz
class	BlockWiedemannLiftingContainer
	Block Wiedemann LiftingContianer. More...
class	BlockWiedemannSolver
struct	Boolean_Trait
struct	Boolean_Trait< false >
struct	Boolean_Trait< true >
class	BooleanSwitch
	Boolean switch object. More...
class	BooleanSwitchFactory
class	Butterfly
	Switching Network based BlackBox Matrix. More...
class	CekstvSwitch
	The default butterfly switch object. More...
class	CekstvSwitchFactory
struct	ChineseRemainder
	No doc. More...
struct	ChineseRemainderParallel
struct	ChineseRemainderSequential
	No doc. More...
class	Chrono
class	ClassicMaxQRationalReconstruction
class	ClassicMulDomain
class	ClassicRationalReconstruction
struct	ClassifyRing
	Default ring category. More...
struct	ClassifyRing< GF2 >
struct	ClassifyRing< Givaro::GFqDom< XXX > >
struct	ClassifyRing< Givaro::Modular< Element, Compute > >
struct	ClassifyRing< Givaro::Modular< Element, Compute > const >
struct	ClassifyRing< Givaro::ModularBalanced< Element > >
struct	ClassifyRing< Givaro::QField< Givaro::Rational > >
struct	ClassifyRing< Givaro::ZRing< Givaro::Integer > >
struct	ClassifyRing< GMPRationalField >
struct	ClassifyRing< Local2_32 >
struct	ClassifyRing< LocalPIRModular< intType > >
struct	ClassifyRing< MultiModDouble >
struct	ClassifyRing< NTL_PID_zz_p >
struct	ClassifyRing< NTL_RR >
struct	ClassifyRing< NTL_ZZ >
struct	ClassifyRing< NTL_ZZ_p >
struct	ClassifyRing< NTL_zz_p >
struct	ClassifyRing< PIR_ntl_ZZ_p >
struct	ClassifyRing< PIRModular< int32_t > >
struct	ClassifyRing< UnparametricRandIter< NTL::GF2E > >
struct	ClassifyRing< UnparametricRandIter< NTL::ZZ_pE > >
struct	ClassifyRing< UnparametricRandIter< NTL::zz_pE > >
struct	ClassifyRing< UnparametricRandIter< NTL::zz_pEX > >
struct	ClassifyRing< UnparametricRandIter< NTL::zz_pX > >
class	Commentator
	Give information to user during runtime. More...
class	Communicator
struct	Companion
	Companion matrix of a monic polynomial. More...
class	Compose
	Blackbox of a product: \(C = AB\), i.e \(Cx \gets A(Bx)\). More...
class	ComposeOwner
	Blackbox of a product: \(C = AB\), i.e \(Cx \gets A(Bx)\). More...
class	ComposeTraits
	used in ..., for example More...
class	ComposeTraits< BlasMatrix< Field, Rep > >
	used in smith-binary, for example More...
class	ConstantVectorStream
	Constant vector factory. More...
struct	ConstSubMatIterator
struct	ContainerCategories
	used to separate BLAS2 and BLAS3 operations More...
struct	ContainerTraits
	Trait for the Category. More...
struct	ContainerTraits< BlasMatrix< _Field, _Rep > >
struct	ContainerTraits< BlasSubmatrix< _Matrix > >
struct	ContainerTraits< BlasSubvector< _Vector > >
struct	ContainerTraits< BlasVector< _Field, _Storage > >
struct	ContainerTraits< SparseMatrix< _Field, SparseMatrixFormat::COO > >
struct	ContainerTraits< SparseMatrix< _Field, SparseMatrixFormat::CSR > >
struct	ContainerTraits< SparseMatrix< _Field, SparseMatrixFormat::ELL > >
struct	ContainerTraits< SparseMatrix< _Field, SparseMatrixFormat::ELL_R > >
struct	ContainerTraits< TransposedBlasMatrix< _Matrix > >
class	CoppersmithDeterminant
class	CoppersmithInvariantFactors
class	CoppersmithRank
class	CoppersmithSolver
struct	CRABuilderEarlyMultip
	NO DOC. More...
struct	CRABuilderEarlySingle
	Heuristic Chinese Remaindering with early termination. More...
struct	CRABuilderFullMultip
	Chinese remaindering of a vector of elements without early termination. More...
struct	CRABuilderFullMultipFixed
	Chinese Remaindering Algorithm for multiple residues. More...
struct	CRABuilderFullMultipMatrix
	NO DOC. More...
struct	CRABuilderFullSingle
	Chinese Remaindering with full precision and no chance of failure. More...
struct	CRABuilderProbSingle
	Chinese Remaindering with guaranteed probability bound and early termination. More...
struct	CRABuilderSingleBase
	Abstract base class for CRA builders. More...
struct	CRABuilderVarPrecEarlyMultip
struct	CRABuilderVarPrecEarlySingle
struct	CRAResidue
	Type information for the residue in a CRA iteration. More...
struct	CRAResidue< Integer, Function >
	Type information for the residue in a CRA iteration. More...
struct	CRAResidue< std::vector< Integer >, Function >
	Type information for the residue in a CRA iteration. More...
class	CSDate
class	CSDouble
class	CSF
	Space efficient representation of sparse matrices. More...
class	CSInt
class	CSString
class	CSValue
struct	DataSeries
	this structure holds a bunch of timings. More...
class	DenseContainer
	Limited doc so far. More...
class	DenseMat
	to be used in standard matrix domain More...
class	DensePolynomial
	Dense Polynomial representation using Givaro. More...
class	DenseReader
struct	DenseSubVectorChooser
struct	DenseVectorChooser
struct	DenseVectorChooser< GF2 >
struct	DetCategory
struct	DetCategory< ScalarMatrix< Field > >
struct	DetCategory< Toeplitz< Field, PD > >
class	Diagonal
	Random diagonal matrices are used heavily as preconditioners. More...
class	Diagonal< GF2, VectorTraits< Vector< GF2 >::Dense >::VectorCategory >
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	DirectSumOwner
class	DixonLiftingContainer
	Dixon Lifting Container. More...
class	DixonSolver
	Interface for the different specialization of p-adic lifting based solvers. More...
class	DixonSolver< Ring, Field, RandomPrime, Method::BlockHankel >
	Block Hankel. More...
class	DixonSolver< Ring, Field, RandomPrime, Method::BlockWiedemann >
	partial specialization of p-adic based solver with block Wiedemann algorithm. More...
class	DixonSolver< Ring, Field, RandomPrime, Method::DenseElimination >
	partial specialization of p-adic based solver with Dixon algorithm. More...
class	DixonSolver< Ring, Field, RandomPrime, Method::SparseElimination >
	Sparse LU. More...
class	DixonSolver< Ring, Field, RandomPrime, Method::SymbolicNumericNorm >
	solver using a hybrid Numeric/Symbolic computation. More...
class	DixonSolver< Ring, Field, RandomPrime, Method::Wiedemann >
	Partial specialization of p-adic based solver with Wiedemann algorithm. More...
struct	dotp
class	DotProductDomain
class	DotProductDomain< GF2 >
class	DotProductDomain< Givaro::Modular< double > >
class	DotProductDomain< Givaro::Modular< float > >
class	DotProductDomain< Givaro::Modular< int16_t > >
class	DotProductDomain< Givaro::Modular< int32_t, Compute > >
class	DotProductDomain< Givaro::Modular< int64_t, Compute_t > >
class	DotProductDomain< Givaro::Modular< int8_t > >
class	DotProductDomain< Givaro::Modular< uint16_t, Compute_t > >
	Specialization of DotProductDomain for unsigned short modular field. More...
class	DotProductDomain< Givaro::Modular< uint32_t, Compute_t > >
	Specialization of DotProductDomain for uint32_t modular field. More...
class	DotProductDomain< Givaro::Modular< uint64_t, Compute_t > >
	Specialization of DotProductDomain for uint64_t modular field. More...
class	DotProductDomain< Givaro::Modular< uint8_t, Compute_t > >
	Specialization of DotProductDomain for unsigned short modular field. More...
class	DotProductDomain< Givaro::ModularBalanced< double > >
	Specialization of DotProductDomain. More...
class	DotProductDomain< Givaro::ModularBalanced< float > >
class	DotProductDomain< Givaro::ModularBalanced< int32_t > >
class	DotProductDomain< Givaro::ModularBalanced< int64_t > >
class	DotProductDomain< PIR_ntl_ZZ_p >
class	DotProductDomain< PIRModular< int32_t > >
struct	EarlyTerm
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	Eliminator
	Elimination system. More...
class	EnvironmentMetaData
	Environment metadata;. More...
class	Exception
	This is the exception class in LinBox. More...
class	FastMaxQRationalReconstruction
class	FastRationalReconstruction
class	FflasCsr
class	FFT
class	FFT_base
class	FFT_base< Field, Simd, typename std::enable_if< Field::is_elt_floating_point_v &&Simd::template is_same_element< Field >::value >::type >
class	FFT_base< Field, Simd, typename std::enable_if< Field::is_elt_integral_v &&Simd::template is_same_element< Field >::value >::type >
class	FFT_multi
class	FFT_multi_base
class	FFT_multi_base< Field, Simd, typename std::enable_if< Field::is_elt_floating_point_v &&Simd::template is_same_element< Field >::value >::type >
class	FFT_multi_base< Field, Simd, typename std::enable_if< Field::is_elt_integral_v &&Simd::template is_same_element< Field >::value >::type >
class	FFTMulDomain
struct	FFTSimdHelper
struct	FIBB
struct	FIBBProduct
class	FieldAbstract
	field base class. More...
class	FieldArchetype
	field specification and archetypical instance. More...
class	FieldAXPY
	FieldAXPY object. More...
class	FieldAXPY< Givaro::Modular< double > >
class	FieldAXPY< Givaro::Modular< float > >
class	FieldAXPY< Givaro::Modular< int16_t > >
class	FieldAXPY< Givaro::Modular< int32_t, Compute > >
class	FieldAXPY< Givaro::Modular< int64_t, Compute_t > >
class	FieldAXPY< Givaro::Modular< int8_t > >
class	FieldAXPY< Givaro::Modular< uint16_t, Compute_t > >
	Specialization of FieldAXPY for uint16_t modular field. More...
class	FieldAXPY< Givaro::Modular< uint32_t, Compute_t > >
	Specialization of FieldAXPY for unsigned short modular field. More...
class	FieldAXPY< Givaro::Modular< uint64_t, Compute_t > >
	Specialization of FieldAXPY for unsigned short modular field. More...
class	FieldAXPY< Givaro::Modular< uint8_t, Compute_t > >
	Specialization of FieldAXPY for uint8_t modular field. More...
class	FieldAXPY< Givaro::ModularBalanced< double > >
	Specialization of FieldAXPY. More...
class	FieldAXPY< Givaro::ModularBalanced< float > >
class	FieldAXPY< Givaro::ModularBalanced< int32_t > >
class	FieldAXPY< Givaro::ModularBalanced< int64_t > >
class	FieldAXPY< NTL_ZZ >
class	FieldAXPY< PIR_ntl_ZZ_p >
class	FieldAXPY< PIRModular< int32_t > >
class	FieldDocumentation
	This field base class exists solely to aid documentation organization. More...
class	FieldEnvelope
	Derived class used to implement the field archetype. More...
class	FieldMetaData
	Field metadata. More...
struct	FieldTraits
	FieldTrait. More...
class	FixedPrimeIterator
	Adaptor class to make a single prime number behave like a PrimeIterator. More...
class	Frobenius
class	FrobeniusLarge
class	FrobeniusSmall
class	GaussDomain
	Repository of functions for rank by elimination on sparse matrices. More...
class	GaussDomain< GF2 >
class	GeneratorMetaData
	Generator metadata;. More...
class	GenericRandIter
	Random field base element generator. More...
struct	GetEntryCategory
	GetEntryCategory is specialized for BB classes that offer a local getEntry. More...
struct	GetEntryCategory< Diagonal< Field, Trait > >
struct	GetEntryCategory< Protected::SparseMatrixGeneric< A, B > >
struct	GetEntryCategory< Protected::SparseMatrixGeneric< A, B, C > >
struct	GetEntryCategory< ScalarMatrix< Field > >
struct	GetEntryCategory< ZeroOne< GF2 > >
class	GF2
class	GF2RandIter
struct	GivaroRnsFixedCRA
	NO DOC... More...
class	GmpRandomPrime
	generating random prime integers, using the gmp library. More...
class	GMPRationalElement
	elements of GMP_Rationals. More...
class	GMPRationalField
class	GMPRationalRandIter
class	Grid
class	GridElement
struct	HadamardLogBoundDetails
class	HalflineMPDomain
class	Hankel
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 ring More...
class	Hom< _Source, Givaro::ZRing< Integer > >
class	Hom< Givaro::QField< Givaro::Rational >, _Target >
class	Hom< Givaro::QField< Givaro::Rational >, Givaro::QField< Givaro::Rational > >
class	Hom< Givaro::ZRing< Integer >, _Target >
class	Hom< Givaro::ZRing< Integer >, Givaro::ZRing< Integer > >
class	Hom< Givaro::ZRing< Integer >, Local2_32 >
class	Hom< NTL_zz_pX, NTL_zz_pE >
class	Hom< PolynomialRing, PolynomialLocalX< PolynomialRing > >
class	Hom< Source, Source >
class	ijElement
class	InconsistentSystem
	Exception thrown when the system to be solved is inconsistent. More...
class	indexDomain
	Class used for permuting indices. More...
struct	IndexedCategory
	Trait to show whether or not the BB class has a Indexed iterator. More...
struct	IndexedCategory< BlasMatrix< Field, _Rep > >
struct	IndexedCategory< LambdaSparseMatrix< Field, Row > >
struct	IndexedCategory< SparseMatrix< Field, Row > >
struct	IndexedCategory< SparseMatrix< Field, SparseMatrixFormat::COO > >
struct	IndexedCategory< SparseMatrix< Field, SparseMatrixFormat::CSR > >
struct	IndexedCategory< SparseMatrix< Field, SparseMatrixFormat::ELL > >
struct	IndexedCategory< SparseMatrix< Field, SparseMatrixFormat::ELL_R > >
struct	IntegerDoubleDetIteration
struct	IntegerModularCharpoly
struct	IntegerModularDet
struct	IntegerModularDetReduced
struct	IntegerModularMinpoly
struct	IntegerModularValence
class	InvariantFactors
class	Inverse
	A Blackbox for the inverse. More...
class	InvertTextbookDomain
	Assumes that Field is a field, not a ring. More...
class	IrrecuperableException
	Something bad an unexpected happened. More...
struct	is_blockbb
struct	is_blockbb< BlockBB< _BB > >
struct	is_blockbb< BlockCompose< A, B > >
struct	is_blockbb< FflasCsr< Field > >
struct	is_blockbb< PascalBlackbox< Field > >
struct	is_blockbb< SparseMatrix< Field, SparseMatrixFormat::TPL > >
struct	is_blockbb< SparseMatrix< Field, SparseMatrixFormat::TPL_omp > >
struct	isTransposed
struct	isTransposed< TransposedBlasMatrix< M > >
struct	isTransposed< TransposedBlasMatrix< TransposedBlasMatrix< M > > >
class	JIT_Matrix
	example of a blackbox that is space efficient, though not time efficient. More...
class	JIT_RandomEntryGenerator
class	KaratsubaMulDomain
class	LABlockLanczosSolver
	Biorthogonalising block Lanczos iteration. More...
class	LambdaSparseMatrix
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...
struct	LazyProduct
class	LidiaGfqRandIter
class	LiftingContainer
class	LiftingContainerBase
struct	LightContainer
class	LinboxBadFormat
class	LinBoxError
class	LinboxError
	base class for execption handling in LinBox More...
class	LinBoxFailure
class	LinboxMathDivZero
class	LinboxMathError
class	LinboxMathInconsistentSystem
struct	Local2_32
	Fast arithmetic mod 2^32, including gcd. More...
class	LocalPIRModular
struct	Map
class	MapleReader
class	MaskedPrimeIterator
	Masked Prime Iterator. More...
class	MasseyDomain
	Berlekamp/Massey algorithm. More...
class	MatrixApplyDomain
class	MatrixApplyDomain< Domain, BlasMatrix< Domain > >
class	MatrixArchetype
	Directly-represented matrix archetype. More...
class	MatrixBlackbox
	Matrix black box. More...
struct	MatrixCategories
	For specializing matrix arithmetic. More...
struct	MatrixContainerCategory
class	MatrixContainerTrait
	NODOC. More...
class	MatrixContainerTrait< BlasMatrix< Field, Rep > >
class	MatrixContainerTrait< BlasMatrix< MultiModDouble > >
class	MatrixContainerTrait< BlasSubmatrix< _Matrix > >
class	MatrixContainerTrait< const BlasMatrix< Field, Rep > >
class	MatrixContainerTrait< const BlasSubmatrix< _Matrix > >
class	MatrixContainerTrait< SparseMatrix< Field, Storage > >
class	MatrixDomain
	Class of matrix arithmetic functions. More...
class	MatrixDomain< GF2 >
	Specialization of MatrixDomain for GF2. More...
class	MatrixDomain< SlicedField< _Field, _WordT > >
class	MatrixEltPointer
	Dense Submatrix representation. More...
class	MatrixEltPointer< const _Matrix >
struct	MatrixHomTrait
	try to map a blackbox over a homorphic ring The most suitable type More...
struct	MatrixHomTrait< BlasMatrix< Ring, typename Vector< Ring >::Dense >, Field >
struct	MatrixHomTrait< SparseMatrix< Ring, SparseMatrixFormat::SparseMap >, Field >
struct	MatrixHomTrait< SparseMatrix< Ring, SparseMatrixFormat::SparsePar >, Field >
struct	MatrixHomTrait< SparseMatrix< Ring, SparseMatrixFormat::SparseSeq >, Field >
class	MatrixInverse
class	MatrixMarketReader
class	MatrixMetaData
	Matrix metadata. More...
class	MatrixPermutation
	Permutation classique. More...
class	MatrixStream
	MatrixStream. More...
class	MatrixStreamReader
	An abstract base class to represent readers for specific formats. More...
struct	MatrixTraits
	NO DOC. More...
struct	MatrixTraits< BlasMatrix< _Field, _Rep > >
struct	MatrixTraits< BlasSubmatrix< _Matrix > >
struct	MatrixTraits< const BlasMatrix< _Field, _Rep > >
struct	MatrixTraits< const BlasSubmatrix< _Matrix > >
struct	MatrixTraits< const DirectSum< BB1, BB2 > >
struct	MatrixTraits< const Protected::SparseMatrixGeneric< Field, Row, Trait > >
struct	MatrixTraits< const SparseMatrix< Field, SparseMatrixFormat::CSR > >
struct	MatrixTraits< const SparseMatrix< Field, SparseMatrixFormat::SparseMap > >
struct	MatrixTraits< const SparseMatrix< Field, SparseMatrixFormat::SparsePar > >
struct	MatrixTraits< const SparseMatrix< Field, SparseMatrixFormat::SparseSeq > >
struct	MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > >
struct	MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > >
struct	MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > >
struct	MatrixTraits< DirectSum< BB1, BB2 > >
struct	MatrixTraits< MatrixArchetype< Element > >
struct	MatrixTraits< Protected::SparseMatrixGeneric< Field, _Row > >
struct	MatrixTraits< Protected::SparseMatrixGeneric< Field, Row, Trait > >
struct	MatrixTraits< SparseMatrix< Field, SparseMatrixFormat::CSR > >
struct	MatrixTraits< SparseMatrix< Field, SparseMatrixFormat::SparseMap > >
struct	MatrixTraits< SparseMatrix< Field, SparseMatrixFormat::SparsePar > >
struct	MatrixTraits< SparseMatrix< Field, SparseMatrixFormat::SparseSeq > >
struct	MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > >
struct	MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > >
struct	MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > >
class	MersenneTwister
class	MessageClass
class	MetaData
	This is the general metadata class. More...
struct	MetaDataSeries
struct	Method
	Define which method to use when working on a system. More...
struct	MethodBase
	Holds everything a method needs to know about the problem. More...
class	MGBlockLanczosSolver
	Block Lanczos iteration. More...
class	MinPoly
class	MinPolyBlas
class	ModularCrooked
class	ModularCrookedRandIter
	Random field base element generator. More...
class	ModularNChooseK
class	ModularRandIter
class	MoorePenrose
	Generalized inverse of a blackbox. More...
struct	MTrandomInt
struct	MTrandomInt< 64 >
class	MulHelper
class	MultiModDouble
class	MultiModRandIter
class	MultiModRandomPrime
class	MVProductDomain
	Helper class to allow specializations of certain matrix-vector products. More...
class	MVProductDomain< Givaro::Modular< int16_t > >
class	MVProductDomain< Givaro::Modular< int32_t, Compute > >
class	MVProductDomain< Givaro::Modular< int64_t, Compute_t > >
class	MVProductDomain< Givaro::Modular< int8_t > >
class	MVProductDomain< Givaro::Modular< uint16_t, Compute_t > >
	Specialization of MVProductDomain for uint16_t modular field. More...
class	MVProductDomain< Givaro::Modular< uint32_t, Compute_t > >
	Specialization of MVProductDomain for uint32_t modular field. More...
class	MVProductDomain< Givaro::Modular< uint64_t, Compute_t > >
	Specialization of MVProductDomain for uint64_t modular field. More...
class	MVProductDomain< Givaro::Modular< uint8_t, Compute_t > >
	Specialization of MVProductDomain for uint8_t modular field. More...
class	MVProductDomain< PIR_ntl_ZZ_p >
class	MVProductDomain< PIRModular< int32_t > >
struct	MyIntegerModularCharpoly
struct	MyIntegerModularDet
struct	MyIntegerModularMinpoly
struct	MyModularCharpoly
struct	MyModularDet
struct	MyModularMinpoly
class	myQueue
struct	MyRationalModularCharpoly
struct	MyRationalModularDet
struct	MyRationalModularMinpoly
class	NoHomError
	Error object for attempt to establish a Hom that cannot exist. More...
class	NotImplementedYet
class	NotImplementedYetException
	Not implemented yet. More...
class	NTL_GF2E
class	NTL_GF2E_Initialiser
struct	NTL_PID_zz_p
	extend Wrapper of zz_p from NTL. More...
struct	NTL_RR
class	NTL_RR_Initialiser
class	NTL_ZZ
	the integer ring. More...
struct	NTL_ZZ_p
	Wrapper of zz_p from NTL. More...
struct	NTL_zz_p
	long ints modulo a positive integer. More...
class	NTL_ZZ_p_Initialiser
class	NTL_zz_p_Initialiser
class	NTL_ZZ_pE
	Wrapper of ZZ_pE from NTL Define a parameterized class to handle easily Givaro::ZRing<NTL::ZZ_pE> field. More...
class	NTL_zz_pE
	zz_pE Define a parameterized class to easily handle Givaro::ZRing<NTL::zz_pE> field More...
class	NTL_ZZ_pE_Initialiser
class	NTL_zz_pE_Initialiser
	use ZZ_pEBak mechanism too ? More...
class	NTL_zz_pEX
	Ring (in fact, a unique factorization domain) of polynomial with coefficients in class NTL_zz_p (integers mod a wordsize prime). More...
class	NTL_zz_pEX_Initialiser
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	NTL_ZZ_pX_Initialiser
class	NTL_zz_pX_Initialiser
class	NTL_ZZRandIter
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	OpCounter
class	OpenCLEnviron
	Container for all pertenant information needed to use an OpenCL device, compile kernels for the device, track resource usage, and gain exclusive access to the device. More...
class	OpenCLMatrixDomain
	Interface for all functionnalities provided for BlasMatrix using GPUs. More...
class	OpenCLMatrixDomainFactory
class	OpenCLResourceController
class	Optimizer
class	OrderBasis
class	OverUnder
class	ParamFuzzy
	Abstract parameterized field of "fuzzy" doubles. More...
class	ParamFuzzyRandIter
class	PascalBlackbox
class	Permutation
class	PIR_ntl_ZZ_p
	extend Wrapper of ZZ_p from NTL. More...
class	PIRModular
struct	PlainDomain
class	PlainMatrix
class	PlainSubmatrix
	to be used in reference matrix domain (PlainDomain). More...
class	PlotData
	The raw data to plot. More...
class	PlotGraph
	The graph (2D). More...
class	PlotStyle
	Represents a table of values to plot (2D). More...
class	PLUQMatrix
	PLUQ factorisation. More...
struct	Point
class	PolyDixonDomain
class	PolyInterpolation
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	PolynomialLocalX
class	PolynomialLocalX< NTL_zz_pEX >
class	PolynomialLocalX< NTL_zz_pX >
class	PolynomialMatrix
class	PolynomialMatrix< _Field, PMType::polfirst >
class	PolynomialMatrixAddDomain
class	PolynomialMatrixDomain
class	PolynomialMatrixFFTMulDomain
class	PolynomialMatrixFFTMulDomain< Givaro::Modular< integer > >
class	PolynomialMatrixFFTMulDomain< Givaro::Modular< RecInt::ruint< K >, RecInt::ruint< L > > >
class	PolynomialMatrixFFTMulDomain< Givaro::Modular< T1, T2 > >
class	PolynomialMatrixFFTMulDomain< Givaro::ZRing< integer > >
class	PolynomialMatrixFFTMulDomain< Givaro::ZRing< RecInt::ruint< K > > >
class	PolynomialMatrixFFTPrimeMulDomain
class	PolynomialMatrixKaraDomain
class	PolynomialMatrixMulDomain
class	PolynomialMatrixNaiveMulDomain
class	PolynomialMatrixThreePrimesFFTMulDomain
class	PolynomialMatrixtoSlicedPolynomialMatrix
class	PolynomialRing
	Polynomials. More...
class	PolySmithFormDomain
class	PolySmithFormLocalXDomain
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	PreconditionFailed
	A precondition failed. More...
struct	PreMap
class	PrimeIterator
	Prime Iterator. More...
class	PrimeSequence
	Adaptor class to make a fixed-length sequence behave like a PrimeIterator. More...
class	PrimeStream
	Prime number stream. More...
class	QMatrix
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	RandomDenseStreamGF2
class	RandomFFTPrime
class	RandomMatrix
class	RandomMatrixTraits
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	RandomSparseStreamGF2
struct	RankBuilder
	random method for constructing rank More...
struct	RankBuildMethod
struct	RankCategory
struct	RankCategory< ScalarMatrix< Field > >
struct	RationalChineseRemainder
	Chinese remainder of rationals. More...
struct	RationalChineseRemainderVarPrec
	Chinese remainder of vector of rationals. More...
struct	RationalCRABuilderEarlyMultip
struct	RationalCRABuilderEarlySingle
struct	RationalCRABuilderFullMultip
class	RationalMatrixFactory
class	RationalReconstruction
	Limited doc so far. More...
struct	RationalSolveHadamardBoundData
class	RationalSolverAdaptive
struct	RationalSolverAdaptiveClass
struct	RationalSolverAdaptiveClass< IRing, OutVector, Container< typename IRing::Element > >
class	RationalSolverSN
struct	RawVector
	Canonical vector types. More...
struct	RawVector< bool >
struct	Rebind
	used in support of Hom, MatrixHom More...
struct	Rebind< std::map< size_t, T >, U >
struct	Rebind< std::pair< std::vector< size_t >, std::vector< T > >, U >
struct	Rebind< std::vector< std::pair< size_t, T > >, U >
struct	Rebind< std::vector< T >, U >
	Rebind. More...
struct	Residue
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 interface 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	RNSfixed
struct	RReconstruction
class	RReconstructionBase
class	RReconstructionBase< Givaro::ZRing< Integer > >
class	ScalarMatrix
	Blackbox for aI. More...
class	SCompose
class	SemiDIteration
	CRA iteration to get a diagonal with the same signature. More...
struct	ShapeFlags
class	showProgression
	Show progression on the terminal (helper) More...
class	SideBySide
class	SigmaBasis
	implementation of \(\sigma\)-basis (minimal basis). More...
class	Signature
struct	SimdFFT
class	Sliced
	The Sliced Matrix class _Domain must be a GF(3) rep, BaseT must be an unsigned int type. More...
struct	SlicedBase
class	SlicedField
class	SlicedPolynomialMatrixAdd
class	SlicedPolynomialMatrixAddin
	C += A. More...
class	SlicedPolynomialMatrixMulKaratsuba
class	SlicedPolynomialMatrixMulToomCook
class	SlicedPolynomialMatrixSub
class	SlicedPolynomialMatrixSubin
	C -= A. More...
class	SlicedPolynomialMatrixtoBlasMatrix
class	SlicedPolynomialMatrixtoPolynomialMatrix
class	SlicedPolynomialMatrixVectorMulKaratsuba
class	SlicedPolynomialVectorAdd
class	SlicedPolynomialVectorAddin
	C += A. More...
class	SlicedPolynomialVectorSub
class	SlicedPolynomialVectorSubin
	C -= A. More...
class	SmithFormAdaptive
class	SmithFormBinary
	Compute Smith form. More...
class	SmithFormIliopoulos
	This is Iliopoulos' algorithm to diagonalize. More...
class	SmithFormKannanBachemDomain
class	SmithFormLocal
	Smith normal form (invariant factors) of a matrix over a local ring. More...
class	SmithFormLocal< Local2_32 >
class	SMSReader
class	SolveFailed
class	Sparse_Vector
	vector< Pair<T,I> > and actualsize More...
class	SparseLULiftingContainer
	SparseLULiftingContainer. More...
class	SparseMatrix
class	SparseMatrix< _Field, SparseMatrixFormat::COO >
	Sparse matrix, Coordinate storage. More...
class	SparseMatrix< _Field, SparseMatrixFormat::COO::implicit >
	Sparse matrix, Coordinate storage. More...
class	SparseMatrix< _Field, SparseMatrixFormat::CSR >
	Sparse matrix, Coordinate storage. More...
class	SparseMatrix< _Field, SparseMatrixFormat::ELL >
	Sparse matrix, Coordinate storage. More...
class	SparseMatrix< _Field, SparseMatrixFormat::ELL_R >
	Sparse matrix, Coordinate storage. More...
class	SparseMatrix< _Field, SparseMatrixFormat::HYB >
	Sparse matrix, Coordinate storage. More...
class	SparseMatrix< _Field, SparseMatrixFormat::SparseMap >
class	SparseMatrix< _Field, SparseMatrixFormat::SparsePar >
class	SparseMatrix< _Field, SparseMatrixFormat::SparseSeq >
class	SparseMatrix< Field_, SparseMatrixFormat::TPL >
	Sparse Matrix in Triples storage. More...
class	SparseMatrix< Field_, SparseMatrixFormat::TPL_omp >
	Sparse matrix representation which stores nonzero entries by i,j,value triples. More...
class	SparseMatrixDomain
class	SparseMatrixReadHelper
	Read helper. More...
class	SparseMatrixWriteHelper
	Write helper. More...
class	SparseMatrixWriteHelper< Protected::SparseMatrixGeneric< _Field, Row, VectorCategories::SparseParallelVectorTag > >
class	SparseRowReader
struct	SparseSequenceVectorPairLessThan
struct	SparseVectorTranslate
struct	SparseVectorTranslate< Field, SparseMatrixFormat::SparseMap >
struct	SparseVectorTranslate< Field, SparseMatrixFormat::SparsePar >
struct	SparseVectorTranslate< Field, SparseMatrixFormat::SparseSeq >
struct	SparseVectorTranslate< Field, typename Vector< Field >::SparseSeq >
class	SpecialFFTMulDomain
class	Squarize
	transpose matrix without copying. More...
class	StandardBasisStream
	Stream for \(e_1,\cdots,e_n\). More...
class	StandardBasisStream< Field, _Vector, VectorCategories::DenseVectorTag >
	Specialization of standard basis stream for dense vectors. More...
class	StandardBasisStream< Field, _Vector, VectorCategories::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	Stats
struct	stepper
class	StorageMetaData
	Storage metadata;. More...
class	Subiterator
	Subvector iterator class provides striding iterators. More...
struct	SubMatIterator
class	Submatrix
	leading principal minor of existing matrix without copying. More...
class	Submatrix< BlasMatrix< _Field >, VectorCategories::DenseVectorTag >
	Specialization for BlasMatrix. More...
class	SubmatrixAdapter
	Generic submatrix view adapter used internally in the OpenCLMatrixDomain. More...
class	SubmatrixOwner
class	SubmatrixOwner< Blackbox, VectorCategories::DenseVectorTag >
	Specialization for dense vectors. More...
class	SubMatrixTraits
class	SubMatrixTraits< BlasMatrix< Field > >
class	SubMatrixTraits< Submatrix< BlasMatrix< Field > > >
struct	SubPolyConst
struct	SubPolyConst< const MatPoly >
class	SubPolynomialMatrix
class	Subvector
	Dense subvector. 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	TestPolySmithFormUtil
class	TimeWatcher
	Helper. More...
class	Toeplitz
	This is the blackbox representation of a Toeplitz matrix. More...
class	Toeplitz< typename _PRing::CoeffField, _PRing >
	Specialization for when the field of matrix elements is the same as the coefficient field of the polynomial field. More...
class	ToeplitzBase
struct	TraceCategory
	Trait to show whether or not the BB class has a local trace function. More...
struct	TraceCategory< ScalarMatrix< Field > >
struct	TraceCategory< Toeplitz< Field, PD > >
class	Transpose
	transpose matrix without copying. More...
class	TransposeAugmentedSystem
class	TransposedBlasMatrix
	TransposedBlasMatrix. More...
class	TransposedBlasMatrix< BlasPermutation< I > >
class	TransposeMatrix
	Matrix transpose. More...
class	TransposeOwner
	transpose matrix without copying. More...
class	TriangularBlasMatrix
	Triangular BLAS matrix. More...
struct	TriangularFIBB
struct	TriplesBBTriple
struct	TriplesBlock
union	TriplesCoord
struct	TriplesDataBlock
union	TriplesSmallCoord
struct	UniqueSamplingTrait
	Whether a prime generator generates a sequence with non repeating numbers. More...
struct	UniqueSamplingTrait< IteratorCategories::DeterministicTag >
class	UnparametricRandIter
class	UnparametricRandIter< NTL::GF2E >
class	UnparametricRandIter< NTL::RR >
class	UnparametricRandIter< NTL::ZZ_p >
	Constructor for random field element generator. More...
class	UnparametricRandIter< NTL::ZZ_pE >
class	UnparametricRandIter< NTL::zz_pE >
class	UnparametricRandIter< NTL::zz_pEX >
class	UnparametricRandIter< NTL::zz_pX >
class	Valence
struct	Vector
	Vector ?? More...
struct	VectorCategories
	List of vector categories. More...
class	VectorDomain
class	VectorDomain< GF2 >
class	VectorDomainBase
class	VectorEltPointer
class	VectorEltPointer< const _Vector >
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...
struct	VectorTraits< BitVector >
struct	VectorTraits< BlasSubvector< _Vector > >
struct	VectorTraits< BlasVector< Field, _Rep > >
struct	VectorTraits< LightContainer< Element > >
struct	VectorTraits< LightContainer< std::pair< size_t, Element > > >
struct	VectorTraits< ReverseVector< Vector > >
struct	VectorTraits< std::deque< std::pair< size_t, Element > > >
struct	VectorTraits< std::list< std::pair< size_t, Element > > >
struct	VectorTraits< std::map< size_t, Element > >
struct	VectorTraits< std::pair< std::vector< size_t >, std::vector< Element > > >
struct	VectorTraits< std::vector< Element > >
struct	VectorTraits< std::vector< std::pair< size_t, Element > > >
struct	VectorTraits< Subvector< Iterator, ConstIterator > >
class	WeakPopovFormDomain
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	ZOQuad
	A class of striped or block-decomposed zero-one matrices. More...

Typedefs
typedef Givaro::Timer	CTimer
template<class CRABase>
using	ChineseRemainder = ChineseRemainderSequential<CRABase>
	Wrapper around PAR/SEQ version of ChineseRemainderXXX<CRABase>.
typedef Givaro::Modular< RecInt::ruint128, RecInt::ruint256 >	MYRECINT
typedef std::pair< Givaro::Integer, size_t >	PairIntRk
typedef ParamFuzzy	DoubleRealApproximation
typedef Givaro::Integer	integer
	Integers in LinBox.
typedef Givaro::Integer	Integer
typedef ptrdiff_t	index_t
template<class _Field>
using	DenseMatrix = BlasMatrix<_Field>
template<class _Field>
using	DenseSubmatrix = BlasSubmatrix<DenseMatrix<_Field> >
typedef uint64_t	Index
template<typename PIR>
using	SmithPair = std::pair<typename PIR::Element,size_t>
template<typename PIR>
using	SmithList = std::list<SmithPair<PIR>>
typedef Givaro::Timer	Timer
typedef Givaro::BaseTimer	BaseTimer
typedef Givaro::UserTimer	UserTimer
typedef Givaro::SysTimer	SysTimer
template<typename _Field>
using	DenseVector = typename DenseVectorChooser<_Field>::type
template<class _Field>
using	DenseSubvector = typename DenseSubVectorChooser<_Field>::type
typedef std::vector< MetaData >	mvector_t
typedef std::vector< double >	dvector_t
	vector of double
typedef std::vector< std::string >	svector_t
typedef std::vector< dvector_t >	dmatrix_t
	matrix of double
typedef std::vector< svector_t >	smatrix_t

Enumerations
enum struct	IterationResult { CONTINUE , SKIP , RESTART }
	Return type for CRA iteration. More...
enum	RReconstructionSchedule { INCREMENTAL , QUADRATIC , GEOMETRIC , CERTIFIED }
enum	ShiftStatus {   SHIFT_GROW , SHIFT_SHRINK , SHIFT_PEAK , SHIFT_SEARCH ,   SHIFT_MAX }
enum	SolverReturnStatus {   SS_OK , SS_FAILED , SS_SINGULAR , SS_INCONSISTENT ,   SS_BAD_PRECONDITIONER }
	define the different return status of the p-adic based solver's computation. More...
enum	SolverLevel { SL_MONTECARLO , SL_LASVEGAS , SL_CERTIFIED }
	Define the different strategy which can be used in the p-adic based solver. More...
enum	{ PRIVILEGIATE_NO_COLUMN_PIVOTING = 1 , PRIVILEGIATE_REDUCING_FILLIN = 2 , PRESERVE_UPPER_MATRIX = 4 }
enum	BBType {   diagonal , permutation , triangular , product ,   lqup , pluq , other }
enum	PMType { polfirst , matfirst , matrowfirst }
enum class	Singularity { Unknown , Singular , NonSingular }
	Singularity of the system. More...
enum class	Dispatch {   Auto , Sequential , SMP , Distributed ,   Combined }
	For integer-based methods that evaluate multiple times the system at different moduli, decides how to dispatch each sub-computations. More...
enum class	SingularSolutionType { Deterministic , Random , Diophantine }
	For Dixon method, which solution type to get when the system is singular. More...
enum class	Preconditioner {   None , Butterfly , Sparse , Toeplitz ,   Symmetrize , PartialDiagonal , PartialDiagonalSymmetrize , FullDiagonal ,   Dense }
	Preconditioner to ensure generic rank profile. More...
enum class	PivotStrategy { None , Linear }
	Pivoting strategy for elimination-based methods. More...
enum	MatrixStreamError {   GOOD , END_OF_MATRIX , END_OF_FILE , BAD_FORMAT ,   NO_FORMAT }

Functions
template<class Iterator, class Comparator>
void	bitonicSort (Iterator begin, Iterator end, const Comparator &comparator=Comparator())
template<class Iterator, class Comparator>
void	bitonicMerge (Iterator begin, Iterator end, const Comparator &comparator=Comparator())
template<class Domain, class Object>
void	BLTraceReport (std::ostream &out, Domain &D, const char *text, size_t iter, const Object &obj)
void	reportS (std::ostream &out, const std::vector< bool > &S, size_t iter)
template<class Field, class Matrix>
void	checkAConjugacy (const MatrixDomain< Field > &MD, const Matrix &AV, const Matrix &V, Matrix &T, size_t AV_iter, size_t V_iter)
template<class Field, class Coefficient>
void	write_maple (const Field &F, const std::vector< Coefficient > &P)
template<class Rationals, template< class > class Vector, class MyMethod>
Vector< typename Rationals::Element > &	rational_charpoly (Vector< typename Rationals::Element > &p, const BlasMatrix< Rationals > &A, const MyMethod &Met=Method::Auto())
template<class Polynomial, class Blackbox>
Polynomial &	cia (Polynomial &P, const Blackbox &A, const Method::DenseElimination &M)
	Algorithm computing the integer characteristic polynomial of a dense matrix.
uint64_t	primes_count (size_t pbits)
	Lower bound on number of b-bit primes.
template<class Field>
size_t &	NullSpaceBasisIn (const Tag::Side Side, BlasMatrix< Field > &A, BlasMatrix< Field > &Ker, size_t &kerdim)
	Nullspace of a dense matrix on a finite field.
template<class DenseMat>
size_t &	NullSpaceBasisIn (const Tag::Side Side, BlasSubmatrix< DenseMat > &A, BlasMatrix< typename DenseMat::Field > &Ker, size_t &kerdim)
template<class Field>
size_t &	NullSpaceBasis (const Tag::Side Side, const BlasMatrix< Field > &A, BlasMatrix< Field > &Ker, size_t &kerdim)
	Nullspace of a dense matrix on a finite field.
template<class DenseMat>
size_t &	NullSpaceBasis (const Tag::Side Side, const BlasSubmatrix< DenseMat > &A, BlasMatrix< typename DenseMat::Field > &Ker, size_t &kerdim)
template<class Field>
size_t	NullSpaceBasisIn (const Field &F, const Tag::Side Side, const size_t &m, const size_t &n, typename Field::Element *A, const size_t &lda, typename Field::Element *&Ker, size_t &ldk, size_t &kerdim)
	Computes the kernel of a dense matrix using LQUP.
template<class Blackbox>
Blackbox::Field::Element &	corrections (Blackbox &IntBB, typename Blackbox::Field::Element &f)
template<class Rationals, class MyMethod>
Rationals::Element &	rational_det (typename Rationals::Element &d, const BlasMatrix< Rationals > &A, const MyMethod &Met=Method::Auto())
template<class Matrix, class Vector, class Ring = typename Matrix::Field>
SolverReturnStatus	certifyEmpty (const Matrix &A, const Vector &b, const MethodBase &method, Integer &certifiedDenFactor)
template<class Field>
void	doubleDetModp (const Field &F, const size_t N, typename Field::Element &d1, typename Field::Element &d2, typename Field::Element *A, const size_t lda, typename Field::Element *b, const size_t incb, typename Field::Element *c, const size_t incc)
template<class BlackBox>
void	doubleDetGivenDivisors (const BlackBox &A, typename BlackBox::Field::Element &d1, typename BlackBox::Field::Element &d2, const typename BlackBox::Field::Element &s1, const typename BlackBox::Field::Element &s2, const bool proof)
template<class BlackBox>
void	doubleDet (typename BlackBox::Field::Element &d1, typename BlackBox::Field::Element &d2, const BlackBox &A, bool proof)
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 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>
int	dyadicToRational (const Ring &Z, BlasVector< Ring > &num, typename Ring::Element &den, BlasVector< Ring > &numx, typename Ring::Element &denx, typename Ring::Element &denBound)
std::ostream &	reportPermutation (std::ostream &out, const std::vector< std::pair< unsigned int, unsigned int > > &P)
template<class _Matrix>
bool	nextnonzero (size_t &k, size_t Ni, const _Matrix &A)
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 Domain, class Object>
void	LABLTraceReport (std::ostream &out, Domain &D, const char *text, size_t iter, const Object &obj)
void	LABLReportPriorityIndices (std::ostream &, std::list< size_t > &, const char *)
template<class Field, class LVector>
void	traceReport (std::ostream &out, VectorDomain< Field > &VD, const char *text, size_t iter, const LVector &v)
template<class Field, class LVector>
void	traceReport (std::ostream &out, const Field &F, const char *text, size_t iter, const typename Field::Element &a)
template<class Ring, class myMethod>
void	lllReduceIn (BlasMatrix< Ring > &H, const myMethod &meth=latticeMethod::latticeNTL_LLL())
template<class Ring, class myMethod>
void	lllReduceIn (BlasMatrix< Ring > &H, BlasMatrix< Ring > &U, const myMethod &meth=latticeMethod::latticeNTL_LLL())
template<class Ring, class myMethod>
void	lllReduce (BlasMatrix< Ring > &H, const BlasMatrix< Ring > &A, const myMethod &meth=latticeMethod::latticeNTL_LLL())
template<class Ring, class myMethod>
void	lllReduce (BlasMatrix< Ring > &H, BlasMatrix< Ring > &U, const BlasMatrix< Ring > &A, const myMethod &meth=latticeMethod::latticeNTL_LLL())
template<class Domain, class Object>
void	MGBLTraceReport (std::ostream &out, Domain &D, const char *text, size_t iter, const Object &obj)
template<class Rationals, template< class > class Vector, class MyMethod>
Vector< typename Rationals::Element > &	rational_minpoly (Vector< typename Rationals::Element > &p, const BlasMatrix< Rationals > &A, const MyMethod &Met=Method::Auto())
std::vector< cl_platform_id >	enumPlatforms ()
	Enumerate all of the platforms currently available on the system.
std::string	getPlatformName (cl_platform_id platform)
	Get the platform name associated with the platform.
double	getPlatformVersion (cl_platform_id platform)
	Get the platform version associated with the platform.
std::vector< std::string >	getPlatformExtensions (cl_platform_id platform)
	Get the platform extensions associated with the platform.
std::vector< cl_device_id >	enumDevices (cl_platform_id platform)
	Enumerate all of the devices currently available on the platform.
cl_context	createContext (cl_platform_id platform, cl_device_id device)
	Create an OpenCL context from a platfrom and device.
OpenCLResourceController &	accessOpenCLResourceController ()
template<class Field>
Givaro::Poly1Dom< Field, Givaro::Dense >::Element &	computePolyDet (typename Givaro::Poly1Dom< Field, Givaro::Dense >::Element &result, DenseMatrix< Givaro::Poly1Dom< Field, Givaro::Dense > > &A, int d)
int	roundUpPowerOfTwo (unsigned int n)
template<class Field, class Matrix>
Givaro::Poly1Dom< Field, Givaro::Dense >::Element &	computePolyDetExtension (typename Givaro::Poly1Dom< Field, Givaro::Dense >::Element &result, Field &F, Matrix &A)
template<typename Field>
bool	check_mul (const PolynomialMatrix< Field, PMType::matfirst > &c, const PolynomialMatrix< Field, PMType::matfirst > &a, const PolynomialMatrix< Field, PMType::matfirst > &b, size_t deg)
template<typename Field>
bool	check_mul (const PolynomialMatrix< Field, PMType::polfirst > &c, const PolynomialMatrix< Field, PMType::polfirst > &a, const PolynomialMatrix< Field, PMType::polfirst > &b, size_t deg)
template<typename MatrixP_F>
bool	check_midproduct (const MatrixP_F &c, const MatrixP_F &a, const MatrixP_F &b, bool smallLeft=true, size_t n0=0, size_t n1=0, size_t deg=0)
uint64_t	maxFFTPrimeValue (uint64_t k, uint64_t pts)
void	getFFTPrime (uint64_t prime_max, size_t lpts, integer bound, std::vector< integer > &bas, size_t k, size_t d)
long	NumBytes (const Integer &m)
int	rational_reconstruction (integer &a, integer &b, const integer &n0, const integer &d0, const integer &B)
int	large_double_division (integer &x, const integer &y, const integer &z)
	NO DOC.
std::ostream &	operator<< (std::ostream &os, LargeDouble &x)
template<class Field>
size_t &	TempLRank (size_t &r, const char *filename, const Field &F)
size_t &	TempLRank (size_t &r, const char *filename, const GF2 &F2)
size_t &	LRank (size_t &r, const char *filename, Givaro::Integer p)
std::vector< size_t > &	PRank (std::vector< size_t > &ranks, size_t &effective_exponent, const char *filename, Givaro::Integer p, size_t e, size_t intr)
std::vector< size_t > &	PRankPowerOfTwo (std::vector< size_t > &ranks, size_t &effective_exponent, const char *filename, size_t e, size_t intr)
std::vector< size_t > &	PRankInteger (std::vector< size_t > &ranks, const char *filename, Givaro::Integer p, size_t e, size_t intr)
std::vector< size_t > &	PRankIntegerPowerOfTwo (std::vector< size_t > &ranks, const char *filename, size_t e, size_t intr)
std::vector< size_t > &	AllPowersRanks (std::vector< size_t > &ranks, const Givaro::Integer &squarefreePrime, const size_t &squarefreeRank, const size_t &exponentBound, const size_t &coprimeRank, const char *filename)
std::vector< Givaro::Integer > &	populateSmithForm (std::vector< Givaro::Integer > &SmithDiagonal, const std::vector< size_t > &ranks, const Givaro::Integer &squarefreePrime, const size_t &squarefreeRank, const size_t &coprimeRank)
template<class Blackbox>
std::vector< Givaro::Integer > &	smithValence (std::vector< Givaro::Integer > &SmithDiagonal, Givaro::Integer &valence, const Blackbox &A, const std::string &filename, Givaro::Integer &coprimeV, size_t method=0)
template<class Blackbox>
std::vector< Givaro::Integer > &	smithValence (std::vector< Givaro::Integer > &SmithDiagonal, const Blackbox &A, const std::string &filename, size_t method=0)
template<class PIR>
std::ostream &	writeCompressedSmith (std::ostream &out, const std::vector< typename PIR::Element > &SmithDiagonal, const PIR &ZZ, const size_t m, const size_t n)
template<class PField>
PField::Coeff &	toeplitz_determinant (const PField &F, typename PField::Coeff &res, const typename PField::Element &T, size_t n)
template<class _Matrix, class Vector1, class Vector2>
Vector1 &	upperTriangularSolveBinary (Vector1 &x, const _Matrix &U, const Vector2 &b)
template<class _Matrix, class Vector1, class Vector2>
Vector1 &	lowerTriangularUnitarySolveBinary (Vector1 &x, const _Matrix &L, const Vector2 &b)
template<class _Matrix, class Vector1, class Vector2>
Vector1 &	upperTriangularSolve (Vector1 &x, const _Matrix &U, const Vector2 &b)
template<class _Matrix, class Vector1, class Vector2>
Vector1 &	upperTriangularSparseSolve (Vector1 &x, size_t rank, const _Matrix &U, const Vector2 &b)
template<class _Matrix, class Vector1, class Vector2>
Vector1 &	lowerTriangularUnitarySolve (Vector1 &x, const _Matrix &L, const Vector2 &b)
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 Field, class BB>
Field::Element &	WhisartTrace (typename Field::Element &trace, const Field &F, const LinBox::Diagonal< Field > &ExtD, const BB &A, const LinBox::Diagonal< Field > &InD)
template<class Field, class BB>
Field::Element &	WhisartTraceTranspose (typename Field::Element &trace, const Field &F, const LinBox::Diagonal< Field > &ExtD, const BB &A, const LinBox::Diagonal< Field > &InD)
template<class Field, class BB>
Field::Element &	WhisartTrace (typename Field::Element &tr, const Field &F, const LinBox::Diagonal< Field > &ExtD, const BB &A, const LinBox::Diagonal< Field > &InD, IndexedTags::NoIndexed t)
template<class Field, class BB>
Field::Element &	WhisartTraceTranspose (typename Field::Element &tr, const Field &F, const LinBox::Diagonal< Field > &ExtD, const BB &A, const LinBox::Diagonal< Field > &InD, IndexedTags::NoIndexed t)
template<class Field, class BB>
Field::Element &	WhisartTrace (typename Field::Element &tr, const Field &F, const LinBox::Diagonal< Field > &ExtD, const BB &A, const LinBox::Diagonal< Field > &InD, IndexedTags::HasIndexed)
template<class Field, class BB>
Field::Element &	WhisartTrace (typename Field::Element &tr, const Field &F, const LinBox::Diagonal< Field > &ExtD, const BB &A, const LinBox::Diagonal< Field > &InD, IndexedTags::HasNext)
template<class Field, class BB>
Field::Element &	WhisartTraceTranspose (typename Field::Element &tr, const Field &F, const LinBox::Diagonal< Field > &ExtD, const BB &A, const LinBox::Diagonal< Field > &InD, IndexedTags::HasIndexed)
template<class Field, class BB>
Field::Element &	WhisartTraceTranspose (typename Field::Element &tr, const Field &F, const LinBox::Diagonal< Field > &ExtD, const BB &A, const LinBox::Diagonal< Field > &InD, IndexedTags::HasNext)
template<class Polynomial, class Blackbox>
Polynomial &	minpoly (Polynomial &P, const Blackbox &A, RingCategories::ModularTag tag, const Method::Wiedemann &M=Method::Wiedemann())
template<class Polynomial, class Blackbox>
Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::WiedemannExtension &M)
template<class OutV, class Matrix, class InV>
OutV &	apply (OutV &y, const Matrix &A, const InV &x)
template<class OutV, class Matrix, class InV>
OutV &	applyTranspose (OutV &y, const Matrix &A, const InV &x)
template<class Domain, class IMatrix>
void	create_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 IVector>
void	create_VectorQadic (const Domain &D, const IVector &V, double *chunks, size_t num_chunks)
template<class Domain, class IMatrix>
void	create_MatrixRNS (const MultiModDouble &F, const Domain &D, const IMatrix &Mat, double *chunks)
template<class Domain, class IVector>
void	create_VectorRNS (const MultiModDouble &F, const Domain &D, const IVector &V, double *chunks)
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<class Field>
void	MatPolyHornerEval (const Field &F, BlasMatrix< Field > &R, const std::vector< BlasMatrix< Field > > &P, const typename Field::Element &a)
template<class Field>
void	VectHornelEval (const Field &F, std::vector< typename Field::Element > &E, const std::vector< typename Field::Element > &P, size_t block, const typename Field::Element &a)
template<class Field>
void	BlockHankelEvaluation (const Field &F, std::vector< BlasMatrix< Field > > &E, const std::vector< BlasMatrix< Field > > &P, size_t k)
template<class Field>
void	BHVectorEvaluation (const Field &F, std::vector< std::vector< typename Field::Element > > &E, const std::vector< typename Field::Element > &P, size_t block)
template<class Field>
void	BHVectorLagrangeCoeff (const Field &F, std::vector< std::vector< typename Field::Element > > &P, size_t k)
template<class Field>
void	BHVectorInterpolation (const Field &F, std::vector< typename Field::Element > &x, const std::vector< std::vector< typename Field::Element > > &E, const std::vector< std::vector< typename Field::Element > > &P, size_t shift)
template<class Field>
DenseMatrix< Field > &	genericNullspaceRandomRight (DenseMatrix< Field > &N, const FIBB< Field > &A)
	N: AN = 0, each col random.
template<class Field>
DenseMatrix< Field > &	genericNullspaceRandomLeft (DenseMatrix< Field > &N, const FIBB< Field > &A)
	N: NA = 0, each row random.
bool	revLexLess (const std::pair< size_t, size_t > &a, const std::pair< size_t, size_t > &b)
template<class _Field1, class _Field2>
bool	areFieldEqual (const _Field1 &F, const _Field2 &G)
template<class _Field, class _Category>
bool	areFieldEqualSpecialised (const _Field &F, const _Field &G, const _Category &m)
template<class _Field>
bool	areFieldEqualSpecialised (const _Field &F, const _Field &G, const RingCategories::ModularTag &m)
template<class _Field>
bool	areFieldEqual (const _Field &F, const _Field &G)
template<class T>
T	abs (const T &a)
double	naturallog (const Givaro::Integer &a)
	Natural logarithm (ln).
template<class T>
std::enable_if<!std::is_unsigned< T >::value, bool >::value	isPositive (const T &t)
	Positiveness of an integer.
template<class T>
std::enable_if< std::is_unsigned< T >::value, bool >::value	isPositive (const T &t)
template<class T>
std::enable_if<!std::is_unsigned< T >::value, bool >::value	isNegative (const T &t)
template<class T>
std::enable_if< std::is_unsigned< T >::value, bool >::value	isNegative (const T &t)
template<typename IntType>
bool	isOdd (const IntType &value)
template<typename IntType>
bool	isEven (const IntType &p)
template<class _Field, class _Storage>
std::ostream &	operator<< (std::ostream &os, const BlasMatrix< _Field, _Storage > &Mat)
	Write a matrix to a stream.
template<class _Matrix>
std::ostream &	operator<< (std::ostream &os, const BlasSubmatrix< _Matrix > &Mat)
template<class _Uint>
std::ostream &	operator<< (std::ostream &o, BlasPermutation< _Uint > &P)
template<class _UnsignedInt>
std::ostream &	operator<< (std::ostream &o, MatrixPermutation< _UnsignedInt > &P)
template<typename Field>
uint64_t	element_storage (const Field &F)
template<>
uint64_t	element_storage (const Givaro::Modular< Givaro::Integer > &F)
template<typename _Field, LinBox::PMType T>
std::ostream &	operator<< (std::ostream &os, const PolynomialMatrix< _Field, T > &P)
template<typename MatPoly>
std::ostream &	operator<< (std::ostream &os, const SubPolynomialMatrix< MatPoly > &P)
void	RandomBlasPermutation (BlasPermutation< size_t > &P)
template<class T>
std::ostream &	operator<< (std::ostream &o, const DenseMat< T > &Mat)
	Write a matrix to a stream.
template<class _Field, class _Storage>
std::ostream &	operator<< (std::ostream &os, const SparseMatrix< _Field, _Storage > &Mat)
template<class _Field, class _Storage>
std::istream &	operator>> (std::istream &is, SparseMatrix< _Field, _Storage > &A)
template<class Field, class Vector>
Vector &	prepare (const Field &F, Vector &y, const typename Field::Element &a)
	y <- ay.
template<class Field, class Row>
std::ostream &	operator<< (std::ostream &os, const Protected::SparseMatrixGeneric< Field, Row > &A)
template<class Field, class Row>
std::istream &	operator>> (std::istream &is, Protected::SparseMatrixGeneric< Field, Row > &A)
template<class Mat1, class Mat2>
Mat1 &	SparseMatrix< Field_, SparseMatrixFormat::TPL >applyLeft (Mat1 &Y, const Mat2 &X) const
std::ostream &	operator<< (std::ostream &out, const TriplesCoord &coord)
TriplesCoord	operator>> (const TriplesCoord &coord, unsigned int shift)
TriplesCoord	operator+ (const TriplesCoord &lhs, const TriplesCoord &rhs)
bool	operator== (const TriplesCoord &lhs, const TriplesCoord &rhs)
bool	operator< (const TriplesCoord &lhs, const TriplesCoord &rhs)
TriplesCoord	operator- (const TriplesCoord &lhs, const TriplesCoord &rhs)
void	coordFromBlock (TriplesCoord &coord)
void	coordToBlock (TriplesCoord &coord)
uint32_t	MultiplyDeBruijnHighestBit (uint32_t v)
template<typename Container>
PrimeSequence< typename Container::const_iterator >	create_prime_sequence (const Container &cont)
	convenience factory to create a PrimeSequence from an STL-like container.
template<class Blackbox, class Polynomial, class MyMethod, class DomainCategory>
Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const DomainCategory &tag, const MyMethod &M)
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 Blackbox, class Polynomial>
Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Auto &M)
template<class Domain, class Polynomial>
Polynomial &	charpoly (Polynomial &P, const SparseMatrix< Domain > &A, const RingCategories::ModularTag &tag, const Method::Auto &M)
template<class Domain, class Polynomial>
Polynomial &	charpoly (Polynomial &P, const BlasMatrix< Domain > &A, const RingCategories::ModularTag &tag, const Method::Auto &M)
template<class Blackbox, class Polynomial>
Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &M)
template<class Blackbox, class Polynomial>
Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	Compute the characteristic polynomial over \(\mathbf{Z}_p\).
template<class Blackbox, class Polynomial>
Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Auto &M)
template<class Blackbox, class Polynomial>
Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Elimination &M)
template<class Matrix, class Polynomial, class Method>
Polynomial &	charpoly (Polynomial &P, const Matrix &A, const RingCategories::IntegerTag &tag, const Method &M)
template<class Blackbox, class Polynomial>
Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
	Compute the characteristic polynomial over \(\mathbf{Z}_p\).
template<class Blackbox, class Polynomial, class MyMethod>
Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::RationalTag &tag, const MyMethod &M)
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 Blackbox, class DetMethod, class DomainCategory>
Blackbox::Field::Element &	detInPlace (typename Blackbox::Field::Element &d, Blackbox &A, const DomainCategory &tag, const DetMethod &Meth)
template<class Blackbox>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A)
template<class Blackbox>
Blackbox::Field::Element &	detInPlace (typename Blackbox::Field::Element &d, Blackbox &A)
template<class Blackbox, class MyMethod>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const MyMethod &Meth)
template<class Blackbox, class MyMethod>
Blackbox::Field::Element &	detInPlace (typename Blackbox::Field::Element &d, Blackbox &A, const MyMethod &Meth)
template<class Blackbox>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Auto &Meth)
template<class Blackbox>
Blackbox::Field::Element &	detInPlace (typename Blackbox::Field::Element &d, Blackbox &A, const RingCategories::ModularTag &tag, const Method::Auto &Meth)
template<class Field>
Field::Element &	det (typename Field::Element &d, const BlasMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &Meth)
template<class Field>
Field::Element &	detInPlace (typename Field::Element &d, BlasMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &Meth)
template<class CField, class PField>
CField::Element &	det (typename CField::Element &res, const Toeplitz< CField, PField > &A)
template<class CField, class PField>
CField::Element &	detInPlace (typename CField::Element &res, Toeplitz< CField, PField > &A)
template<class Blackbox>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &Meth)
template<class Blackbox>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Wiedemann &Meth)
template<class Blackbox>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &Meth)
template<class Blackbox>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &Meth)
template<class Field, class Vector>
Field::Element &	det (typename Field::Element &d, const SparseMatrix< Field, Vector > &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &Meth)
template<class Field>
Field::Element &	detInPlace (typename Field::Element &d, SparseMatrix< Field, SparseMatrixFormat::SparseSeq > &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &Meth)
template<class Field, class Vector>
Field::Element &	det (typename Field::Element &d, const SparseMatrix< Field, Vector > &A, const RingCategories::ModularTag &tag, const Method::Elimination &Meth)
template<class Field>
Field::Element &	detInPlace (typename Field::Element &d, SparseMatrix< Field, SparseMatrixFormat::SparseSeq > &A, const RingCategories::ModularTag &tag, const Method::Elimination &Meth)
template<class Field, class Vector>
Field::Element &	detInPlace (typename Field::Element &d, SparseMatrix< Field, Vector > &A, const RingCategories::ModularTag &tag, const Method::Elimination &Meth)
template<class Blackbox>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &Meth)
template<class Blackbox>
Blackbox::Field::Element &	detInPlace (typename Blackbox::Field::Element &d, Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &Meth)
template<class Field>
Field::Element &	detInPlace (typename Field::Element &d, BlasMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Elimination &Meth)
template<class Field>
Field::Element &	detInPlace (typename Field::Element &d, BlasMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &Meth)
template<class Field>
Field::Element &	detInPlace (typename Field::Element &d, BlasMatrix< Field > &A)
	Rank of Blackbox A.
template<class Blackbox, class MyMethod>
Blackbox::Field::Element &	cra_det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &Meth)
template<class Blackbox, class MyMethod>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &Meth)
template<class Blackbox, class MyMethod>
Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::RationalTag &tag, const MyMethod &Meth)
template<class Field, class MyMethod>
Field::Element &	det (typename Field::Element &d, const BlasMatrix< Field > &A, const RingCategories::RationalTag &tag, const MyMethod &Meth)
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	rowEchelon (Matrix &E, const Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Compute the row echelon form of a matrix, not reduced.
template<class Matrix, class EchelonMethod>
size_t	rowEchelon (Matrix &E, const Matrix &A, const EchelonMethod &m)
	rowEchelon dispatcher for automated category tag.
template<class Matrix>
size_t	rowEchelon (Matrix &E, const Matrix &A)
	rowEchelon dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	rowEchelon (Matrix &E, Matrix &T, const Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Compute the row echelon form of a matrix, not reduced, and the related transformation matrix.
template<class Matrix, class EchelonMethod>
size_t	rowEchelon (Matrix &E, Matrix &T, const Matrix &A, const EchelonMethod &m)
	rowEchelon dispatcher for automated category tag.
template<class Matrix>
size_t	rowEchelon (Matrix &E, Matrix &T, const Matrix &A)
	rowEchelon dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	rowEchelonize (Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Replace the input matrix by its row echelon form, not reduced.
template<class Matrix, class EchelonMethod>
size_t	rowEchelonize (Matrix &A, const EchelonMethod &m)
	rowEchelonize dispatcher for automated category tag.
template<class Matrix>
size_t	rowEchelonize (Matrix &A)
	rowEchelonize dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	rowEchelonize (Matrix &A, Matrix &T, const CategoryTag &tag, const EchelonMethod &m)
	Compute the row echelon form of a matrix, not reduced, and the related transformation matrix.
template<class Matrix, class EchelonMethod>
size_t	rowEchelonize (Matrix &A, Matrix &T, const EchelonMethod &m)
	rowEchelonize dispatcher for automated category tag.
template<class Matrix>
size_t	rowEchelonize (Matrix &A, Matrix &T)
	rowEchelonize dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	reducedRowEchelon (Matrix &E, const Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Compute the reduced row echelon form of a matrix.
template<class Matrix, class EchelonMethod>
size_t	reducedRowEchelon (Matrix &E, const Matrix &A, const EchelonMethod &m)
	reducedRowEchelon dispatcher for automated category tag.
template<class Matrix>
size_t	reducedRowEchelon (Matrix &E, const Matrix &A)
	reducedRowEchelon dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	reducedRowEchelon (Matrix &E, Matrix &T, const Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Compute the reduced row echelon form of a matrix, and the related transformation matrix.
template<class Matrix, class EchelonMethod>
size_t	reducedRowEchelon (Matrix &E, Matrix &T, const Matrix &A, const EchelonMethod &m)
	reducedRowEchelon dispatcher for automated category tag.
template<class Matrix>
size_t	reducedRowEchelon (Matrix &E, Matrix &T, const Matrix &A)
	reducedRowEchelon dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	reducedRowEchelonize (Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Replace the input matrix by its reduced row echelon form.
template<class Matrix, class EchelonMethod>
size_t	reducedRowEchelonize (Matrix &A, const EchelonMethod &m)
	reducedRowEchelonize dispatcher for automated category tag.
template<class Matrix>
size_t	reducedRowEchelonize (Matrix &A)
	reducedRowEchelonize dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	reducedRowEchelonize (Matrix &A, Matrix &T, const CategoryTag &tag, const EchelonMethod &m)
	Compute the reduced row echelon form of a matrix, and the related transformation matrix.
template<class Matrix, class EchelonMethod>
size_t	reducedRowEchelonize (Matrix &A, Matrix &T, const EchelonMethod &m)
	reducedRowEchelonize dispatcher for automated category tag.
template<class Matrix>
size_t	reducedRowEchelonize (Matrix &A, Matrix &T)
	reducedRowEchelonize dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	colEchelon (Matrix &E, const Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Compute the column echelon form of a matrix, not reduced.
template<class Matrix, class EchelonMethod>
size_t	colEchelon (Matrix &E, const Matrix &A, const EchelonMethod &m)
	colEchelon dispatcher for automated category tag.
template<class Matrix>
size_t	colEchelon (Matrix &E, const Matrix &A)
	colEchelon dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	colEchelon (Matrix &E, Matrix &T, const Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Compute the column echelon form of a matrix, not reduced, and the related transformation matrix.
template<class Matrix, class EchelonMethod>
size_t	colEchelon (Matrix &E, Matrix &T, const Matrix &A, const EchelonMethod &m)
	colEchelon dispatcher for automated category tag.
template<class Matrix>
size_t	colEchelon (Matrix &E, Matrix &T, const Matrix &A)
	colEchelon dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	colEchelonize (Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Replace the input matrix by its column echelon form, not reduced.
template<class Matrix, class EchelonMethod>
size_t	colEchelonize (Matrix &A, const EchelonMethod &m)
	colEchelonize dispatcher for automated category tag.
template<class Matrix>
size_t	colEchelonize (Matrix &A)
	colEchelonize dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	colEchelonize (Matrix &A, Matrix &T, const CategoryTag &tag, const EchelonMethod &m)
	Compute the column echelon form of a matrix, not reduced, and the related transformation matrix.
template<class Matrix, class EchelonMethod>
size_t	colEchelonize (Matrix &A, Matrix &T, const EchelonMethod &m)
	colEchelonize dispatcher for automated category tag.
template<class Matrix>
size_t	colEchelonize (Matrix &A, Matrix &T)
	colEchelonize dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	reducedColEchelon (Matrix &E, const Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Compute the reduced column echelon form of a matrix.
template<class Matrix, class EchelonMethod>
size_t	reducedColEchelon (Matrix &E, const Matrix &A, const EchelonMethod &m)
	reducedColEchelon dispatcher for automated category tag.
template<class Matrix>
size_t	reducedColEchelon (Matrix &E, const Matrix &A)
	reducedColEchelon dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	reducedColEchelon (Matrix &E, Matrix &T, const Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Compute the reduced column echelon form of a matrix, and the related transformation matrix.
template<class Matrix, class EchelonMethod>
size_t	reducedColEchelon (Matrix &E, Matrix &T, const Matrix &A, const EchelonMethod &m)
	reducedColEchelon dispatcher for automated category tag.
template<class Matrix>
size_t	reducedColEchelon (Matrix &E, Matrix &T, const Matrix &A)
	reducedColEchelon dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	reducedColEchelonize (Matrix &A, const CategoryTag &tag, const EchelonMethod &m)
	Replace the input matrix by its reduced column echelon form.
template<class Matrix, class EchelonMethod>
size_t	reducedColEchelonize (Matrix &A, const EchelonMethod &m)
	reducedColEchelonize dispatcher for automated category tag.
template<class Matrix>
size_t	reducedColEchelonize (Matrix &A)
	reducedColEchelonize dispatcher for automated method.
template<class Matrix, class CategoryTag, class EchelonMethod>
size_t	reducedColEchelonize (Matrix &A, Matrix &T, const CategoryTag &tag, const EchelonMethod &m)
	Compute the reduced column echelon form of a matrix, and the related transformation matrix.
template<class Matrix, class EchelonMethod>
size_t	reducedColEchelonize (Matrix &A, Matrix &T, const EchelonMethod &m)
	reducedColEchelonize dispatcher for automated category tag.
template<class Matrix>
size_t	reducedColEchelonize (Matrix &A, Matrix &T)
	reducedColEchelonize dispatcher for automated method.
template<class Matrix, class CategoryTag>
size_t	rowEchelon (Matrix &E, const Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	rowEchelon specialisation for Auto.
template<class Field>
size_t	rowEchelon (DenseMatrix< Field > &E, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	rowEchelon specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	rowEchelon (Matrix &E, Matrix &T, const Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	rowEchelon specialisation for Auto.
template<class Field>
size_t	rowEchelon (DenseMatrix< Field > &E, DenseMatrix< Field > &T, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	rowEchelon specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	rowEchelonize (Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	rowEchelonize specialisation for Auto.
template<class Field>
size_t	rowEchelonize (DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	rowEchelonize specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	rowEchelonize (Matrix &A, Matrix &T, const CategoryTag &tag, const Method::Auto &m)
	rowEchelonize specialisation for Auto.
template<class Field>
size_t	rowEchelonize (DenseMatrix< Field > &A, DenseMatrix< Field > &T, const RingCategories::ModularTag &tag, const Method::Auto &m)
	rowEchelonize specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	reducedRowEchelon (Matrix &E, const Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	reducedRowEchelon specialisation for Auto.
template<class Field>
size_t	reducedRowEchelon (DenseMatrix< Field > &E, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	reducedRowEchelon specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	reducedRowEchelon (Matrix &E, Matrix &T, const Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	reducedRowEchelon specialisation for Auto.
template<class Field>
size_t	reducedRowEchelon (DenseMatrix< Field > &E, DenseMatrix< Field > &T, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	reducedRowEchelon specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	reducedRowEchelonize (Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	reducedRowEchelonize specialisation for Auto.
template<class Field>
size_t	reducedRowEchelonize (DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	reducedRowEchelonize specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	reducedRowEchelonize (Matrix &A, Matrix &T, const CategoryTag &tag, const Method::Auto &m)
	reducedRowEchelonize specialisation for Auto.
template<class Field>
size_t	reducedRowEchelonize (DenseMatrix< Field > &A, DenseMatrix< Field > &T, const RingCategories::ModularTag &tag, const Method::Auto &m)
	reducedRowEchelonize specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	colEchelon (Matrix &E, const Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	colEchelon specialisation for Auto.
template<class Field>
size_t	colEchelon (DenseMatrix< Field > &E, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	colEchelon specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	colEchelon (Matrix &E, Matrix &T, const Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	colEchelon specialisation for Auto.
template<class Field>
size_t	colEchelon (DenseMatrix< Field > &E, DenseMatrix< Field > &T, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	colEchelon specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	colEchelonize (Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	colEchelonize specialisation for Auto.
template<class Field>
size_t	colEchelonize (DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	colEchelonize specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	colEchelonize (Matrix &A, Matrix &T, const CategoryTag &tag, const Method::Auto &m)
	colEchelonize specialisation for Auto.
template<class Field>
size_t	colEchelonize (DenseMatrix< Field > &A, DenseMatrix< Field > &T, const RingCategories::ModularTag &tag, const Method::Auto &m)
	colEchelonize specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	reducedColEchelon (Matrix &E, const Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	reducedColEchelon specialisation for Auto.
template<class Field>
size_t	reducedColEchelon (DenseMatrix< Field > &E, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	reducedColEchelon specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	reducedColEchelon (Matrix &E, Matrix &T, const Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	reducedColEchelon specialisation for Auto.
template<class Field>
size_t	reducedColEchelon (DenseMatrix< Field > &E, DenseMatrix< Field > &T, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	reducedColEchelon specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	reducedColEchelonize (Matrix &A, const CategoryTag &tag, const Method::Auto &m)
	reducedColEchelonize specialisation for Auto.
template<class Field>
size_t	reducedColEchelonize (DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
	reducedColEchelonize specialisation for Auto with DenseMatrix and ModularTag.
template<class Matrix, class CategoryTag>
size_t	reducedColEchelonize (Matrix &A, Matrix &T, const CategoryTag &tag, const Method::Auto &m)
	reducedColEchelonize specialisation for Auto.
template<class Field>
size_t	reducedColEchelonize (DenseMatrix< Field > &A, DenseMatrix< Field > &T, const RingCategories::ModularTag &tag, const Method::Auto &m)
	reducedColEchelonize specialisation for Auto with DenseMatrix and ModularTag.
template<class Field>
size_t	rowEchelon (DenseMatrix< Field > &E, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	rowEchelon specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	rowEchelon (DenseMatrix< Field > &E, DenseMatrix< Field > &T, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	rowEchelon with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	rowEchelonize (DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	rowEchelonize specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	rowEchelonize (DenseMatrix< Field > &A, DenseMatrix< Field > &T, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	rowEchelonize with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	reducedRowEchelon (DenseMatrix< Field > &E, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	reducedRowEchelon specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	reducedRowEchelon (DenseMatrix< Field > &E, DenseMatrix< Field > &T, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	reducedRowEchelon with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	reducedRowEchelonize (DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	reducedRowEchelonize specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	reducedRowEchelonize (DenseMatrix< Field > &A, DenseMatrix< Field > &T, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	reducedRowEchelonize with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	colEchelon (DenseMatrix< Field > &E, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	colEchelon specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	colEchelon (DenseMatrix< Field > &E, DenseMatrix< Field > &T, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	colEchelon with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	colEchelonize (DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	colEchelonize specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	colEchelonize (DenseMatrix< Field > &A, DenseMatrix< Field > &T, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	colEchelonize with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	reducedColEchelon (DenseMatrix< Field > &E, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	reducedColEchelon specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	reducedColEchelon (DenseMatrix< Field > &E, DenseMatrix< Field > &T, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	reducedColEchelon with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	reducedColEchelonize (DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	reducedColEchelonize specialisation for DenseElimination with DenseMatrix and ModularTag.
template<class Field>
size_t	reducedColEchelonize (DenseMatrix< Field > &A, DenseMatrix< Field > &T, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	reducedColEchelonize with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.
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 Field, class Trait, class BB>
Field::Element &	getEntry (typename Field::Element &x, const Compose< Diagonal< Field, Trait >, BB > &A, const size_t i, const size_t j)
template<class BB, class Field, class Trait>
Field::Element &	getEntry (typename Field::Element &x, const Compose< BB, Diagonal< Field, Trait > > &A, const size_t i, const size_t j)
template<class Field, class T1, class T2>
Field::Element &	getEntry (typename Field::Element &x, const Compose< Diagonal< Field, T1 >, Diagonal< Field, T2 > > &A, const size_t i, const size_t j)
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 BB>
BB::Field::Element &	getEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j, SolutionTags::Generic t)
template<class BB>
BB::Field::Element &	getEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j, SolutionTags::Local t)
template<class ConstIterator>
bool	vectorLogNorm (double &logNorm, const ConstIterator &begin, const ConstIterator &end)
template<class IMatrix>
void	HadamardRowLogBound (double &logBound, double &minLogNorm, const IMatrix &A)
	Precise Hadamard bound (bound on determinant) by taking the row-wise euclidean norm.
template<class IMatrix>
void	HadamardRowLogBound (double &logBound, double &minLogNorm, const IMatrix &A, const MatrixCategories::RowColMatrixTag &tag)
template<class IMatrix>
void	HadamardRowLogBound (double &logBound, double &minLogNorm, const IMatrix &A, const MatrixCategories::RowMatrixTag &tag)
template<class IMatrix>
void	HadamardRowLogBound (double &logBound, double &minLogNorm, const IMatrix &A, const MatrixCategories::BlackboxTag &tag)
template<class IMatrix>
void	HadamardColLogBound (double &logBound, double &minLogNorm, const IMatrix &A)
	Precise Hadamard bound (bound on determinant) by taking the column-wise euclidean norm.
template<class IMatrix>
void	HadamardColLogBound (double &logBound, double &minLogNorm, const IMatrix &A, const MatrixCategories::RowColMatrixTag &tag)
template<class IMatrix>
void	HadamardColLogBound (double &logBound, double &minLogNorm, const IMatrix &A, const MatrixCategories::RowMatrixTag &tag)
template<class IMatrix>
void	HadamardColLogBound (double &logBound, double &minLogNorm, const IMatrix &A, const MatrixCategories::BlackboxTag &tag)
template<class IMatrix>
HadamardLogBoundDetails	DetailedHadamardBound (const IMatrix &A)
	Precise Hadamard bound (bound on determinant) by taking the minimum of the column-wise and the row-wise euclidean norm.
template<class IMatrix>
double	HadamardBound (const IMatrix &A)
	Precise Hadamard bound (bound on determinant) by taking the minimum of the column-wise and the row-wise euclidean norm.
template<class IMatrix, class MTag>
Integer &	InfinityNorm (Integer &max, const IMatrix &A, const MTag &tag)
	Returns the maximal absolute value.
template<class IMatrix>
Integer &	InfinityNorm (Integer &max, const IMatrix &A, const MatrixCategories::RowColMatrixTag &tag)
template<class IMatrix>
double	FastHadamardBound (const IMatrix &A, const Integer &infnorm)
	Returns the bit size of the Hadamard bound.
template<class IMatrix>
double	FastHadamardBound (const IMatrix &A, const MatrixCategories::RowColMatrixTag &tag)
template<class IMatrix>
double	FastHadamardBound (const IMatrix &A, const MatrixCategories::BlackboxTag &tag)
template<class IMatrix>
double	FastHadamardBound (const IMatrix &A)
template<class IMatrix>
double	FastCharPolyDumasPernetWanBound (const IMatrix &A, const Integer &infnorm)
	Bound on the coefficients of the characteristic polynomial.
template<class IMatrix>
double	FastCharPolyGoldsteinGrahamBound (const IMatrix &A, const Integer &infnorm)
	A.J.
template<class IMatrix>
double	FastCharPolyHadamardBound (const IMatrix &A)
template<class Matrix, class Vector>
std::enable_if< std::is_same< typenameFieldTraits< typenameMatrix::Field >::categoryTag, RingCategories::IntegerTag >::value, RationalSolveHadamardBoundData >::type	RationalSolveHadamardBound (const Matrix &A, const Vector &b)
	Bound on the rational solution of a linear system Ax = b.
template<class Matrix, class Vector>
std::enable_if< std::is_same< typenameFieldTraits< typenameMatrix::Field >::categoryTag, RingCategories::RationalTag >::value, RationalSolveHadamardBoundData >::type	RationalSolveHadamardBound (const Matrix &A, const Vector &b)
	@fixme Needed to solve-cra.h, but can't be used yet.
template<class Blackbox, class isPositiveDefiniteMethod, class DomainCategory>
bool	isPositiveDefinite (const Blackbox &A, const DomainCategory &tag, const isPositiveDefiniteMethod &M)
template<class Blackbox, class MyMethod>
bool	isPositiveDefinite (const Blackbox &A, const MyMethod &M)
	Compute the isPositiveDefinite of A.
template<class Blackbox>
bool	isPositiveDefinite (const Blackbox &A)
template<class Blackbox, class MyMethod>
bool	isPositiveDefinite (const Blackbox &A, const RingCategories::ModularTag &tag, const MyMethod &M)
template<class Blackbox>
bool	isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Auto &M)
template<class Blackbox>
bool	isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Elimination &M)
template<class Blackbox>
bool	isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Blackbox &M)
template<class Blackbox>
bool	isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Wiedemann &M)
template<class Blackbox>
bool	isPositiveDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::DenseElimination &M)
template<class Ring>
bool	isPositiveDefinite (const BlasMatrix< Ring > &A, const RingCategories::IntegerTag &tag, const Method::DenseElimination &M)
template<class Blackbox, class isPositiveSemiDefiniteMethod, class DomainCategory>
bool	isPositiveSemiDefinite (const Blackbox &A, const DomainCategory &tag, const isPositiveSemiDefiniteMethod &M)
template<class Blackbox, class MyMethod>
bool	isPositiveSemiDefinite (const Blackbox &A, const MyMethod &M)
	Determine if A is positive semidefinite.
template<class Blackbox>
bool	isPositiveSemiDefinite (const Blackbox &A)
template<class Blackbox, class MyMethod>
bool	isPositiveSemiDefinite (const Blackbox &A, const RingCategories::ModularTag &tag, const MyMethod &M)
template<class Blackbox>
bool	isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Auto &M)
template<class Blackbox>
bool	isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Elimination &M)
template<class Blackbox>
bool	isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Blackbox &M)
template<class Blackbox>
bool	isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::Wiedemann &M)
template<class Blackbox>
bool	isPositiveSemiDefinite (const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::DenseElimination &M)
template<class Ring>
bool	isPositiveSemiDefinite (const BlasMatrix< Ring > &A, const RingCategories::IntegerTag &tag, const Method::DenseElimination &M)
template<class Matrix>
bool	useBlackboxMethod (const Matrix &A)
template<class Field>
bool	useBlackboxMethod (const LinBox::DenseMatrix< Field > &A)
template<class Blackbox, class Polynomial, class DomainCategory, class MyMethod>
Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const DomainCategory &tag, const MyMethod &M)
	Minimal polynomial of a blackbox linear operator A. The resulting polynomial is a vector of coefficients. Somewhere we should document our handling of polys.
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 Polynomial, class Blackbox>
Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Auto &M)
template<class Polynomial, class Field>
Polynomial &	minpoly (Polynomial &P, const BlasMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Auto &M)
template<class Polynomial, class Blackbox>
Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &M)
template<class Polynomial, class Blackbox>
Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
template<class Polynomial, class Blackbox>
Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
template<class Polynomial, class Blackbox, class MyMethod>
Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class Blackbox, class Polynomial, class MyMethod>
Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const RingCategories::RationalTag &tag, const MyMethod &M)
template<class Field, template< class > class Polynomial, class MyMethod>
Polynomial< typename Field::Element > &	minpoly (Polynomial< typename Field::Element > &P, const BlasMatrix< Field > &A, const RingCategories::RationalTag &tag, const MyMethod &M)
template<class Blackbox, class Method, class DomainCategory>
size_t &	rank (size_t &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, class Method, class DomainCategory>
size_t &	rankInPlace (size_t &r, Blackbox &A, const DomainCategory &tag, const Method &M)
template<class Blackbox>
size_t &	rank (size_t &r, const Blackbox &A)
	Compute the rank of a linear transform A over a field.
template<class Blackbox, class Method>
size_t &	rank (size_t &r, const Blackbox &A, const Method &M)
	Compute the rank of a linear transform A over a field.
template<class Blackbox>
size_t &	rankInPlace (size_t &r, Blackbox &A)
	Rank of A.
template<class Blackbox>
size_t &	rank (size_t &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
template<class Blackbox>
size_t &	rank (size_t &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &m)
template<class Field, class Vector>
size_t &	rank (size_t &r, const SparseMatrix< Field, Vector > &A, const RingCategories::ModularTag &tag, const Method::Elimination &m)
template<class Blackbox>
size_t &	rank (size_t &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &m)
template<class Blackbox>
size_t &	rank (size_t &res, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Wiedemann &M)
	M may be Method::Wiedemann().
template<class Field>
size_t &	rankInPlace (size_t &r, SparseMatrix< Field, SparseMatrixFormat::SparseSeq > &A, const RingCategories::ModularTag &tag, const Method::Elimination &m)
template<class Field>
size_t &	rank (size_t &r, const SparseMatrix< Field, SparseMatrixFormat::SparseSeq > &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
	M may be Method::SparseElimination().
template<class Blackbox, class DomainCategory>
size_t &	rank (size_t &r, const Blackbox &A, const DomainCategory &tag, const Method::SparseElimination &M)
template<class Blackbox>
size_t &	rank (size_t &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
template<class Blackbox, class MyMethod>
size_t &	integral_rank (size_t &r, const Blackbox &A, const MyMethod &M)
template<class Blackbox, class MyMethod>
size_t &	rank (size_t &r, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class Blackbox, class Method>
size_t &	rank (size_t &r, const Blackbox &A, const RingCategories::RationalTag &tag, const Method &M)
template<class Blackbox>
size_t &	rank (size_t &r, const Blackbox &A, const RingCategories::RationalTag &tag, const Method::SparseElimination &M)
template<class Field, class Method>
size_t &	rankInPlace (size_t &r, SparseMatrix< Field, SparseMatrixFormat::SparseSeq > &A, const Method &M)
template<class Blackbox, class Ring>
size_t &	rankInPlace (size_t &r, Blackbox &A, const RingCategories::IntegerTag &tag, const Method::SparseElimination &M)
size_t &	rankInPlace (size_t &r, GaussDomain< GF2 >::Matrix &A, const Method::SparseElimination &)
	specialization to \( \mathbf{F}_2 \)
size_t &	rankInPlace (size_t &r, GaussDomain< GF2 >::Matrix &A, const RingCategories::ModularTag &, const Method::SparseElimination &M)
	specialization to \( \mathbf{F}_2 \)
template<class Field>
size_t &	rankInPlace (size_t &r, BlasMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::DenseElimination &M)
	A is modified.
template<class Field>
size_t &	rankInPlace (size_t &r, BlasMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Elimination &m)
template<class Blackbox>
size_t &	rankInPlace (size_t &r, Blackbox &A, const RingCategories::ModularTag &tag, const Method::Auto &m)
template<class Blackbox>
size_t &	rankInPlace (size_t &r, Blackbox &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
template<class Ring, class Vector>
SmithList< Ring > &	compressedSmith (SmithList< Ring > &c, const Vector &SmithDiagonal, const Ring &R, const size_t m, const size_t n)
template<class Ring>
SmithList< Ring > &	compressedSmith (SmithList< Ring > &c, const BlasVector< Ring > &v)
template<class Blackbox, class Method>
SmithList< typename Blackbox::Field > &	smithForm (SmithList< typename Blackbox::Field > &S, const Blackbox &A, const Method &M)
	Compute the Smith form of A.
template<class Blackbox, class Method>
BlasVector< typename Blackbox::Field > &	smithForm (BlasVector< typename Blackbox::Field > &V, const Blackbox &A, const Method &M)
template<class Blackbox>
SmithList< typename Blackbox::Field > &	smithForm (SmithList< typename Blackbox::Field > &S, const Blackbox &A)
template<class Blackbox>
BlasVector< typename Blackbox::Field > &	smithForm (BlasVector< typename Blackbox::Field > &V, const Blackbox &A)
SmithList< Givaro::ZRing< Integer > > &	smithForm (SmithList< Givaro::ZRing< Integer > > &S, const BlasMatrix< Givaro::ZRing< Integer > > &A, const RingCategories::IntegerTag &tag, const Method::Auto &M)
BlasVector< typename Givaro::ZRing< Integer > > &	smithForm (BlasVector< typename Givaro::ZRing< Integer > > &V, const BlasMatrix< Givaro::ZRing< Integer > > &A, const RingCategories::IntegerTag &tag, const Method::Auto &M)
template<class ResultVector, class Matrix, class Vector, class CategoryTag, class SolveMethod>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const CategoryTag &tag, const SolveMethod &m)
	Solve Ax = b, for x.
template<class ResultVector, class Matrix, class Vector, class SolveMethod>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const SolveMethod &m)
	Solve dispatcher for automated category tag.
template<class ResultVector, class Matrix, class Vector>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b)
	Solve dispatcher for automated solve method.
template<class RatVector, class RatMatrix, class Vector, class SolveMethod>
RatVector &	solve (RatVector &x, const RatMatrix &A, const Vector &b, const RingCategories::RationalTag &tag, const SolveMethod &m)
	Solve specialisation on RationalTag, with a generic method.
template<class RatVector, class Matrix, class Vector, class SolveMethod>
std::enable_if< std::is_same< typenameSolveMethod::CategoryTag, RingCategories::IntegerTag >::value &&std::is_same< typenameFieldTraits< typenameRatVector::Field >::categoryTag, RingCategories::RationalTag >::value, RatVector & >::type	solve (RatVector &x, const Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const SolveMethod &m)
	Solve specialisation on IntegerTag with Vector<QField> as result.
template<class Matrix, class Vector, class SolveMethod>
std::enable_if< std::is_same< typenameSolveMethod::CategoryTag, RingCategories::IntegerTag >::value, VectorFraction< typenameMatrix::Field > & >::type	solve (VectorFraction< typename Matrix::Field > &x, const Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const SolveMethod &m)
	Solve specialisation on IntegerTag with VectorFraction as result.
template<class IntVector, class Matrix, class Vector, class CategoryTag, class SolveMethod>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const Matrix &A, const Vector &b, const CategoryTag &tag, const SolveMethod &m)
	Rational solve Ax = b, for x expressed as xNum/xDen.
template<class IntVector, class Matrix, class Vector, class SolveMethod>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const SolveMethod &m)
	Rational solve dispatcher for unimplemented methods.
template<class IntVector, class Matrix, class Vector, class SolveMethod>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const Matrix &A, const Vector &b, const SolveMethod &m)
	Rational solve dispatcher for automated category tag.
template<class IntVector, class Matrix, class Vector>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const Matrix &A, const Vector &b)
	Rational solve dispatcher for automated solve method.
template<class ResultVector, class Matrix, class Vector, class CategoryTag, class SolveMethod>
ResultVector &	solveInPlace (ResultVector &x, Matrix &A, const Vector &b, const CategoryTag &tag, const SolveMethod &m)
	Solve Ax = b, for x.
template<class ResultVector, class Matrix, class Vector, class SolveMethod>
ResultVector &	solveInPlace (ResultVector &x, Matrix &A, const Vector &b, const SolveMethod &m)
	Solve in place dispatcher for automated category tag.
template<class ResultVector, class Matrix, class Vector>
ResultVector &	solveInPlace (ResultVector &x, Matrix &A, const Vector &b)
	Solve in place dispatcher for automated solve method.
template<class IntVector, class Matrix, class Vector, class SolveMethod, class CategoryTag>
void	solveInPlace (IntVector &xNum, typename IntVector::Element &xDen, Matrix &A, const Vector &b, const CategoryTag &tag, const SolveMethod &m)
	Rational solve in place Ax = b, for x expressed as xNum/xDen.
template<class IntVector, class Matrix, class Vector, class SolveMethod>
void	solveInPlace (IntVector &xNum, typename IntVector::Element &xDen, Matrix &A, const Vector &b, const SolveMethod &m)
	Rational solve in place dispatcher for automated category tag.
template<class IntVector, class Matrix, class Vector>
void	solveInPlace (IntVector &xNum, typename IntVector::Element &xDen, Matrix &A, const Vector &b)
	Rational solve in place dispatcher for automated solve method.
template<class ResultVector, class Matrix, class Vector, class CategoryTag>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const CategoryTag &tag, const Method::Auto &m)
	Solve specialisation for Auto.
template<class ResultVector, class Field, class Vector>
ResultVector &	solve (ResultVector &x, const DenseMatrix< Field > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::Auto &m)
	Solve specialisation for Auto with DenseMatrix and ModularTag.
template<class ResultVector, class... MatrixArgs, class Vector>
ResultVector &	solve (ResultVector &x, const SparseMatrix< MatrixArgs... > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::Auto &m)
	Solve specialisation for Auto with SparseMatrix and ModularTag.
template<class ResultVector, class Matrix, class Vector>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Auto &m)
	Solve specialisation for Auto and IntegerTag.
template<class ResultVector, class Matrix, class Vector>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const RingCategories::RationalTag &tag, const Method::Auto &m)
	Solve specialisation for Auto and RationalTag.
template<class IntVector, class Matrix, class Vector>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Auto &m)
	Solve specialization for Auto and IntegerTag.
template<class ResultVector, class Matrix, class Vector, class CategoryTag>
ResultVector &	solveInPlace (ResultVector &x, Matrix &A, const Vector &b, const CategoryTag &tag, const Method::Auto &m)
	Solve in place specialisation for Auto.
template<class ResultVector, class Matrix, class Vector>
ResultVector &	solveInPlace (ResultVector &x, Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Auto &m)
	Solve in place specialisation for Auto and IntegerTag.
template<class ResultVector, class Field, class Vector, class CategoryTag>
std::enable_if<!std::is_same< CategoryTag, RingCategories::IntegerTag >::value, ResultVector & >::type	solveInPlace (ResultVector &x, DenseMatrix< Field > &A, const Vector &b, const CategoryTag &tag, const Method::Auto &m)
	Solve in place specialisation for Auto with DenseMatrix and non-IntegerTag.
template<class ResultVector, class... MatrixArgs, class Vector, class CategoryTag>
std::enable_if<!std::is_same< CategoryTag, RingCategories::IntegerTag >::value, ResultVector & >::type	solveInPlace (ResultVector &x, SparseMatrix< MatrixArgs... > &A, const Vector &b, const CategoryTag &tag, const Method::Auto &m)
	Solve in place specialisation for Auto with SparseMatrix and non-IntegerTag.
template<class Matrix, class Vector>
void	solveInPlace (Vector &xNum, typename Vector::Element &xDen, Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Auto &m)
	Solve in place specialization for Auto and IntegerTag.
template<class ResultVector, class Matrix, class Vector, class CategoryTag>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const CategoryTag &tag, const Method::Blackbox &m)
	Solve specialisation for Blackbox.
template<class ResultVector, class Matrix, class Vector, class CategoryTag>
ResultVector &	solveInPlace (ResultVector &x, Matrix &A, const Vector &b, const CategoryTag &tag, const Method::Blackbox &m)
	Solve in place specialisation for Blackbox.
template<class IntVector, class Matrix, class Vector, class IterationMethod>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::CRA< IterationMethod > &m)
	Solve specialization with Chinese Remainder Algorithm method for an Integer or Rational tags.
template<class RatVector, class RatMatrix, class IterationMethod>
RatVector &	solve (RatVector &x, const RatMatrix &A, const RatVector &b, const RingCategories::RationalTag &tag, const Method::CRA< IterationMethod > &m)
	Solve specialization with Chinese Remainder Algorithm method for a Rational matrix.
template<class Matrix, class Vector>
Vector &	solve (Vector &x, const Matrix &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::DenseElimination &m)
	Solve specialisation for DenseElimination.
template<class Field, class Vector>
Vector &	solve (Vector &x, const DenseMatrix< Field > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::DenseElimination &m)
	Solve specialisation for DenseElimination on dense matrices with ModularTag.
template<class IntVector, class Blackbox, class Vector>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const Blackbox &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Dixon &m)
	Solve specialisation for Dixon on blackboxes matrices.
template<class IntVector, class Ring, class Vector>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const DenseMatrix< Ring > &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Dixon &m)
	Solve specialisation for Dixon on dense matrices.
template<class IntVector, class... MatrixArgs, class Vector>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const SparseMatrix< MatrixArgs... > &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Dixon &m)
	Solve specialisation for Dixon on sparse matrices.
template<class Matrix, class Vector, class CategoryTag>
Vector &	solve (Vector &x, const Matrix &A, const Vector &b, const CategoryTag &tag, const Method::Elimination &m)
	Solve specialisation for Elimination.
template<class MatrixField, class Vector, class CategoryTag>
Vector &	solve (Vector &x, const DenseMatrix< MatrixField > &A, const Vector &b, const CategoryTag &tag, const Method::Elimination &m)
	Solve specialisation for Elimination with DenseMatrix.
template<class MatrixField, class Vector, class CategoryTag>
Vector &	solve (Vector &x, const SparseMatrix< MatrixField > &A, const Vector &b, const CategoryTag &tag, const Method::Elimination &m)
	Solve specialisation for Elimination with SparseMatrix.
template<class Matrix, class Vector, class CategoryTag>
Vector &	solveInPlace (Vector &x, Matrix &A, const Vector &b, const CategoryTag &tag, const Method::Elimination &m)
	Solve in place specialisation for Elimination.
template<class MatrixField, class Vector, class CategoryTag>
Vector &	solveInPlace (Vector &x, DenseMatrix< MatrixField > &A, const Vector &b, const CategoryTag &tag, const Method::Elimination &m)
	Solve in place specialisation for Elimination with DenseMatrix.
template<class MatrixField, class Vector, class CategoryTag>
Vector &	solveInPlace (Vector &x, SparseMatrix< MatrixField > &A, const Vector &b, const CategoryTag &tag, const Method::Elimination &m)
	Solve in place specialisation for Elimination with SparseMatrix.
template<class Matrix, class Vector, class CategoryTag>
Vector &	solve (Vector &x, const Matrix &A, const Vector &b, const CategoryTag &tag, const Method::Lanczos &m)
	Solve specialisation for Lanczos.
template<class Matrix, class Vector>
Vector &	solve (Vector &x, const Matrix &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::Lanczos &m)
	Solve specialisation for Lanczos with ModularTag.
template<class Matrix, class Vector, class CategoryTag>
Vector &	solve (Vector &x, const Matrix &A, const Vector &b, const CategoryTag &tag, const Method::BlockLanczos &m)
	Solve specialisation for BlockLanczos.
template<class Matrix, class Vector>
Vector &	solve (Vector &x, const Matrix &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlockLanczos &m)
	Solve specialisation for BlockLanczos with ModularTag.
template<class IntVector, class Matrix, class Vector>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::SymbolicNumericNorm &m)
template<class IntVector, class Ring, class Vector>
void	solve (IntVector &xNum, typename IntVector::Element &xDen, const DenseMatrix< Ring > &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::SymbolicNumericNorm &m)
	Solve specialisation for SymbolicNumericNorm with IntegerTag on DenseMatrix.
template<class Matrix, class Vector>
Vector &	solve (Vector &x, const Matrix &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::SparseElimination &m)
	Solve specialisation for SparseElimination.
template<class... MatrixArgs, class Vector>
Vector &	solve (Vector &x, const SparseMatrix< MatrixArgs... > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::SparseElimination &m)
	Solve specialisation for SparseElimination with SparseMatrix.
template<class... MatrixArgs, class Vector>
Vector &	solveInPlace (Vector &x, SparseMatrix< MatrixArgs... > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::SparseElimination &m)
	Solve in place specialisation for SparseElimination with SparseMatrix.
template<class ResultVector, class Matrix, class Vector, class CategoryTag>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const CategoryTag &tag, const Method::Wiedemann &m)
	Solve specialisation for Wiedemann.
template<class ResultVector, class Matrix, class Vector>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Wiedemann &m)
	Solve specialisation for Wiedemann with IntegerTag.
template<class ResultVector, class Matrix, class Vector>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::Wiedemann &m)
	Solve specialisation for Wiedemann with ModularTag.
template<class ResultVector, class Matrix, class Vector, class CategoryTag>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const CategoryTag &tag, const Method::BlockWiedemann &m)
	Solve specialisation for BlockWiedemann.
template<class ResultVector, class Matrix, class Vector>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlockWiedemann &m)
	Solve specialisation for BlockWiedemann with ModularTag.
template<class ResultVector, class Matrix, class Vector, class CategoryTag>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const CategoryTag &tag, const Method::Coppersmith &m)
	Solve specialisation for Coppersmith.
template<class ResultVector, class Matrix, class Vector>
ResultVector &	solve (ResultVector &x, const Matrix &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::Coppersmith &m)
	Solve specialisation for Coppersmith on ModularTag.
template<class BB>
BB::Field::Element &	trace (typename BB::Field::Element &t, const BB &A)
	Sum of the eigenvalues.
template<class BB>
BB::Field::Element &	trace (typename BB::Field::Element &t, const BB &A, SolutionTags::Generic tt)
template<class BB>
BB::Field::Element &	trace (typename BB::Field::Element &t, const BB &A, SolutionTags::Local tt)
template<class Blackbox, class DomainCategory, class MyMethod>
Blackbox::Field::Element &	valence (typename Blackbox::Field::Element &V, const Blackbox &A, const DomainCategory &tag, const MyMethod &M)
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 Blackbox>
Blackbox::Field::Element &	valence (typename Blackbox::Field::Element &v, const Blackbox &A)
template<class Blackbox, class MyMethod>
Blackbox::Field::Element &	valence (typename Blackbox::Field::Element &v, const Blackbox &A, const RingCategories::ModularTag &tag, const MyMethod &M)
template<class Blackbox, class MyMethod>
Blackbox::Field::Element &	valence (typename Blackbox::Field::Element &V, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class Blackbox>
Blackbox::Field::Element &	squarizeValence (typename Blackbox::Field::Element &val_A, const Blackbox &A, size_t method=0)
Commentator &	commentator ()
Commentator &	commentator (std::ostream &stream)
void	parseArguments (int argc, char **argv, Argument *args, bool printDefaults=true)
double	nroot (double a, long r, double precision)
long	isnpower (long &l, long a)
std::ostream &	operator<< (std::ostream &o, const LinboxError &E)
bool	equalCaseInsensitive (const std::string &s1, const char *s2)
uint64_t	serialize (std::vector< uint8_t > &bytes, float value)
uint64_t	serialize (std::vector< uint8_t > &bytes, double value)
uint64_t	serialize (std::vector< uint8_t > &bytes, int8_t value)
uint64_t	serialize (std::vector< uint8_t > &bytes, uint8_t value)
uint64_t	serialize (std::vector< uint8_t > &bytes, int16_t value)
uint64_t	serialize (std::vector< uint8_t > &bytes, uint16_t value)
uint64_t	serialize (std::vector< uint8_t > &bytes, int32_t value)
uint64_t	serialize (std::vector< uint8_t > &bytes, uint32_t value)
uint64_t	serialize (std::vector< uint8_t > &bytes, int64_t value)
uint64_t	serialize (std::vector< uint8_t > &bytes, uint64_t value)
uint64_t	unserialize (float &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	unserialize (double &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	unserialize (int8_t &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	unserialize (uint8_t &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	unserialize (int16_t &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	unserialize (uint16_t &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	unserialize (int32_t &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	unserialize (uint32_t &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	unserialize (int64_t &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	unserialize (uint64_t &value, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
uint64_t	serialize (std::vector< uint8_t > &bytes, const Integer &integer)
	Serializes an Integer with its underlying __mpz_struct.
uint64_t	unserialize (Integer &integer, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
	Unserializes an Integer.
template<class Field>
uint64_t	serialize (std::vector< uint8_t > &bytes, const BlasMatrix< Field > &M)
	Serializes a BlasMatrix.
template<class Field>
uint64_t	unserialize (BlasMatrix< Field > &M, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
	Unserializes a BlasMatrix.
template<class Field>
uint64_t	serialize (std::vector< uint8_t > &bytes, const SparseMatrix< Field > &M)
	Serializes a SparseMatrix.
template<class Field>
uint64_t	unserialize (SparseMatrix< Field > &M, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
	Unserializes a SparseMatrix.
template<class Field>
uint64_t	serialize (std::vector< uint8_t > &bytes, const BlasVector< Field > &V)
	Serializes a BlasVector.
template<class Field>
uint64_t	unserialize (BlasVector< Field > &V, const std::vector< uint8_t > &bytes, uint64_t offset=0u)
	Unserializes a BlasVector.
template<class T>
uint64_t	serialize_raw (std::vector< uint8_t > &bytes, const T &value)
template<class T>
uint64_t	unserialize_raw (T &value, const std::vector< uint8_t > &bytes, uint64_t offset)
template<class Field>
std::ostream &	writeMMComment (std::ostream &os, Field &F, std::string name, std::string comment)
	Write second line and comment part of matrix market header.
template<class BB>
std::ostream &	writeMMCoordHeader (std::ostream &os, BB &A, size_t nnz, std::string name, std::string comment="")
	Write matrix market header (up to the i,j,val lines) for a sparse or structured matrix.
template<class BB>
std::ostream &	writeMMPatternHeader (std::ostream &os, BB &A, size_t nnz, std::string name, std::string comment="")
	Write matrix market header (up to the i,j lines) for a {0,1} sparse or structured matrix.
template<class BB>
std::ostream &	writeMMArrayHeader (std::ostream &os, BB &A, std::string name, std::string comment="")
	Write matrix market header (up to the entry lines) for a dense matrix.
template<class Mat>
std::ostream &	writeMMArray (std::ostream &os, Mat &A, std::string name, std::string comment="")
	Generic dense matrix writer to matrix market array format (col major).
std::string	eltype (float x)
	eltype(x) returns a string containing the name of the type of field or ring element x.
std::string	eltype (double x)
std::string	eltype (int8_t x)
std::string	eltype (int16_t x)
std::string	eltype (int32_t x)
std::string	eltype (int64_t x)
std::string	eltype (integer x)
std::string	eltype (uint8_t x)
std::string	eltype (uint16_t x)
std::string	eltype (uint32_t x)
std::string	eltype (uint64_t x)
std::istream &	operator>> (std::istream &is, BitVector::reference &a)
std::ostream &	operator<< (std::ostream &os, BitVector::reference &a)
std::ostream &	operator<< (std::ostream &os, BitVector::const_reference &a)
template<class Vector>
std::ostream &	operator<< (std::ostream &os, const BlasSubvector< Vector > &V)
template<class Vector>
bool	operator== (const BlasSubvector< Vector > &v1, const BlasSubvector< Vector > &v2)
template<class Field, class Storage>
bool	operator== (const BlasVector< Field, Storage > &v1, const BlasVector< Field, Storage > &v2)
template<class Field, class Storage>
std::ostream &	operator<< (std::ostream &os, const BlasVector< Field, Storage > &V)
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.
template<class Field, class Vector, class VectorTrait>
Vector	randomVector (Field &F, size_t n, typename Field::RandIter &r, VectorCategories::DenseVectorTag< VectorTrait > tag)
template<class Field, class Vector, class VectorTrait>
Vector	randomVector (Field &F, size_t n, typename Field::RandIter &r, VectorCategories::SparseSequenceVectorTag< VectorTrait > tag)
template<class Field, class Vector, class VectorTrait>
Vector	randomVector (Field &F, size_t n, typename Field::RandIter &r, VectorCategories::SparseAssociativeVectorTag< VectorTrait > tag)
void	isPower2 (size_t n)
template<class Ring, class Matrix>
Matrix &	hadamard (const Ring &R, Matrix &Mat, size_t n)
template<class Ring, class Matrix>
Matrix &	invhilb (const Ring &R, Matrix &Mat, int n)
template<class Ring, class Matrix>
Matrix &	jordanform (const Ring &R, Matrix &Mat, size_t n)
template<class Ring, class Matrix>
Matrix &	minmat (const Ring &R, Matrix &Mat, size_t n)
template<class Ring, class Matrix>
Matrix &	maxmat (const Ring &R, Matrix &Mat, size_t n)
template<class Ring, class Matrix>
Matrix &	qlehmer (const Ring &R, Matrix &Mat, size_t n)
template<class Ring, class Matrix>
Matrix &	randomAns (const Ring &R, Matrix &Mat, size_t n, size_t epr)
bool	used (vector< int > &array, int value)
template<class Ring, class Matrix>
Matrix &	randomMat (const Ring &R, Matrix &Mat, size_t n, size_t epr)
size_t &	RandIntInInt (const size_t &s, size_t &RIII, const int &seed=0)
	gives a random number such that \(0 \leq RIII < s\).
void	RandomPermutation (size_t *P, const size_t &len)
	Creates a random Lapack style Permutation P of size len.
int	permutationDet (size_t *P, const size_t len)
template<class Field>
bool	CheckRank (const Field &F, const typename Field ::Element *A, const size_t &m, const size_t &n, const size_t &lda, const size_t &alledged_rank)
	Checks we got the right rank.
template<class Field>
bool	CheckRank (const Field &F, const BlasMatrix< Field > &A, const size_t &alledged_rank)
template<class Field>
bool	CheckRank (const Field &F, const BlasSubmatrix< Field > &A, const size_t &alledged_rank)
template<class Field>
bool	CheckDet (const Field &F, const typename Field ::Element *A, const size_t &m, const size_t &lda, const typename Field ::Element &alledged_det)
template<class Field>
void	RandomMatrixWithRank (const Field &F, typename Field ::Element *A, const size_t &m, const size_t &n, const size_t &lda, const size_t &rank)
	Builds a m x n random matrix of rank rank over field F.
template<class Field>
void	RandomMatrixWithDet (const Field &F, typename Field ::Element *A, const size_t &m, const size_t &lda, const typename Field ::Element &det)
	Builds a m x m random matrix of determinant det over field F.
template<typename Container>
Integer &	magnitude (Integer &max_elt, const Container &v)
void	showAdvanceLinear (size_t curr, size_t min, size_t max)
	show the advancement (on the terminal) suppose linear advancement
void	showFinish (size_t curr, size_t all)
	tells the current series of measure has completed (on the terminal)
void	showSkip (size_t curr, size_t all)
	tells the current series of measure was skipped (on the terminal)
double	computeMFLOPS (const double &tim, const double mflo, const size_t rpt=1)
	computes the number of megaflops.
dvector_t &	insertTime (dvector_t &tim3, const double &tps)
	inserts a time in a vector of 3 best times.
double	computeMFLOPS (const dvector_t &tim, const double mflo, Tag::TimeSelect ts=Tag::TimeSelect::bestThree)
	computes the number of megaflops.
bool	isDigit (const std::string &s)
	Check if a string is actually a double.
bool	fortifiedString (const std::string &s)
	Tells is a string has double quotes around.
std::string	unfortifyString (const std::string &s)
	removes the surrounding quotes.
std::string	fortifyString (const std::string &s)
	adds surrounding quotes.
char	randomAlNum ()
	random :alnum: char. [[:alnum:]] characters are in range
std::string	randomAlNum (const size_t &m)
	random :alnum: string.
std::string	getDateTime (const std::string &sep)
	get ISO time and date
smatrix_t	getMachineInformation ()
	get some machine information (not cpu yet)
template<class T>
std::string	toString (T &nam)
	Converts anything to a string.
bool	findKeyword (size_t &i, const svector_t::const_iterator &begin, const svector_t::const_iterator &end, const std::string &keyword)
	finds keyword betwen begin and end, return true if found and i is the index where it is (possibly correspondig to end)
double	fit2 (const dvector_t &X, const dvector_t &Y, int n, double x)
	fit X[n-1,n],Y[n-1,n] and return evaluation at x.
double	fit3 (const dvector_t &X, const dvector_t &Y, int n, double x)
	fit X[n-2,n],Y[n-2,n] and return evaluation at x.
std::ostream &	operator<< (std::ostream &out, const CSValue &v)
template<>
NTL::GF2E &	Caster (NTL::GF2E &x, const Integer &y)
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.

Variables
double	g_time1 =0.0
double	g_time2 =0.0
double	g_time3 =0.0
double	g_time4 =0.0
const char *	solverReturnString [6] = {"OK", "FAILED", "SINGULAR", "INCONSISTENT", "BAD_PRECONDITIONER", "BAD_PRIME"}
const long	_DEGINFTY_ = -1
const char *	matrixMulKernelModular1DP
const char *	matrixMulKernelModular1SP
const char *	matrixMulKernelModular8DP
const char *	matrixMulKernelModular16SP
const char *	matrixMulKernelModular32DP
const char *	matrixMulKernelModular32SP
const char *	matrixMulKernelModular1024DP
const char *	matrixMulKernelModular1024SP
const char *	matrixMuladdKernelModular1DP
const char *	matrixMuladdKernelModular1SP
const char *	matrixMuladdKernelModular8DP
const char *	matrixMuladdKernelModular16SP
const char *	matrixMuladdKernelModular32DP
const char *	matrixMuladdKernelModular32SP
const char *	matrixMuladdKernelModular1024DP
const char *	matrixMuladdKernelModular1024SP
const char *	matrixAxpyKernelModular1DP
const char *	matrixAxpyKernelModular1SP
const char *	matrixAxpyKernelModular8DP
const char *	matrixAxpyKernelModular16SP
const char *	matrixAxpyKernelModular32DP
const char *	matrixAxpyKernelModular32SP
const char *	matrixAxpyKernelModular1024DP
const char *	matrixAxpyKernelModular1024SP
const char *	matrixMaxpyKernelModular1DP
const char *	matrixMaxpyKernelModular1SP
const char *	matrixMaxpyKernelModular8DP
const char *	matrixMaxpyKernelModular16SP
const char *	matrixMaxpyKernelModular32DP
const char *	matrixMaxpyKernelModular32SP
const char *	matrixMaxpyKernelModular1024DP
const char *	matrixMaxpyKernelModular1024SP
const char *	matrixAxmyKernelModular1DP
const char *	matrixAxmyKernelModular1SP
const char *	matrixAxmyKernelModular8DP
const char *	matrixAxmyKernelModular16SP
const char *	matrixAxmyKernelModular32DP
const char *	matrixAxmyKernelModular32SP
const char *	matrixAxmyKernelModular1024DP
const char *	matrixAxmyKernelModular1024SP
const int	BlasBound = 1 << 26
const char *	dpKernelSources []
const char *	dpKernelNames []
const char *	spKernelSources []
const char *	spKernelNames []
uint64_t	lambda = 1000000000

Detailed Description

Namespace in which all linbox code resides.

Provides way to serialize any kind of data, like matrices, vectors and Integer in a platform-independent way.

The matrix class Sliced is defined.

Bug

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

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

Warning

The timer comes from Givaro and lives in its anonymous namespace.

Bug

those are not just traits:

It adheres to the LinBox dense matrix interface.

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

Serialize functions add data to a prexisting vector of bytes, they return the number of bytes written. Unserialize ones read a vector of bytes starting at a specific offset, the number of bytes read.

As a convention, all numbers are written little-endian.

Todo

GMP Integers can be configured with limbs of different sizes (32 or 64 bits), depending on the machine. We do not handle that right now, but storing info about their dimension might be a good idea, to at least emit a warning.

Typedef Documentation

CTimer

typedef Givaro::Timer CTimer

MYRECINT

typedef Givaro::Modular<RecInt::ruint128,RecInt::ruint256> MYRECINT

PairIntRk

typedef std::pair<Givaro::Integer,size_t> PairIntRk

DoubleRealApproximation

typedef ParamFuzzy DoubleRealApproximation

Integer

typedef Givaro::Integer Integer

Examples

examples/smithvalence.C.

index_t

typedef ptrdiff_t index_t

DenseMatrix

template<class _Field>

using DenseMatrix = BlasMatrix<_Field>

DenseSubmatrix

template<class _Field>

using DenseSubmatrix = BlasSubmatrix<DenseMatrix<_Field> >

Index

typedef uint64_t Index

SmithPair

template<typename PIR>

using SmithPair = std::pair<typename PIR::Element,size_t>

SmithList

template<typename PIR>

using SmithList = std::list<SmithPair<PIR>>

Timer

typedef Givaro::Timer Timer

BaseTimer

typedef Givaro::BaseTimer BaseTimer

UserTimer

typedef Givaro::UserTimer UserTimer

SysTimer

typedef Givaro::SysTimer SysTimer

DenseVector

template<typename _Field>

using DenseVector = typename DenseVectorChooser<_Field>::type

DenseSubvector

template<class _Field>

using DenseSubvector = typename DenseSubVectorChooser<_Field>::type

mvector_t

typedef std::vector<MetaData> mvector_t

dvector_t

typedef std::vector<double> dvector_t

vector of double

svector_t

typedef std::vector<std::string> svector_t

dmatrix_t

typedef std::vector<dvector_t> dmatrix_t

matrix of double

smatrix_t

typedef std::vector<svector_t> smatrix_t

Enumeration Type Documentation

IterationResult

enum struct IterationResult

strong

Return type for CRA iteration.

The function object passed to the ChineseRemainder operators should return one of these values on each iteration.

Enumerator
CONTINUE	successful iteration; add to the result and keep going
SKIP	"bad prime"; ignore this result and keep going
RESTART	all previous iterations were bad; start over with this residue

RReconstructionSchedule

enum RReconstructionSchedule

Enumerator
INCREMENTAL
QUADRATIC
GEOMETRIC
CERTIFIED

ShiftStatus

enum ShiftStatus

Enumerator
SHIFT_GROW
SHIFT_SHRINK
SHIFT_PEAK
SHIFT_SEARCH
SHIFT_MAX

anonymous enum

anonymous enum

Enumerator
PRIVILEGIATE_NO_COLUMN_PIVOTING
PRIVILEGIATE_REDUCING_FILLIN
PRESERVE_UPPER_MATRIX

BBType

enum BBType

Enumerator
diagonal
permutation
triangular
product
lqup
pluq
other

PMType

enum PMType

Enumerator
polfirst
matfirst
matrowfirst

Singularity

enum class Singularity

strong

Singularity of the system.

Only meaningful if the matrix is square.

Enumerator
Unknown	We don't know yet, or the matrix is not square.
Singular	The matrix is non-invertible.
NonSingular	The matrix is invertible.

Dispatch

enum class Dispatch

strong

For integer-based methods that evaluate multiple times the system at different moduli, decides how to dispatch each sub-computations.

Enumerator
Auto	Let implementation decide what to use.
Sequential	All sub-computations are done sequentially.
SMP	Use symmetric multiprocessing (Paladin) to do sub-computations.
Distributed	Use MPI to distribute sub-computations accross nodes.
Combined	Use MPI then Paladin on each node.

SingularSolutionType

enum class SingularSolutionType

strong

For Dixon method, which solution type to get when the system is singular.

Enumerator
Deterministic	The solution should be the easiest to compute and always the same.
Random	The solution should be random and different at each call.
Diophantine	The solution is given over the integers.

Preconditioner

enum class Preconditioner

strong

Preconditioner to ensure generic rank profile.

Enumerator
None	Do not use any preconditioner.
Butterfly	Use a butterfly network, see Butterfly.
Sparse	Use a sparse preconditioner, c.f. (Mulders 2000).
Toeplitz	Use a Toeplitz preconditioner, c.f. (Kaltofen and Saunders 1991).
Symmetrize	Use At A (Eberly and Kaltofen 1997).
PartialDiagonal	Use A D, where D is a random non-singular diagonal matrix (Eberly and Kaltofen 1997).
PartialDiagonalSymmetrize	Use At D A (Eberly and Kaltofen 1997).
FullDiagonal	Use D1 At D2 A D1 (Eberly and Kaltofen 1997).
Dense	Multiply (@fixme or add?) by a random dense matrix (used by Dixon).

PivotStrategy

enum class PivotStrategy

strong

Pivoting strategy for elimination-based methods.

Enumerator
None
Linear

MatrixStreamError

enum MatrixStreamError

Enumerator
GOOD
END_OF_MATRIX
END_OF_FILE
BAD_FORMAT
NO_FORMAT

Function Documentation

bitonicSort()

template<class Iterator, class Comparator>

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

bitonicMerge()

template<class Iterator, class Comparator>

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

BLTraceReport()

template<class Domain, class Object>

void BLTraceReport ( std::ostream & out, Domain & D, const char * text, size_t iter, const Object & obj )

inline

reportS()

void reportS ( std::ostream & out, const std::vector< bool > & S, size_t iter )

inline

checkAConjugacy()

template<class Field, class Matrix>

void checkAConjugacy ( const MatrixDomain< Field > & MD, const Matrix & AV, const Matrix & V, Matrix & T, size_t AV_iter, size_t V_iter )

inline

write_maple()

template<class Field, class Coefficient>

void write_maple	(	const Field &	F,
		const std::vector< Coefficient > &	P )

rational_charpoly()

template<class Rationals, template< class > class Vector, class MyMethod>

Vector< typename Rationals::Element > & rational_charpoly	(	Vector< typename Rationals::Element > &	p,
		const BlasMatrix< Rationals > &	A,
		const MyMethod &	Met = Method::Auto() )

NullSpaceBasisIn() [1/3]

template<class Field>

size_t & NullSpaceBasisIn	(	const Tag::Side	Side,
		BlasMatrix< Field > &	A,
		BlasMatrix< Field > &	Ker,
		size_t &	kerdim )

Nullspace of a dense matrix on a finite field.

A is modified.

Parameters

	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

Returns

kerdim

Todo

make it work for BlasSubmatrix too

NullSpaceBasisIn() [2/3]

template<class DenseMat>

size_t & NullSpaceBasisIn	(	const Tag::Side	Side,
		BlasSubmatrix< DenseMat > &	A,
		BlasMatrix< typename DenseMat::Field > &	Ker,
		size_t &	kerdim )

Todo

uses too much memory

Todo

use copy

NullSpaceBasis() [1/2]

template<class Field>

size_t & NullSpaceBasis	(	const Tag::Side	Side,
		const BlasMatrix< Field > &	A,
		BlasMatrix< Field > &	Ker,
		size_t &	kerdim )

Nullspace of a dense matrix on a finite field.

A is preserved.

Parameters

	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

Returns

kerdim

Todo

make it work for BlasSubmatrix too

NullSpaceBasis() [2/2]

template<class DenseMat>

size_t & NullSpaceBasis	(	const Tag::Side	Side,
		const BlasSubmatrix< DenseMat > &	A,
		BlasMatrix< typename DenseMat::Field > &	Ker,
		size_t &	kerdim )

NullSpaceBasisIn() [3/3]

template<class Field>

size_t NullSpaceBasisIn	(	const Field &	F,
		const Tag::Side	Side,
		const size_t &	m,
		const size_t &	n,
		typename Field::Element *	A,
		const size_t &	lda,
		typename Field::Element *&	Ker,
		size_t &	ldk,
		size_t &	kerdim )

Computes the kernel of a dense matrix using LQUP.

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

Warning

timings may vary and these choices were made on an experimental basis.

Parameters

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.

Returns

dimension of the kernel.

Warning

A is modified.

corrections()

template<class Blackbox>

Blackbox::Field::Element & corrections	(	Blackbox &	IntBB,
		typename Blackbox::Field::Element &	f )

rational_det()

template<class Rationals, class MyMethod>

Rationals::Element & rational_det	(	typename Rationals::Element &	d,
		const BlasMatrix< Rationals > &	A,
		const MyMethod &	Met = Method::Auto() )

certifyEmpty()

template<class Matrix, class Vector, class Ring = typename Matrix::Field>

SolverReturnStatus certifyEmpty	(	const Matrix &	A,
		const Vector &	b,
		const MethodBase &	method,
		Integer &	certifiedDenFactor )

doubleDetModp()

template<class Field>

void doubleDetModp	(	const Field &	F,
		const size_t	N,
		typename Field::Element &	d1,
		typename Field::Element &	d2,
		typename Field::Element *	A,
		const size_t	lda,
		typename Field::Element *	b,
		const size_t	incb,
		typename Field::Element *	c,
		const size_t	incc )

doubleDetGivenDivisors()

template<class BlackBox>

void doubleDetGivenDivisors	(	const BlackBox &	A,
		typename BlackBox::Field::Element &	d1,
		typename BlackBox::Field::Element &	d2,
		const typename BlackBox::Field::Element &	s1,
		const typename BlackBox::Field::Element &	s2,
		const bool	proof )

doubleDet()

template<class BlackBox>

void doubleDet	(	typename BlackBox::Field::Element &	d1,
		typename BlackBox::Field::Element &	d2,
		const BlackBox &	A,
		bool	proof )

partial_hegcd()

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.

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.

dyadicToRational() [1/2]

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.

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.

dyadicToRational() [2/2]

template<class Ring>

int dyadicToRational	(	const Ring &	Z,
		BlasVector< Ring > &	num,
		typename Ring::Element &	den,
		BlasVector< Ring > &	numx,
		typename Ring::Element &	denx,
		typename Ring::Element &	denBound )

reportPermutation()

std::ostream & reportPermutation	(	std::ostream &	out,
		const std::vector< std::pair< unsigned int, unsigned int > > &	P )

nextnonzero()

template<class _Matrix>

bool nextnonzero ( size_t & k, size_t Ni, const _Matrix & A )

inline

LABLTraceReport()

template<class Domain, class Object>

void LABLTraceReport ( std::ostream & out, Domain & D, const char * text, size_t iter, const Object & obj )

inline

LABLReportPriorityIndices()

void LABLReportPriorityIndices	(	std::ostream &	,
		std::list< size_t > &	,
		const char *	)

traceReport() [1/2]

template<class Field, class LVector>

void traceReport ( std::ostream & out, VectorDomain< Field > & VD, const char * text, size_t iter, const LVector & v )

inline

traceReport() [2/2]

template<class Field, class LVector>

void traceReport	(	std::ostream &	out,
		const Field &	F,
		const char *	text,
		size_t	iter,
		const typename Field::Element &	a )

lllReduceIn() [1/2]

template<class Ring, class myMethod>

void lllReduceIn	(	BlasMatrix< Ring > &	H,
		const myMethod &	meth = latticeMethod::latticeNTL_LLL () )

lllReduceIn() [2/2]

template<class Ring, class myMethod>

void lllReduceIn	(	BlasMatrix< Ring > &	H,
		BlasMatrix< Ring > &	U,
		const myMethod &	meth = latticeMethod::latticeNTL_LLL () )

lllReduce() [1/2]

template<class Ring, class myMethod>

void lllReduce	(	BlasMatrix< Ring > &	H,
		const BlasMatrix< Ring > &	A,
		const myMethod &	meth = latticeMethod::latticeNTL_LLL () )

lllReduce() [2/2]

template<class Ring, class myMethod>

void lllReduce	(	BlasMatrix< Ring > &	H,
		BlasMatrix< Ring > &	U,
		const BlasMatrix< Ring > &	A,
		const myMethod &	meth = latticeMethod::latticeNTL_LLL () )

MGBLTraceReport()

template<class Domain, class Object>

void MGBLTraceReport ( std::ostream & out, Domain & D, const char * text, size_t iter, const Object & obj )

inline

rational_minpoly()

template<class Rationals, template< class > class Vector, class MyMethod>

Vector< typename Rationals::Element > & rational_minpoly	(	Vector< typename Rationals::Element > &	p,
		const BlasMatrix< Rationals > &	A,
		const MyMethod &	Met = Method::Auto() )

enumPlatforms()

std::vector< cl_platform_id > enumPlatforms

(

)

Enumerate all of the platforms currently available on the system.

getPlatformName()

std::string getPlatformName

(

cl_platform_id

platform

)

Get the platform name associated with the platform.

getPlatformVersion()

double getPlatformVersion

(

cl_platform_id

platform

)

Get the platform version associated with the platform.

getPlatformExtensions()

std::vector< std::string > getPlatformExtensions

(

cl_platform_id

platform

)

Get the platform extensions associated with the platform.

enumDevices()

std::vector< cl_device_id > enumDevices

(

cl_platform_id

platform

)

Enumerate all of the devices currently available on the platform.

createContext()

cl_context createContext	(	cl_platform_id	platform,
		cl_device_id	device )

Create an OpenCL context from a platfrom and device.

accessOpenCLResourceController()

OpenCLResourceController & accessOpenCLResourceController

(

)

computePolyDet()

template<class Field>

Givaro::Poly1Dom< Field, Givaro::Dense >::Element & computePolyDet	(	typename Givaro::Poly1Dom< Field, Givaro::Dense >::Element &	result,
		DenseMatrix< Givaro::Poly1Dom< Field, Givaro::Dense > > &	A,
		int	d )

roundUpPowerOfTwo()

int roundUpPowerOfTwo

(

unsigned int

n

)

computePolyDetExtension()

template<class Field, class Matrix>

Givaro::Poly1Dom< Field, Givaro::Dense >::Element & computePolyDetExtension	(	typename Givaro::Poly1Dom< Field, Givaro::Dense >::Element &	result,
		Field &	F,
		Matrix &	A )

check_mul() [1/2]

template<typename Field>

bool check_mul ( const PolynomialMatrix< Field, PMType::matfirst > & c, const PolynomialMatrix< Field, PMType::matfirst > & a, const PolynomialMatrix< Field, PMType::matfirst > & b, size_t deg )

inline

check_mul() [2/2]

template<typename Field>

bool check_mul ( const PolynomialMatrix< Field, PMType::polfirst > & c, const PolynomialMatrix< Field, PMType::polfirst > & a, const PolynomialMatrix< Field, PMType::polfirst > & b, size_t deg )

inline

check_midproduct()

template<typename MatrixP_F>

bool check_midproduct ( const MatrixP_F & c, const MatrixP_F & a, const MatrixP_F & b, bool smallLeft = true, size_t n0 = 0, size_t n1 = 0, size_t deg = 0 )

inline

maxFFTPrimeValue()

uint64_t maxFFTPrimeValue ( uint64_t k, uint64_t pts )

inline

getFFTPrime()

void getFFTPrime ( uint64_t prime_max, size_t lpts, integer bound, std::vector< integer > & bas, size_t k, size_t d )

inline

NumBytes()

long NumBytes ( const Integer & m )

inline

rational_reconstruction()

int rational_reconstruction ( integer & a, integer & b, const integer & n0, const integer & d0, const integer & B )

inline

large_double_division()

int large_double_division	(	integer &	x,
		const integer &	y,
		const integer &	z )

NO DOC.

operator<<() [1/17]

std::ostream & operator<<	(	std::ostream &	os,
		LargeDouble &	x )

TempLRank() [1/2]

template<class Field>

size_t & TempLRank	(	size_t &	r,
		const char *	filename,
		const Field &	F )

TempLRank() [2/2]

size_t & TempLRank	(	size_t &	r,
		const char *	filename,
		const GF2 &	F2 )

LRank()

size_t & LRank	(	size_t &	r,
		const char *	filename,
		Givaro::Integer	p )

PRank()

std::vector< size_t > & PRank	(	std::vector< size_t > &	ranks,
		size_t &	effective_exponent,
		const char *	filename,
		Givaro::Integer	p,
		size_t	e,
		size_t	intr )

PRankPowerOfTwo()

std::vector< size_t > & PRankPowerOfTwo	(	std::vector< size_t > &	ranks,
		size_t &	effective_exponent,
		const char *	filename,
		size_t	e,
		size_t	intr )

PRankInteger()

std::vector< size_t > & PRankInteger	(	std::vector< size_t > &	ranks,
		const char *	filename,
		Givaro::Integer	p,
		size_t	e,
		size_t	intr )

PRankIntegerPowerOfTwo()

std::vector< size_t > & PRankIntegerPowerOfTwo	(	std::vector< size_t > &	ranks,
		const char *	filename,
		size_t	e,
		size_t	intr )

AllPowersRanks()

std::vector< size_t > & AllPowersRanks	(	std::vector< size_t > &	ranks,
		const Givaro::Integer &	squarefreePrime,
		const size_t &	squarefreeRank,
		const size_t &	exponentBound,
		const size_t &	coprimeRank,
		const char *	filename )

populateSmithForm()

std::vector< Givaro::Integer > & populateSmithForm	(	std::vector< Givaro::Integer > &	SmithDiagonal,
		const std::vector< size_t > &	ranks,
		const Givaro::Integer &	squarefreePrime,
		const size_t &	squarefreeRank,
		const size_t &	coprimeRank )

smithValence() [1/2]

template<class Blackbox>

std::vector< Givaro::Integer > & smithValence	(	std::vector< Givaro::Integer > &	SmithDiagonal,
		Givaro::Integer &	valence,
		const Blackbox &	A,
		const std::string &	filename,
		Givaro::Integer &	coprimeV,
		size_t	method = 0 )

smithValence() [2/2]

template<class Blackbox>

std::vector< Givaro::Integer > & smithValence	(	std::vector< Givaro::Integer > &	SmithDiagonal,
		const Blackbox &	A,
		const std::string &	filename,
		size_t	method = 0 )

writeCompressedSmith()

template<class PIR>

std::ostream & writeCompressedSmith	(	std::ostream &	out,
		const std::vector< typename PIR::Element > &	SmithDiagonal,
		const PIR &	ZZ,
		const size_t	m,
		const size_t	n )

toeplitz_determinant()

template<class PField>

PField::Coeff & toeplitz_determinant	(	const PField &	F,
		typename PField::Coeff &	res,
		const typename PField::Element &	T,
		size_t	n )

upperTriangularSolveBinary()

template<class _Matrix, class Vector1, class Vector2>

Vector1 & upperTriangularSolveBinary	(	Vector1 &	x,
		const _Matrix &	U,
		const Vector2 &	b )

lowerTriangularUnitarySolveBinary()

template<class _Matrix, class Vector1, class Vector2>

Vector1 & lowerTriangularUnitarySolveBinary	(	Vector1 &	x,
		const _Matrix &	L,
		const Vector2 &	b )

upperTriangularSolve()

template<class _Matrix, class Vector1, class Vector2>

Vector1 & upperTriangularSolve	(	Vector1 &	x,
		const _Matrix &	U,
		const Vector2 &	b )

upperTriangularSparseSolve()

template<class _Matrix, class Vector1, class Vector2>

Vector1 & upperTriangularSparseSolve	(	Vector1 &	x,
		size_t	rank,
		const _Matrix &	U,
		const Vector2 &	b )

lowerTriangularUnitarySolve()

template<class _Matrix, class Vector1, class Vector2>

Vector1 & lowerTriangularUnitarySolve	(	Vector1 &	x,
		const _Matrix &	L,
		const Vector2 &	b )

reduceIn()

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

vectorGcdIn()

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

vectorGcd()

template<class Domain, class Vector>

Domain::Element vectorGcd	(	Domain &	D,
		Vector &	v )

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

WhisartTrace() [1/4]

template<class Field, class BB>

Field::Element & WhisartTrace	(	typename Field::Element &	trace,
		const Field &	F,
		const LinBox::Diagonal< Field > &	ExtD,
		const BB &	A,
		const LinBox::Diagonal< Field > &	InD )

WhisartTraceTranspose() [1/4]

template<class Field, class BB>

Field::Element & WhisartTraceTranspose	(	typename Field::Element &	trace,
		const Field &	F,
		const LinBox::Diagonal< Field > &	ExtD,
		const BB &	A,
		const LinBox::Diagonal< Field > &	InD )

WhisartTrace() [2/4]

template<class Field, class BB>

Field::Element & WhisartTrace	(	typename Field::Element &	tr,
		const Field &	F,
		const LinBox::Diagonal< Field > &	ExtD,
		const BB &	A,
		const LinBox::Diagonal< Field > &	InD,
		IndexedTags::NoIndexed	t )

WhisartTraceTranspose() [2/4]

template<class Field, class BB>

Field::Element & WhisartTraceTranspose	(	typename Field::Element &	tr,
		const Field &	F,
		const LinBox::Diagonal< Field > &	ExtD,
		const BB &	A,
		const LinBox::Diagonal< Field > &	InD,
		IndexedTags::NoIndexed	t )

WhisartTrace() [3/4]

template<class Field, class BB>

Field::Element & WhisartTrace	(	typename Field::Element &	tr,
		const Field &	F,
		const LinBox::Diagonal< Field > &	ExtD,
		const BB &	A,
		const LinBox::Diagonal< Field > &	InD,
		IndexedTags::HasIndexed	)

WhisartTrace() [4/4]

template<class Field, class BB>

Field::Element & WhisartTrace	(	typename Field::Element &	tr,
		const Field &	F,
		const LinBox::Diagonal< Field > &	ExtD,
		const BB &	A,
		const LinBox::Diagonal< Field > &	InD,
		IndexedTags::HasNext	)

WhisartTraceTranspose() [3/4]

template<class Field, class BB>

Field::Element & WhisartTraceTranspose	(	typename Field::Element &	tr,
		const Field &	F,
		const LinBox::Diagonal< Field > &	ExtD,
		const BB &	A,
		const LinBox::Diagonal< Field > &	InD,
		IndexedTags::HasIndexed	)

WhisartTraceTranspose() [4/4]

template<class Field, class BB>

Field::Element & WhisartTraceTranspose	(	typename Field::Element &	tr,
		const Field &	F,
		const LinBox::Diagonal< Field > &	ExtD,
		const BB &	A,
		const LinBox::Diagonal< Field > &	InD,
		IndexedTags::HasNext	)

minpoly() [1/13]

template<class Polynomial, class Blackbox>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		RingCategories::ModularTag	tag,
		const Method::Wiedemann &	M = Method::Wiedemann () )

minpoly() [2/13]

template<class Polynomial, class Blackbox>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::WiedemannExtension &	M )

apply()

template<class OutV, class Matrix, class InV>

OutV & apply ( OutV & y, const Matrix & A, const InV & x )

inline

applyTranspose()

template<class OutV, class Matrix, class InV>

OutV & applyTranspose ( OutV & y, const Matrix & A, const InV & x )

inline

create_MatrixQadic()

template<class Domain, class IMatrix>

void create_MatrixQadic	(	const Domain &	D,
		const IMatrix &	Mat,
		double *	chunks,
		size_t	num_chunks,
		const integer	shift = 0 )

split an integer matrix into a padic chunk representation

create_VectorQadic() [1/2]

template<class Domain, class IVector>

void create_VectorQadic	(	const Domain &	D,
		const IVector &	V,
		double *	chunks,
		size_t	num_chunks )

create_MatrixRNS()

template<class Domain, class IMatrix>

void create_MatrixRNS	(	const MultiModDouble &	F,
		const Domain &	D,
		const IMatrix &	Mat,
		double *	chunks )

create_VectorRNS()

template<class Domain, class IVector>

void create_VectorRNS	(	const MultiModDouble &	F,
		const Domain &	D,
		const IVector &	V,
		double *	chunks )

create_VectorQadic() [2/2]

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

create_VectorQadic_32()

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

MatPolyHornerEval()

template<class Field>

void MatPolyHornerEval	(	const Field &	F,
		BlasMatrix< Field > &	R,
		const std::vector< BlasMatrix< Field > > &	P,
		const typename Field::Element &	a )

VectHornelEval()

template<class Field>

void VectHornelEval	(	const Field &	F,
		std::vector< typename Field::Element > &	E,
		const std::vector< typename Field::Element > &	P,
		size_t	block,
		const typename Field::Element &	a )

BlockHankelEvaluation()

template<class Field>

void BlockHankelEvaluation	(	const Field &	F,
		std::vector< BlasMatrix< Field > > &	E,
		const std::vector< BlasMatrix< Field > > &	P,
		size_t	k )

BHVectorEvaluation()

template<class Field>

void BHVectorEvaluation	(	const Field &	F,
		std::vector< std::vector< typename Field::Element > > &	E,
		const std::vector< typename Field::Element > &	P,
		size_t	block )

BHVectorLagrangeCoeff()

template<class Field>

void BHVectorLagrangeCoeff	(	const Field &	F,
		std::vector< std::vector< typename Field::Element > > &	P,
		size_t	k )

BHVectorInterpolation()

template<class Field>

void BHVectorInterpolation	(	const Field &	F,
		std::vector< typename Field::Element > &	x,
		const std::vector< std::vector< typename Field::Element > > &	E,
		const std::vector< std::vector< typename Field::Element > > &	P,
		size_t	shift )

setButterfly()

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

inline

A function used with Butterfly Blackbox Matrices.

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

Returns

vector of booleans for setting switches

Parameters

x	vector of booleans marking elements to switch into contiguous block
j	offset of contiguous block

genericNullspaceRandomRight()

template<class Field>

DenseMatrix< Field > & genericNullspaceRandomRight	(	DenseMatrix< Field > &	N,
		const FIBB< Field > &	A )

N: AN = 0, each col random.

genericNullspaceRandomLeft()

template<class Field>

DenseMatrix< Field > & genericNullspaceRandomLeft	(	DenseMatrix< Field > &	N,
		const FIBB< Field > &	A )

N: NA = 0, each row random.

revLexLess()

bool revLexLess	(	const std::pair< size_t, size_t > &	a,
		const std::pair< size_t, size_t > &	b )

areFieldEqual() [1/2]

template<class _Field1, class _Field2>

bool areFieldEqual	(	const _Field1 &	F,
		const _Field2 &	G )

areFieldEqualSpecialised() [1/2]

template<class _Field, class _Category>

bool areFieldEqualSpecialised	(	const _Field &	F,
		const _Field &	G,
		const _Category &	m )

areFieldEqualSpecialised() [2/2]

template<class _Field>

bool areFieldEqualSpecialised	(	const _Field &	F,
		const _Field &	G,
		const RingCategories::ModularTag &	m )

areFieldEqual() [2/2]

template<class _Field>

bool areFieldEqual	(	const _Field &	F,
		const _Field &	G )

abs()

template<class T>

T abs

(

const T &

a

)

naturallog()

double naturallog ( const Givaro::Integer & a )

inline

Natural logarithm (ln).

log(2) being close to 0.69314718055994531

Parameters

a

integer.

Returns

ln(a).

isPositive() [1/2]

template<class T>

std::enable_if<!std::is_unsigned< T >::value, bool >::value isPositive ( const T & t )

inline

Positiveness of an integer.

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

Parameters

x

integer

Returns

true iff x>=0.

isPositive() [2/2]

template<class T>

std::enable_if< std::is_unsigned< T >::value, bool >::value isPositive ( const T & t )

inline

isNegative() [1/2]

template<class T>

std::enable_if<!std::is_unsigned< T >::value, bool >::value isNegative ( const T & t )

inline

isNegative() [2/2]

template<class T>

std::enable_if< std::is_unsigned< T >::value, bool >::value isNegative ( const T & t )

inline

isOdd()

template<typename IntType>

bool isOdd ( const IntType & value )

inline

isEven()

template<typename IntType>

bool isEven ( const IntType & p )

inline

operator<<() [2/17]

template<class _Field, class _Storage>

std::ostream & operator<<	(	std::ostream &	os,
		const BlasMatrix< _Field, _Storage > &	Mat )

Write a matrix to a stream.

The C++ way using operator<<

Parameters

o	output stream
Mat	matrix to write.

operator<<() [3/17]

template<class _Matrix>

std::ostream & operator<<	(	std::ostream &	os,
		const BlasSubmatrix< _Matrix > &	Mat )

operator<<() [4/17]

template<class _Uint>

std::ostream & operator<<	(	std::ostream &	o,
		BlasPermutation< _Uint > &	P )

operator<<() [5/17]

template<class _UnsignedInt>

std::ostream & operator<<	(	std::ostream &	o,
		MatrixPermutation< _UnsignedInt > &	P )

element_storage() [1/2]

template<typename Field>

uint64_t element_storage ( const Field & F )

inline

element_storage() [2/2]

template<>

uint64_t element_storage ( const Givaro::Modular< Givaro::Integer > & F )

inline

operator<<() [6/17]

template<typename _Field, LinBox::PMType T>

std::ostream & operator<< ( std::ostream & os, const PolynomialMatrix< _Field, T > & P )

inline

operator<<() [7/17]

template<typename MatPoly>

std::ostream & operator<< ( std::ostream & os, const SubPolynomialMatrix< MatPoly > & P )

inline

RandomBlasPermutation()

void RandomBlasPermutation

(

BlasPermutation< size_t > &

P

)

Todo

To be factorized.

operator<<() [8/17]

template<class T>

std::ostream & operator<<	(	std::ostream &	o,
		const DenseMat< T > &	Mat )

Write a matrix to a stream.

The C++ way using operator<<

Parameters

o	output stream
Mat	matrix to write.

operator<<() [9/17]

template<class _Field, class _Storage>

std::ostream & operator<<	(	std::ostream &	os,
		const SparseMatrix< _Field, _Storage > &	Mat )

operator>>() [1/4]

template<class _Field, class _Storage>

std::istream & operator>>	(	std::istream &	is,
		SparseMatrix< _Field, _Storage > &	A )

prepare()

template<class Field, class Vector>

Vector & prepare	(	const Field &	F,
		Vector &	y,
		const typename Field::Element &	a )

y <- ay.

Todo

Vector knows Field

operator<<() [10/17]

template<class Field, class Row>

std::ostream & operator<<	(	std::ostream &	os,
		const Protected::SparseMatrixGeneric< Field, Row > &	A )

operator>>() [2/4]

template<class Field, class Row>

std::istream & operator>>	(	std::istream &	is,
		Protected::SparseMatrixGeneric< Field, Row > &	A )

SparseMatrix< Field_, SparseMatrixFormat::TPL >applyLeft()

template<class Mat1, class Mat2>

Mat1 & SparseMatrix< Field_, SparseMatrixFormat::TPL >applyLeft	(	Mat1 &	Y,
		const Mat2 &	X ) const

operator<<() [11/17]

std::ostream & operator<< ( std::ostream & out, const TriplesCoord & coord )

inline

operator>>() [3/4]

TriplesCoord operator>> ( const TriplesCoord & coord, unsigned int shift )

inline

operator+()

TriplesCoord operator+ ( const TriplesCoord & lhs, const TriplesCoord & rhs )

inline

operator==() [1/3]

bool operator== ( const TriplesCoord & lhs, const TriplesCoord & rhs )

inline

operator<()

bool operator< ( const TriplesCoord & lhs, const TriplesCoord & rhs )

inline

operator-()

TriplesCoord operator- ( const TriplesCoord & lhs, const TriplesCoord & rhs )

inline

coordFromBlock()

void coordFromBlock ( TriplesCoord & coord )

inline

coordToBlock()

void coordToBlock ( TriplesCoord & coord )

inline

MultiplyDeBruijnHighestBit()

uint32_t MultiplyDeBruijnHighestBit ( uint32_t v )

inline

create_prime_sequence()

template<typename Container>

PrimeSequence< typename Container::const_iterator > create_prime_sequence

(

const Container &

cont

)

convenience factory to create a PrimeSequence from an STL-like container.

charpoly() [1/13]

template<class Blackbox, class Polynomial, class MyMethod, class DomainCategory>

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

charpoly() [2/13]

template<class Blackbox, class Polynomial, class MyMethod>

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

...using an optional Method parameter

Parameters

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

Returns

a reference to P.

charpoly() [3/13]

template<class Blackbox, class Polynomial>

Polynomial & charpoly	(	Polynomial &	P,
		const Blackbox &	A )

...using default method

charpoly() [4/13]

template<class Blackbox, class Polynomial>

Polynomial & charpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	M )

charpoly() [5/13]

template<class Domain, class Polynomial>

Polynomial & charpoly	(	Polynomial &	P,
		const SparseMatrix< Domain > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	M )

charpoly() [6/13]

template<class Domain, class Polynomial>

Polynomial & charpoly	(	Polynomial &	P,
		const BlasMatrix< Domain > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	M )

charpoly() [7/13]

template<class Blackbox, class Polynomial>

Polynomial & charpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Elimination &	M )

charpoly() [8/13]

template<class Blackbox, class Polynomial>

Polynomial & charpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::DenseElimination &	M )

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

Compute the characteristic polynomial of a matrix using dense elimination methods

Parameters

P	Polynomial where to store the result
A	Blackbox representing the matrix
tag
M

charpoly() [9/13]

template<class Blackbox, class Polynomial>

Polynomial & charpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Auto &	M )

charpoly() [10/13]

template<class Blackbox, class Polynomial>

Polynomial & charpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Elimination &	M )

charpoly() [11/13]

template<class Matrix, class Polynomial, class Method>

Polynomial & charpoly	(	Polynomial &	P,
		const Matrix &	A,
		const RingCategories::IntegerTag &	tag,
		const Method &	M )

charpoly() [12/13]

template<class Blackbox, class Polynomial>

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

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

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

Parameters

P	Polynomial where to store the result
A	Blackbox representing the matrix
tag
M

charpoly() [13/13]

template<class Blackbox, class Polynomial, class MyMethod>

Polynomial & charpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::RationalTag &	tag,
		const MyMethod &	M )

detInPlace() [1/12]

template<class Blackbox, class DetMethod, class DomainCategory>

Blackbox::Field::Element & detInPlace	(	typename Blackbox::Field::Element &	d,
		Blackbox &	A,
		const DomainCategory &	tag,
		const DetMethod &	Meth )

det() [1/15]

template<class Blackbox>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A )

detInPlace() [2/12]

template<class Blackbox>

Blackbox::Field::Element & detInPlace	(	typename Blackbox::Field::Element &	d,
		Blackbox &	A )

det() [2/15]

template<class Blackbox, class MyMethod>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const MyMethod &	Meth )

detInPlace() [3/12]

template<class Blackbox, class MyMethod>

Blackbox::Field::Element & detInPlace	(	typename Blackbox::Field::Element &	d,
		Blackbox &	A,
		const MyMethod &	Meth )

det() [3/15]

template<class Blackbox>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	Meth )

detInPlace() [4/12]

template<class Blackbox>

Blackbox::Field::Element & detInPlace	(	typename Blackbox::Field::Element &	d,
		Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	Meth )

det() [4/15]

template<class Field>

Field::Element & det	(	typename Field::Element &	d,
		const BlasMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	Meth )

detInPlace() [5/12]

template<class Field>

Field::Element & detInPlace	(	typename Field::Element &	d,
		BlasMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	Meth )

det() [5/15]

template<class CField, class PField>

CField::Element & det	(	typename CField::Element &	res,
		const Toeplitz< CField, PField > &	A )

detInPlace() [6/12]

template<class CField, class PField>

CField::Element & detInPlace	(	typename CField::Element &	res,
		Toeplitz< CField, PField > &	A )

det() [6/15]

template<class Blackbox>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Blackbox &	Meth )

det() [7/15]

template<class Blackbox>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Wiedemann &	Meth )

det() [8/15]

template<class Blackbox>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::DenseElimination &	Meth )

det() [9/15]

template<class Blackbox>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::SparseElimination &	Meth )

det() [10/15]

template<class Field, class Vector>

Field::Element & det	(	typename Field::Element &	d,
		const SparseMatrix< Field, Vector > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::SparseElimination &	Meth )

detInPlace() [7/12]

template<class Field>

Field::Element & detInPlace	(	typename Field::Element &	d,
		SparseMatrix< Field, SparseMatrixFormat::SparseSeq > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::SparseElimination &	Meth )

det() [11/15]

template<class Field, class Vector>

Field::Element & det	(	typename Field::Element &	d,
		const SparseMatrix< Field, Vector > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Elimination &	Meth )

detInPlace() [8/12]

template<class Field>

Field::Element & detInPlace	(	typename Field::Element &	d,
		SparseMatrix< Field, SparseMatrixFormat::SparseSeq > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Elimination &	Meth )

detInPlace() [9/12]

template<class Field, class Vector>

Field::Element & detInPlace	(	typename Field::Element &	d,
		SparseMatrix< Field, Vector > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Elimination &	Meth )

det() [12/15]

template<class Blackbox>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Elimination &	Meth )

detInPlace() [10/12]

template<class Blackbox>

Blackbox::Field::Element & detInPlace	(	typename Blackbox::Field::Element &	d,
		Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Elimination &	Meth )

detInPlace() [11/12]

template<class Field>

Field::Element & detInPlace	(	typename Field::Element &	d,
		BlasMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Elimination &	Meth )

detInPlace() [12/12]

template<class Field>

Field::Element & detInPlace	(	typename Field::Element &	d,
		BlasMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::DenseElimination &	Meth )

cra_det()

template<class Blackbox, class MyMethod>

Blackbox::Field::Element & cra_det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const MyMethod &	Meth )

det() [13/15]

template<class Blackbox, class MyMethod>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const MyMethod &	Meth )

det() [14/15]

template<class Blackbox, class MyMethod>

Blackbox::Field::Element & det	(	typename Blackbox::Field::Element &	d,
		const Blackbox &	A,
		const RingCategories::RationalTag &	tag,
		const MyMethod &	Meth )

det() [15/15]

template<class Field, class MyMethod>

Field::Element & det	(	typename Field::Element &	d,
		const BlasMatrix< Field > &	A,
		const RingCategories::RationalTag &	tag,
		const MyMethod &	Meth )

rowEchelon() [1/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t rowEchelon ( Matrix & E, const Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the row echelon form of a matrix, not reduced.

Returns the row echelon form. The pivots are nonzero but not necessarily ones. The form is not reduced, which means that coefficients above each pivot are not necessarily zeros.

Parameters

[out]	E	the row echelon form
[in]	A	matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

rowEchelon() [2/12]

template<class Matrix, class EchelonMethod>

size_t rowEchelon ( Matrix & E, const Matrix & A, const EchelonMethod & m )

inline

rowEchelon dispatcher for automated category tag.

rowEchelon() [3/12]

template<class Matrix>

size_t rowEchelon ( Matrix & E, const Matrix & A )

inline

rowEchelon dispatcher for automated method.

rowEchelon() [4/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t rowEchelon ( Matrix & E, Matrix & T, const Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the row echelon form of a matrix, not reduced, and the related transformation matrix.

Returns the row echelon form E and a transformation matrix T such that T . A = E. The pivots are nonzero but not necessarily ones. The form is not reduced, which means that coefficients above each pivot are not necessarily zeros.

Parameters

[out]	E	the row echelon form
[out]	T	the transformation matrix
[in]	A	matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

rowEchelon() [5/12]

template<class Matrix, class EchelonMethod>

size_t rowEchelon ( Matrix & E, Matrix & T, const Matrix & A, const EchelonMethod & m )

inline

rowEchelon dispatcher for automated category tag.

rowEchelon() [6/12]

template<class Matrix>

size_t rowEchelon ( Matrix & E, Matrix & T, const Matrix & A )

inline

rowEchelon dispatcher for automated method.

rowEchelonize() [1/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t rowEchelonize ( Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Replace the input matrix by its row echelon form, not reduced.

The pivots are nonzero but not necessarily ones. The form is not reduced, which means that coefficients above each pivot are not necessarily zeros.

Parameters

	[in/out]	A matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

rowEchelonize() [2/12]

template<class Matrix, class EchelonMethod>

size_t rowEchelonize ( Matrix & A, const EchelonMethod & m )

inline

rowEchelonize dispatcher for automated category tag.

rowEchelonize() [3/12]

template<class Matrix>

size_t rowEchelonize ( Matrix & A )

inline

rowEchelonize dispatcher for automated method.

rowEchelonize() [4/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t rowEchelonize ( Matrix & A, Matrix & T, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the row echelon form of a matrix, not reduced, and the related transformation matrix.

Returns the row echelon form E and a transformation matrix T such that T . A = E. The input matrix is replaced by the row echelon form. The pivots are nonzero but not necessarily ones. The form is not reduced, which means that coefficients above each pivot are not necessarily zeros.

Parameters

	[in/out]	A matrix
[out]	T	the transformation matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

rowEchelonize() [5/12]

template<class Matrix, class EchelonMethod>

size_t rowEchelonize ( Matrix & A, Matrix & T, const EchelonMethod & m )

inline

rowEchelonize dispatcher for automated category tag.

rowEchelonize() [6/12]

template<class Matrix>

size_t rowEchelonize ( Matrix & A, Matrix & T )

inline

rowEchelonize dispatcher for automated method.

reducedRowEchelon() [1/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t reducedRowEchelon ( Matrix & E, const Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the reduced row echelon form of a matrix.

Returns the reduced row echelon form. The pivots are ones. The form is reduced, which means that coefficients above each pivot are zeros.

Parameters

[out]	E	the reduced row echelon form
[in]	A	matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

reducedRowEchelon() [2/12]

template<class Matrix, class EchelonMethod>

size_t reducedRowEchelon ( Matrix & E, const Matrix & A, const EchelonMethod & m )

inline

reducedRowEchelon dispatcher for automated category tag.

reducedRowEchelon() [3/12]

template<class Matrix>

size_t reducedRowEchelon ( Matrix & E, const Matrix & A )

inline

reducedRowEchelon dispatcher for automated method.

reducedRowEchelon() [4/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t reducedRowEchelon ( Matrix & E, Matrix & T, const Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the reduced row echelon form of a matrix, and the related transformation matrix.

Returns the reduced row echelon form E and a transformation matrix T such that T . A = E. The pivots are ones. The form is reduced, which means that coefficients above each pivot are zeros.

Parameters

[out]	E	the reduced row echelon form
[out]	T	the transformation matrix
[in]	A	matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

reducedRowEchelon() [5/12]

template<class Matrix, class EchelonMethod>

size_t reducedRowEchelon ( Matrix & E, Matrix & T, const Matrix & A, const EchelonMethod & m )

inline

reducedRowEchelon dispatcher for automated category tag.

reducedRowEchelon() [6/12]

template<class Matrix>

size_t reducedRowEchelon ( Matrix & E, Matrix & T, const Matrix & A )

inline

reducedRowEchelon dispatcher for automated method.

reducedRowEchelonize() [1/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t reducedRowEchelonize ( Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Replace the input matrix by its reduced row echelon form.

The pivots are ones. The form is reduced, which means that coefficients above each pivot are zeros.

Parameters

	[in/out]	A matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

reducedRowEchelonize() [2/12]

template<class Matrix, class EchelonMethod>

size_t reducedRowEchelonize ( Matrix & A, const EchelonMethod & m )

inline

reducedRowEchelonize dispatcher for automated category tag.

reducedRowEchelonize() [3/12]

template<class Matrix>

size_t reducedRowEchelonize ( Matrix & A )

inline

reducedRowEchelonize dispatcher for automated method.

reducedRowEchelonize() [4/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t reducedRowEchelonize ( Matrix & A, Matrix & T, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the reduced row echelon form of a matrix, and the related transformation matrix.

Returns the reduced row echelon form E and a transformation matrix T such that T . A = E. The input matrix is replaced by the reduced row echelon form. The pivots are ones. The form is reduced, which means that coefficients above each pivot are zeros.

Parameters

	[in/out]	A matrix
[out]	T	the transformation matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

reducedRowEchelonize() [5/12]

template<class Matrix, class EchelonMethod>

size_t reducedRowEchelonize ( Matrix & A, Matrix & T, const EchelonMethod & m )

inline

reducedRowEchelonize dispatcher for automated category tag.

reducedRowEchelonize() [6/12]

template<class Matrix>

size_t reducedRowEchelonize ( Matrix & A, Matrix & T )

inline

reducedRowEchelonize dispatcher for automated method.

colEchelon() [1/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t colEchelon ( Matrix & E, const Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the column echelon form of a matrix, not reduced.

Returns the column echelon form. The pivots are nonzero but not necessarily ones. The form is not reduced, which means that coefficients above each pivot are not necessarily zeros.

Parameters

[out]	E	the column echelon form
[in]	A	matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

colEchelon() [2/12]

template<class Matrix, class EchelonMethod>

size_t colEchelon ( Matrix & E, const Matrix & A, const EchelonMethod & m )

inline

colEchelon dispatcher for automated category tag.

colEchelon() [3/12]

template<class Matrix>

size_t colEchelon ( Matrix & E, const Matrix & A )

inline

colEchelon dispatcher for automated method.

colEchelon() [4/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t colEchelon ( Matrix & E, Matrix & T, const Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the column echelon form of a matrix, not reduced, and the related transformation matrix.

Returns the column echelon form E and a transformation matrix T such that T . A = E. The pivots are nonzero but not necessarily ones. The form is not reduced, which means that coefficients above each pivot are not necessarily zeros.

Parameters

[out]	E	the column echelon form
[out]	T	the transformation matrix
[in]	A	matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

colEchelon() [5/12]

template<class Matrix, class EchelonMethod>

size_t colEchelon ( Matrix & E, Matrix & T, const Matrix & A, const EchelonMethod & m )

inline

colEchelon dispatcher for automated category tag.

colEchelon() [6/12]

template<class Matrix>

size_t colEchelon ( Matrix & E, Matrix & T, const Matrix & A )

inline

colEchelon dispatcher for automated method.

colEchelonize() [1/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t colEchelonize ( Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Replace the input matrix by its column echelon form, not reduced.

The pivots are nonzero but not necessarily ones. The form is not reduced, which means that coefficients above each pivot are not necessarily zeros.

Parameters

	[in/out]	A matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

colEchelonize() [2/12]

template<class Matrix, class EchelonMethod>

size_t colEchelonize ( Matrix & A, const EchelonMethod & m )

inline

colEchelonize dispatcher for automated category tag.

colEchelonize() [3/12]

template<class Matrix>

size_t colEchelonize ( Matrix & A )

inline

colEchelonize dispatcher for automated method.

colEchelonize() [4/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t colEchelonize ( Matrix & A, Matrix & T, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the column echelon form of a matrix, not reduced, and the related transformation matrix.

Returns the column echelon form E and a transformation matrix T such that T . A = E. The input matrix is replaced by the column echelon form. The pivots are nonzero but not necessarily ones. The form is not reduced, which means that coefficients above each pivot are not necessarily zeros.

Parameters

	[in/out]	A matrix
[out]	T	the transformation matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

colEchelonize() [5/12]

template<class Matrix, class EchelonMethod>

size_t colEchelonize ( Matrix & A, Matrix & T, const EchelonMethod & m )

inline

colEchelonize dispatcher for automated category tag.

colEchelonize() [6/12]

template<class Matrix>

size_t colEchelonize ( Matrix & A, Matrix & T )

inline

colEchelonize dispatcher for automated method.

reducedColEchelon() [1/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t reducedColEchelon ( Matrix & E, const Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the reduced column echelon form of a matrix.

Returns the reduced column echelon form. The pivots are ones. The form is reduced, which means that coefficients above each pivot are zeros.

Parameters

[out]	E	the reduced column echelon form
[in]	A	matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

reducedColEchelon() [2/12]

template<class Matrix, class EchelonMethod>

size_t reducedColEchelon ( Matrix & E, const Matrix & A, const EchelonMethod & m )

inline

reducedColEchelon dispatcher for automated category tag.

reducedColEchelon() [3/12]

template<class Matrix>

size_t reducedColEchelon ( Matrix & E, const Matrix & A )

inline

reducedColEchelon dispatcher for automated method.

reducedColEchelon() [4/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t reducedColEchelon ( Matrix & E, Matrix & T, const Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the reduced column echelon form of a matrix, and the related transformation matrix.

Returns the reduced column echelon form E and a transformation matrix T such that T . A = E. The pivots are ones. The form is reduced, which means that coefficients above each pivot are zeros.

Parameters

[out]	E	the reduced column echelon form
[out]	T	the transformation matrix
[in]	A	matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

reducedColEchelon() [5/12]

template<class Matrix, class EchelonMethod>

size_t reducedColEchelon ( Matrix & E, Matrix & T, const Matrix & A, const EchelonMethod & m )

inline

reducedColEchelon dispatcher for automated category tag.

reducedColEchelon() [6/12]

template<class Matrix>

size_t reducedColEchelon ( Matrix & E, Matrix & T, const Matrix & A )

inline

reducedColEchelon dispatcher for automated method.

reducedColEchelonize() [1/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t reducedColEchelonize ( Matrix & A, const CategoryTag & tag, const EchelonMethod & m )

inline

Replace the input matrix by its reduced column echelon form.

The pivots are ones. The form is reduced, which means that coefficients above each pivot are zeros.

Parameters

	[in/out]	A matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

reducedColEchelonize() [2/12]

template<class Matrix, class EchelonMethod>

size_t reducedColEchelonize ( Matrix & A, const EchelonMethod & m )

inline

reducedColEchelonize dispatcher for automated category tag.

reducedColEchelonize() [3/12]

template<class Matrix>

size_t reducedColEchelonize ( Matrix & A )

inline

reducedColEchelonize dispatcher for automated method.

reducedColEchelonize() [4/12]

template<class Matrix, class CategoryTag, class EchelonMethod>

size_t reducedColEchelonize ( Matrix & A, Matrix & T, const CategoryTag & tag, const EchelonMethod & m )

inline

Compute the reduced column echelon form of a matrix, and the related transformation matrix.

Returns the reduced column echelon form E and a transformation matrix T such that T . A = E. The input matrix is replaced by the reduced column echelon form. The pivots are ones. The form is reduced, which means that coefficients above each pivot are zeros.

Parameters

	[in/out]	A matrix
[out]	T	the transformation matrix
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

the rank of the matrix

reducedColEchelonize() [5/12]

template<class Matrix, class EchelonMethod>

size_t reducedColEchelonize ( Matrix & A, Matrix & T, const EchelonMethod & m )

inline

reducedColEchelonize dispatcher for automated category tag.

reducedColEchelonize() [6/12]

template<class Matrix>

size_t reducedColEchelonize ( Matrix & A, Matrix & T )

inline

reducedColEchelonize dispatcher for automated method.

rowEchelon() [7/12]

template<class Matrix, class CategoryTag>

size_t rowEchelon	(	Matrix &	E,
		const Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

rowEchelon specialisation for Auto.

rowEchelon() [8/12]

template<class Field>

size_t rowEchelon	(	DenseMatrix< Field > &	E,
		const DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

rowEchelon specialisation for Auto with DenseMatrix and ModularTag.

rowEchelon() [9/12]

template<class Matrix, class CategoryTag>

size_t rowEchelon	(	Matrix &	E,
		Matrix &	T,
		const Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

rowEchelon specialisation for Auto.

rowEchelon() [10/12]

template<class Field>

size_t rowEchelon	(	DenseMatrix< Field > &	E,
		DenseMatrix< Field > &	T,
		const DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

rowEchelon specialisation for Auto with DenseMatrix and ModularTag.

rowEchelonize() [7/12]

template<class Matrix, class CategoryTag>

size_t rowEchelonize	(	Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

rowEchelonize specialisation for Auto.

rowEchelonize() [8/12]

template<class Field>

size_t rowEchelonize	(	DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

rowEchelonize specialisation for Auto with DenseMatrix and ModularTag.

rowEchelonize() [9/12]

template<class Matrix, class CategoryTag>

size_t rowEchelonize	(	Matrix &	A,
		Matrix &	T,
		const CategoryTag &	tag,
		const Method::Auto &	m )

rowEchelonize specialisation for Auto.

rowEchelonize() [10/12]

template<class Field>

size_t rowEchelonize	(	DenseMatrix< Field > &	A,
		DenseMatrix< Field > &	T,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

rowEchelonize specialisation for Auto with DenseMatrix and ModularTag.

reducedRowEchelon() [7/12]

template<class Matrix, class CategoryTag>

size_t reducedRowEchelon	(	Matrix &	E,
		const Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

reducedRowEchelon specialisation for Auto.

reducedRowEchelon() [8/12]

template<class Field>

size_t reducedRowEchelon	(	DenseMatrix< Field > &	E,
		const DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

reducedRowEchelon specialisation for Auto with DenseMatrix and ModularTag.

reducedRowEchelon() [9/12]

template<class Matrix, class CategoryTag>

size_t reducedRowEchelon	(	Matrix &	E,
		Matrix &	T,
		const Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

reducedRowEchelon specialisation for Auto.

reducedRowEchelon() [10/12]

template<class Field>

size_t reducedRowEchelon	(	DenseMatrix< Field > &	E,
		DenseMatrix< Field > &	T,
		const DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

reducedRowEchelon specialisation for Auto with DenseMatrix and ModularTag.

reducedRowEchelonize() [7/12]

template<class Matrix, class CategoryTag>

size_t reducedRowEchelonize	(	Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

reducedRowEchelonize specialisation for Auto.

reducedRowEchelonize() [8/12]

template<class Field>

size_t reducedRowEchelonize	(	DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

reducedRowEchelonize specialisation for Auto with DenseMatrix and ModularTag.

reducedRowEchelonize() [9/12]

template<class Matrix, class CategoryTag>

size_t reducedRowEchelonize	(	Matrix &	A,
		Matrix &	T,
		const CategoryTag &	tag,
		const Method::Auto &	m )

reducedRowEchelonize specialisation for Auto.

reducedRowEchelonize() [10/12]

template<class Field>

size_t reducedRowEchelonize	(	DenseMatrix< Field > &	A,
		DenseMatrix< Field > &	T,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

reducedRowEchelonize specialisation for Auto with DenseMatrix and ModularTag.

colEchelon() [7/12]

template<class Matrix, class CategoryTag>

size_t colEchelon	(	Matrix &	E,
		const Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

colEchelon specialisation for Auto.

colEchelon() [8/12]

template<class Field>

size_t colEchelon	(	DenseMatrix< Field > &	E,
		const DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

colEchelon specialisation for Auto with DenseMatrix and ModularTag.

colEchelon() [9/12]

template<class Matrix, class CategoryTag>

size_t colEchelon	(	Matrix &	E,
		Matrix &	T,
		const Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

colEchelon specialisation for Auto.

colEchelon() [10/12]

template<class Field>

size_t colEchelon	(	DenseMatrix< Field > &	E,
		DenseMatrix< Field > &	T,
		const DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

colEchelon specialisation for Auto with DenseMatrix and ModularTag.

colEchelonize() [7/12]

template<class Matrix, class CategoryTag>

size_t colEchelonize	(	Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

colEchelonize specialisation for Auto.

colEchelonize() [8/12]

template<class Field>

size_t colEchelonize	(	DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

colEchelonize specialisation for Auto with DenseMatrix and ModularTag.

colEchelonize() [9/12]

template<class Matrix, class CategoryTag>

size_t colEchelonize	(	Matrix &	A,
		Matrix &	T,
		const CategoryTag &	tag,
		const Method::Auto &	m )

colEchelonize specialisation for Auto.

colEchelonize() [10/12]

template<class Field>

size_t colEchelonize	(	DenseMatrix< Field > &	A,
		DenseMatrix< Field > &	T,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

colEchelonize specialisation for Auto with DenseMatrix and ModularTag.

reducedColEchelon() [7/12]

template<class Matrix, class CategoryTag>

size_t reducedColEchelon	(	Matrix &	E,
		const Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

reducedColEchelon specialisation for Auto.

reducedColEchelon() [8/12]

template<class Field>

size_t reducedColEchelon	(	DenseMatrix< Field > &	E,
		const DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

reducedColEchelon specialisation for Auto with DenseMatrix and ModularTag.

reducedColEchelon() [9/12]

template<class Matrix, class CategoryTag>

size_t reducedColEchelon	(	Matrix &	E,
		Matrix &	T,
		const Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

reducedColEchelon specialisation for Auto.

reducedColEchelon() [10/12]

template<class Field>

size_t reducedColEchelon	(	DenseMatrix< Field > &	E,
		DenseMatrix< Field > &	T,
		const DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

reducedColEchelon specialisation for Auto with DenseMatrix and ModularTag.

reducedColEchelonize() [7/12]

template<class Matrix, class CategoryTag>

size_t reducedColEchelonize	(	Matrix &	A,
		const CategoryTag &	tag,
		const Method::Auto &	m )

reducedColEchelonize specialisation for Auto.

reducedColEchelonize() [8/12]

template<class Field>

size_t reducedColEchelonize	(	DenseMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

reducedColEchelonize specialisation for Auto with DenseMatrix and ModularTag.

reducedColEchelonize() [9/12]

template<class Matrix, class CategoryTag>

size_t reducedColEchelonize	(	Matrix &	A,
		Matrix &	T,
		const CategoryTag &	tag,
		const Method::Auto &	m )

reducedColEchelonize specialisation for Auto.

reducedColEchelonize() [10/12]

template<class Field>

size_t reducedColEchelonize	(	DenseMatrix< Field > &	A,
		DenseMatrix< Field > &	T,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

reducedColEchelonize specialisation for Auto with DenseMatrix and ModularTag.

rowEchelon() [11/12]

template<class Field>

size_t rowEchelon ( DenseMatrix< Field > & E, const DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

rowEchelon specialisation for DenseElimination with DenseMatrix and ModularTag.

rowEchelon() [12/12]

template<class Field>

size_t rowEchelon ( DenseMatrix< Field > & E, DenseMatrix< Field > & T, const DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

rowEchelon with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.

rowEchelonize() [11/12]

template<class Field>

size_t rowEchelonize ( DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

rowEchelonize specialisation for DenseElimination with DenseMatrix and ModularTag.

rowEchelonize() [12/12]

template<class Field>

size_t rowEchelonize ( DenseMatrix< Field > & A, DenseMatrix< Field > & T, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

rowEchelonize with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.

reducedRowEchelon() [11/12]

template<class Field>

size_t reducedRowEchelon ( DenseMatrix< Field > & E, const DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

reducedRowEchelon specialisation for DenseElimination with DenseMatrix and ModularTag.

reducedRowEchelon() [12/12]

template<class Field>

size_t reducedRowEchelon ( DenseMatrix< Field > & E, DenseMatrix< Field > & T, const DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

reducedRowEchelon with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.

reducedRowEchelonize() [11/12]

template<class Field>

size_t reducedRowEchelonize ( DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

reducedRowEchelonize specialisation for DenseElimination with DenseMatrix and ModularTag.

reducedRowEchelonize() [12/12]

template<class Field>

size_t reducedRowEchelonize ( DenseMatrix< Field > & A, DenseMatrix< Field > & T, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

reducedRowEchelonize with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.

colEchelon() [11/12]

template<class Field>

size_t colEchelon ( DenseMatrix< Field > & E, const DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

colEchelon specialisation for DenseElimination with DenseMatrix and ModularTag.

colEchelon() [12/12]

template<class Field>

size_t colEchelon ( DenseMatrix< Field > & E, DenseMatrix< Field > & T, const DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

colEchelon with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.

colEchelonize() [11/12]

template<class Field>

size_t colEchelonize ( DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

colEchelonize specialisation for DenseElimination with DenseMatrix and ModularTag.

colEchelonize() [12/12]

template<class Field>

size_t colEchelonize ( DenseMatrix< Field > & A, DenseMatrix< Field > & T, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

colEchelonize with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.

reducedColEchelon() [11/12]

template<class Field>

size_t reducedColEchelon ( DenseMatrix< Field > & E, const DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

reducedColEchelon specialisation for DenseElimination with DenseMatrix and ModularTag.

reducedColEchelon() [12/12]

template<class Field>

size_t reducedColEchelon ( DenseMatrix< Field > & E, DenseMatrix< Field > & T, const DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

reducedColEchelon with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.

reducedColEchelonize() [11/12]

template<class Field>

size_t reducedColEchelonize ( DenseMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

reducedColEchelonize specialisation for DenseElimination with DenseMatrix and ModularTag.

reducedColEchelonize() [12/12]

template<class Field>

size_t reducedColEchelonize ( DenseMatrix< Field > & A, DenseMatrix< Field > & T, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

reducedColEchelonize with transformation specialisation for DenseElimination with DenseMatrix and ModularTag.

getEntry() [1/7]

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.

getEntry() [2/7]

template<class Field, class Trait, class BB>

Field::Element & getEntry	(	typename Field::Element &	x,
		const Compose< Diagonal< Field, Trait >, BB > &	A,
		const size_t	i,
		const size_t	j )

getEntry() [3/7]

template<class BB, class Field, class Trait>

Field::Element & getEntry	(	typename Field::Element &	x,
		const Compose< BB, Diagonal< Field, Trait > > &	A,
		const size_t	i,
		const size_t	j )

getEntry() [4/7]

template<class Field, class T1, class T2>

Field::Element & getEntry	(	typename Field::Element &	x,
		const Compose< Diagonal< Field, T1 >, Diagonal< Field, T2 > > &	A,
		const size_t	i,
		const size_t	j )

getEntry() [5/7]

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.

getEntry() [6/7]

template<class BB>

BB::Field::Element & getEntry	(	typename BB::Field::Element &	x,
		const BB &	A,
		const size_t	i,
		const size_t	j,
		SolutionTags::Generic	t )

getEntry() [7/7]

template<class BB>

BB::Field::Element & getEntry	(	typename BB::Field::Element &	x,
		const BB &	A,
		const size_t	i,
		const size_t	j,
		SolutionTags::Local	t )

vectorLogNorm()

template<class ConstIterator>

bool vectorLogNorm	(	double &	logNorm,
		const ConstIterator &	begin,
		const ConstIterator &	end )

HadamardRowLogBound() [1/4]

template<class IMatrix>

void HadamardRowLogBound	(	double &	logBound,
		double &	minLogNorm,
		const IMatrix &	A )

Precise Hadamard bound (bound on determinant) by taking the row-wise euclidean norm.

The result is expressed as bit size.

HadamardRowLogBound() [2/4]

template<class IMatrix>

void HadamardRowLogBound	(	double &	logBound,
		double &	minLogNorm,
		const IMatrix &	A,
		const MatrixCategories::RowColMatrixTag &	tag )

HadamardRowLogBound() [3/4]

template<class IMatrix>

void HadamardRowLogBound	(	double &	logBound,
		double &	minLogNorm,
		const IMatrix &	A,
		const MatrixCategories::RowMatrixTag &	tag )

HadamardRowLogBound() [4/4]

template<class IMatrix>

void HadamardRowLogBound	(	double &	logBound,
		double &	minLogNorm,
		const IMatrix &	A,
		const MatrixCategories::BlackboxTag &	tag )

HadamardColLogBound() [1/4]

template<class IMatrix>

void HadamardColLogBound	(	double &	logBound,
		double &	minLogNorm,
		const IMatrix &	A )

Precise Hadamard bound (bound on determinant) by taking the column-wise euclidean norm.

The result is expressed as bit size.

HadamardColLogBound() [2/4]

template<class IMatrix>

void HadamardColLogBound	(	double &	logBound,
		double &	minLogNorm,
		const IMatrix &	A,
		const MatrixCategories::RowColMatrixTag &	tag )

HadamardColLogBound() [3/4]

template<class IMatrix>

void HadamardColLogBound	(	double &	logBound,
		double &	minLogNorm,
		const IMatrix &	A,
		const MatrixCategories::RowMatrixTag &	tag )

HadamardColLogBound() [4/4]

template<class IMatrix>

void HadamardColLogBound	(	double &	logBound,
		double &	minLogNorm,
		const IMatrix &	A,
		const MatrixCategories::BlackboxTag &	tag )

DetailedHadamardBound()

template<class IMatrix>

HadamardLogBoundDetails DetailedHadamardBound

(

const IMatrix &

A

)

Precise Hadamard bound (bound on determinant) by taking the minimum of the column-wise and the row-wise euclidean norm.

The results are expressed as bit size.

HadamardBound()

template<class IMatrix>

double HadamardBound

(

const IMatrix &

A

)

Precise Hadamard bound (bound on determinant) by taking the minimum of the column-wise and the row-wise euclidean norm.

The result is expressed as bit size.

InfinityNorm() [1/2]

template<class IMatrix, class MTag>

Integer & InfinityNorm ( Integer & max, const IMatrix & A, const MTag & tag )

inline

Returns the maximal absolute value.

InfinityNorm() [2/2]

template<class IMatrix>

Integer & InfinityNorm ( Integer & max, const IMatrix & A, const MatrixCategories::RowColMatrixTag & tag )

inline

FastHadamardBound() [1/4]

template<class IMatrix>

double FastHadamardBound ( const IMatrix & A, const Integer & infnorm )

inline

Returns the bit size of the Hadamard bound.

This is a larger estimation but faster to compute.

FastHadamardBound() [2/4]

template<class IMatrix>

double FastHadamardBound ( const IMatrix & A, const MatrixCategories::RowColMatrixTag & tag )

inline

FastHadamardBound() [3/4]

template<class IMatrix>

double FastHadamardBound ( const IMatrix & A, const MatrixCategories::BlackboxTag & tag )

inline

FastHadamardBound() [4/4]

template<class IMatrix>

double FastHadamardBound ( const IMatrix & A )

inline

FastCharPolyDumasPernetWanBound()

template<class IMatrix>

double FastCharPolyDumasPernetWanBound ( const IMatrix & A, const Integer & infnorm )

inline

Bound on the coefficients of the characteristic polynomial.

Bibliography

"Efficient Computation of the Characteristic Polynomial". Dumas Pernet Wan ISSAC'05.

FastCharPolyGoldsteinGrahamBound()

template<class IMatrix>

double FastCharPolyGoldsteinGrahamBound ( const IMatrix & A, const Integer & infnorm )

inline

A.J.

Goldstein et R.L. Graham. A Hadamard-type bound on the coefficients of a determinant of polynomials. SIAM Review, volume 15, 1973, pages 657-658.

FastCharPolyHadamardBound()

template<class IMatrix>

double FastCharPolyHadamardBound ( const IMatrix & A )

inline

RationalSolveHadamardBound() [1/2]

template<class Matrix, class Vector>

std::enable_if< std::is_same< typenameFieldTraits< typenameMatrix::Field >::categoryTag, RingCategories::IntegerTag >::value, RationalSolveHadamardBoundData >::type RationalSolveHadamardBound	(	const Matrix &	A,
		const Vector &	b )

Bound on the rational solution of a linear system Ax = b.

Return bounds on the bit sizes of both denominator and numerator of the solution x.

Note

Matrix and Vector should be over Integer.

RationalSolveHadamardBound() [2/2]

template<class Matrix, class Vector>

std::enable_if< std::is_same< typenameFieldTraits< typenameMatrix::Field >::categoryTag, RingCategories::RationalTag >::value, RationalSolveHadamardBoundData >::type RationalSolveHadamardBound	(	const Matrix &	A,
		const Vector &	b )

@fixme Needed to solve-cra.h, but can't be used yet.

isPositiveDefinite() [1/10]

template<class Blackbox, class isPositiveDefiniteMethod, class DomainCategory>

bool isPositiveDefinite	(	const Blackbox &	A,
		const DomainCategory &	tag,
		const isPositiveDefiniteMethod &	M )

isPositiveDefinite() [2/10]

template<class Blackbox, class MyMethod>

bool isPositiveDefinite	(	const Blackbox &	A,
		const MyMethod &	M )

Compute the isPositiveDefinite of A.

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

Parameters

A	Black box of which to compute the isPositiveDefinite
M	may be a Method::Auto (default), Method::Blackbox, Method::Elimination, or of other method type.

isPositiveDefinite() [3/10]

template<class Blackbox>

bool isPositiveDefinite

(

const Blackbox &

A

)

isPositiveDefinite() [4/10]

template<class Blackbox, class MyMethod>

bool isPositiveDefinite	(	const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const MyMethod &	M )

isPositiveDefinite() [5/10]

template<class Blackbox>

bool isPositiveDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Auto &	M )

Bug

should try a modular minpoly and decide on the degree of that...

Bug

this crude size check can be refined

isPositiveDefinite() [6/10]

template<class Blackbox>

bool isPositiveDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Elimination &	M )

isPositiveDefinite() [7/10]

template<class Blackbox>

bool isPositiveDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Blackbox &	M )

isPositiveDefinite() [8/10]

template<class Blackbox>

bool isPositiveDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Wiedemann &	M )

isPositiveDefinite() [9/10]

template<class Blackbox>

bool isPositiveDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::DenseElimination &	M )

Bug

why map (same field)? This is a copy.

isPositiveDefinite() [10/10]

template<class Ring>

bool isPositiveDefinite	(	const BlasMatrix< Ring > &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::DenseElimination &	M )

isPositiveSemiDefinite() [1/10]

template<class Blackbox, class isPositiveSemiDefiniteMethod, class DomainCategory>

bool isPositiveSemiDefinite	(	const Blackbox &	A,
		const DomainCategory &	tag,
		const isPositiveSemiDefiniteMethod &	M )

isPositiveSemiDefinite() [2/10]

template<class Blackbox, class MyMethod>

bool isPositiveSemiDefinite	(	const Blackbox &	A,
		const MyMethod &	M )

Determine if A is positive semidefinite.

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

Parameters

A	Black box of which to compute the isPositiveSemiDefinite
M	may be a Method::Auto (SemiDefault), Method::Blackbox, Method::Elimination, or of other method type.

isPositiveSemiDefinite() [3/10]

template<class Blackbox>

bool isPositiveSemiDefinite

(

const Blackbox &

A

)

isPositiveSemiDefinite() [4/10]

template<class Blackbox, class MyMethod>

bool isPositiveSemiDefinite	(	const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const MyMethod &	M )

isPositiveSemiDefinite() [5/10]

template<class Blackbox>

bool isPositiveSemiDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Auto &	M )

isPositiveSemiDefinite() [6/10]

template<class Blackbox>

bool isPositiveSemiDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Elimination &	M )

isPositiveSemiDefinite() [7/10]

template<class Blackbox>

bool isPositiveSemiDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Blackbox &	M )

isPositiveSemiDefinite() [8/10]

template<class Blackbox>

bool isPositiveSemiDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Wiedemann &	M )

isPositiveSemiDefinite() [9/10]

template<class Blackbox>

bool isPositiveSemiDefinite	(	const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::DenseElimination &	M )

Warning

this is a copy

isPositiveSemiDefinite() [10/10]

template<class Ring>

bool isPositiveSemiDefinite	(	const BlasMatrix< Ring > &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::DenseElimination &	M )

useBlackboxMethod() [1/2]

template<class Matrix>

bool useBlackboxMethod

(

const Matrix &

A

)

useBlackboxMethod() [2/2]

template<class Field>

bool useBlackboxMethod

(

const LinBox::DenseMatrix< Field > &

A

)

minpoly() [3/13]

template<class Blackbox, class Polynomial, class DomainCategory, class MyMethod>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const DomainCategory &	tag,
		const MyMethod &	M )

Minimal polynomial of a blackbox linear operator A. The resulting polynomial is a vector of coefficients. Somewhere we should document our handling of polys.

minpoly() [4/13]

template<class Blackbox, class Polynomial, class MyMethod>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const MyMethod &	M )

...using an optional Method parameter

Parameters

P	the output minimal polynomial. If the polynomial is of degree d, this random access container has size d+1, the 0-th entry is the constant coefficient and the d-th is 1 since the minpoly is monic.
A	a blackbox matrix
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::Auto (the default). See methods.h for more options.

Returns

a reference to P.

minpoly() [5/13]

template<class Polynomial, class Blackbox>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A )

...using default Method

minpoly() [6/13]

template<class Polynomial, class Blackbox>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	M )

The minpoly with Auto Method

minpoly() [7/13]

template<class Polynomial, class Field>

Polynomial & minpoly	(	Polynomial &	P,
		const BlasMatrix< Field > &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	M )

The minpoly with Auto Method on BlasMatrix

minpoly() [8/13]

template<class Polynomial, class Blackbox>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Elimination &	M )

The minpoly with Elimination Method

minpoly() [9/13]

template<class Polynomial, class Blackbox>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::DenseElimination &	M )

The minpoly with DenseElimination Method

minpoly() [10/13]

template<class Polynomial, class Blackbox>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const Method::Blackbox &	M )

The minpoly with BlackBox Method

minpoly() [11/13]

template<class Polynomial, class Blackbox, class MyMethod>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const MyMethod &	M )

minpoly() [12/13]

template<class Blackbox, class Polynomial, class MyMethod>

Polynomial & minpoly	(	Polynomial &	P,
		const Blackbox &	A,
		const RingCategories::RationalTag &	tag,
		const MyMethod &	M )

minpoly() [13/13]

template<class Field, template< class > class Polynomial, class MyMethod>

Polynomial< typename Field::Element > & minpoly	(	Polynomial< typename Field::Element > &	P,
		const BlasMatrix< Field > &	A,
		const RingCategories::RationalTag &	tag,
		const MyMethod &	M )

rankInPlace() [1/11]

template<class Blackbox, class Method, class DomainCategory>

size_t & rankInPlace ( size_t & r, Blackbox & A, const DomainCategory & tag, const Method & M )

inline

Examples

examples/sparseelimrank.C.

rankInPlace() [2/11]

template<class Blackbox>

size_t & rankInPlace ( size_t & r, Blackbox & A )

inline

Rank of A.

A may be modified

Parameters

A	matrix
r	rank

Bug

there is no Elimination() method there.

rank() [1/11]

template<class Blackbox>

size_t & rank ( size_t & r, const Blackbox & A, const RingCategories::ModularTag & tag, const Method::Auto & m )

inline

Bug

choose (benchmark) better cuttoff (size, nbnz, sparse rep)

rank() [2/11]

template<class Blackbox>

size_t & rank ( size_t & r, const Blackbox & A, const RingCategories::ModularTag & tag, const Method::Elimination & m )

inline

rank() [3/11]

template<class Field, class Vector>

size_t & rank ( size_t & r, const SparseMatrix< Field, Vector > & A, const RingCategories::ModularTag & tag, const Method::Elimination & m )

inline

rank() [4/11]

template<class Blackbox>

size_t & rank ( size_t & r, const Blackbox & A, const RingCategories::ModularTag & tag, const Method::Blackbox & m )

inline

rank() [5/11]

template<class Blackbox>

size_t & rank ( size_t & res, const Blackbox & A, const RingCategories::ModularTag & tag, const Method::Wiedemann & M )

inline

M may be Method::Wiedemann().

Bug

This is too much for solutions. It belongs in algorithms

rankInPlace() [3/11]

template<class Field>

size_t & rankInPlace ( size_t & r, SparseMatrix< Field, SparseMatrixFormat::SparseSeq > & A, const RingCategories::ModularTag & tag, const Method::Elimination & m )

inline

rank() [6/11]

template<class Field>

size_t & rank ( size_t & r, const SparseMatrix< Field, SparseMatrixFormat::SparseSeq > & A, const RingCategories::ModularTag & tag, const Method::SparseElimination & M )

inline

M may be Method::SparseElimination().

rank() [7/11]

template<class Blackbox, class DomainCategory>

size_t & rank ( size_t & r, const Blackbox & A, const DomainCategory & tag, const Method::SparseElimination & M )

inline

rank() [8/11]

template<class Blackbox>

size_t & rank ( size_t & r, const Blackbox & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

integral_rank()

template<class Blackbox, class MyMethod>

size_t & integral_rank ( size_t & r, const Blackbox & A, const MyMethod & M )

inline

rank() [9/11]

template<class Blackbox, class MyMethod>

size_t & rank ( size_t & r, const Blackbox & A, const RingCategories::IntegerTag & tag, const MyMethod & M )

inline

rank() [10/11]

template<class Blackbox, class Method>

size_t & rank ( size_t & r, const Blackbox & A, const RingCategories::RationalTag & tag, const Method & M )

inline

rank() [11/11]

template<class Blackbox>

size_t & rank ( size_t & r, const Blackbox & A, const RingCategories::RationalTag & tag, const Method::SparseElimination & M )

inline

rankInPlace() [4/11]

template<class Field, class Method>

size_t & rankInPlace ( size_t & r, SparseMatrix< Field, SparseMatrixFormat::SparseSeq > & A, const Method & M )

inline

rankInPlace() [5/11]

template<class Blackbox, class Ring>

size_t & rankInPlace ( size_t & r, Blackbox & A, const RingCategories::IntegerTag & tag, const Method::SparseElimination & M )

inline

rankInPlace() [6/11]

size_t & rankInPlace ( size_t & r, GaussDomain< GF2 >::Matrix & A, const Method::SparseElimination &  )

inline

specialization to \( \mathbf{F}_2 \)

rankInPlace() [7/11]

size_t & rankInPlace ( size_t & r, GaussDomain< GF2 >::Matrix & A, const RingCategories::ModularTag & , const Method::SparseElimination & M )

inline

specialization to \( \mathbf{F}_2 \)

rankInPlace() [8/11]

template<class Field>

size_t & rankInPlace ( size_t & r, BlasMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::DenseElimination & M )

inline

A is modified.

rankInPlace() [9/11]

template<class Field>

size_t & rankInPlace ( size_t & r, BlasMatrix< Field > & A, const RingCategories::ModularTag & tag, const Method::Elimination & m )

inline

rankInPlace() [10/11]

template<class Blackbox>

size_t & rankInPlace ( size_t & r, Blackbox & A, const RingCategories::ModularTag & tag, const Method::Auto & m )

inline

rankInPlace() [11/11]

template<class Blackbox>

size_t & rankInPlace ( size_t & r, Blackbox & A, const RingCategories::ModularTag & tag, const Method::SparseElimination & M )

inline

compressedSmith() [1/2]

template<class Ring, class Vector>

SmithList< Ring > & compressedSmith	(	SmithList< Ring > &	c,
		const Vector &	SmithDiagonal,
		const Ring &	R,
		const size_t	m,
		const size_t	n )

compressedSmith() [2/2]

template<class Ring>

SmithList< Ring > & compressedSmith	(	SmithList< Ring > &	c,
		const BlasVector< Ring > &	v )

smithForm() [1/5]

template<class Blackbox, class Method>

BlasVector< typename Blackbox::Field > & smithForm	(	BlasVector< typename Blackbox::Field > &	V,
		const Blackbox &	A,
		const Method &	M )

smithForm() [2/5]

template<class Blackbox>

SmithList< typename Blackbox::Field > & smithForm	(	SmithList< typename Blackbox::Field > &	S,
		const Blackbox &	A )

smithForm() [3/5]

template<class Blackbox>

BlasVector< typename Blackbox::Field > & smithForm	(	BlasVector< typename Blackbox::Field > &	V,
		const Blackbox &	A )

smithForm() [4/5]

SmithList< Givaro::ZRing< Integer > > & smithForm	(	SmithList< Givaro::ZRing< Integer > > &	S,
		const BlasMatrix< Givaro::ZRing< Integer > > &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Auto &	M )

smithForm() [5/5]

BlasVector< typename Givaro::ZRing< Integer > > & smithForm	(	BlasVector< typename Givaro::ZRing< Integer > > &	V,
		const BlasMatrix< Givaro::ZRing< Integer > > &	A,
		const RingCategories::IntegerTag &	tag,
		const Method::Auto &	M )

solve() [1/42]

template<class ResultVector, class Matrix, class Vector, class CategoryTag, class SolveMethod>

ResultVector & solve ( ResultVector & x, const Matrix & A, const Vector & b, const CategoryTag & tag, const SolveMethod & m )

inline

Solve Ax = b, for x.

Returns a vector x such that Ax = b.

Specifically:

• A non singular: the unique solution is returned.
• A singular:
  • Consistent system: a random solution is returned. The method parameter can contain an hint that an arbitrary element of the solution space is acceptable instead, which can be faster to compute if one doesn't expect a result in that case.
  • Inconsistent system: LinboxMathInconsistentSystem is thrown.
  • Internal failure: LinboxError is thrown.

CategoryTag is defaulted to FieldTraits<Matrix::Field>::categoryTag() when omitted.

• Method::Auto
  • DenseMatrix > Method::DenseElimination
  • SparseMatrix > Method::SparseElimination
  • Otherwise | - Row or column dimension < LINBOX_USE_BLACKBOX_THRESHOLD > Method::Elimination | - Otherwise > Method::Blackbox
• Method::Elimination
  • DenseMatrix > Method::DenseElimination
  • SparseMatrix > Method::SparseElimination
  • Otherwise > Method::DenseElimination or Method::SparseElimination given matrix sparsity
• Method::DenseElimination
  • DenseMatrix | - ModularTag > LQUPMatrix<Field>::left_solve | - IntegerTag | | - RatVector > Method::Dixon | | - Otherwise > Error | - Otherwise > Error (Not implemented)
  • Otherwise > Method::DenseElimination but copy to a DenseMatrix first
• Method::SparseElimination
  • SparseMatrix | - IntegerTag > Method::Dixon | - Otherwise > GaussDomain<Field>::solveInPlace
  • Otherwise > Method::SparseElimination but copy to SparseMatrix first
• Method::CRA
  • IntegerTag | - Dispatch::Distributed > ChineseRemainderDistributed | - Otherwise > RationalChineseRemainder
  • Otherwise > Error
• Method::Dixon
  • IntegerTag | - DenseMatrix > DixonSolver<..., Method::DenseElimination> | - SparseMatrix > DixonSolver<..., Method::SparseElimination> | - Otherwise > Error
  • Otherwise > Error
• Method::Blackbox > Method::Wiedemann
• Method::Wiedemann
  • ModularTag > WiedemannSolver
  • IntegerTag > Method::Dixon
  • Otherwise > Error
• Method::BlockWiedemann [

  Deprecated

  , not tested]

  • ModularTag > BlockWiedemannSolver
  • Otherwise > Error

Parameters

[out]	x	solution, can be a rational solution (vector of numerators and one denominator)
[in]	A	matrix
[in]	b	target
[in]	tag	domain of computation
[in]	m	method to use (

See also

solutions/method.h)

Returns

reference to x

solve() [2/42]

template<class ResultVector, class Matrix, class Vector, class SolveMethod>

ResultVector & solve ( ResultVector & x, const Matrix & A, const Vector & b, const SolveMethod & m )

inline

Solve dispatcher for automated category tag.

solve() [3/42]

template<class ResultVector, class Matrix, class Vector>

ResultVector & solve ( ResultVector & x, const Matrix & A, const Vector & b )

inline

Solve dispatcher for automated solve method.

solve() [4/42]

template<class RatVector, class RatMatrix, class Vector, class SolveMethod>

RatVector & solve	(	RatVector &	x,
		const RatMatrix &	A,
		const Vector &	b,
		const RingCategories::RationalTag &	tag,
		const SolveMethod &	m )

Solve specialisation on RationalTag, with a generic method.

solve() [5/42]

template<class RatVector, class Matrix, class Vector, class SolveMethod>

std::enable_if< std::is_same< typenameSolveMethod::CategoryTag, RingCategories::IntegerTag >::value &&std::is_same< typenameFieldTraits< typenameRatVector::Field >::categoryTag, RingCategories::RationalTag >::value, RatVector & >::type solve	(	RatVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::IntegerTag &	tag,
		const SolveMethod &	m )

Solve specialisation on IntegerTag with Vector<QField> as result.

This forward to the rational interface (num, den). But will only work if the ResultVector if a vector of some Rational type.

solve() [6/42]

template<class Matrix, class Vector, class SolveMethod>

std::enable_if< std::is_same< typenameSolveMethod::CategoryTag, RingCategories::IntegerTag >::value, VectorFraction< typenameMatrix::Field > & >::type solve	(	VectorFraction< typename Matrix::Field > &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::IntegerTag &	tag,
		const SolveMethod &	m )

Solve specialisation on IntegerTag with VectorFraction as result.

This forward to the rational interface (num, den).

solve() [7/42]

template<class IntVector, class Matrix, class Vector, class CategoryTag, class SolveMethod>

void solve ( IntVector & xNum, typename IntVector::Element & xDen, const Matrix & A, const Vector & b, const CategoryTag & tag, const SolveMethod & m )

inline

Rational solve Ax = b, for x expressed as xNum/xDen.

Second interface for solving, only valid for RingCategories::IntegerTag.

Solve with this interface will usually go for CRA or Dixon lifting, as non-modular elimination would snowball elements to very big values.

solve() [8/42]

template<class IntVector, class Matrix, class Vector, class SolveMethod>

void solve ( IntVector & xNum, typename IntVector::Element & xDen, const Matrix & A, const Vector & b, const RingCategories::IntegerTag & tag, const SolveMethod & m )

inline

Rational solve dispatcher for unimplemented methods.

solve() [9/42]

template<class IntVector, class Matrix, class Vector, class SolveMethod>

void solve ( IntVector & xNum, typename IntVector::Element & xDen, const Matrix & A, const Vector & b, const SolveMethod & m )

inline

Rational solve dispatcher for automated category tag.

solve() [10/42]

template<class IntVector, class Matrix, class Vector>

void solve ( IntVector & xNum, typename IntVector::Element & xDen, const Matrix & A, const Vector & b )

inline

Rational solve dispatcher for automated solve method.

solveInPlace() [1/16]

template<class ResultVector, class Matrix, class Vector, class CategoryTag, class SolveMethod>

ResultVector & solveInPlace ( ResultVector & x, Matrix & A, const Vector & b, const CategoryTag & tag, const SolveMethod & m )

inline

Solve Ax = b, for x.

Returns a vector x such that Ax = b. A can be modified.

See documentation for solve.

solveInPlace() [2/16]

template<class ResultVector, class Matrix, class Vector, class SolveMethod>

ResultVector & solveInPlace ( ResultVector & x, Matrix & A, const Vector & b, const SolveMethod & m )

inline

Solve in place dispatcher for automated category tag.

solveInPlace() [3/16]

template<class ResultVector, class Matrix, class Vector>

ResultVector & solveInPlace ( ResultVector & x, Matrix & A, const Vector & b )

inline

Solve in place dispatcher for automated solve method.

solveInPlace() [4/16]

template<class IntVector, class Matrix, class Vector, class SolveMethod, class CategoryTag>

void solveInPlace ( IntVector & xNum, typename IntVector::Element & xDen, Matrix & A, const Vector & b, const CategoryTag & tag, const SolveMethod & m )

inline

Rational solve in place Ax = b, for x expressed as xNum/xDen.

The matrix A might be modified.

Second interface for solving in place, only valid for RingCategories::IntegerTag.

solveInPlace() [5/16]

template<class IntVector, class Matrix, class Vector, class SolveMethod>

void solveInPlace ( IntVector & xNum, typename IntVector::Element & xDen, Matrix & A, const Vector & b, const SolveMethod & m )

inline

Rational solve in place dispatcher for automated category tag.

solveInPlace() [6/16]

template<class IntVector, class Matrix, class Vector>

void solveInPlace ( IntVector & xNum, typename IntVector::Element & xDen, Matrix & A, const Vector & b )

inline

Rational solve in place dispatcher for automated solve method.

solve() [11/42]

template<class ResultVector, class Matrix, class Vector, class CategoryTag>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Auto &	m )

Solve specialisation for Auto.

solve() [12/42]

template<class ResultVector, class Field, class Vector>

ResultVector & solve	(	ResultVector &	x,
		const DenseMatrix< Field > &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

Solve specialisation for Auto with DenseMatrix and ModularTag.

solve() [13/42]

template<class ResultVector, class... MatrixArgs, class Vector>

ResultVector & solve	(	ResultVector &	x,
		const SparseMatrix< MatrixArgs... > &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::Auto &	m )

Solve specialisation for Auto with SparseMatrix and ModularTag.

solve() [14/42]

template<class ResultVector, class Matrix, class Vector>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::IntegerTag &	tag,
		const Method::Auto &	m )

Solve specialisation for Auto and IntegerTag.

solve() [15/42]

template<class ResultVector, class Matrix, class Vector>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::RationalTag &	tag,
		const Method::Auto &	m )

Solve specialisation for Auto and RationalTag.

solve() [16/42]

template<class IntVector, class Matrix, class Vector>

void solve ( IntVector & xNum, typename IntVector::Element & xDen, const Matrix & A, const Vector & b, const RingCategories::IntegerTag & tag, const Method::Auto & m )

inline

Solve specialization for Auto and IntegerTag.

solveInPlace() [7/16]

template<class ResultVector, class Matrix, class Vector, class CategoryTag>

ResultVector & solveInPlace	(	ResultVector &	x,
		Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Auto &	m )

Solve in place specialisation for Auto.

solveInPlace() [8/16]

template<class ResultVector, class Matrix, class Vector>

ResultVector & solveInPlace	(	ResultVector &	x,
		Matrix &	A,
		const Vector &	b,
		const RingCategories::IntegerTag &	tag,
		const Method::Auto &	m )

Solve in place specialisation for Auto and IntegerTag.

solveInPlace() [9/16]

template<class ResultVector, class Field, class Vector, class CategoryTag>

std::enable_if<!std::is_same< CategoryTag, RingCategories::IntegerTag >::value, ResultVector & >::type solveInPlace	(	ResultVector &	x,
		DenseMatrix< Field > &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Auto &	m )

Solve in place specialisation for Auto with DenseMatrix and non-IntegerTag.

solveInPlace() [10/16]

template<class ResultVector, class... MatrixArgs, class Vector, class CategoryTag>

std::enable_if<!std::is_same< CategoryTag, RingCategories::IntegerTag >::value, ResultVector & >::type solveInPlace	(	ResultVector &	x,
		SparseMatrix< MatrixArgs... > &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Auto &	m )

Solve in place specialisation for Auto with SparseMatrix and non-IntegerTag.

solveInPlace() [11/16]

template<class Matrix, class Vector>

void solveInPlace ( Vector & xNum, typename Vector::Element & xDen, Matrix & A, const Vector & b, const RingCategories::IntegerTag & tag, const Method::Auto & m )

inline

Solve in place specialization for Auto and IntegerTag.

solve() [17/42]

template<class ResultVector, class Matrix, class Vector, class CategoryTag>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Blackbox &	m )

Solve specialisation for Blackbox.

solveInPlace() [12/16]

template<class ResultVector, class Matrix, class Vector, class CategoryTag>

ResultVector & solveInPlace	(	ResultVector &	x,
		Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Blackbox &	m )

Solve in place specialisation for Blackbox.

solve() [18/42]

template<class IntVector, class Matrix, class Vector, class IterationMethod>

void solve ( IntVector & xNum, typename IntVector::Element & xDen, const Matrix & A, const Vector & b, const RingCategories::IntegerTag & tag, const Method::CRA< IterationMethod > & m )

inline

Solve specialization with Chinese Remainder Algorithm method for an Integer or Rational tags.

If a Dispatch::Distributed is used, please note that the result will only be set on the master node.

solve() [19/42]

template<class RatVector, class RatMatrix, class IterationMethod>

RatVector & solve ( RatVector & x, const RatMatrix & A, const RatVector & b, const RingCategories::RationalTag & tag, const Method::CRA< IterationMethod > & m )

inline

Solve specialization with Chinese Remainder Algorithm method for a Rational matrix.

solve() [20/42]

template<class Matrix, class Vector>

Vector & solve	(	Vector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::DenseElimination &	m )

Solve specialisation for DenseElimination.

solve() [21/42]

template<class Field, class Vector>

Vector & solve	(	Vector &	x,
		const DenseMatrix< Field > &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::DenseElimination &	m )

Solve specialisation for DenseElimination on dense matrices with ModularTag.

solve() [22/42]

template<class IntVector, class Blackbox, class Vector>

void solve	(	IntVector &	xNum,
		typename IntVector::Element &	xDen,
		const Blackbox &	A,
		const Vector &	b,
		const RingCategories::IntegerTag &	tag,
		const Method::Dixon &	m )

Solve specialisation for Dixon on blackboxes matrices.

solve() [23/42]

template<class IntVector, class Ring, class Vector>

void solve	(	IntVector &	xNum,
		typename IntVector::Element &	xDen,
		const DenseMatrix< Ring > &	A,
		const Vector &	b,
		const RingCategories::IntegerTag &	tag,
		const Method::Dixon &	m )

Solve specialisation for Dixon on dense matrices.

solve() [24/42]

template<class IntVector, class... MatrixArgs, class Vector>

void solve	(	IntVector &	xNum,
		typename IntVector::Element &	xDen,
		const SparseMatrix< MatrixArgs... > &	A,
		const Vector &	b,
		const RingCategories::IntegerTag &	tag,
		const Method::Dixon &	m )

Solve specialisation for Dixon on sparse matrices.

solve() [25/42]

template<class Matrix, class Vector, class CategoryTag>

Vector & solve	(	Vector &	x,
		const Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Elimination &	m )

Solve specialisation for Elimination.

solve() [26/42]

template<class MatrixField, class Vector, class CategoryTag>

Vector & solve	(	Vector &	x,
		const DenseMatrix< MatrixField > &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Elimination &	m )

Solve specialisation for Elimination with DenseMatrix.

solve() [27/42]

template<class MatrixField, class Vector, class CategoryTag>

Vector & solve	(	Vector &	x,
		const SparseMatrix< MatrixField > &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Elimination &	m )

Solve specialisation for Elimination with SparseMatrix.

solveInPlace() [13/16]

template<class Matrix, class Vector, class CategoryTag>

Vector & solveInPlace	(	Vector &	x,
		Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Elimination &	m )

Solve in place specialisation for Elimination.

solveInPlace() [14/16]

template<class MatrixField, class Vector, class CategoryTag>

Vector & solveInPlace	(	Vector &	x,
		DenseMatrix< MatrixField > &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Elimination &	m )

Solve in place specialisation for Elimination with DenseMatrix.

solveInPlace() [15/16]

template<class MatrixField, class Vector, class CategoryTag>

Vector & solveInPlace	(	Vector &	x,
		SparseMatrix< MatrixField > &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Elimination &	m )

Solve in place specialisation for Elimination with SparseMatrix.

solve() [28/42]

template<class Matrix, class Vector, class CategoryTag>

Vector & solve	(	Vector &	x,
		const Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Lanczos &	m )

Solve specialisation for Lanczos.

solve() [29/42]

template<class Matrix, class Vector>

Vector & solve	(	Vector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::Lanczos &	m )

Solve specialisation for Lanczos with ModularTag.

solve() [30/42]

template<class Matrix, class Vector, class CategoryTag>

Vector & solve	(	Vector &	x,
		const Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::BlockLanczos &	m )

Solve specialisation for BlockLanczos.

solve() [31/42]

template<class Matrix, class Vector>

Vector & solve	(	Vector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::BlockLanczos &	m )

Solve specialisation for BlockLanczos with ModularTag.

solve() [32/42]

template<class IntVector, class Matrix, class Vector>

void solve ( IntVector & xNum, typename IntVector::Element & xDen, const Matrix & A, const Vector & b, const RingCategories::IntegerTag & tag, const Method::SymbolicNumericNorm & m )

inline

solve() [33/42]

template<class IntVector, class Ring, class Vector>

void solve ( IntVector & xNum, typename IntVector::Element & xDen, const DenseMatrix< Ring > & A, const Vector & b, const RingCategories::IntegerTag & tag, const Method::SymbolicNumericNorm & m )

inline

Solve specialisation for SymbolicNumericNorm with IntegerTag on DenseMatrix.

solve() [34/42]

template<class Matrix, class Vector>

Vector & solve	(	Vector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::SparseElimination &	m )

Solve specialisation for SparseElimination.

solve() [35/42]

template<class... MatrixArgs, class Vector>

Vector & solve	(	Vector &	x,
		const SparseMatrix< MatrixArgs... > &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::SparseElimination &	m )

Solve specialisation for SparseElimination with SparseMatrix.

solveInPlace() [16/16]

template<class... MatrixArgs, class Vector>

Vector & solveInPlace	(	Vector &	x,
		SparseMatrix< MatrixArgs... > &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::SparseElimination &	m )

Solve in place specialisation for SparseElimination with SparseMatrix.

solve() [36/42]

template<class ResultVector, class Matrix, class Vector, class CategoryTag>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Wiedemann &	m )

Solve specialisation for Wiedemann.

solve() [37/42]

template<class ResultVector, class Matrix, class Vector>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::IntegerTag &	tag,
		const Method::Wiedemann &	m )

Solve specialisation for Wiedemann with IntegerTag.

solve() [38/42]

template<class ResultVector, class Matrix, class Vector>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::Wiedemann &	m )

Solve specialisation for Wiedemann with ModularTag.

solve() [39/42]

template<class ResultVector, class Matrix, class Vector, class CategoryTag>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::BlockWiedemann &	m )

Solve specialisation for BlockWiedemann.

solve() [40/42]

template<class ResultVector, class Matrix, class Vector>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::BlockWiedemann &	m )

Solve specialisation for BlockWiedemann with ModularTag.

solve() [41/42]

template<class ResultVector, class Matrix, class Vector, class CategoryTag>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const CategoryTag &	tag,
		const Method::Coppersmith &	m )

Solve specialisation for Coppersmith.

solve() [42/42]

template<class ResultVector, class Matrix, class Vector>

ResultVector & solve	(	ResultVector &	x,
		const Matrix &	A,
		const Vector &	b,
		const RingCategories::ModularTag &	tag,
		const Method::Coppersmith &	m )

Solve specialisation for Coppersmith on ModularTag.

trace() [1/3]

template<class BB>

BB::Field::Element & trace	(	typename BB::Field::Element &	t,
		const BB &	A )

Sum of the eigenvalues.

Also it is the sum of the diagonal entries.

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

trace() [2/3]

template<class BB>

BB::Field::Element & trace	(	typename BB::Field::Element &	t,
		const BB &	A,
		SolutionTags::Generic	tt )

trace() [3/3]

template<class BB>

BB::Field::Element & trace	(	typename BB::Field::Element &	t,
		const BB &	A,
		SolutionTags::Local	tt )

valence() [1/4]

template<class Blackbox, class DomainCategory, class MyMethod>

Blackbox::Field::Element & valence	(	typename Blackbox::Field::Element &	V,
		const Blackbox &	A,
		const DomainCategory &	tag,
		const MyMethod &	M )

valence() [2/4]

template<class Blackbox>

Blackbox::Field::Element & valence	(	typename Blackbox::Field::Element &	v,
		const Blackbox &	A )

valence() [3/4]

template<class Blackbox, class MyMethod>

Blackbox::Field::Element & valence	(	typename Blackbox::Field::Element &	v,
		const Blackbox &	A,
		const RingCategories::ModularTag &	tag,
		const MyMethod &	M )

valence() [4/4]

template<class Blackbox, class MyMethod>

Blackbox::Field::Element & valence	(	typename Blackbox::Field::Element &	V,
		const Blackbox &	A,
		const RingCategories::IntegerTag &	tag,
		const MyMethod &	M )

squarizeValence()

template<class Blackbox>

Blackbox::Field::Element & squarizeValence	(	typename Blackbox::Field::Element &	val_A,
		const Blackbox &	A,
		size_t	method = 0 )

commentator() [1/2]

Commentator & commentator ( )

inline

commentator() [2/2]

Commentator & commentator ( std::ostream & stream )

inline

parseArguments()

void parseArguments ( int argc, char ** argv, Argument * args, bool printDefaults = true )

inline

nroot()

double nroot	(	double	a,
		long	r,
		double	precision )

isnpower()

long isnpower	(	long &	l,
		long	a )

operator<<() [12/17]

std::ostream & operator<<	(	std::ostream &	o,
		const LinboxError &	E )

equalCaseInsensitive()

bool equalCaseInsensitive ( const std::string & s1, const char * s2 )

inline

serialize() [1/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, float value )

inline

serialize() [2/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, double value )

inline

serialize() [3/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, int8_t value )

inline

serialize() [4/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, uint8_t value )

inline

serialize() [5/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, int16_t value )

inline

serialize() [6/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, uint16_t value )

inline

serialize() [7/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, int32_t value )

inline

serialize() [8/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, uint32_t value )

inline

serialize() [9/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, int64_t value )

inline

serialize() [10/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, uint64_t value )

inline

unserialize() [1/14]

uint64_t unserialize ( float & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

unserialize() [2/14]

uint64_t unserialize ( double & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

unserialize() [3/14]

uint64_t unserialize ( int8_t & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

unserialize() [4/14]

uint64_t unserialize ( uint8_t & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

unserialize() [5/14]

uint64_t unserialize ( int16_t & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

unserialize() [6/14]

uint64_t unserialize ( uint16_t & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

unserialize() [7/14]

uint64_t unserialize ( int32_t & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

unserialize() [8/14]

uint64_t unserialize ( uint32_t & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

unserialize() [9/14]

uint64_t unserialize ( int64_t & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

unserialize() [10/14]

uint64_t unserialize ( uint64_t & value, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

serialize() [11/14]

uint64_t serialize ( std::vector< uint8_t > & bytes, const Integer & integer )

inline

Serializes an Integer with its underlying __mpz_struct.

Returns the number of bytes written.

Format is (by bytes count): 0-3 _mp_size Number of mp_limb_t in _mp_d, can be negative to indicate negative number. 4-.. _mp_d The limbs of length (abs(_mp_size) * sizeof(mp_limb_t))

Note

As said, we're not sure of how many bytes we will write here, because mp_limb_t can be either 32 or 64 bytes-long depending on configuration. We force it to be 64 bit-long so that it becomes platform-independent.

unserialize() [11/14]

uint64_t unserialize ( Integer & integer, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

Unserializes an Integer.

serialize() [12/14]

template<class Field>

uint64_t serialize ( std::vector< uint8_t > & bytes, const BlasMatrix< Field > & M )

inline

Serializes a BlasMatrix.

Format is (by bytes count): 0-7 n Row dimension of matrix 8-15 m Column dimension of matrix 16-.. Entries of the matrix, (n * m) row-majored

unserialize() [12/14]

template<class Field>

uint64_t unserialize ( BlasMatrix< Field > & M, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

Unserializes a BlasMatrix.

The matrix will be resized if necessary.

serialize() [13/14]

template<class Field>

uint64_t serialize ( std::vector< uint8_t > & bytes, const SparseMatrix< Field > & M )

inline

Serializes a SparseMatrix.

Format is (by bytes count): 0-7 n Row dimension of matrix 8-15 m Column dimension of matrix 23-.. Entries of the matrix, only non-zero, stored as: 0-7 i Row index 8-15 j Column index 16-.. Entry value (8 bytes) End of sparse entries, with a value of 0xFFFFFFFF'FFFFFFFF

unserialize() [13/14]

template<class Field>

uint64_t unserialize ( SparseMatrix< Field > & M, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

Unserializes a SparseMatrix.

The matrix will be resized if necessary.

serialize() [14/14]

template<class Field>

uint64_t serialize ( std::vector< uint8_t > & bytes, const BlasVector< Field > & V )

inline

Serializes a BlasVector.

Format is (by bytes count): 0-7 l Length of the vector 16-.. Entries of the vector

unserialize() [14/14]

template<class Field>

uint64_t unserialize ( BlasVector< Field > & V, const std::vector< uint8_t > & bytes, uint64_t offset = 0u )

inline

Unserializes a BlasVector.

The vector will be resized if necessary.

serialize_raw()

template<class T>

uint64_t serialize_raw ( std::vector< uint8_t > & bytes, const T & value )

inline

unserialize_raw()

template<class T>

uint64_t unserialize_raw ( T & value, const std::vector< uint8_t > & bytes, uint64_t offset )

inline

writeMMComment()

template<class Field>

std::ostream & writeMMComment	(	std::ostream &	os,
		Field &	F,
		std::string	name,
		std::string	comment )

Write second line and comment part of matrix market header.

writeMMCoordHeader()

template<class BB>

std::ostream & writeMMCoordHeader	(	std::ostream &	os,
		BB &	A,
		size_t	nnz,
		std::string	name,
		std::string	comment = "" )

Write matrix market header (up to the i,j,val lines) for a sparse or structured matrix.

writeMMPatternHeader()

template<class BB>

std::ostream & writeMMPatternHeader	(	std::ostream &	os,
		BB &	A,
		size_t	nnz,
		std::string	name,
		std::string	comment = "" )

Write matrix market header (up to the i,j lines) for a {0,1} sparse or structured matrix.

writeMMArrayHeader()

template<class BB>

std::ostream & writeMMArrayHeader	(	std::ostream &	os,
		BB &	A,
		std::string	name,
		std::string	comment = "" )

Write matrix market header (up to the entry lines) for a dense matrix.

writeMMArray()

template<class Mat>

std::ostream & writeMMArray	(	std::ostream &	os,
		Mat &	A,
		std::string	name,
		std::string	comment = "" )

Generic dense matrix writer to matrix market array format (col major).

eltype() [1/11]

std::string eltype ( float x )

inline

eltype(x) returns a string containing the name of the type of field or ring element x.

eltype() [2/11]

std::string eltype ( double x )

inline

eltype() [3/11]

std::string eltype ( int8_t x )

inline

eltype() [4/11]

std::string eltype ( int16_t x )

inline

eltype() [5/11]

std::string eltype ( int32_t x )

inline

eltype() [6/11]

std::string eltype ( int64_t x )

inline

eltype() [7/11]

std::string eltype ( integer x )

inline

eltype() [8/11]

std::string eltype ( uint8_t x )

inline

eltype() [9/11]

std::string eltype ( uint16_t x )

inline

eltype() [10/11]

std::string eltype ( uint32_t x )

inline

eltype() [11/11]

std::string eltype ( uint64_t x )

inline

operator>>() [4/4]

std::istream & operator>> ( std::istream & is, BitVector::reference & a )

inline

operator<<() [13/17]

std::ostream & operator<< ( std::ostream & os, BitVector::reference & a )

inline

operator<<() [14/17]

std::ostream & operator<< ( std::ostream & os, BitVector::const_reference & a )

inline

operator<<() [15/17]

template<class Vector>

std::ostream & operator<<	(	std::ostream &	os,
		const BlasSubvector< Vector > &	V )

operator==() [2/3]

template<class Vector>

bool operator==	(	const BlasSubvector< Vector > &	v1,
		const BlasSubvector< Vector > &	v2 )

operator==() [3/3]

template<class Field, class Storage>

bool operator==	(	const BlasVector< Field, Storage > &	v1,
		const BlasVector< Field, Storage > &	v2 )

operator<<() [16/17]

template<class Field, class Storage>

std::ostream & operator<<	(	std::ostream &	os,
		const BlasVector< Field, Storage > &	V )

randomVector() [1/4]

template<class Field, class Vector>

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

inline

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

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

Returns

v vector of random field elements

Parameters

F	Field in which arithmetic is done
n	integer number of elements in vector
r	Random field element generator

randomVector() [2/4]

template<class Field, class Vector, class VectorTrait>

Vector randomVector ( Field & F, size_t n, typename Field::RandIter & r, VectorCategories::DenseVectorTag< VectorTrait > tag )

inline

randomVector() [3/4]

template<class Field, class Vector, class VectorTrait>

Vector randomVector ( Field & F, size_t n, typename Field::RandIter & r, VectorCategories::SparseSequenceVectorTag< VectorTrait > tag )

inline

randomVector() [4/4]

template<class Field, class Vector, class VectorTrait>

Vector randomVector ( Field & F, size_t n, typename Field::RandIter & r, VectorCategories::SparseAssociativeVectorTag< VectorTrait > tag )

inline

isPower2()

void isPower2

(

size_t

n

)

hadamard()

template<class Ring, class Matrix>

Matrix & hadamard	(	const Ring &	R,
		Matrix &	Mat,
		size_t	n )

invhilb()

template<class Ring, class Matrix>

Matrix & invhilb	(	const Ring &	R,
		Matrix &	Mat,
		int	n )

jordanform()

template<class Ring, class Matrix>

Matrix & jordanform	(	const Ring &	R,
		Matrix &	Mat,
		size_t	n )

minmat()

template<class Ring, class Matrix>

Matrix & minmat	(	const Ring &	R,
		Matrix &	Mat,
		size_t	n )

maxmat()

template<class Ring, class Matrix>

Matrix & maxmat	(	const Ring &	R,
		Matrix &	Mat,
		size_t	n )

qlehmer()

template<class Ring, class Matrix>

Matrix & qlehmer	(	const Ring &	R,
		Matrix &	Mat,
		size_t	n )

randomAns()

template<class Ring, class Matrix>

Matrix & randomAns	(	const Ring &	R,
		Matrix &	Mat,
		size_t	n,
		size_t	epr )

Bug

use BlasVector.

used()

bool used	(	vector< int > &	array,
		int	value )

randomMat()

template<class Ring, class Matrix>

Matrix & randomMat	(	const Ring &	R,
		Matrix &	Mat,
		size_t	n,
		size_t	epr )

RandIntInInt()

size_t & RandIntInInt	(	const size_t &	s,
		size_t &	RIII,
		const int &	seed = 0 )

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

basic..

Parameters

[in]	s	sup
[in]	seed	seed. If 0 (default) we create a new one.
[out]	RIII	random integer in the interval \([[0, s-1]]\).

Returns

a reference to RIII

RandomPermutation()

void RandomPermutation	(	size_t *	P,
		const size_t &	len )

Creates a random Lapack style Permutation P of size len.

permutationDet()

int permutationDet	(	size_t *	P,
		const size_t	len )

CheckRank() [1/3]

template<class Field>

bool CheckRank	(	const Field &	F,
		const typename Field ::Element *	A,
		const size_t &	m,
		const size_t &	n,
		const size_t &	lda,
		const size_t &	alledged_rank )

Checks we got the right rank.

Parameters

F	field
A	matrix
m	rows
n	cols
lda	leadin dimmension
alledged_rank	supposedly correct rank.

Returns

alledged_rank==rank(A)

Parameters

alledged_rank

Bug

not used

CheckRank() [2/3]

template<class Field>

bool CheckRank	(	const Field &	F,
		const BlasMatrix< Field > &	A,
		const size_t &	alledged_rank )

CheckRank() [3/3]

template<class Field>

bool CheckRank	(	const Field &	F,
		const BlasSubmatrix< Field > &	A,
		const size_t &	alledged_rank )

CheckDet()

template<class Field>

bool CheckDet	(	const Field &	F,
		const typename Field ::Element *	A,
		const size_t &	m,
		const size_t &	lda,
		const typename Field ::Element &	alledged_det )

RandomMatrixWithRank()

template<class Field>

void RandomMatrixWithRank	(	const Field &	F,
		typename Field ::Element *	A,
		const size_t &	m,
		const size_t &	n,
		const size_t &	lda,
		const size_t &	rank )

Builds a m x n random matrix of rank rank over field F.

RandomMatrixWithDet()

template<class Field>

void RandomMatrixWithDet	(	const Field &	F,
		typename Field ::Element *	A,
		const size_t &	m,
		const size_t &	lda,
		const typename Field ::Element &	det )

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

Parameters

det

Bug

not used

magnitude()

template<typename Container>

Integer & magnitude	(	Integer &	max_elt,
		const Container &	v )

showAdvanceLinear()

void showAdvanceLinear	(	size_t	curr,
		size_t	min,
		size_t	max )

show the advancement (on the terminal) suppose linear advancement

Parameters

curr	current iteration
min	starting iteration
max	terminal iteration

showFinish()

void showFinish	(	size_t	curr,
		size_t	all )

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

Parameters

curr	current iteration
all	number of iterations

showSkip()

void showSkip	(	size_t	curr,
		size_t	all )

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

Parameters

curr	current iteration
all	number of iterations

computeMFLOPS() [1/2]

double computeMFLOPS	(	const double &	tim,
		const double	mflo,
		const size_t	rpt = 1 )

computes the number of megaflops.

Parameters

tim	timer (seconds)
mflo	number of operations (1e6 operations)
rpt	number of experiences

Returns

mflo/(tim*rpt)

insertTime()

dvector_t & insertTime	(	dvector_t &	tim3,
		const double &	tps )

inserts a time in a vector of 3 best times.

Parameters

tim3	ordered form min to max vector of 3 best times
tps	inserts that time in tim3 if better.

Returns

a reference to tim3

computeMFLOPS() [2/2]

double computeMFLOPS	(	const dvector_t &	tim,
		const double	mflo,
		Tag::TimeSelect	ts = Tag::TimeSelect::bestThree )

computes the number of megaflops.

Parameters

tim	timer (seconds)
mflo	number of operations (1e6 operations)
ts	number of experiences to select.

See also

TimeSelect. Default to the best three

Returns

mflo/(tim*rpt)

isDigit()

bool isDigit

(

const std::string &

s

)

Check if a string is actually a double.

Parameters

s	string to check

Returns

true/false

fortifiedString()

bool fortifiedString

(

const std::string &

s

)

Tells is a string has double quotes around.

Parameters

s	string to test

Returns

true if s[0] == s[last] == '"'

unfortifyString()

std::string unfortifyString

(

const std::string &

s

)

removes the surrounding quotes.

Parameters

s	removes quotes around if necessary

Returns

s without surrounding double quotes if necessary

fortifyString()

std::string fortifyString

(

const std::string &

s

)

adds surrounding quotes.

Parameters

s	add quotes around if necessary

Returns

s with surrounding double quotes if necessary

randomAlNum() [1/2]

char randomAlNum

(

)

random :alnum: char. [[:alnum:]] characters are in range

• num : 48-57
• AL : 67-90
• al : 97-122

Returns

a random alphabetic or numeric char.

randomAlNum() [2/2]

std::string randomAlNum

(

const size_t &

m

)

random :alnum: string.

Parameters

m	size of string [[:alnum:]] characters are in range num : 48-57 AL : 67-90 al : 97-122

Returns

a random alphabetic or numeric char.

getDateTime()

std::string getDateTime

(

const std::string &

sep = " "

)

get ISO time and date

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

Parameters

sep	separation between

getMachineInformation()

smatrix_t getMachineInformation

(

)

get some machine information (not cpu yet)

toString()

template<class T>

std::string toString

(

T &

nam

)

Converts anything to a string.

Parameters

nam	to be put in a string.

findKeyword()

bool findKeyword	(	size_t &	i,
		const svector_t::const_iterator &	begin,
		const svector_t::const_iterator &	end,
		const std::string &	keyword )

finds keyword betwen begin and end, return true if found and i is the index where it is (possibly correspondig to end)

fit2()

double fit2	(	const dvector_t &	X,
		const dvector_t &	Y,
		int	nn,
		double	x )

fit X[n-1,n],Y[n-1,n] and return evaluation at x.

fit3()

double fit3	(	const dvector_t &	X,
		const dvector_t &	Y,
		int	n,
		double	x )

fit X[n-2,n],Y[n-2,n] and return evaluation at x.

operator<<() [17/17]

std::ostream & operator<<	(	std::ostream &	out,
		const CSValue &	v )

Caster()

template<>

NTL::GF2E & Caster	(	NTL::GF2E &	x,
		const Integer &	y )

Variable Documentation

g_time1

double g_time1 =0.0

g_time2

double g_time2 =0.0

g_time3

double g_time3 =0.0

g_time4

double g_time4 =0.0

solverReturnString

const char * solverReturnString = {"OK", "FAILED", "SINGULAR", "INCONSISTENT", "BAD_PRECONDITIONER", "BAD_PRIME"}

_DEGINFTY_

const long _DEGINFTY_ = -1

matrixMulKernelModular1DP

const char* matrixMulKernelModular1DP

matrixMulKernelModular1SP

const char* matrixMulKernelModular1SP

matrixMulKernelModular8DP

const char* matrixMulKernelModular8DP

matrixMulKernelModular16SP

const char* matrixMulKernelModular16SP

matrixMulKernelModular32DP

const char* matrixMulKernelModular32DP

matrixMulKernelModular32SP

const char* matrixMulKernelModular32SP

matrixMulKernelModular1024DP

const char* matrixMulKernelModular1024DP

matrixMulKernelModular1024SP

const char* matrixMulKernelModular1024SP

matrixMuladdKernelModular1DP

const char* matrixMuladdKernelModular1DP

matrixMuladdKernelModular1SP

const char* matrixMuladdKernelModular1SP

matrixMuladdKernelModular8DP

const char* matrixMuladdKernelModular8DP

matrixMuladdKernelModular16SP

const char* matrixMuladdKernelModular16SP

matrixMuladdKernelModular32DP

const char* matrixMuladdKernelModular32DP

matrixMuladdKernelModular32SP

const char* matrixMuladdKernelModular32SP

matrixMuladdKernelModular1024DP

const char* matrixMuladdKernelModular1024DP

matrixMuladdKernelModular1024SP

const char* matrixMuladdKernelModular1024SP

matrixAxpyKernelModular1DP

const char* matrixAxpyKernelModular1DP

matrixAxpyKernelModular1SP

const char* matrixAxpyKernelModular1SP

matrixAxpyKernelModular8DP

const char* matrixAxpyKernelModular8DP

matrixAxpyKernelModular16SP

const char* matrixAxpyKernelModular16SP

matrixAxpyKernelModular32DP

const char* matrixAxpyKernelModular32DP

matrixAxpyKernelModular32SP

const char* matrixAxpyKernelModular32SP

matrixAxpyKernelModular1024DP

const char* matrixAxpyKernelModular1024DP

matrixAxpyKernelModular1024SP

const char* matrixAxpyKernelModular1024SP

matrixMaxpyKernelModular1DP

const char* matrixMaxpyKernelModular1DP

matrixMaxpyKernelModular1SP

const char* matrixMaxpyKernelModular1SP

matrixMaxpyKernelModular8DP

const char* matrixMaxpyKernelModular8DP

matrixMaxpyKernelModular16SP

const char* matrixMaxpyKernelModular16SP

matrixMaxpyKernelModular32DP

const char* matrixMaxpyKernelModular32DP

matrixMaxpyKernelModular32SP

const char* matrixMaxpyKernelModular32SP

matrixMaxpyKernelModular1024DP

const char* matrixMaxpyKernelModular1024DP

matrixMaxpyKernelModular1024SP

const char* matrixMaxpyKernelModular1024SP

matrixAxmyKernelModular1DP

const char* matrixAxmyKernelModular1DP

matrixAxmyKernelModular1SP

const char* matrixAxmyKernelModular1SP

matrixAxmyKernelModular8DP

const char* matrixAxmyKernelModular8DP

matrixAxmyKernelModular16SP

const char* matrixAxmyKernelModular16SP

matrixAxmyKernelModular32DP

const char* matrixAxmyKernelModular32DP

matrixAxmyKernelModular32SP

const char* matrixAxmyKernelModular32SP

matrixAxmyKernelModular1024DP

const char* matrixAxmyKernelModular1024DP

matrixAxmyKernelModular1024SP

const char* matrixAxmyKernelModular1024SP

BlasBound

const int BlasBound = 1 << 26

dpKernelSources

const char* dpKernelSources[]

Initial value:

= {
            matrixMulKernelModular1DP, matrixMulKernelModular8DP,
            matrixMulKernelModular32DP, matrixMulKernelModular1024DP,
            matrixMuladdKernelModular1DP, matrixMuladdKernelModular8DP,
            matrixMuladdKernelModular32DP, matrixMuladdKernelModular1024DP,
            matrixAxpyKernelModular1DP, matrixAxpyKernelModular8DP,
            matrixAxpyKernelModular32DP, matrixAxpyKernelModular1024DP,
            matrixMaxpyKernelModular1DP, matrixMaxpyKernelModular8DP,
            matrixMaxpyKernelModular32DP, matrixMaxpyKernelModular1024DP,
            matrixAxmyKernelModular1DP, matrixAxmyKernelModular8DP,
            matrixAxmyKernelModular32DP, matrixAxmyKernelModular1024DP}

dpKernelNames

const char* dpKernelNames[]

Initial value:

= {
            "matrixMulKernelModular1DP", "matrixMulKernelModular8DP",
            "matrixMulKernelModular32DP", "matrixMulKernelModular1024DP",
            "matrixMuladdKernelModular1DP", "matrixMuladdKernelModular8DP",
            "matrixMuladdKernelModular32DP", "matrixMuladdKernelModular1024DP",
            "matrixAxpyKernelModular1DP", "matrixAxpyKernelModular8DP",
            "matrixAxpyKernelModular32DP", "matrixAxpyKernelModular1024DP",
            "matrixMaxpyKernelModular1DP", "matrixMaxpyKernelModular8DP",
            "matrixMaxpyKernelModular32DP", "matrixMaxpyKernelModular1024DP",
            "matrixAxmyKernelModular1DP", "matrixAxmyKernelModular8DP",
            "matrixAxmyKernelModular32DP", "matrixAxmyKernelModular1024DP"}

spKernelSources

const char* spKernelSources[]

Initial value:

= {
            matrixMulKernelModular1SP, matrixMulKernelModular16SP,
            matrixMulKernelModular32SP, matrixMulKernelModular1024SP,
            matrixMuladdKernelModular1SP, matrixMuladdKernelModular16SP,
            matrixMuladdKernelModular32SP, matrixMuladdKernelModular1024SP,
            matrixAxpyKernelModular1SP, matrixAxpyKernelModular16SP,
            matrixAxpyKernelModular32SP, matrixAxpyKernelModular1024SP,
            matrixMaxpyKernelModular1SP, matrixMaxpyKernelModular16SP,
            matrixMaxpyKernelModular32SP, matrixMaxpyKernelModular1024SP,
            matrixAxmyKernelModular1SP, matrixAxmyKernelModular16SP,
            matrixAxmyKernelModular32SP, matrixAxmyKernelModular1024SP}

spKernelNames

const char* spKernelNames[]

Initial value:

= {
            "matrixMulKernelModular1SP", "matrixMulKernelModular16SP",
            "matrixMulKernelModular32SP", "matrixMulKernelModular1024SP",
            "matrixMuladdKernelModular1SP", "matrixMuladdKernelModular16SP",
            "matrixMuladdKernelModular32SP", "matrixMuladdKernelModular1024SP",
            "matrixAxpyKernelModular1SP", "matrixAxpyKernelModular16SP",
            "matrixAxpyKernelModular32SP", "matrixAxpyKernelModular1024SP",
            "matrixMaxpyKernelModular1SP", "matrixMaxpyKernelModular16SP",
            "matrixMaxpyKernelModular32SP", "matrixMaxpyKernelModular1024SP",
            "matrixAxmyKernelModular1SP", "matrixAxmyKernelModular16SP",
            "matrixAxmyKernelModular32SP", "matrixAxmyKernelModular1024SP"}

lambda

uint64_t lambda = 1000000000