LinBox Namespace Reference

Data Structures
class	FactorMult
class	FieldFactorMult
class	BlackboxBlockContainerBase
	A base class for BlackboxBlockContainer. The primary member function is begin(). It returns an iterator which after i increments (++) dereferences to $U A^i V$, for $U$ and $V$ determined by the init function. It is designed to be used with implementations of Block Berlekamp-Massey such as BlockMasseyDomain. More...
class	BlackboxBlockContainerBase::const_iterator
class	BlackboxBlockContainer
class	BlackboxBlockContainerRecord
class	BlackboxContainerBase
	A base class for BlackboxContainer. The primary member function is begin(). It returns an iterator which after i increments (++) dereferences to $v^T A^i u$, for $v$ and $u$ determined by the form of construction. It is designed to be used with implementations of Berlekamp-Massey such as MasseyDom. More...
class	BlackboxContainerBase::const_iterator
class	BlackboxContainerSymmetric
	See base class for doc. More...
class	BlackboxContainerSymmetrize
	Symmetrizing iterator (for rank computations). # //================================================================ // LinBox Project 1999 // Symmetrizing iterator (for rank computations) // Same left and right vector // A is supposed to have tranpose-vector product // the sequence is this->u^t this->u, (A this->u)^t (A this->u) = this->u^t (A^t A) this->u, // (A^t (A this->u))^t (A^t (A this->u)) = this->u^t (A^t A)^2 this->u , etc. // Time-stamp: <13 Jun 02 18:16:43 Jean-Guillaume.Dumas@imag.fr> // ================================================================ #. More...
class	BlackboxContainer
	Limited doc so far. More...
class	BlasMatrixDomainMulAdd
class	BlasMatrixDomainMul
class	BlasMatrixDomainMulin
class	BlasMatrixDomainInv
class	BlasMatrixDomainRank
class	BlasMatrixDomainDet
class	BlasMatrixDomainLeftSolve
class	BlasMatrixDomainRightSolve
class	BlasMatrixDomainMinpoly
class	BlasMatrixDomainCharpoly
class	BlasMatrixDomain
class	BlockLanczosSolver
class	BlockMasseyDomain
	Compute the linear generator of a sequence of matrices Giorgi, Jeannerod Villard algorithm from ISSAC'03 This class encapsulates the functionality required for computing the block minimal polynomial of a matrix. More...
class	BlockWiedemannSolver
struct	LazyProduct
struct	ChineseRemainder
class	CRA
class	DenseContainer
	Limited doc so far. More...
class	DiophantineSolver
	DiophantineSolver<QSolver> creates a diophantine solver using a QSolver to generate rational solutions Methods solve, randomSolve just expose functions from underlying rational solver. Method diophantineSolve creates a solution with minimal denominator, and can also create a certificate of minimality (described in 'Certified Dense Linear System Solving' by Mulders+Storjohann) which will be left in the public field lastCertificate. More...
class	Eliminator
class	GaussDomain
	Repository of functions for rank by elimination on sparse matrices. Several versions allow for adjustment of the pivoting strategy and for choosing in-place elimination or for not modifying the input matrix. Also an LU interface is offered. More...
class	LABlockLanczosSolver
class	LanczosSolver
	Solve a linear system using the conjugate Lanczos iteration. Lanczos system solver class. This class encapsulates the functionality required for solving a linear system through the conjugate Lanczos iteration. More...
class	LastInvariantFactor
	This is used in a Smith Form algorithm. This computes the last invariant factor of an integer matrix, whether zero or not, by rational solving. More...
class	LiftingContainer
class	LiftingContainerBase
class	LiftingContainerBase::const_iterator
class	DixonLiftingContainer
class	WiedemannLiftingContainer
class	BlockWiedemannLiftingContainer
class	MasseyDomain
	Berlekamp/Massey algorithm. Domain Massey Computation is stopped when the polynomials remain the same for more than EARLY_TERM_THRESOLD When minimal polynomial equals characteristic polynomial, 2 additional iterations are needed to compute it (parameter DEFAULT_ADDITIONAL_ITERATION), but those iterations are not needed for the rank. More...
struct	MatrixHomTrait
struct	MatrixHomTrait< DenseMatrixBase< typename Ring::Element >, Field >
struct	MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparseSeq >, Field >
struct	MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparsePar >, Field >
struct	MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparseMap >, Field >
struct	MatrixHomTrait< DenseMatrix< Ring >, Field >
struct	MatrixHomTrait< BlasBlackbox< Ring >, Field >
class	MatrixInverse
class	MatrixRank
class	MGBlockLanczosSolver
	Block Lanczos iteration. More...
class	MinPoly
class	MinPolyBlas
class	OneInvariantFactor
	Limited doc so far. More...
class	RationalReconstruction
	Limited doc so far. Used, for instance, after LiftingContainer. More...
class	RationalSolverAdaptive
class	RationalSolver
	interface for the different specialization of p-adic lifting based solvers. More...
class	RationalSolver< Ring, Field, RandomPrime, WiedemannTraits >
	partial specialization of p-adic based solver with Wiedemann algorithm More...
class	RationalSolver< Ring, Field, RandomPrime, BlockWiedemannTraits >
	partial specialization of p-adic based solver with block Wiedemann algorithm More...
class	RationalSolver< Ring, Field, RandomPrime, DixonTraits >
	partial specialization of p-adic based solver with Dixon algorithm More...
class	RationalSolver< Ring, Field, RandomPrime, NumericalTraits >
	partial specialization of p-adic based solver with a hybrid Numeric/Symbolic computation More...
class	Signature
class	Signature::BLAS_LPM_Method
class	Signature::Minpoly_Method
class	SmithFormAdaptive
class	SmithFormBinary
	Compute Smith form. More...
class	SmithFormIliopoulos
	This is Iliopoulos' algorithm do diagonalize. Compute Smith Form by elimination modulo m, for some modulus m such as S(n), the last invariant factor. The elimination method is originally described in "Worst Case Complexity Bounds on Algorithms for computing the Canonical Structure of Finite Abelian Groups and the Hermite and Smith Normal Forms of an Integer Matrix", by Costas Iliopoulos. More...
class	SmithFormLocal
	Smith normal form (invariant factors) of a matrix over a local ring. More...
class	SmithFormLocal< Local2_32 >
class	VectorFraction
	VectorFraction<Domain> is a vector of rational elements with common reduced denominator. Here Domain is a ring supporting the gcd, eg NTL_ZZ or PID_integer For compatability with the return type of rationalSolver, it allows conversion from/to std::vector<std::pair<Domain::Element> >. All functions will return the fraction in reduced form, calling reduce() if necessary. More...
class	WiedemannSolver
	Linear system solvers based on Wiedemann's method. This class encapsulates all of the functionality for linear system solving with Wiedemann's algorithm. It includes the random solution and random nullspace element of Kaltofen and Saunders (1991), as well as the certificate of inconsistency of Giesbrecht, Lobo, and Saunders (1998). More...
class	BlasApply
class	MatrixApplyDomain
	blackbox apply optimizations More...
class	BlasMatrixApplyDomain
class	MatrixApplyDomain< Domain, BlasMatrix< typename Domain::Element > >
class	MatrixApplyDomain< Domain, DenseMatrix< Domain > >
class	MatrixApplyDomain< Domain, BlasBlackbox< Domain > >
class	BlackboxArchetype
	showing the member functions provided by all blackbox matrix classes. More...
class	BlackboxInterface
	This blackbox base class exists solely to aid documentation organization. More...
class	Thread
struct	BBBase
class	LessTypeInfo
class	BBThread
class	BlasBlackbox
	template <class> More...
struct	BlasBlackbox::rebind
struct	MatrixTraits< BlasBlackbox< Field > >
struct	MatrixTraits< const BlasBlackbox< Field > >
class	MatrixContainerTrait< BlasBlackbox< Field > >
class	MatrixContainerTrait< const BlasBlackbox< Field > >
class	Butterfly
	Switching Network based BlackBox Matrix. A good preconditioner. More...
struct	Butterfly::rebind
struct	Companion
	Companion matrix of a monic polynomial. More...
struct	Companion::rebind
class	Compose
	General case. More...
struct	Compose::rebind
class	Compose< _Blackbox, _Blackbox >
	specialization for _Blackbox1 = _Blackbox2 More...
struct	Compose< _Blackbox, _Blackbox >::rebind
class	ComposeTraits
	used in ..., for example More...
class	ComposeTraits< DenseMatrix< Field > >
	used in smith-binary, for example More...
class	DenseMatrix
	Blackbox interface to dense matrix representation. More...
struct	DenseMatrix::rebind
struct	MatrixTraits< DenseMatrix< Field > >
struct	MatrixTraits< const DenseMatrix< Field > >
class	DenseMatrixFactory
class	Diagonal
	General diagonal, not be implemented. More...
class	Diagonal< _Field, VectorCategories::DenseVectorTag >
	Specialization of Diagonal for application to dense vectors. More...
struct	Diagonal< _Field, VectorCategories::DenseVectorTag >::rebind
class	Diagonal< Field, VectorCategories::SparseSequenceVectorTag >
	Specialization of Diagonal for application to sparse sequence vectors. More...
struct	Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::rebind
class	Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >
	Specialization of Diagonal for application to sparse associative vectors. More...
struct	Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::rebind
class	Dif
	Blackbox of a difference: C := A - B, i.e. Cx = Ax - Bx. More...
struct	Dif::rebind
class	DirectSum
	If C = DirectSum(A, B) and y = xA and z = wB, then (y,z) = (x,w)C. More...
struct	DirectSum::rebind
class	DirectSum< Blackbox, Blackbox >
struct	DirectSum< Blackbox, Blackbox >::rebind
class	BlackboxFactory
	A tool for computations with integer and rational matrices. The blackbox factory provides a facility for performing integer or rational computations by reducing modulo one or more primes and recovering the solution with Chinese Remaindering, lifting, or rational reconstruction. It is an interface that provides one method which, given a field, produces a black box representing a particular matrix over that field. The factory object may be passed to various procedures, such as rank, det, and solve, which will perform the required modular reductions to find integer or rational solutions. More...
class	Frobenius
	template <class> More...
struct	Frobenius::rebind
class	Hilbert
	Example of a blackbox that is space efficient, though not time efficient. More...
struct	Hilbert::rebind
class	Hilbert< _Field, VectorCategories::DenseVectorTag >
class	Hilbert< _Field, VectorCategories::SparseSequenceVectorTag >
class	Hilbert< _Field, VectorCategories::SparseAssociativeVectorTag >
class	Inverse
	A Blackbox for the inverse. Not efficient if many applications are used. More...
struct	Inverse::rebind
class	MoorePenrose
	Generalized inverse of a blackbox. Efficiency concerns when many applications are used. More...
struct	MoorePenrose::rebind
class	Hankel
	template <class> More...
struct	Hankel::rebind
class	Sylvester
	template <class> More...
struct	Sylvester::rebind
class	Toeplitz
	This is the blackbox representation of a Toeplitz matrix. More...
struct	Toeplitz::rebind
class	NullMatrix
	This is a representation of the 0 by 0 empty matrix which does not occupy memory. It has it's uses! More...
struct	NullMatrix::rebind
class	Permutation
	size is n. More...
struct	Permutation::rebind
class	PolynomialBB
	represent the matrix P(A) where A is a blackbox and P a polynomial More...
struct	PolynomialBB::rebind
class	RandomMatrixTraits
class	RandomMatrix
struct	RandomMatrix::rebind
class	ScalarMatrix
	Blackbox for aI. Use particularly for representing 0 and I. More...
struct	ScalarMatrix::rebind
class	SCompose
class	SparseMatrix
	vector of sparse rows. More...
struct	SparseMatrix::rebind
class	SparseMatrixFactory
struct	MatrixTraits< SparseMatrix< Field, _Row > >
struct	MatrixTraits< const SparseMatrix< Field, _Row > >
class	SubMatrixTraits< DenseMatrix< Field > >
class	SubMatrixTraits< Submatrix< DenseMatrix< Field > > >
class	Submatrix
class	Submatrix< Blackbox, VectorCategories::DenseVectorTag >
struct	Submatrix< Blackbox, VectorCategories::DenseVectorTag >::rebind
class	Submatrix< DenseMatrix< _Field >, VectorCategories::DenseVectorTag >
struct	Submatrix< DenseMatrix< _Field >, VectorCategories::DenseVectorTag >::rebind
class	SubRowMatrix< Matrix, MatrixCategories::RowMatrixTag >
struct	SubRowMatrix< Matrix, MatrixCategories::RowMatrixTag >::rebind
class	Sum
	blackbox of a matrix sum without copying. More...
struct	Sum::rebind
class	Transpose
	transpose matrix without copying. More...
struct	Transpose::rebind
class	TriplesBB
	wrapper for NAG Sparse Matrix format. More...
struct	TriplesBB::rebind
class	ZeroOne
	Time and space efficient representation of sparse {0,1}-matrices. More...
struct	ZeroOne::rebind
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	GivPolynomial
	Polynomials over a domain. More...
struct	GivPolynomial::rebind
class	GMPRationalElement
	elements of GMP_Rationals. More...
class	FFLAS
	BLAS for matrices over finite fields. More...
class	FFPACK
	Set of elimination based routines for dense linear algebra with matrices over finite prime field of characteristic less than 2^26. More...
class	FieldAbstract
	field base class. More...
class	FieldArchetype
	field specification and archetypical instance. More...
class	FieldEnvelope
	Derived class used to implement the field archetype. More...
class	FieldInterface
	This field base class exists solely to aid documentation organization. More...
class	RingCategories
struct	RingCategories::GenericTag
struct	RingCategories::ModularTag
struct	RingCategories::IntegerTag
struct	RingCategories::RationalTag
struct	ClassifyRing
struct	FieldTraits
struct	ClassifyRing< GF2 >
class	GF2
struct	ClassifyRing< GivaroExtension< BaseField > >
struct	FieldTraits< GivaroExtension< BaseField > >
struct	GivaroField
	give LinBox fields an allure of Givaro Fields More...
class	GivaroExtension
class	GivaroExtension< GivaroGfq >
class	Hom< BaseField, GivaroExtension< BaseField > >
struct	ClassifyRing< GivaroGfq >
class	GivaroGfq
struct	ClassifyRing< GivaroMontg >
class	GivaroMontg
	wrapper of Givaro's Montgomery<Std32>. More...
struct	ClassifyRing< GivaroRational >
class	GivaroRational
struct	ClassifyRing< GivaroZpz< Tag > >
class	GivaroZpz
	wrapper of Givaro's ZpzDom. More...
class	FieldAXPY< GivaroZpz< Std32 > >
class	FieldAXPY< GivaroZpz< Std16 > >
class	DotProductDomain< GivaroZpz< Std32 > >
class	DotProductDomain< GivaroZpz< Std16 > >
struct	ClassifyRing< GMP_Integers >
struct	ClassifyRing< GMPRationalField >
class	GMPRationalField
class	NoHomError
	Error object for attempt to establish a Hom that cannot exist. More...
class	Hom
	map element of source ring(field) to target ring More...
class	Hom< Source, Source >
struct	ClassifyRing< LidiaGfq >
class	LidiaGfq
	defines the Galois Field GF(pk). More...
struct	ClassifyRing< Local2_32 >
struct	Local2_32
	Fast arithmetic mod 2^32, including gcd. More...
struct	ClassifyRing< Modular< int > >
class	Modular< int >
	template <> More...
class	FieldAXPY< Modular< int > >
class	DotProductDomain< Modular< int > >
struct	ClassifyRing< Modular< int32 > >
class	Modular< int32 >
	template <> More...
class	FieldAXPY< Modular< int32 > >
class	DotProductDomain< Modular< int32 > >
struct	ClassifyRing< Modular< int8 > >
class	Modular< int8 >
	Specialization of Modular to signed 8 bit element type with efficient dot product. More...
class	FieldAXPY< Modular< int8 > >
class	DotProductDomain< Modular< int8 > >
class	MVProductDomain< Modular< int8 > >
struct	ClassifyRing< Modular< double > >
class	Modular< double >
	template <> More...
class	FieldAXPY< Modular< double > >
class	DotProductDomain< Modular< double > >
class	MVProductDomain< Modular< int32 > >
struct	ClassifyRing< Modular< short > >
class	Modular< int16 >
	Specialization of Modular to short element type with efficient dot product. More...
class	FieldAXPY< Modular< int16 > >
class	DotProductDomain< Modular< int16 > >
class	MVProductDomain< Modular< int16 > >
struct	ClassifyRing< Modular< Element > >
class	ModularBase
class	Modular
	Prime fields of positive characteristic implemented directly in LinBox. More...
class	Modular< uint8 >
	Allows compact storage when the modulus is less than 2^8. More...
class	Modular< uint16 >
	Specialization of class Modular for uint16 element type. More...
class	Modular< uint32 >
	Specialization of class Modular for uint32 element type. More...
class	FieldAXPY< Modular< _Element > >
class	FieldAXPY< Modular< uint8 > >
class	FieldAXPY< Modular< uint16 > >
class	FieldAXPY< Modular< uint32 > >
class	DotProductDomain< Modular< uint8 > >
class	DotProductDomain< Modular< uint16 > >
class	DotProductDomain< Modular< uint32 > >
class	MVProductDomain< Modular< uint8 > >
class	MVProductDomain< Modular< uint16 > >
class	MVProductDomain< Modular< uint32 > >
struct	ClassifyRing< UnparametricRandIter< NTL::GF2E > >
class	UnparametricRandIter< NTL::GF2E >
	template<> More...
class	NTL_GF2E
struct	ClassifyRing< NTL_zz_p >
struct	NTL_zz_p
struct	ClassifyRing< UnparametricRandIter< NTL::zz_pE > >
class	UnparametricRandIter< NTL::zz_pE >
struct	ClassifyRing< NTL_PID_zz_p >
struct	NTL_PID_zz_p
	extend Wrapper of zz_p from NTL. Add PID functions More...
struct	ClassifyRing< UnparametricField< NTL::RR > >
struct	ClassifyRing< NTL_ZZ >
class	FieldAXPY< NTL_ZZ >
struct	ClassifyRing< UnparametricField< NTL::ZZ_p > >
struct	NTL_ZZ_p
struct	ClassifyRing< UnparametricRandIter< NTL::ZZ_pE > >
class	UnparametricRandIter< NTL::ZZ_pE >
class	NTL_ZZ_pE
class	ParamFuzzy
struct	ClassifyRing< PID_integer >
struct	ClassifyRIng< PIRModular< int > >
class	PIRModular< int >
	template <> More...
class	FieldAXPY< PIRModular< int > >
class	DotProductDomain< PIRModular< int > >
class	MVProductDomain< PIRModular< int32 > >
struct	ClassifyRIng< PIRModular< int32 > >
class	PIRModular< int32 >
	template <> More...
class	FieldAXPY< PIRModular< int32 > >
class	DotProductDomain< PIRModular< int32 > >
struct	ClassifyRIng< PIR_ntl_ZZ_p >
class	PIR_ntl_ZZ_p
	extend Wrapper of ZZ_p from NTL. Add PIR functions More...
class	FieldAXPY< PIR_ntl_ZZ_p >
class	DotProductDomain< PIR_ntl_ZZ_p >
class	MVProductDomain< PIR_ntl_ZZ_p >
struct	Rebind
	used in support of Hom, MatrixHom More...
struct	ClassifyRing< UnparametricField< K > >
class	UnparametricField
class	FieldAXPY< UnparametricField< integer > >
class	BlackboxSymmetrizeIterator
class	MatrixArchetype
struct	MatrixTraits< MatrixArchetype< Element > >
class	MatrixContainerTrait< BlasMatrix< typename Field::Element > >
class	MatrixContainerTrait< const BlasMatrix< typename Field::Element > >
class	BlasMatrix
	Limited docs so far. More...
class	BlasTag
class	TriangularBlasMatrix
struct	MatrixTraits< BlasMatrix< Element > >
struct	MatrixTraits< const BlasMatrix< Element > >
class	indexDomain
class	BlasPermutation
class	TransposedBlasMatrix
class	TransposedBlasMatrix< TransposedBlasMatrix< Matrix > >
class	DenseRowsMatrix
struct	MatrixTraits< DenseRowsMatrix< Row > >
class	DenseSubmatrix
struct	DenseSubmatrix::rebind
struct	MatrixTraits< DenseSubmatrix< Element > >
class	DenseMatrixBase
struct	DenseMatrixBase::rebind
struct	MatrixTraits< DenseMatrixBase< Element > >
struct	MatrixTraits< const DenseMatrixBase< Element > >
class	FactorizedMatrixLeftSolve
class	FactorizedMatrixRightSolve
class	FactorizedMatrixLeftLSolve
class	FactorizedMatrixRightLSolve
class	FactorizedMatrixLeftUSolve
class	FactorizedMatrixRightUSolve
class	LQUPMatrix
struct	MatrixContainerCategory
struct	MatrixContainerCategory::BlasContainer
struct	MatrixContainerCategory::Container
struct	MatrixContainerCategory::Blackbox
class	MatrixContainerTrait
class	MatrixContainerTrait< DenseMatrixBase< typename Field::Element > >
class	MatrixContainerTrait< SparseMatrixBase< typename Field::Element > >
class	MatrixContainerTrait< DenseMatrix< Field > >
class	MatrixContainerTrait< SparseMatrix< Field > >
struct	MatrixCategories
	For specializing matrix arithmetic. More...
struct	MatrixCategories::BlackboxTag
struct	MatrixCategories::RowMatrixTag
struct	MatrixCategories::ColMatrixTag
struct	MatrixCategories::RowColMatrixTag
struct	MatrixTraits
class	MVProductDomain
	Helper class to allow specializations of certain matrix-vector products. More...
class	MatrixDomain
	Class of matrix arithmetic functions. More...
class	InvalidMatrixInput
class	FieldIO
	Dummy field for conceptually unclear io. More...
class	SparseMatrixWriteHelper
class	SparseMatrixWriteHelper::NoField
class	SparseMatrixReadWriteHelper
class	SparseMatrixWriteHelper< _Element, Row, VectorCategories::SparseParallelVectorTag >
class	SparseMatrixWriteHelper< _Element, Row, VectorCategories::SparseParallelVectorTag >::NoField
class	SparseMatrixBase
struct	SparseMatrixBase::rebind
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >
struct	SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >::rebind
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >::_RawIterator
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >::_RawIndexedIterator
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >
struct	SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >::rebind
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >::_RawIterator
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >::_RawIndexedIterator
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >
struct	SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >::rebind
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >::_RawIterator
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >::_RawIndexedIterator
struct	MatrixTraits< SparseMatrixBase< Element, Row, Trait > >
struct	MatrixTraits< const SparseMatrixBase< Element, Row, Trait > >
class	TransposeMatrix
class	TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag >
class	TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag >
class	TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag >
struct	MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > >
struct	MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > >
struct	MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > >
struct	MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > >
struct	MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > >
struct	MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > >
class	RandIterAbstract
class	RandIterArchetype
class	RandIterEnvelope
class	GenericRandIter
class	GF2RandIter
class	GmpRandomPrime
	generating random prime integers, using the gmp library. More...
class	GMPRationalRandIter
class	LidiaGfqRandIter
class	MersenneTwister
class	ModularRandIter
class	ModularBase::RandIter
class	NonzeroRandIter
class	NTL_ZZRandIter
class	ParamFuzzyRandIter
class	RandomPrime
class	UnparametricRandIter
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	GivPolynomialRing
	polynomials with coefficients modulo some power of two More...
class	PowerOfTwoModular
	Ring of elements modulo some power of two. More...
struct	PowerOfTwoModular::RandIter
class	RingInterface
	This ring base class exists solely to aid documentation organization. More...
struct	IntegerModularDet
struct	Specifier
struct	HybridSpecifier
struct	BlackboxSpecifier
struct	EliminationSpecifier
struct	WiedemannTraits
struct	LanczosTraits
struct	BlockLanczosTraits
struct	SparseEliminationTraits
struct	DixonTraits
struct	BlockWiedemannTraits
struct	NumericalTraits
struct	BlasEliminationTraits
struct	NonBlasEliminationTraits
struct	Method
	Method specifiers for controlling algorithm choice. More...
struct	SolverTraits
class	SolveFailed
class	InconsistentSystem
struct	IntegerModularMinpoly
class	SolverConcept
	showing functions expected of solver objects More...
class	Valence
class	Wiedemann
	solutions all based on Wiedemann's algorithm. More...
class	BooleanSwitch
class	BooleanSwitchFactory
class	CekstvSwitch
class	CekstvSwitchFactory
struct	LessThanString
class	ActivityState
	used by commentator More...
class	Commentator
	give information to user during runtime More...
struct	Commentator::StepsAndTime
struct	Commentator::Activity
class	MessageClass
class	PreconditionFailed
class	LinboxError
class	LinboxMathError
class	LinboxMathDivZero
class	LinboxBadFormat
class	FieldAXPY
class	DenseReader
class	MapleDense1Reader
class	MapleSparse1Reader
class	MatrixMarketReader
class	SMSReader
class	SparseRowReader
class	MatrixStreamReader
class	MatrixStream
class	PrimeStream
class	BaseTimer
	base for class RealTimer; class SysTimer; class UserTimer; More...
class	RealTimer
class	UserTimer
class	SysTimer
class	Timer
class	BitVector
struct	VectorTraits< BitVector >
class	ReverseVector
struct	VectorTraits< ReverseVector< Vector > >
class	Sparse_Vector
	vector< Pair<T> > and actualsize More...
class	VectorStream
	Vector factory. More...
class	ConstantVectorStream
class	RandomDenseStream
class	RandomDenseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag >
class	RandomSparseStream
class	RandomSparseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag >
class	RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseSequenceVectorTag >
class	RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseAssociativeVectorTag >
class	RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseParallelVectorTag >
class	StandardBasisStream
class	StandardBasisStream< Field, _Vector, VectorCategories::DenseVectorTag >
class	StandardBasisStream< Field, _Vector, VectorCategories::SparseSequenceVectorTag >
class	StandardBasisStream< Field, _Vector, VectorCategories::SparseAssociativeVectorTag >
class	StandardBasisStream< Field, _Vector, VectorCategories::SparseParallelVectorTag >
class	Subiterator
	Subvector iterator class provides striding iterators. More...
class	Subvector
	Dense subvector. More...
struct	VectorTraits< Subvector< Iterator, ConstIterator > >
class	VectorDomainBase
class	DotProductDomain
class	VectorDomain
struct	VectorCategories
	List of vector categories. More...
struct	VectorCategories::GenericVectorTag
struct	VectorCategories::DenseZeroOneVectorTag
struct	VectorCategories::SparseZeroOneVectorTag
struct	VectorCategories::DenseVectorTag
struct	VectorCategories::SparseSequenceVectorTag
struct	VectorCategories::SparseAssociativeVectorTag
struct	VectorCategories::SparseParallelVectorTag
struct	SparseSequenceVectorPairLessThan
struct	VectorTraits
struct	VectorTraits< std::vector< Element > >
struct	VectorTraits< std::vector< std::pair< size_t, Element > > >
struct	VectorTraits< std::list< std::pair< size_t, Element > > >
struct	VectorTraits< std::deque< std::pair< size_t, Element > > >
struct	VectorTraits< std::map< size_t, Element > >
struct	VectorTraits< std::pair< std::vector< size_t >, std::vector< Element > > >
class	RawVector
struct	Vector
struct	Vector::rebind
struct	Rebind< std::vector< 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::map< size_t, T >, U >
int32
This is a representation of 32 bit ints, usually equivalent to `int'. The use of `int32' ensures you are working with 32 bit signed ints, [-2^31..2^31). Similarly, int8, int16, and int64 are defined.
typedef signed __LINBOX_INT32	int32
typedef signed __LINBOX_INT64	int64
typedef unsigned __LINBOX_INT8	uint8
typedef unsigned __LINBOX_INT16	uint16
uint32
This is a representation of 32 bit unsigned ints, usually equivalent to `unsigned int'. The use of `uint32' ensures you are working with 32 bit unsigned ints, [0..2^32). Similarly, uint8, uint16, and uint64 are defined.
typedef unsigned __LINBOX_INT32	uint32
typedef unsigned __LINBOX_INT64	uint64
template<class T> T	abs (const T &a)
Butterfly
Butterfly preconditioner and supporting function
std::vector< bool >	setButterfly (const std::vector< bool > &x, size_t j=0)
[NOHEADER]
template<class Field>	Diagonal< Field, VectorCategories::DenseVectorTag >::Diagonal (const Field F, const std::vector< typename Field::Element > &v)
template<class _Field>	Diagonal< _Field, VectorCategories::DenseVectorTag >::Diagonal (const Field F, const size_t n)
template<class Field>	Diagonal< Field, VectorCategories::DenseVectorTag >::Diagonal (const Field F, const size_t n, typename Field::RandIter &iter)
template<class OutVector, class InVector> OutVector &	Diagonal< Field, VectorCategories::DenseVectorTag >::apply (OutVector &y, const InVector &x) const
template<class Field>	Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::Diagonal (const Field F, const std::vector< typename Field::Element > &v)
template<class OutVector, class InVector> OutVector &	Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::apply (OutVector &y, const InVector &x) const
template<class Field>	Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::Diagonal (const Field F, const std::vector< typename Field::Element > &v)
template<class OutVector, class InVector> OutVector &	Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::apply (OutVector &y, const InVector &x) const
NTL_zz_p
long ints modulo a positive integer. While NTL allows any int to serve as the modulus, only prime moduli yield fields. The primality of the modulus will not be checked, so it is the programmer's responsibility to supply a prime modulus if a field is wanted. These specializations allow the {UnparametricField} template class to be used to wrap NTL's { zz} class as a LinBox field. Uses nice trick for mod p via floating point.
template<>	UnparametricField< NTL::zz_p >::UnparametricField (integer q, size_t e)
template<> NTL::zz_p &	UnparametricField< NTL::zz_p >::init (NTL::zz_p &x, const integer &y) const
template<> integer &	UnparametricField< NTL::zz_p >::convert (integer &x, const NTL::zz_p &y) const
template<> integer &	UnparametricField< NTL::zz_p >::cardinality (integer &c) const
template<> integer &	UnparametricField< NTL::zz_p >::characteristic (integer &c) const
template<> NTL::zz_p &	UnparametricField< NTL::zz_p >::inv (NTL::zz_p &x, const NTL::zz_p &y) const
template<> bool	UnparametricField< NTL::zz_p >::isZero (const NTL::zz_p &x) const
template<> bool	UnparametricField< NTL::zz_p >::isOne (const NTL::zz_p &x) const
template<> NTL::zz_p &	UnparametricField< NTL::zz_p >::invin (NTL::zz_p &x) const
template<> std::ostream &	UnparametricField< NTL::zz_p >::write (std::ostream &os) const
template<>	UnparametricRandIter< NTL::zz_p >::UnparametricRandIter (const UnparametricField< NTL::zz_p > &F, const integer &size, const integer &seed)
	Constructor for random field element generator.
template<> NTL::zz_p &	UnparametricRandIter< NTL::zz_p >::random (NTL::zz_p &x) const
	Random field element creator.
class RR.
Rational number field. This field is provided as a convenience in a few places. Use with caution because expression swell. This specialization allows the {UnparametricField} template class to be used to wrap NTL's RR class as a LinBox field.
template<> NTL::RR &	UnparametricField< NTL::RR >::init (NTL::RR &x, const integer &y) const
template<> integer &	UnparametricField< NTL::RR >::convert (integer &x, const NTL::RR &y) const
template<> NTL::RR &	UnparametricField< NTL::RR >::inv (NTL::RR &x, const NTL::RR &y) const
template<> bool	UnparametricField< NTL::RR >::isZero (const NTL::RR &x) const
template<> bool	UnparametricField< NTL::RR >::isOne (const NTL::RR &x) const
template<> NTL::RR &	UnparametricField< NTL::RR >::invin (NTL::RR &x) const
template<> std::ostream &	UnparametricField< NTL::RR >::write (std::ostream &os) const
template<> NTL::RR &	UnparametricRandIter< NTL::RR >::random (NTL::RR &elt) const
NTL_ZZ_p
Arbitrary precision integers modulus a positive integer. While NTL allows any integer to serve as the modulus, only prime moduli yield fields. Therefore, while arthmetic operations may be valid for any modulus, only prime moduli are supported in this implementation. The primality of the modulus will not be checked, so it is the programmer's responsibility to supply a prime modulus. These specializations allow the {UnparametricField} template class to be used to wrap NTL's { ZZ} class as a LinBox field.
template<>	UnparametricField< NTL::ZZ_p >::UnparametricField (integer q, size_t e)
template<> integer &	UnparametricField< NTL::ZZ_p >::convert (integer &x, const NTL::ZZ_p &y) const
template<> double &	UnparametricField< NTL::ZZ_p >::convert (double &x, const NTL::ZZ_p &y) const
template<> integer &	UnparametricField< NTL::ZZ_p >::cardinality (integer &c) const
template<> integer &	UnparametricField< NTL::ZZ_p >::characteristic (integer &c) const
template<> NTL::ZZ_p &	UnparametricField< NTL::ZZ_p >::inv (NTL::ZZ_p &x, const NTL::ZZ_p &y) const
template<> bool	UnparametricField< NTL::ZZ_p >::isZero (const NTL::ZZ_p &x) const
template<> bool	UnparametricField< NTL::ZZ_p >::isOne (const NTL::ZZ_p &x) const
template<> NTL::ZZ_p &	UnparametricField< NTL::ZZ_p >::invin (NTL::ZZ_p &x) const
template<> std::ostream &	UnparametricField< NTL::ZZ_p >::write (std::ostream &os) const
template<>	UnparametricRandIter< NTL::ZZ_p >::UnparametricRandIter (const UnparametricField< NTL::ZZ_p > &F, const integer &size, const integer &seed)
	Constructor for random field element generator.
template<> NTL::ZZ_p &	UnparametricRandIter< NTL::ZZ_p >::random (NTL::ZZ_p &x) const
	Random field element creator.
Typedefs
typedef std::vector< BBBase * >	BB_list
typedef std::map< const std::type_info *, BB_list, LessTypeInfo >	BB_list_list
typedef UnparametricField< integer >	GMP_Integers
typedef NTL_ZZRandIter	RandIter
	the integer ring. class NTL_ZZ {
typedef NTL::ZZ	Element
typedef ParamFuzzy	DoubleRealApproximation
typedef Integer	integer
	This is a representation of arbitrary integers.
typedef signed __LINBOX_INT8	int8
typedef signed __LINBOX_INT16	int16
Enumerations
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	FileFormatTag {   FORMAT_DETECT, FORMAT_GUILLAUME, FORMAT_TURNER, FORMAT_MATLAB,   FORMAT_MAPLE, FORMAT_PRETTY, FORMAT_MAGMACPT }
	tags for SparseMatrixBase::read() and write() More...
enum	MatrixStreamError {   AMBIGUOUS_FORMAT = -1, GOOD, END_OF_MATRIX, END_OF_FILE,   BAD_FORMAT, NO_FORMAT }
Functions
template<class Blackbox, class Polynomial, class Categorytag> Polynomial &	blackboxcharpoly (Polynomial &P, const Blackbox &A, const Categorytag &tag)
template<class Blackbox> GivPolynomial< typename Blackbox::Field::Element > &	blackboxcharpoly (GivPolynomial< typename Blackbox::Field::Element > &P, const Blackbox &A, const RingCategories::IntegerTag &tag)
template<class Blackbox> GivPolynomial< typename Blackbox::Field::Element > &	blackboxcharpoly (GivPolynomial< typename Blackbox::Field::Element > &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
template<class Polynomial> int	updateFactorsMult (FieldFactorMult< Polynomial > *ffm, const size_t n, int *goal)
template<class FieldPoly, class IntPoly> void	trials (list< vector< FactorMult< FieldPoly, IntPoly > > > &sols, const int goal, vector< FactorMult< FieldPoly, IntPoly > > &ufv, const int i0)
template<class Polynomial> void	trials (list< vector< FieldFactorMult< Polynomial > > > &sols, const int goal, vector< FieldFactorMult< Polynomial > > &ufv, const int i0)
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 Polynomial, class Blackbox> Polynomial &	cia (Polynomial &P, const Blackbox &A, const Method::BlasElimination &M)
template<class Vector> long	density (const Vector &v)
	Estimate nonzero entries in a vector, used in parallel elimination.
template<class Vector, class VectorCategory> long	density (const Vector &, VectorCategory)
template<class Vector> long	density (const Vector &v, VectorCategories::DenseVectorTag)
template<class Vector> long	density (const Vector &v, VectorCategories::SparseSequenceVectorTag)
template<class Vector> long	density (const Vector &v, VectorCategories::SparseAssociativeVectorTag)
template<class Vector> long	density (const Vector &v, VectorCategories::SparseParallelVectorTag)
template<class Ring, class ItMatrix> void	SpecialBound (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const ItMatrix &A)
template<class Ring> void	BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const DenseMatrixBase< typename Ring::Element > &A)
template<class Ring> void	BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const DenseSubmatrix< typename Ring::Element > &A)
template<class Ring> void	BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const SparseMatrix< Ring > &A)
template<class Ring, class Matrix1, class Matrix2> void	BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const Compose< Matrix1, Matrix2 > &A)
template<class Ring, class Matrix> void	BoundBlackbox (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const Transpose< Matrix > &A)
template<class Ring, class ItMatrix> void	ApplyBound (const Ring &R, typename Ring::Element &bound_A, const ItMatrix &A)
int	rational_reconstruction (integer &a, integer &b, const integer &n0, const integer &d0, const integer &B)
template<class Domain> void	reduceIn (Domain &D, std::pair< typename Domain::Element, typename Domain::Element > &frac)
template<class Domain, class Vector> void	vectorGcdIn (typename Domain::Element &result, Domain &D, Vector &v)
template<class Domain, class Vector> Domain::Element	vectorGcd (Domain &D, Vector &v)
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_padic_chunk (const Domain &D, const IMatrix &M, double *chunks, size_t num_chunks)
	split an integer matrix into a padic chunk representation
void *	runThread (void *arg)
template<class Matrix, class Out, class In> BBThread< Matrix, Out, In > *	createBBThread (const Matrix *m, Out *out, const In *in)
template<class Field> bool	checkBlasApply (const Field &F, size_t n)
template<class Field>	Hilbert< Field, VectorCategories::DenseVectorTag >::Hilbert (Field F, size_t n)
template<class OutVector, class InVector> OutVector &	Hilbert< Field, VectorCategories::DenseVectorTag >::apply (OutVector &y, const InVector &x) const
template<class Field>	Hilbert< Field, VectorCategories::SparseSequenceVectorTag >::Hilbert (Field F, size_t n)
template<class OutVector, class InVector> OutVector &	Hilbert< Field, VectorCategories::SparseSequenceVectorTag >::apply (OutVector &y, const InVector &x) const
template<class Field>	Hilbert< Field, VectorCategories::SparseAssociativeVectorTag >::Hilbert (Field F, size_t n)
template<class OutVector, class InVector> OutVector &	Hilbert< Field, VectorCategories::SparseAssociativeVectorTag >::apply (OutVector &y, const InVector &x) const
std::ostream &	operator<< (std::ostream &os, GMPRationalElement &elt)
std::istream &	operator>> (std::istream &is, GMPRationalElement &elt)
template<> NTL::GF2E &	UnparametricField< NTL::GF2E >::init (NTL::GF2E &x, const integer &y) const
template<> integer &	UnparametricField< NTL::GF2E >::convert (integer &x, const NTL::GF2E &y) const
template<> bool	UnparametricField< NTL::GF2E >::isZero (const NTL::GF2E &a) const
template<> bool	UnparametricField< NTL::GF2E >::isOne (const NTL::GF2E &a) const
template<> integer &	UnparametricField< NTL::GF2E >::characteristic (integer &c) const
template<> integer &	UnparametricField< NTL::GF2E >::cardinality (integer &c) const
template<> NTL::GF2E &	UnparametricField< NTL::GF2E >::inv (NTL::GF2E &x, const NTL::GF2E &y) const
template<> NTL::GF2E &	UnparametricField< NTL::GF2E >::invin (NTL::GF2E &x) const
template<> std::istream &	UnparametricField< NTL::GF2E >::read (std::istream &is, NTL::GF2E &x) const
template<> NTL::zz_pE &	UnparametricField< NTL::zz_pE >::init (NTL::zz_pE &x, const integer &y) const
template<> integer &	UnparametricField< NTL::zz_pE >::convert (integer &x, const NTL::zz_pE &y) const
template<> bool	UnparametricField< NTL::zz_pE >::isZero (const NTL::zz_pE &a) const
template<> bool	UnparametricField< NTL::zz_pE >::isOne (const NTL::zz_pE &a) const
template<> integer &	UnparametricField< NTL::zz_pE >::characteristic (integer &c) const
template<> integer &	UnparametricField< NTL::zz_pE >::cardinality (integer &c) const
template<> NTL::zz_pE &	UnparametricField< NTL::zz_pE >::inv (NTL::zz_pE &x, const NTL::zz_pE &y) const
template<> NTL::zz_pE &	UnparametricField< NTL::zz_pE >::invin (NTL::zz_pE &x) const
template<> std::istream &	UnparametricField< NTL::zz_pE >::read (std::istream &is, NTL::zz_pE &x) const
	NTL_ZZ (int p=0, int exp=1)
integer &	cardinality (integer &c) const
integer &	characteristic (integer &c) const
std::ostream &	write (std::ostream &out) const
std::istream &	read (std::istream &in) const
template<class Element2> Element &	init (Element &x, const Element2 &y) const
	Init x from y.
Element &	init (Element &x, const Element &y) const
	Init from a NTL::ZZ.
Element &	init (Element &x, const int64 &y) const
	Init from an int64.
Element &	init (Element &x, const uint64 &y) const
	Init from a uint64.
Element &	init (Element &x, const integer &y) const
	I don't know how to init from integer efficiently.
integer &	convert (integer &x, const Element &y)
	Convert y to an Element.
double &	convert (double &x, const Element &y)
Element &	assign (Element &x, const Element &y) const
	x = y.
bool	areEqual (const Element &x, const Element &y) const
	Test if x == y.
bool	isZero (const Element &x) const
	Test if x == 0.
bool	isOne (const Element &x) const
	Test if x == 1.
Element &	add (Element &x, const Element &y, const Element &z) const
	return x = y + z
Element &	sub (Element &x, const Element &y, const Element &z) const
	return x = y - z
template<class Int> Element &	mul (Element &x, const Element &y, const Int &z) const
	return x = y * z
Element &	div (Element &x, const Element &y, const Element &z) const
	If z divides y, return x = y / z, otherwise, throw an exception.
Element &	inv (Element &x, const Element &y) const
	If y is a unit, return x = 1 / y, otherwsie, throw an exception.
Element &	neg (Element &x, const Element &y) const
	return x = -y;
template<class Int> Element &	axpy (Element &r, const Element &a, const Int &x, const Element &y) const
	return r = a x + y
Element &	addin (Element &x, const Element &y) const
	return x += y;
Element &	subin (Element &x, const Element &y) const
	return x -= y;
template<class Int> Element &	mulin (Element &x, const Int &y) const
	return x *= y;
Element &	divin (Element &x, const Element &y) const
	If y divides x, return x /= y, otherwise throw an exception.
Element &	invin (Element &x)
	If x is a unit, x = 1 / x, otherwise, throw an exception.
Element &	negin (Element &x) const
	return x = -x;
template<class Int> Element &	axpyin (Element &r, const Element &a, const Int &x) const
	return r += a x
std::ostream &	write (std::ostream &out, const Element &y) const
	out << y;
std::istream &	read (std::istream &in, Element &x) const
	read x from istream in
bool	isUnit (const Element &x) const
	Test if x is a unit.
Element &	gcd (Element &g, const Element &a, const Element &b) const
	return g = gcd (a, b)
Element &	gcdin (Element &g, const Element &b) const
	return g = gcd (g, b)
Element &	xgcd (Element &g, Element &s, Element &t, const Element &a, const Element &b) const
	g = gcd(a, b) = a*s + b*t. The coefficients s and t are defined according to the standard Euclidean algorithm applied to |a| and |b|, with the signs then adjusted according to the signs of a and b.
Element &	lcm (Element &c, const Element &a, const Element &b) const
	c = lcm (a, b)
Element &	lcmin (Element &l, const Element &b) const
	l = lcm (l, b)
Element &	sqrt (Element &x, const Element &y) const
	x = floor ( sqrt(y)).
long	reconstructRational (Element &a, Element &b, const Element &x, const Element &m, const Element &a_bound, const Element &b_bound) const
	Requires 0 <= x < m, m > 2 * a_bound * b_bound, a_bound >= 0, b_bound > 0 This routine either returns 0, leaving a and b unchanged, or returns 1 and sets a and b so that (1) a = b x (mod m), (2) |a| <= a_bound, 0 < b <= b_bound, and (3) gcd(m, b) = gcd(a, b).
Element &	quo (Element &q, const Element &a, const Element &b) const
	q = floor (x/y);
Element &	rem (Element &r, const Element &a, const Element &b) const
	r = remindar of a / b
Element &	quoin (Element &a, const Element &b) const
	a = quotient (a, b)
Element &	remin (Element &x, const Element &y) const
	a = quotient (a, b)
void	quoRem (Element &q, Element &r, const Element &a, const Element &b) const
	q = [a/b], r = a - b*q |r| < |b|, and if r != 0, sign(r) = sign(b)
bool	isDivisor (const Element &a, const Element &b) const
	Test if b | a.
long	compare (const Element &a, const Element &b) const
Element &	abs (Element &x, const Element &a) const
int	getMaxModulus ()
template<> NTL::ZZ_p &	UnparametricField< NTL::ZZ_p >::init (NTL::ZZ_p &x, const integer &y) const
	Initialization of field element from an integer. Behaves like C++ allocator construct. This function assumes the output field element x has already been constructed, but that it is not already initialized. This done by converting to a std::string : inefficient but correct.
template<> NTL::ZZ_pE &	UnparametricField< NTL::ZZ_pE >::init (NTL::ZZ_pE &x, const integer &y) const
template<> bool	UnparametricField< NTL::ZZ_pE >::isZero (const NTL::ZZ_pE &a) const
template<> bool	UnparametricField< NTL::ZZ_pE >::isOne (const NTL::ZZ_pE &a) const
template<> integer &	UnparametricField< NTL::ZZ_pE >::convert (integer &c, const NTL::ZZ_pE &e) const
template<> integer &	UnparametricField< NTL::ZZ_pE >::characteristic (integer &c) const
template<> integer &	UnparametricField< NTL::ZZ_pE >::cardinality (integer &c) const
template<> NTL::ZZ_pE &	UnparametricField< NTL::ZZ_pE >::inv (NTL::ZZ_pE &x, const NTL::ZZ_pE &y) const
template<> NTL::ZZ_pE &	UnparametricField< NTL::ZZ_pE >::invin (NTL::ZZ_pE &x) const
template<> std::istream &	UnparametricField< NTL::ZZ_pE >::read (std::istream &is, NTL::ZZ_pE &x) const
template<class Element, class Row> std::ostream &	operator<< (std::ostream &os, const SparseMatrixBase< Element, Row > &A)
template<class Element, class Row> std::istream &	operator>> (std::istream &is, SparseMatrixBase< Element, Row > &A)
uint32	hiBit (uint32 u)
uint32	loBit (uint32 u)
uint32	loBits (uint32 u)
uint32	mixBits (uint32 u, uint32 v)
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 Polynomial, class Blackbox, class DomainCategory> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const DomainCategory &tag, const Method::Hybrid &M)
template<class Polynomial, class Field, class DomainCategory> Polynomial &	charpoly (Polynomial &P, const DenseMatrix< Field > &A, const DomainCategory &tag, const Method::Hybrid &M)
template<class Polynomial, class Blackbox, class DomainCategory> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const DomainCategory &tag, const Method::Elimination &M)
template<class Polynomial, class Blackbox> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
	Compute the characteristic polynomial over { Z_p}.
template<class Polynomial, class Blackbox> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::IntegerTag &tag, const Method::BlasElimination &M)
	Compute the characteristic polynomial over { Z}.
template<class Polynomial, class Blackbox, class Categorytag> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const Categorytag &tag, const Method::Blackbox &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 &M)
template<class Blackbox, class MyMethod> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const MyMethod &M)
	Compute the determinant of A.
template<class Blackbox> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A)
template<class Blackbox> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Field> Field::Element &	det (typename Field::Element &d, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Blackbox> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &M)
template<class Blackbox> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
template<class Blackbox> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Wiedemann &M)
template<class Blackbox> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
template<class Field> Field::Element &	detin (typename Field::Element &d, BlasBlackbox< Field > &A)
	A will be modified.
template<class Blackbox, class MyMethod> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class BB> BB::Field::Element &	getEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j)
	Getting the i,j entry of the blackbox.
template<class BB> BB::Field::Element &	getEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j, const Method::Hybrid &m)
	our best guess
template<class Field> Field::Element &	getEntry (typename Field::Element &x, const DenseMatrix< Field > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class Field> Field::Element &	getEntry (typename Field::Element &x, const SparseMatrix< Field > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class Field> Field::Element &	getEntry (typename Field::Element &x, const ScalarMatrix< Field > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class Field, class Trait> Field::Element &	getEntry (typename Field::Element &x, const Diagonal< Field, Trait > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class BB> BB::Field::Element &	getEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j, const Method::Elimination &m)
	our elimination (a fake in this case)
template<class Blackbox> Blackbox::Field::Element &	getEntry (typename Blackbox::Field::Element &res, const Blackbox &A, const size_t i, const size_t j, const Method::Blackbox &m)
template<class Field, class Trait, class BlackBox> Field::Element &	getEntry (typename Field::Element &t, const Compose< Diagonal< Field, Trait >, BlackBox > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class BlackBox, class Field, class Trait> Field::Element &	getEntry (typename Field::Element &t, const Compose< BlackBox, Diagonal< Field, Trait > > &A, const size_t i, const size_t j, const Method::Hybrid &m)
template<class Field, class T1, class T2> Field::Element &	getEntry (typename Field::Element &t, const Compose< Diagonal< Field, T1 >, Diagonal< Field, T2 > > &A, const size_t i, const size_t j, const Method::Hybrid &m)
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)
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::Hybrid &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::BlasElimination &M)
template<class Ring> bool	isPositiveDefinite (const DenseMatrix< Ring > &A, const RingCategories::IntegerTag &tag, const Method::BlasElimination &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)
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::Hybrid &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::BlasElimination &M)
template<class Ring> bool	isPositiveSemiDefinite (const DenseMatrix< Ring > &A, const RingCategories::IntegerTag &tag, const Method::BlasElimination &M)
template<class Field> void	LU (DenseMatrix< Field > &M)
template<class Field> void	LU (Submatrix< DenseMatrix< Field > > &M)
template<class Matrix> void	LL_MULIN (Matrix &M, const Matrix &L)
template<class Matrix> void	RU_MULIN (Matrix &R, const Matrix &U)
template<class Matrix> void	AXMYIN (Matrix &, const Matrix &, const Matrix &)
template<class BB> bool	useBB (const BB &A)
template<class Field> bool	useBB (const 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)
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::Hybrid &M)
template<class Polynomial, class Field> Polynomial &	minpoly (Polynomial &P, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Hybrid &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::BlasElimination &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> Polynomial &	minpoly (Polynomial &P, const Blackbox &A, RingCategories::ModularTag tag, const Method::Wiedemann &M=Method::Wiedemann())
template<class Polynomial, class Blackbox, class MyMethod> Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class Blackbox> unsigned long &	rank (unsigned long &r, const Blackbox &A)
template<class Matrix> unsigned long &	rankin (unsigned long &r, Matrix &A)
template<class Blackbox> unsigned long &	rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Hybrid &m)
template<class Blackbox> unsigned long &	rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &m)
template<class Field, class Vector> unsigned long &	rank (unsigned long &r, const SparseMatrix< Field, Vector > &A, const RingCategories::ModularTag &tag, const Method::Elimination &m)
template<class Blackbox> unsigned long &	rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::NonBlasElimination &m)
template<class Blackbox> unsigned long &	rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &m)
template<class Blackbox, class Method> unsigned long &	rank (unsigned long &r, const Blackbox &A, const Method &M)
template<class Blackbox> unsigned long &	rank (unsigned long &res, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Wiedemann &M)
	M may be Method::Wiedemann().
template<class Field> unsigned long &	rank (unsigned long &r, const SparseMatrix< Field, typename LinBox::Vector< Field >::SparseSeq > &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
	M may be Method::SparseElimination().
template<class Field> unsigned long &	rankin (unsigned long &r, SparseMatrix< Field, typename LinBox::Vector< Field >::SparseSeq > &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
	M may be Method::SparseElimination().
template<class Blackbox> unsigned long &	rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
	Change of representation to be able to call the sparse elimination.
template<class Blackbox> unsigned long &	rank (unsigned long &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
	M may be Method::BlasElimination().
template<class Matrix> unsigned long &	rankin (unsigned long &r, Matrix &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M)
	A is modified.
template<class Field> unsigned long &	rankin (unsigned long &r, BlasBlackbox< Field > &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
	A is modified.
template<class Blackbox, class MyMethod> unsigned long &	rank (unsigned long &r, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class I1, class Lp> void	distinct (I1 a, I1 b, Lp &c)
template<class Output, class Blackbox, class SmithMethod, class DomainCategory> Output &	smithForm (Output &S, const Blackbox &A, const DomainCategory &tag, const SmithMethod &M)
template<class Output, class Blackbox, class MyMethod> Output &	smithForm (Output &S, const Blackbox &A, const MyMethod &M)
template<class Output, class Blackbox> Output &	smithForm (Output &S, const Blackbox &A)
template<> list< pair< integer, size_t > > &	smithForm (list< pair< integer, size_t > > &S, const DenseMatrix< NTL_ZZ > &A, const RingCategories::IntegerTag &tag, const Method::Hybrid &M)
template<class Vector, class Blackbox, class SolveMethod, class DomainCategory> Vector &	solve (Vector &x, const Blackbox &A, const Vector &b, const DomainCategory &tag, const SolveMethod &M)
template<class Vector, class Blackbox, class SolveMethod> Vector &	solve (Vector &x, const Blackbox &A, const Vector &b, const SolveMethod &M)
	Solve Ax = b, for x.
template<class Vector, class Blackbox> Vector &	solve (Vector &x, const Blackbox &A, const Vector &b)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const Method::Hybrid &m)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const Method::Blackbox &m)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const Method::Elimination &m)
template<class Vector, class Field> Vector &	solve (Vector &x, const SparseMatrix< Field > &A, const Vector &b, const Method::Elimination &m)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlasElimination &m)
template<class Vector, class Field> Vector &	solve (Vector &x, const BlasBlackbox< Field > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlasElimination &m)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::BlasElimination &m)
template<class Vector, class Field> Vector &	solve (Vector &x, const BlasBlackbox< Field > &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::BlasElimination &m)
template<class Vector, class Field> Vector &	solve (Vector &x, const DenseMatrix< Field > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlasElimination &m)
template<class Vector, class Ring> Vector &	solve (Vector &x, const BlasBlackbox< Ring > &A, const Vector &b, const RingCategories::IntegerTag tag, const Method::Dixon &m)
	solver specialization with DixonTraits over integer (no copying)
template<class Vector, class Ring> Vector &	solve (Vector &x, const DenseMatrix< Ring > &A, const Vector &b, const RingCategories::IntegerTag tag, const Method::Dixon &m)
	solver specialization with DixonTraits over integer (no copying)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::NonBlasElimination &m)
template<class Vector, class Field> Vector &	solve (Vector &x, const DenseMatrix< Field > &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::NonBlasElimination &m)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::BlockLanczos &m)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::BlockLanczos &m)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const RingCategories::ModularTag &tag, const Method::Wiedemann &m)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &A, const Vector &b, const RingCategories::IntegerTag &tag, const Method::Wiedemann &m)
template<class BB> BB::Field::Element &	trace (typename BB::Field::Element &t, const BB &A)
	sum of eigenvalues
template<class BB> BB::Field::Element &	trace (typename BB::Field::Element &t, const BB &A, const Method::Hybrid &m)
	our best guess
template<class Field> Field::Element &	trace (typename Field::Element &t, const DenseMatrix< Field > &A, const Method::Hybrid &m)
template<class Field, class Row> Field::Element &	trace (typename Field::Element &t, const SparseMatrix< Field, Row > &A, const Method::Hybrid &m)
template<class Field, class Trait> Field::Element &	trace (typename Field::Element &t, const Diagonal< Field, Trait > &A, const Method::Hybrid &m)
template<class Field> Field::Element &	trace (typename Field::Element &t, const ScalarMatrix< Field > &A, const Method::Hybrid &m)
template<class BB> BB::Field::Element &	trace (typename BB::Field::Element &t, const BB &A, const Method::Elimination &m)
	our elimination (a fake in this case)
template<class Blackbox> Blackbox::Field::Element &	trace (typename Blackbox::Field::Element &res, const Blackbox &A, const Method::Blackbox &m)
template<class Field, class Trait, class BlackBox> Field::Element &	trace (typename Field::Element &t, const Compose< Diagonal< Field, Trait >, BlackBox > &A, const Method::Hybrid &m)
template<class BlackBox, class Field, class Trait> Field::Element &	trace (typename Field::Element &t, const Compose< BlackBox, Diagonal< Field, Trait > > &A, const Method::Hybrid &m)
template<class Field, class T1, class T2> Field::Element &	trace (typename Field::Element &t, const Compose< Diagonal< Field, T1 >, Diagonal< Field, T2 > > &A, const Method::Hybrid &m)
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)
std::ostream &	operator<< (std::ostream &o, const BaseTimer &BT)
std::ostream &	operator<< (std::ostream &o, const Timer &T)
template<class Field, class Vector> Vector	randomVector (Field &F, size_t n, typename Field::RandIter &r)
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)
template<class Element> Element &	noop (Element &a, const Element &b)
template<class Field> void	fieldTest (const Field &f, double *array, long iter=1000000)
int64	getOps (int &a, float &b)
template<class Field> bool	LU_MUL_TEST (const DenseMatrix< Field > &M, const DenseMatrix< Field > &L, const DenseMatrix< Field > &U)
Variables
const int	DEFAULTLIFTHRESHOLD = 5
const int	DEFAULTOIFTHRESHOLD = 30
const double	CROSSOVER = 0.6
const char *	solverReturnString [] = {"OK", "FAILED", "SINGULAR", "INCONSISTENT", "BAD_PRECONDITIONER", "BAD_PRIME"}
const long	_DEGINFTY_ = -1
Out &BlackboxParallel(Out &out, const Matrix &m, const In &in, BBBase::BBType type) Out	BlackboxParallel )(Out &out, const Matrix &cm, const In &in, BBBase::BBType type)
	This is a matrix representation supporting a parallel matrix vector product.
const double	doubleTransform = 2.3283064365386962890625e-10
const int	N = 624
const int	M = 397
const uint32	K = 0x9908B0DFU
unsigned int	degree
const int	BlasBound = 1 << 26
Commentator	commentator

---

Typedef Documentation

typedef std::vector<BBBase*> BB_list

typedef std::map<const std::type_info*, BB_list, LessTypeInfo> BB_list_list

typedef NTL::ZZ Element

typedef ParamFuzzy DoubleRealApproximation

typedef signed __LINBOX_INT8 int8

typedef signed __LINBOX_INT16 int16

typedef signed __LINBOX_INT32 int32

typedef signed __LINBOX_INT64 int64

typedef unsigned __LINBOX_INT8 uint8

typedef unsigned __LINBOX_INT16 uint16

typedef unsigned __LINBOX_INT32 uint32

typedef unsigned __LINBOX_INT64 uint64

---

Enumeration Type Documentation

enum FileFormatTag

tags for SparseMatrixBase::read() and write() Enumeration values: FORMAT_DETECT  FORMAT_GUILLAUME  FORMAT_TURNER  FORMAT_MATLAB  FORMAT_MAPLE  FORMAT_PRETTY  FORMAT_MAGMACPT

enum MatrixStreamError

Enumeration values: AMBIGUOUS_FORMAT  GOOD  END_OF_MATRIX  END_OF_FILE  BAD_FORMAT  NO_FORMAT

---

Function Documentation

Polynomial& blackboxcharpoly (  Polynomial &  P, const Blackbox &  A, const Categorytag &  tag )

GivPolynomial<typename Blackbox::Field::Element>& blackboxcharpoly (  GivPolynomial< typename Blackbox::Field::Element > &  P, const Blackbox &  A, const RingCategories::IntegerTag &  tag )

GivPolynomial<typename Blackbox::Field::Element>& blackboxcharpoly (  GivPolynomial< typename Blackbox::Field::Element > &  P, const Blackbox &  A, const RingCategories::ModularTag &  tag, const Method::Blackbox &  M )

int updateFactorsMult (  FieldFactorMult< Polynomial > *  ffm, const size_t  n, int *  goal )

void trials (  list< vector< FactorMult< FieldPoly, IntPoly > > > &  sols, const int  goal, vector< FactorMult< FieldPoly, IntPoly > > &  ufv, const int  i0 )

void trials (  list< vector< FieldFactorMult< Polynomial > > > &  sols, const int  goal, vector< FieldFactorMult< Polynomial > > &  ufv, const int  i0 )

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

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

Polynomial& cia (  Polynomial &  P, const Blackbox &  A, const Method::BlasElimination &  M )

long density (  const Vector &  v  )  [inline]

Estimate nonzero entries in a vector, used in parallel elimination.

long density (  const Vector &  , VectorCategory  )  [inline]

long density (  const Vector &  v, VectorCategories::DenseVectorTag  )  [inline]

long density (  const Vector &  v, VectorCategories::SparseSequenceVectorTag  )  [inline]

long density (  const Vector &  v, VectorCategories::SparseAssociativeVectorTag  )  [inline]

long density (  const Vector &  v, VectorCategories::SparseParallelVectorTag  )  [inline]

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

BoundBlackbox: Sets H_col_sqr <- H_col(A)^2, short_col_sqr <- short_col(A)^2 where H_col(A) is prod_j sqrt(sum_i a_ij^2) ('Hadamard column bound') short_col(A) is min_j sqrt(sum_i a_ij^2) ('shortest column') note: H_col is not actually a norm! but it is what we need for lifting bound computation

void BoundBlackbox (  const Ring &  R, typename Ring::Element &  H_col_sqr, typename Ring::Element &  short_col_sqr, const DenseMatrixBase< typename Ring::Element > &  A )

void BoundBlackbox (  const Ring &  R, typename Ring::Element &  H_col_sqr, typename Ring::Element &  short_col_sqr, const DenseSubmatrix< typename Ring::Element > &  A )

void BoundBlackbox (  const Ring &  R, typename Ring::Element &  H_col_sqr, typename Ring::Element &  short_col_sqr, const SparseMatrix< Ring > &  A )

void BoundBlackbox (  const Ring &  R, typename Ring::Element &  H_col_sqr, typename Ring::Element &  short_col_sqr, const Compose< Matrix1, Matrix2 > &  A )

void BoundBlackbox (  const Ring &  R, typename Ring::Element &  H_col_sqr, typename Ring::Element &  short_col_sqr, const Transpose< Matrix > &  A )

void ApplyBound (  const Ring &  R, typename Ring::Element &  bound_A, const ItMatrix &  A )

ApplyBound: computes bound_A <- max_i(max(sum_{j|a_ij > 0} a_ij, sum_{j|a_ij < 0} |a_ij|)) this is useful because for all u, v >= 0: [b has all entries in -u..v] => [each entry of A.b is at most (u+v)*bound_A in absolute value]

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

void reduceIn (  Domain &  D, std::pair< typename Domain::Element, typename Domain::Element > &  frac )

utility function to reduce a rational pair to lowest form

void vectorGcdIn (  typename Domain::Element &  result, Domain &  D, Vector &  v )

utility function to gcd-in a vector of elements over a domain

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

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

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

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

void create_padic_chunk (  const Domain &  D, const IMatrix &  M, double *  chunks, size_t  num_chunks )

split an integer matrix into a padic chunk representation

void* runThread (  void *  arg  )

BBThread<Matrix, Out, In>* createBBThread (  const Matrix *  m, Out *  out, const In *  in )

bool checkBlasApply (  const Field &  F, size_t  n )

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

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 log  reference to ostream for logging

Diagonal< Field, VectorCategories::DenseVectorTag >::Diagonal (  const Field  F, const std::vector< typename Field::Element > &  v )  [inline]

Diagonal< _Field, VectorCategories::DenseVectorTag >::Diagonal (  const Field  F, const size_t  n )  [inline]

Diagonal< Field, VectorCategories::DenseVectorTag >::Diagonal (  const Field  F, const size_t  n, typename Field::RandIter &  iter )  [inline]

OutVector& Diagonal< Field, VectorCategories::DenseVectorTag >::apply (  OutVector &  y, const InVector &  x )  const [inline]

Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::Diagonal (  const Field  F, const std::vector< typename Field::Element > &  v )  [inline]

OutVector& Diagonal< Field, VectorCategories::SparseSequenceVectorTag >::apply (  OutVector &  y, const InVector &  x )  const [inline]

Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::Diagonal (  const Field  F, const std::vector< typename Field::Element > &  v )  [inline]

OutVector& Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::apply (  OutVector &  y, const InVector &  x )  const [inline]

Hilbert< Field, VectorCategories::DenseVectorTag >::Hilbert (  Field  F, size_t  n )  [inline]

OutVector& Hilbert< Field, VectorCategories::DenseVectorTag >::apply (  OutVector &  y, const InVector &  x )  const [inline]

Hilbert< Field, VectorCategories::SparseSequenceVectorTag >::Hilbert (  Field  F, size_t  n )  [inline]

OutVector& Hilbert< Field, VectorCategories::SparseSequenceVectorTag >::apply (  OutVector &  y, const InVector &  x )  const [inline]

Hilbert< Field, VectorCategories::SparseAssociativeVectorTag >::Hilbert (  Field  F, size_t  n )  [inline]

OutVector& Hilbert< Field, VectorCategories::SparseAssociativeVectorTag >::apply (  OutVector &  y, const InVector &  x )  const [inline]

std::ostream& operator<< (  std::ostream &  os, GMPRationalElement &  elt )

std::istream& operator>> (  std::istream &  is, GMPRationalElement &  elt )

NTL::GF2E& UnparametricField< NTL::GF2E >::init (  NTL::GF2E &  x, const integer &  y )  const

integer& UnparametricField< NTL::GF2E >::convert (  integer &  x, const NTL::GF2E &  y )  const

bool UnparametricField< NTL::GF2E >::isZero (  const NTL::GF2E &  a  )  const

bool UnparametricField< NTL::GF2E >::isOne (  const NTL::GF2E &  a  )  const

integer& UnparametricField< NTL::GF2E >::characteristic (  integer &  c  )  const

integer& UnparametricField< NTL::GF2E >::cardinality (  integer &  c  )  const

NTL::GF2E& UnparametricField< NTL::GF2E >::inv (  NTL::GF2E &  x, const NTL::GF2E &  y )  const

NTL::GF2E& UnparametricField< NTL::GF2E >::invin (  NTL::GF2E &  x  )  const

std::istream& UnparametricField< NTL::GF2E >::read (  std::istream &  is, NTL::GF2E &  x )  const

UnparametricField< NTL::zz_p >::UnparametricField (  integer  q, size_t  e )

NTL::zz_p& UnparametricField< NTL::zz_p >::init (  NTL::zz_p &  x, const integer &  y )  const

Initialization of field element from an integer. This Uses NTL's { to} function. Returns: reference to field element. Parameters: x  field element to contain output (reference returned). y  integer.

integer& UnparametricField< NTL::zz_p >::convert (  integer &  x, const NTL::zz_p &  y )  const

Conversion of field element to an integer. This function assumes the output field element x has already been constructed, but that it is not already initialized. For now, this is done by converting the element type to a C++ long and then to the integer type through the use of static cast and NTL's to_long function. This, of course, assumes such static casts are possible. This function should be changed in the future to avoid using long. Returns: reference to integer. Parameters: x  reference to integer to contain output (reference returned). y  constant reference to field element.

integer& UnparametricField< NTL::zz_p >::cardinality (  integer &  c  )  const

Cardinality. Return integer representing cardinality of the field. Returns the modulus of the field, which should be prime. Returns: integer representing cardinality of the field

integer& UnparametricField< NTL::zz_p >::characteristic (  integer &  c  )  const

Characteristic. Return integer representing characteristic of the field. Returns the modulus of the field, which should be prime. Returns: integer representing characteristic of the field.

NTL::zz_p& UnparametricField< NTL::zz_p >::inv (  NTL::zz_p &  x, const NTL::zz_p &  y )  const

Multiplicative Inverse. x = 1 / y This function assumes both field elements have already been constructed and initialized. Returns: reference to x. Parameters: x  field element (reference returned). y  field element.

bool UnparametricField< NTL::zz_p >::isZero (  const NTL::zz_p &  x  )  const

Zero equality. Test if field element is equal to zero. This function assumes the field element has already been constructed and initialized. In this specialization, NTL's IsZero function is called. Returns: boolean true if equals zero, false if not. Parameters: x  field element.

bool UnparametricField< NTL::zz_p >::isOne (  const NTL::zz_p &  x  )  const

One equality. Test if field element is equal to one. This function assumes the field element has already been constructed and initialized. In this specialization, NTL's IsOne function is called. Returns: boolean true if equals one, false if not. Parameters: x  field element.

NTL::zz_p& UnparametricField< NTL::zz_p >::invin (  NTL::zz_p &  x  )  const

Inplace Multiplicative Inverse. x = 1 / x This function assumes both field elements have already been constructed and initialized. Returns: reference to x. Parameters: x  field element (reference returned).

std::ostream& UnparametricField< NTL::zz_p >::write (  std::ostream &  os  )  const

Print field. Returns: output stream to which field is written. Parameters: os  output stream to which field is written.

UnparametricRandIter< NTL::zz_p >::UnparametricRandIter (  const UnparametricField< NTL::zz_p > &  F, const integer &  size, const integer &  seed )

Constructor for random field element generator.

NTL::zz_p& UnparametricRandIter< NTL::zz_p >::random (  NTL::zz_p &  x  )  const

Random field element creator.

NTL::zz_pE& UnparametricField< NTL::zz_pE >::init (  NTL::zz_pE &  x, const integer &  y )  const

integer& UnparametricField< NTL::zz_pE >::convert (  integer &  x, const NTL::zz_pE &  y )  const

bool UnparametricField< NTL::zz_pE >::isZero (  const NTL::zz_pE &  a  )  const

bool UnparametricField< NTL::zz_pE >::isOne (  const NTL::zz_pE &  a  )  const

integer& UnparametricField< NTL::zz_pE >::characteristic (  integer &  c  )  const

integer& UnparametricField< NTL::zz_pE >::cardinality (  integer &  c  )  const

NTL::zz_pE& UnparametricField< NTL::zz_pE >::inv (  NTL::zz_pE &  x, const NTL::zz_pE &  y )  const

NTL::zz_pE& UnparametricField< NTL::zz_pE >::invin (  NTL::zz_pE &  x  )  const

std::istream& UnparametricField< NTL::zz_pE >::read (  std::istream &  is, NTL::zz_pE &  x )  const

NTL_ZZ (  int  p = 0, int  exp = 1 )

integer& cardinality (  integer &  c  )  const [inline]

integer& characteristic (  integer &  c  )  const [inline]

std::ostream& write (  std::ostream &  out  )  const

std::istream& read (  std::istream &  in  )  const

Element& init (  Element &  x, const Element2 &  y )  const [inline]

Init x from y.

Element& init (  Element &  x, const Element &  y )  const [inline]

Init from a NTL::ZZ.

Element& init (  Element &  x, const int64 &  y )  const [inline]

Init from an int64.

Element& init (  Element &  x, const uint64 &  y )  const [inline]

Init from a uint64.

Element& init (  Element &  x, const integer &  y )  const [inline]

I don't know how to init from integer efficiently.

integer& convert (  integer &  x, const Element &  y )  [inline, static]

Convert y to an Element.

double& convert (  double &  x, const Element &  y )  [inline, static]

Element& assign (  Element &  x, const Element &  y )  const [inline]

x = y.

bool areEqual (  const Element &  x, const Element &  y )  const [inline]

Test if x == y.

bool isZero (  const Element &  x  )  const [inline]

Test if x == 0.

bool isOne (  const Element &  x  )  const [inline]

Test if x == 1.

Element& add (  Element &  x, const Element &  y, const Element &  z )  const [inline]

return x = y + z

Element& sub (  Element &  x, const Element &  y, const Element &  z )  const [inline]

return x = y - z

Element& mul (  Element &  x, const Element &  y, const Int &  z )  const [inline]

return x = y * z

Element& div (  Element &  x, const Element &  y, const Element &  z )  const [inline]

If z divides y, return x = y / z, otherwise, throw an exception.

Element& inv (  Element &  x, const Element &  y )  const [inline]

If y is a unit, return x = 1 / y, otherwsie, throw an exception.

Element& neg (  Element &  x, const Element &  y )  const [inline]

return x = -y;

Element& axpy (  Element &  r, const Element &  a, const Int &  x, const Element &  y )  const [inline]

return r = a x + y

Element& addin (  Element &  x, const Element &  y )  const [inline]

return x += y;

Element& subin (  Element &  x, const Element &  y )  const [inline]

return x -= y;

Element& mulin (  Element &  x, const Int &  y )  const [inline]

return x *= y;

Element& divin (  Element &  x, const Element &  y )  const [inline]

If y divides x, return x /= y, otherwise throw an exception.

Element& invin (  Element &  x  )  [inline]

If x is a unit, x = 1 / x, otherwise, throw an exception.

Element& negin (  Element &  x  )  const [inline]

return x = -x;

Element& axpyin (  Element &  r, const Element &  a, const Int &  x )  const [inline]

return r += a x

std::ostream& write (  std::ostream &  out, const Element &  y )  const

out << y;

std::istream& read (  std::istream &  in, Element &  x )  const

read x from istream in

bool isUnit (  const Element &  x  )  const [inline]

Test if x is a unit.

Element& gcd (  Element &  g, const Element &  a, const Element &  b )  const [inline]

return g = gcd (a, b)

Element& gcdin (  Element &  g, const Element &  b )  const [inline]

return g = gcd (g, b)

Element& xgcd (  Element &  g, Element &  s, Element &  t, const Element &  a, const Element &  b )  const [inline]

g = gcd(a, b) = a*s + b*t. The coefficients s and t are defined according to the standard Euclidean algorithm applied to |a| and |b|, with the signs then adjusted according to the signs of a and b.

Element& lcm (  Element &  c, const Element &  a, const Element &  b )  const [inline]

c = lcm (a, b)

Element& lcmin (  Element &  l, const Element &  b )  const [inline]

l = lcm (l, b)

Element& sqrt (  Element &  x, const Element &  y )  const [inline]

x = floor ( sqrt(y)).

long reconstructRational (  Element &  a, Element &  b, const Element &  x, const Element &  m, const Element &  a_bound, const Element &  b_bound )  const [inline]

Requires 0 <= x < m, m > 2 * a_bound * b_bound, a_bound >= 0, b_bound > 0 This routine either returns 0, leaving a and b unchanged, or returns 1 and sets a and b so that (1) a = b x (mod m), (2) |a| <= a_bound, 0 < b <= b_bound, and (3) gcd(m, b) = gcd(a, b).

Element& quo (  Element &  q, const Element &  a, const Element &  b )  const [inline]

q = floor (x/y);

Element& rem (  Element &  r, const Element &  a, const Element &  b )  const [inline]

r = remindar of a / b

Element& quoin (  Element &  a, const Element &  b )  const [inline]

a = quotient (a, b)

Element& remin (  Element &  x, const Element &  y )  const [inline]

a = quotient (a, b)

void quoRem (  Element &  q, Element &  r, const Element &  a, const Element &  b )  const [inline]

q = [a/b], r = a - b*q |r| < |b|, and if r != 0, sign(r) = sign(b)

bool isDivisor (  const Element &  a, const Element &  b )  const [inline]

Test if b | a.

long compare (  const Element &  a, const Element &  b )  const [inline]

compare two elements, a and b return 1, if a > b return 0, if a = b; return -1. if a < b

Element& abs (  Element &  x, const Element &  a )  const [inline]

return the absolute value x = abs (a);

int getMaxModulus (   )  [inline, static]

UnparametricField< NTL::ZZ_p >::UnparametricField (  integer  q, size_t  e )

integer& UnparametricField< NTL::ZZ_p >::convert (  integer &  x, const NTL::ZZ_p &  y )  const

Conversion of field element to an integer. This function assumes the output field element x has already been constructed, but that it is not already initialized. This done by converting to a std::string : inefficient but correct. Returns: reference to integer. Parameters: x  reference to integer to contain output (reference returned). y  constant reference to field element.

double& UnparametricField< NTL::ZZ_p >::convert (  double &  x, const NTL::ZZ_p &  y )  const

integer& UnparametricField< NTL::ZZ_p >::cardinality (  integer &  c  )  const

Cardinality. Return integer representing cardinality of the field. Returns the modulus of the field, which should be prime. Returns: integer representing cardinality of the field

integer& UnparametricField< NTL::ZZ_p >::characteristic (  integer &  c  )  const

Characteristic. Return integer representing characteristic of the field. Returns the modulus of the field, which should be prime. Returns: integer representing characteristic of the field.

NTL::ZZ_p& UnparametricField< NTL::ZZ_p >::inv (  NTL::ZZ_p &  x, const NTL::ZZ_p &  y )  const

Multiplicative Inverse. x = 1 / y This function assumes both field elements have already been constructed and initialized. Returns: reference to x. Parameters: x  field element (reference returned). y  field element.

bool UnparametricField< NTL::ZZ_p >::isZero (  const NTL::ZZ_p &  x  )  const

Zero equality. Test if field element is equal to zero. This function assumes the field element has already been constructed and initialized. In this specialization, NTL's IsZero function is called. Returns: boolean true if equals zero, false if not. Parameters: x  field element.

bool UnparametricField< NTL::ZZ_p >::isOne (  const NTL::ZZ_p &  x  )  const

One equality. Test if field element is equal to one. This function assumes the field element has already been constructed and initialized. In this specialization, NTL's IsOne function is called. Returns: boolean true if equals one, false if not. Parameters: x  field element.

NTL::ZZ_p& UnparametricField< NTL::ZZ_p >::invin (  NTL::ZZ_p &  x  )  const

Inplace Multiplicative Inverse. x = 1 / x This function assumes both field elements have already been constructed and initialized. Returns: reference to x. Parameters: x  field element (reference returned).

std::ostream& UnparametricField< NTL::ZZ_p >::write (  std::ostream &  os  )  const

Print field. Returns: output stream to which field is written. Parameters: os  output stream to which field is written.

UnparametricRandIter< NTL::ZZ_p >::UnparametricRandIter (  const UnparametricField< NTL::ZZ_p > &  F, const integer &  size, const integer &  seed )

Constructor for random field element generator.

NTL::ZZ_p& UnparametricRandIter< NTL::ZZ_p >::random (  NTL::ZZ_p &  x  )  const

Random field element creator.

NTL::ZZ_pE& UnparametricField< NTL::ZZ_pE >::init (  NTL::ZZ_pE &  x, const integer &  y )  const

bool UnparametricField< NTL::ZZ_pE >::isZero (  const NTL::ZZ_pE &  a  )  const

bool UnparametricField< NTL::ZZ_pE >::isOne (  const NTL::ZZ_pE &  a  )  const

integer& UnparametricField< NTL::ZZ_pE >::convert (  integer &  c, const NTL::ZZ_pE &  e )  const

integer& UnparametricField< NTL::ZZ_pE >::characteristic (  integer &  c  )  const

integer& UnparametricField< NTL::ZZ_pE >::cardinality (  integer &  c  )  const

NTL::ZZ_pE& UnparametricField< NTL::ZZ_pE >::inv (  NTL::ZZ_pE &  x, const NTL::ZZ_pE &  y )  const

NTL::ZZ_pE& UnparametricField< NTL::ZZ_pE >::invin (  NTL::ZZ_pE &  x  )  const

std::istream& UnparametricField< NTL::ZZ_pE >::read (  std::istream &  is, NTL::ZZ_pE &  x )  const

T abs (  const T &  a  )

std::ostream& operator<< (  std::ostream &  os, const SparseMatrixBase< Element, Row > &  A )

std::istream& operator>> (  std::istream &  is, SparseMatrixBase< Element, Row > &  A )

uint32 hiBit (  uint32  u  )  [inline, static]

uint32 loBit (  uint32  u  )  [inline, static]

uint32 loBits (  uint32  u  )  [inline, static]

uint32 mixBits (  uint32  u, uint32  v )  [inline, static]

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

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

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

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

...using default method

Polynomial& charpoly (  Polynomial &  P, const Blackbox &  A, const DomainCategory &  tag, const Method::Hybrid &  M )

Polynomial& charpoly (  Polynomial &  P, const DenseMatrix< Field > &  A, const DomainCategory &  tag, const Method::Hybrid &  M )

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

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