---

LinBox Namespace Reference

Compounds
class	ActivityState
	used by commentator This stores a snapshot of the state of the commentator's activity stack, so it may be restored after an exception is thrown More...
class	BaseTimer
class	BasicReader
class	BitVector
struct	BlackboxSpecifier
struct	BlasEliminationTraits
struct	BlockLanczosTraits
struct	BlockWiedemannTraits
class	BooleanSwitch
class	BooleanSwitchFactory
class	CekstvSwitch
class	CekstvSwitchFactory
class	const_reference
class	const_iterator
class	ConstantVectorStream
class	DenseReader
class	RawVector
struct	Rebind< std::map< size_t, T >, U >
struct	Rebind< std::pair< std::vector< size_t >, std::vector< T > >, U >
struct	Rebind< std::vector< std::pair< size_t, T > >, U >
struct	Rebind< std::vector< T >, U >
struct	rebind
struct	SparseSequenceVectorPairLessThan
struct	Vector
struct	SparseParallelVectorTag
struct	SparseAssociativeVectorTag
struct	SparseSequenceVectorTag
struct	DenseVectorTag
struct	SparseZeroOneVectorTag
struct	DenseZeroOneVectorTag
struct	DixonTraits
class	DotProductDomain
struct	EliminationSpecifier
class	FieldAXPY
class	FieldReaderAnalyzer
class	GenericRandIter
struct	GenericVectorTag
class	GF2RandIter
class	GivPolynomialRing
class	GmpRandomPrime
	generating random prime integers, using the gmp library. More...
class	GMPRationalRandIter
struct	HybridSpecifier
class	InconsistentSystem
struct	IntegerModularDet
struct	IntegerModularMinpoly
struct	IntegerModularSOLUTION
class	iterator
struct	LanczosTraits
struct	LessThanString
class	LidiaGfqRandIter
class	LinboxBadFormat
class	LinboxError
class	LinboxMathDivZero
class	LinboxMathError
struct	LPM_Method
class	MapleDense1Reader
class	MapleSparse1Reader
class	MatrixMarketReader
class	MatrixStream
class	MatrixStreamReader
struct	MatrixTraits< const SparseMatrixBase< Element, Row, Trait > >
struct	MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > >
struct	MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > >
struct	MatrixTraits< const TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > >
struct	MatrixTraits< SparseMatrixBase< Element, Row, Trait > >
struct	MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag > >
struct	MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag > >
struct	MatrixTraits< TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag > >
class	MersenneTwister
struct	Method
	Method specifiers for controlling algorithm choice. More...
struct	MinpolyMethod
class	ModularRandIter
class	NoFiniteExtendedInLinBox
struct	NonBlasEliminationTraits
class	NonzeroRandIter
class	NoTableFiniteInLinBox
class	NTL_ZZRandIter
struct	NumericalTraits
class	ParamFuzzyRandIter
class	PowerOfTwoModular
struct	RandIter
class	PreconditionFailed
class	PrimeStream
class	RandIter
class	RandIterAbstract
class	RandIterArchetype
class	RandIterEnvelope
class	RandomDenseStream
class	RandomDenseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag >
class	RandomPrime
class	RandomSparseStream
class	RandomSparseStream< Field, _Vector, RandIter, VectorCategories::DenseVectorTag >
class	RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseAssociativeVectorTag >
class	RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseParallelVectorTag >
class	RandomSparseStream< Field, _Vector, RandIter, VectorCategories::SparseSequenceVectorTag >
class	Reader
class	ReaderBlackBoxFactory
class	ReaderIterator
class	ReaderNotAField
class	RealTimer
class	reference
class	ReverseVector
class	RingAbstract
class	RingArchetype
class	RingEnvelope
class	RingInterface
class	SMSReader
class	SolveFailed
struct	SolverTraits
struct	SparseEliminationTraits
class	_RawIndexedIterator
class	_RawIterator
struct	rebind
class	_RawIndexedIterator
class	_RawIterator
struct	rebind
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseAssociativeVectorTag >
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseParallelVectorTag >
class	_RawIndexedIterator
class	_RawIterator
struct	BBBase
class	BBThread
class	FieldIO
	Dummy field for conceptually unclear io. More...
class	InvalidMatrixInput
struct	ColMatrixTag
struct	BlackboxTag
struct	MatrixCategories
	For specializing matrix arithmetic. More...
struct	Blackbox
class	BlackboxArchetype
	showing the member functions provided by all blackbox matrix classes. More...
class	BlackboxFactory
	A tool for computations with integer and rational matrices. @doc 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	BlackboxInterface
class	BlackboxSymmetrizeIterator
class	BlasApply
class	BlasBlackbox
	template <class _Field> More...
struct	Container
struct	BlasContainer
class	BlasMatrix
	@memo Limited docs so far. More...
class	BlasMatrixApplyDomain
class	BlasPermutation
class	BlasTag
class	Butterfly
	Butterfly Switching Network based BlackBox Matrix. A good preconditioner. @doc Implements butterfly switching network on a LinBox vector as a black box matrix through the use of a switch object. More...
struct	ClassifyRing
struct	ClassifyRing< DoubelFMod >
struct	ClassifyRing< GF2 >
struct	ClassifyRing< GivaroExtension< BaseField > >
struct	ClassifyRing< GivaroGfq >
struct	ClassifyRing< GivaroMontg >
struct	ClassifyRing< GivaroRational >
struct	ClassifyRing< GivaroZpz< Tag > >
struct	ClassifyRing< GMP_Integers >
struct	ClassifyRing< GMPRationalField >
struct	ClassifyRing< LidiaGfq >
struct	ClassifyRing< Local2_32 >
struct	ClassifyRing< Modular< double > >
struct	ClassifyRing< Modular< Element > >
struct	ClassifyRing< Modular< int > >
struct	ClassifyRing< Modular< int32 > >
struct	ClassifyRing< Modular< int8 > >
struct	ClassifyRing< Modular< short > >
struct	ClassifyRing< NTL_PID_zz_p >
struct	ClassifyRing< NTL_ZZ >
struct	ClassifyRing< NTL_zz_p >
struct	ClassifyRing< PID_integer >
struct	ClassifyRIng< PIR_ntl_ZZ_p >
struct	ClassifyRIng< PIRModular< int > >
struct	ClassifyRIng< PIRModular< int32 > >
struct	ClassifyRing< UnparametricField< K > >
struct	ClassifyRing< UnparametricField< NTL::RR > >
struct	ClassifyRing< UnparametricField< NTL::ZZ_p > >
struct	ClassifyRing< UnparametricRandIter< NTL::GF2E > >
struct	ClassifyRing< UnparametricRandIter< NTL::ZZ_pE > >
struct	ClassifyRing< UnparametricRandIter< NTL::zz_pE > >
class	ConstRawIndexedIterator
class	ColIterator
struct	Companion
	Companion matrix of a monic polynomial. More...
class	Compose
	General case. More...
class	Compose< _Blackbox, _Blackbox >
	specialization for _Blackbox1 = _Blackbox2 More...
class	ComposeTraits
class	ComposeTraits< DenseMatrix< Field > >
class	ConstColIterator
class	ConstRowIterator
class	DenseMatrixBase
class	ConstRawIterator
class	DenseMatrix
	Blackbox interface to dense matrix representation. More...
class	DenseMatrixFactory
class	DenseRowsMatrix
class	DenseSubmatrix
class	Diagonal
	General diagonal, not be implemented. More...
class	Diagonal< _Field, VectorCategories::DenseVectorTag >
	Specialization of Diagonal for application to dense vectors. More...
class	Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >
	Specialization of Diagonal for application to sparse associative vectors. More...
class	Diagonal< Field, VectorCategories::SparseSequenceVectorTag >
	Specialization of Diagonal for application to sparse sequence vectors. More...
class	Diagonal< GF2, VectorTraits< Vector< GF2 >::Dense >::VectorCategory >
class	Dif
	Blackbox of a difference: C := A - B, i.e. Cx = Ax - Bx. More...
class	DirectSum
	If C = DirectSum(A, B) and y = xA and z = wB, then (y,z) = (x,w)C. More...
class	DirectSum< Blackbox, Blackbox >
class	DotProductDomain< DoubleFmod >
class	DotProductDomain< GF2 >
class	DotProductDomain< GivaroZpz< Std16 > >
class	DotProductDomain< GivaroZpz< Std32 > >
class	DotProductDomain< Modular< double > >
class	DotProductDomain< Modular< int > >
class	DotProductDomain< Modular< int16 > >
class	DotProductDomain< Modular< int32 > >
class	DotProductDomain< Modular< int8 > >
class	DotProductDomain< Modular< uint16 > >
class	DotProductDomain< Modular< uint32 > >
class	DotProductDomain< Modular< uint8 > >
class	DotProductDomain< PIR_ntl_ZZ_p >
class	DotProductDomain< PIRModular< int > >
class	DotProductDomain< PIRModular< int32 > >
class	DoubleFmod
class	ElementAbstract
	Abstract element base class, a technicality. More...
class	ElementArchetype
	This is the Field and Ring element interface specification and archetypical instance class. @doc Element classes must contain public default constructor, copy constructor, assignment operator, and destructor. Note that primitive types such as int and double meet this specification. More...
class	ElementEnvelope
	Adaptor from archetypical interface to abstract interface, a technicality. More...
class	FactorizedMatrixLeftLSolve
class	FactorizedMatrixLeftLSolve< Field, BlasMatrix< typename Field::Element > >
class	FactorizedMatrixLeftLSolve< Field, std::vector< typename Field::Element > >
class	FactorizedMatrixLeftSolve
class	FactorizedMatrixLeftSolve< Field, BlasMatrix< typename Field::Element > >
class	FactorizedMatrixLeftSolve< Field, std::vector< typename Field::Element > >
class	FactorizedMatrixLeftUSolve
class	FactorizedMatrixLeftUSolve< Field, BlasMatrix< typename Field::Element > >
class	FactorizedMatrixLeftUSolve< Field, std::vector< typename Field::Element > >
class	FactorizedMatrixRightLSolve
class	FactorizedMatrixRightLSolve< Field, BlasMatrix< typename Field::Element > >
class	FactorizedMatrixRightLSolve< Field, std::vector< typename Field::Element > >
class	FactorizedMatrixRightSolve
class	FactorizedMatrixRightSolve< Field, BlasMatrix< typename Field::Element > >
class	FactorizedMatrixRightSolve< Field, std::vector< typename Field::Element > >
class	FactorizedMatrixRightUSolve
class	FactorizedMatrixRightUSolve< Field, BlasMatrix< typename Field::Element > >
class	FactorizedMatrixRightUSolve< Field, std::vector< typename Field::Element > >
class	FFLAS
	BLAS for matrices over finite fields. More...
class	FFPACK
	Set of elimination based routines for dense linear algebra with matrices over finite field. More...
class	FieldAbstract
class	FieldArchetype
class	FieldAXPY< DoubleFmod >
class	FieldAXPY< GivaroZpz< Std16 > >
class	FieldAXPY< GivaroZpz< Std32 > >
class	FieldAXPY< Modular< _Element > >
class	FieldAXPY< Modular< double > >
class	FieldAXPY< Modular< int > >
class	FieldAXPY< Modular< int16 > >
class	FieldAXPY< Modular< int32 > >
class	FieldAXPY< Modular< int8 > >
class	FieldAXPY< Modular< uint16 > >
class	FieldAXPY< Modular< uint32 > >
class	FieldAXPY< Modular< uint8 > >
class	FieldAXPY< NTL_ZZ >
class	FieldAXPY< PIR_ntl_ZZ_p >
class	FieldAXPY< PIRModular< int > >
class	FieldAXPY< PIRModular< int32 > >
class	FieldAXPY< UnparametricField< integer > >
class	FieldEnvelope
class	FieldInterface
	This field base class exists solely to aid documentation organization. @doc For the general field member function documentation consult the FieldArchetype. For specific properties of individual representations consult the specific field classes. More...
struct	FieldTraits
struct	FieldTraits< GivaroExtension< BaseField > >
class	GF2
class	GivaroExtension
class	GivaroGfq
class	GivaroMontg
class	GivaroRational
class	GivaroZpz
class	GMPRationalField
class	Hom
class	Hom< Source, Source >
class	ImageField
class	indexDomain
class	LidiaGfq
struct	Local2_32
class	LQUPMatrix
class	MatrixArchetype
struct	MatrixContainerCategory
class	MatrixContainerTrait
class	MatrixContainerTrait< BlasMatrix< typename Field::Element > >
class	MatrixContainerTrait< const BlasMatrix< typename Field::Element > >
class	MatrixContainerTrait< DenseMatrix< Field > >
class	MatrixContainerTrait< DenseMatrixBase< typename Field::Element > >
class	MatrixContainerTrait< SparseMatrix< Field > >
class	MatrixContainerTrait< SparseMatrixBase< typename Field::Element > >
class	MatrixDomain
	Class of matrix arithmetic functions. More...
class	MatrixDomain< GF2 >
struct	MatrixTraits
struct	MatrixTraits< BlasMatrix< Element > >
struct	MatrixTraits< const BlasMatrix< Element > >
struct	MatrixTraits< const DenseMatrixBase< Element > >
struct	MatrixTraits< DenseMatrixBase< Element > >
struct	MatrixTraits< DenseRowsMatrix< Row > >
struct	MatrixTraits< DenseSubmatrix< Element > >
struct	MatrixTraits< MatrixArchetype< Element > >
class	Modular
	Prime fields of positive characteristic implemented directly in LinBox. @doc This parameterized field can be used to construct prime fields. Typical use would be Modular<integer> for integers modulo a large prime, Modular<uint32>, modular<int>, or modular<double> for integers modulo a wordsize * prime. Each of those has specialized performance features suitable to certain applications. More...
class	Modular< double >
class	Modular< int >
	Specialization of Modular to int element type with efficient dot product. @doc Efficient element operations for dot product, mul, axpy, by using floating point inverse of modulus (borrowed from NTL) and some use of non-normalized intermediate values. More...
class	Modular< int16 >
	Specialization of Modular to short element type with efficient dot product. @doc Efficient element operations for dot product, mul, axpy, by using floating point inverse of modulus (borrowed from NTL) and some use of non-normalized intermediate values. More...
class	Modular< int32 >
	Specialization of Modular to int32 element type with efficient dot product. @doc Efficient element operations for dot product, mul, axpy, by using floating point inverse of modulus (borrowed from NTL) and some use of non-normalized intermediate values. More...
class	Modular< int8 >
	Specialization of Modular to signed 8 bit element type with efficient dot product. @doc Efficient element operations for dot product, mul, axpy, by using floating point inverse of modulus (borrowed from NTL) and some use of non-normalized intermediate values. 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	Modular< uint8 >
	Allows compact storage when the modulus is less than 2^8. @doc Requires 1 < the modulus < 2^8, normally prime. See FieldArchetype for member specifications. More...
class	ModularBase
class	MVProductDomain
	Helper class to allow specializations of certain matrix-vector products. More...
class	MVProductDomain< Modular< int16 > >
class	MVProductDomain< Modular< int32 > >
class	MVProductDomain< Modular< int8 > >
class	MVProductDomain< Modular< uint16 > >
class	MVProductDomain< Modular< uint32 > >
class	MVProductDomain< Modular< uint8 > >
class	MVProductDomain< PIR_ntl_ZZ_p >
class	MVProductDomain< PIRModular< int32 > >
struct	rebind
struct	rebind
class	SparseMatrixBase
class	SparseMatrixBase< _Element, _Row, VectorCategories::SparseSequenceVectorTag >
class	NoField
class	SparseMatrixReadWriteHelper
class	NoField
class	NoHomError
	Error object for attempt to establish a Hom that cannot exist. More...
class	NTL_GF2E
struct	NTL_PID_zz_p
	extend Wrapper of zz_p from NTL. Add PID functions More...
class	NTL_ZZ
struct	NTL_ZZ_p
struct	NTL_zz_p
class	NTL_ZZ_pE
class	NTL_zz_pE
class	ParamFuzzy
class	PID_double
class	PID_integer
class	PIR_ntl_ZZ_p
	extend Wrapper of ZZ_p from NTL. Add PIR functions More...
class	PIRModular< int >
class	PIRModular< int32 >
class	RandomDenseStreamGF2
class	RandomSparseStreamGF2
class	RawIterator
class	RawIndexedIterator
class	RawVector< bool >
struct	rebind
struct	rebind
struct	Rebind
struct	RationalTag
struct	IntegerTag
struct	ModularTag
struct	GenericTag
class	GMPRationalElement
class	RingCategories
class	RowIterator
struct	RowMatrixTag
struct	RowColMatrixTag
class	SparseMatrixWriteHelper
class	SparseMatrixWriteHelper< _Element, Row, VectorCategories::SparseParallelVectorTag >
class	SparseRowReader
struct	Specifier
class	StandardBasisStream
class	StandardBasisStream< Field, _Vector, VectorCategories::DenseVectorTag >
class	StandardBasisStream< Field, _Vector, VectorCategories::SparseAssociativeVectorTag >
class	StandardBasisStream< Field, _Vector, VectorCategories::SparseParallelVectorTag >
class	StandardBasisStream< Field, _Vector, VectorCategories::SparseSequenceVectorTag >
class	Subiterator
class	Subvector
class	SysTimer
struct	TagTreeFrame
class	Timer
class	TransposedBlasMatrix
class	TransposedBlasMatrix< TransposedBlasMatrix< Matrix > >
class	TransposeMatrix
class	TransposeMatrix< Matrix, MatrixCategories::ColMatrixTag >
class	TransposeMatrix< Matrix, MatrixCategories::RowColMatrixTag >
class	TransposeMatrix< Matrix, MatrixCategories::RowMatrixTag >
class	TriangularBlasMatrix
class	UnparametricField
class	UnparametricRandIter
class	UnparametricRandIter< NTL::GF2E >
class	UnparametricRandIter< NTL::ZZ_pE >
class	UnparametricRandIter< NTL::zz_pE >
class	UnSupportedMatrixType
class	UserTimer
class	Valence
struct	VectorCategories
class	VectorDomain
class	VectorDomain< GF2 >
class	VectorDomainBase
class	VectorStream
struct	VectorTraits
struct	VectorTraits< BitVector >
struct	VectorTraits< ReverseVector< Vector > >
struct	VectorTraits< std::deque< std::pair< size_t, Element > > >
struct	VectorTraits< std::list< std::pair< size_t, Element > > >
struct	VectorTraits< std::map< size_t, Element > >
struct	VectorTraits< std::pair< std::vector< size_t >, std::vector< Element > > >
struct	VectorTraits< std::vector< Element > >
struct	VectorTraits< std::vector< std::pair< size_t, Element > > >
struct	VectorTraits< Subvector< Iterator, ConstIterator > >
struct	WiedemannTraits
class	Writer
struct	WriterFrame
class	RawIndexIterator
class	RawIterator
class	Mod32Field
class	NormField
class	FieldType
class	Frobenius
	template <class _Field> More...
class	Hankel
	template <class _Field> More...
class	Hilbert
	Example of a blackbox that is space efficient, though not time efficient. More...
class	Hilbert< _Field, VectorCategories::DenseVectorTag >
class	Hilbert< _Field, VectorCategories::SparseAssociativeVectorTag >
class	Hilbert< _Field, VectorCategories::SparseSequenceVectorTag >
class	Inverse
	A Blackbox for the inverse. Not efficient if many applications are used. More...
class	LessTypeInfo
class	MatrixApplyDomain
class	MatrixApplyDomain< Domain, BlasBlackbox< Domain > >
class	MatrixApplyDomain< Domain, BlasMatrix< typename Domain::Element > >
class	MatrixApplyDomain< Domain, DenseMatrix< Domain > >
struct	rebind
class	MatrixContainerTrait< BlasBlackbox< Field > >
class	MatrixContainerTrait< const BlasBlackbox< Field > >
struct	MatrixTraits< BlasBlackbox< Field > >
struct	MatrixTraits< const BlasBlackbox< Field > >
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	MatrixTraits< const DenseMatrix< Field > >
struct	MatrixTraits< const SparseMatrix< Field, _Row > >
struct	MatrixTraits< DenseMatrix< Field > >
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	MatrixTraits< SparseMatrix< Field, _Row > >
class	MoorePenrose
	Generalized inverse of a blackbox. Efficiency concerns when many applications are used. More...
struct	rebind
struct	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	rebind
class	Permutation
	size is n. More...
struct	rebind
class	PolynomialBB
	represent the matrix P(A) where A is a blackbox and P a polynomial More...
struct	rebind
class	RandomMatrix
class	RandomMatrixTraits
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
struct	rebind
class	ScalarMatrix
	Blackbox for aI. Use particularly for representing 0 and I. More...
class	SCompose
class	SparseMatrix
	vector of sparse rows. More...
class	SparseMatrixFactory
class	Submatrix
class	Submatrix< Blackbox, VectorCategories::DenseVectorTag >
class	Submatrix< DenseMatrix< _Field >, VectorCategories::DenseVectorTag >
class	SubMatrixTraits< DenseMatrix< Field > >
class	SubMatrixTraits< Submatrix< DenseMatrix< Field > > >
class	SubRowMatrix< Matrix, MatrixCategories::RowMatrixTag >
class	Sum
	blackbox of a matrix sum without copying. More...
struct	rebind
struct	rebind
class	Minpoly_Method
class	BLAS_LPM_Method
class	BlockWiedemannLiftingContainer
class	DixonLiftingContainer
class	const_iterator
class	InnerProductArray
struct	Iterate
struct	ElimStep
class	BasisTransformation
class	BlackboxBlockContainer
class	BlackboxBlockContainerBase
	A base class for BlackboxBlockContainer. The primary member function is begin(). @doc 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	const_iterator
class	BlackboxBlockContainerRecord
class	BlackboxContainer
	Limited doc so far. More...
class	BlackboxContainerBase
	A base class for BlackboxContainer. The primary member function is begin(). @doc 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	const_iterator
class	BlackboxContainerSymmetric
	See base class for doc. More...
class	BlackboxContainerSymmetrize
	Symmetrizing iterator (for rank computations). @doc # //================================================================ // LinBox Project 1999 // Symmetrizing iterator (for rank computations) // Same left and right vector // A is supposed to have tranpose-vector product // the sequence is u^t u, (A u)^t (A u) = u^t (A^t A) u, // (A^t (A u))^t (A^t (A u)) = u^t (A^t A)^2 u , etc. // Time-stamp: <13 Jun 02 18:16:43 Jean-Guillaume.Dumas@imag.fr> // ================================================================ #. More...
class	BlasMatrixDomain
class	BlasMatrixDomainCharpoly
class	BlasMatrixDomainCharpoly< Field, Polynomial, Container, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainDet
class	BlasMatrixDomainDet< Field, BlasBlackbox< Field > >
class	BlasMatrixDomainDet< Field, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainInv
class	BlasMatrixDomainInv< Field, BlasBlackbox< Field > >
class	BlasMatrixDomainInv< Field, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainLeftSolve
class	BlasMatrixDomainLeftSolve< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainLeftSolve< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > >
class	BlasMatrixDomainLeftSolve< Field, std::vector< typename Field::Element >, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainLeftSolve< Field, std::vector< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMinpoly
class	BlasMatrixDomainMinpoly< Field, Polynomial, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMul
class	BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element >, BlasPermutation >
class	BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element >, TransposedBlasMatrix< BlasPermutation > >
class	BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasPermutation, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, BlasPermutation, TriangularBlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, TransposedBlasMatrix< BlasPermutation >, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMul< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element >, BlasPermutation >
class	BlasMatrixDomainMul< Field, std::vector< typename Field::Element >, BlasPermutation, std::vector< typename Field::Element > >
class	BlasMatrixDomainMul< Field, std::vector< typename Field::Element >, std::vector< typename Field::Element >, BlasPermutation >
class	BlasMatrixDomainMul< Field, std::vector< typename Field::Element >, std::vector< typename Field::Element >, TransposedBlasMatrix< BlasPermutation > >
class	BlasMatrixDomainMul< Field, std::vector< typename Field::Element >, TransposedBlasMatrix< BlasPermutation >, std::vector< typename Field::Element > >
class	BlasMatrixDomainMulAdd
class	BlasMatrixDomainMulAdd< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMulAdd< Field, std::vector< typename Field::Element >, BlasMatrix< typename Field::Element >, std::vector< typename Field::Element > >
class	BlasMatrixDomainMulAdd< Field, std::vector< typename Field::Element >, std::vector< typename Field::Element >, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMulin
class	BlasMatrixDomainMulin< Field, BlasMatrix< typename Field::Element >, BlasPermutation >
class	BlasMatrixDomainMulin< Field, BlasMatrix< typename Field::Element >, TransposedBlasMatrix< BlasPermutation > >
class	BlasMatrixDomainMulin< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > >
class	BlasMatrixDomainMulin< Field, std::vector< typename Field::Element >, BlasPermutation >
class	BlasMatrixDomainMulin< Field, std::vector< typename Field::Element >, TransposedBlasMatrix< BlasPermutation > >
class	BlasMatrixDomainRank
class	BlasMatrixDomainRank< Field, BlasBlackbox< Field > >
class	BlasMatrixDomainRank< Field, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainRightSolve
class	BlasMatrixDomainRightSolve< Field, BlasMatrix< typename Field::Element >, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainRightSolve< Field, BlasMatrix< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > >
class	BlasMatrixDomainRightSolve< Field, std::vector< typename Field::Element >, BlasMatrix< typename Field::Element > >
class	BlasMatrixDomainRightSolve< Field, std::vector< typename Field::Element >, TriangularBlasMatrix< typename Field::Element > >
class	BlockLanczosSolver
class	BlockMasseyDomain
	Compute the linear generator of a sequence of matrices @doc 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	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 @doc 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. @doc 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	IliopoulosElimination
	This is Iliopoulos' algorithm do diagonalize. @doc 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	LABlockLanczosSolver
class	LanczosSolver
	Solve a linear system using the conjugate Lanczos iteration. @doc 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. @doc This computes the last invariant factor of an integer matrix, whether zero or not, by rational solving. More...
struct	LazyProduct
class	LiftingContainer
class	LiftingContainerBase
class	LocalSmith
	Smith normal form (invariant factors) of a matrix over a local ring. More...
class	LocalSmith< Local2_32 >
class	MasseyDomain
	Berlekamp/Massey algorithm. @doc 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< BlasBlackbox< Ring >, Field >
struct	MatrixHomTrait< DenseMatrix< Ring >, Field >
struct	MatrixHomTrait< DenseMatrixBase< typename Ring::Element >, Field >
struct	MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparseMap >, Field >
struct	MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparsePar >, Field >
struct	MatrixHomTrait< SparseMatrix< Ring, typename Vector< Ring >::SparseSeq >, 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	RationalSolver
class	RationalSolver< Ring, Field, RandomPrime, BlockWiedemannTraits >
class	RationalSolver< Ring, Field, RandomPrime, DixonTraits >
class	RationalSolver< Ring, Field, RandomPrime, NumericalTraits >
class	RationalSolver< Ring, Field, RandomPrime, WiedemannTraits >
class	RationalSolverAdaptive
class	Signature
class	SmithForm
	Compute Smith form. More...
class	SmithFormAdaptive
class	Sylvester
class	Thread
class	Toeplitz
	This is the blackbox representation of a Toeplitz matrix. More...
class	Transpose
	transpose matrix without copying. More...
class	TriplesBB
	wrapper for NAG Sparse Matrix format. More...
class	VectorFraction
	VectorFraction<Domain> is a vector of rational elements with common reduced denominator. @doc 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	WiedemannLiftingContainer
class	WiedemannSolver
	Linear system solvers based on Wiedemann's method. @doc 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	ZeroOne
	Time and space efficient representation of sparse {0,1}-matrices. More...
int32
@memo This is a representation of 32 bit ints, usually equivalent to `int'. @doc 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
@memo This is a representation of 32 bit unsigned ints, usually equivalent to `unsigned int'. @doc 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
GMP Rational field
Field of rational numbers using GMP @doc This is a wrapper for the GMP rational number facility, built to the interface of the field archetype.
std::ostream &	operator<< (std::ostream &os, GMPRationalElement &elt)
std::istream &	operator>> (std::istream &is, GMPRationalElement &elt)
NTL_zz_p
long ints modulo a positive integer. @doc 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 \Ref{UnparametricField} template class to be used to wrap NTL's {\tt zz\_p} class as a LinBox field. Uses nice trick for mod p via floating point.
	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< NTL::zz_p > (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 \Ref{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. @doc 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 \Ref{UnparametricField} template class to be used to wrap NTL's {\tt ZZ\_p} class as a LinBox field.
doc of NTL_ZZ_p	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< NTL::ZZ_p > (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 ParamFuzzy	DoubleRealApproximation
typedef Integer	integer
typedef signed __LINBOX_INT8	int8
typedef signed __LINBOX_INT16	int16
typedef GMPRationalElement	rational
Enumerations
enum	SolverReturnStatus {   SS_OK, SS_FAILED, SS_SINGULAR, SS_INCONSISTENT,   SS_BAD_PRECONDITIONER }
enum	SolverLevel { SL_MONTECARLO, SL_LASVEGAS, SL_CERTIFIED }
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 Iterator, class Comparator> void	bitonicSort (Iterator begin, Iterator end, const Comparator &comparator=Comparator())
template<class Iterator, class Comparator> void	bitonicMerge (Iterator begin, Iterator end, const Comparator &comparator=Comparator())
template<class Domain, class Object> void	BLTraceReport (std::ostream &out, Domain &D, const char *text, size_t iter, const Object &obj)
void	reportS (std::ostream &out, const std::vector< bool > &S, size_t iter)
template<class Field, class Matrix> void	checkAConjugacy (const MatrixDomain< Field > &MD, const Matrix &AV, const Matrix &V, Matrix &T, size_t AV_iter, size_t V_iter)
template<class Blackbox, class MethodTraits> integer &	det_cra (integer &res, const Blackbox &A, const MethodTraits &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)
std::ostream &	reportPermutation (std::ostream &out, const std::vector< std::pair< unsigned int, unsigned int > > &P)
template<class Domain, class Object> void	LABLTraceReport (std::ostream &out, Domain &D, const char *text, size_t iter, const Object &obj)
void	LABLReportPriorityIndices (std::ostream &, std::list< size_t > &, const char *)
template<class Field, class Vector> void	traceReport (std::ostream &out, VectorDomain< Field > &VD, const char *text, size_t iter, const Vector &v)
template<class Field, class Vector> void	traceReport (std::ostream &out, const Field &F, const char *text, size_t iter, const typename Field::Element &a)
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)
template<class Domain, class Object> void	MGBLTraceReport (std::ostream &out, Domain &D, const char *text, size_t iter, const Object &obj)
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
template<class Out, class Matrix, class In> Out &	BlackboxParallel (Out &out, const Matrix &m, const In &in, BBBase::BBType type)
	This is a matrix representation supporting a parallel matrix vector product.
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>	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
size_t	mul_bound_compute (const long long pi)
size_t	mul_bound (const long long pi)
size_t	bound_compute (const long long pi)
size_t	bound_compute_centered (const long long pi)
size_t	bound (const long long pi)
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
NTL::GF2E &	UnparametricField< NTL::GF2E >::inv (NTL::GF2E &x, const NTL::GF2E &y) const
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
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
template<> std::istream &	UnparametricField< NTL::zz_pE >::read (std::istream &is, NTL::zz_pE &x) const
template<> NTL::ZZ_p &	UnparametricField< NTL::ZZ_p >::init (NTL::ZZ_p &x, const integer &y) const
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
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
template<> std::istream &	UnparametricField< NTL::ZZ_pE >::read (std::istream &is, NTL::ZZ_pE &x) const
int	operator!= (const integer &a, const integer &b)
int	operator!= (int l, const integer &n)
int	operator!= (long l, const integer &n)
int	operator== (const integer &a, const integer &b)
int	operator== (int l, const integer &n)
int	operator== (long l, const integer &n)
int	operator== (const integer &n, int l)
int	operator== (const integer &n, long l)
int	operator< (const integer &a, const integer &b)
int	operator< (const int l, const integer &n)
int	operator< (const long l, const integer &n)
int	operator> (const integer &a, const integer &b)
int	operator> (int l, const integer &n)
int	operator> (long l, const integer &n)
int	operator<= (const integer &a, const integer &b)
int	operator<= (const integer &n, int l)
int	operator<= (const integer &n, long l)
int	operator<= (int l, const integer &n)
int	operator<= (long l, const integer &n)
int	operator>= (const integer &a, const integer &b)
int	operator>= (int l, const integer &n)
int	operator>= (long l, const integer &n)
int	operator>= (const integer &n, int l)
int	operator>= (const integer &n, long l)
integer	operator+ (const int l, const integer &n)
integer	operator+ (const unsigned int l, const integer &n)
integer	operator+ (const long l, const integer &n)
integer	operator+ (const unsigned long l, const integer &n)
integer	operator+ (const integer &n, const int l)
integer	operator+ (const integer &n, const unsigned int l)
integer &	operator+= (integer &n, const int l)
integer &	operator+= (integer &n, const unsigned int l)
integer	operator- (const int l, const integer &n)
integer	operator- (const unsigned int l, const integer &n)
integer	operator- (const long l, const integer &n)
integer	operator- (const unsigned long l, const integer &n)
integer	operator- (const integer &n, const int l)
integer	operator- (const integer &n, const unsigned int l)
integer &	operator-= (integer &n, const int l)
integer &	operator-= (integer &n, const unsigned int l)
integer	operator * (const int l, const integer &n)
integer	operator * (const unsigned int l, const integer &n)
integer	operator * (const long l, const integer &n)
integer	operator * (const unsigned long l, const integer &n)
integer	operator * (const integer &n, const int l)
integer	operator * (const integer &n, const unsigned int l)
integer &	operator *= (integer &n, const int l)
integer &	operator *= (integer &n, const unsigned int l)
integer	operator/ (const int l, const integer &n)
integer	operator/ (const long l, const integer &n)
integer	operator/ (const integer &n, const int l)
integer	operator/ (const integer &n, const unsigned int l)
integer &	operator/= (integer &n, const int l)
integer &	operator/= (integer &n, const long l)
integer &	operator/= (integer &n, const unsigned int l)
integer	operator% (const int l, const integer &n)
integer	operator% (const long l, const integer &n)
integer	operator% (const integer &n, const int l)
integer	operator% (const integer &n, const unsigned int l)
integer &	operator%= (integer &n, const int l)
integer &	operator%= (integer &n, const unsigned int l)
int	isone (const integer &a)
int	iszero (const integer &a)
int	iszero (const short int a)
int	iszero (const int a)
int	iszero (const long a)
int	iszero (const unsigned short int a)
int	iszero (const unsigned int a)
int	iszero (const unsigned long a)
int	sign (const integer &a)
unsigned long	length (const integer &a)
integer	abs (const integer &n)
integer	operator<<= (integer &n, unsigned int l)
integer	operator<<= (integer &n, unsigned long l)
integer	operator>>= (integer &n, unsigned int l)
integer	operator>>= (integer &n, unsigned long l)
ostream &	operator<< (ostream &o, const integer &a)
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)
template<class Field> std::ostream &	SparseMatrixWriteHelper< Element, Row, VectorCategories::SparseParallelVectorTag >::write (const SparseMatrixBase< Element, Row > &A, std::ostream &os, const Field &F, FileFormatTag format)
template<class Element, class Row> void	SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::setEntry (size_t i, size_t j, const Element &value)
template<class Element, class Row> Element &	SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::refEntry (size_t i, size_t j)
template<class Element, class Row> const Element &	SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::getEntry (size_t i, size_t j) const
template<class Element, class Row> const Element &	SparseMatrixBase< Element, Row, VectorCategories::SparseAssociativeVectorTag >::getEntry (size_t i, size_t j) const
template<class Element, class Row> void	SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::setEntry (size_t i, size_t j, const Element &value)
template<class Element, class Row> Element &	SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::refEntry (size_t i, size_t j)
template<class Element, class Row> const Element &	SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::getEntry (size_t i, size_t j) const
template<class Vector> Vector &	SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::columnDensity (Vector &v) const
template<class Vector> Vector &	SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::columnDensity (Vector &v) const
template<class Vector> Vector &	SparseMatrixBase< Element, Row, VectorCategories::SparseAssociativeVectorTag >::columnDensity (Vector &v) const
template<class Element, class Row> SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag > &	SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::transpose (SparseMatrixBase &AT) const
template<class Element, class Row> SparseMatrixBase< Element, Row, VectorCategories::SparseAssociativeVectorTag > &	SparseMatrixBase< Element, Row, VectorCategories::SparseAssociativeVectorTag >::transpose (SparseMatrixBase &AT) const
template<class Element, class Row> SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag > &	SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::transpose (SparseMatrixBase &AT) const
template<class Blackbox, class Polynomial, class DomainCategory, class MyMethod> 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 Polynomial, class Blackbox> Polynomial &	charpoly (Polynomial &P, const Blackbox &A)
	...using default Method
template<class Polynomial, class Blackbox> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Polynomial, class Field> Polynomial &	charpoly (Polynomial &P, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Polynomial, class Blackbox> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &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)
template<class Polynomial, class Blackbox> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
template<class Polynomial, class Blackbox> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, RingCategories::ModularTag tag, const Method::Wiedemann &M=Method::Wiedemann())
template<class Polynomial, class Blackbox, class MyMethod> Polynomial &	charpoly (Polynomial &P, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class Blackbox, class DetMethod, class DomainCategory> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const DomainCategory &tag, const DetMethod &M)
template<class Blackbox, class MyMethod> Blackbox::Field::Element &	det (typename Blackbox::Field::Element &d, const Blackbox &A, const MyMethod &M)
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 Matrix, class Method> bool	isPosDef (Matrix &A, Method m)
template<class Matrix> bool	isPosDef (Matrix &A)
template<class Matrix> bool	isPosDef (Matrix &A, BLAS_LPM_Method m)
template<class Matrix> bool	isPosDef (Matrix &A, Minpoly_Method m)
template<class Matrix, class Method> bool	isPosSemidef (Matrix &A, Method m)
template<class Matrix> bool	isPosSemidef (Matrix &A)
template<class Matrix> bool	isPosSemidef (Matrix &A, BLAS_LPM_Method m)
template<class Matrix> bool	isPosSemidef (Matrix &A, Minpoly_Method 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 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 Field, class Blackbox> Field::Element &	det (typename Field::Element &res, const Blackbox &A, const Field &F, const MethodTrait::Wiedemann &M=MethodTrait::Wiedemann())
template<class Blackbox, class Field> integer &	det (integer &res, BlackboxFactory< Field, Blackbox > &factory)
template<class Field, class Blackbox, class Polynomial, class FieldCategoryTag> Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const Field &F, const FieldCategoryTag &tag, const MethodTrait::Wiedemann &M=MethodTrait::Wiedemann())
template<class Blackbox, class Polynomial> Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const MethodTrait::Wiedemann &M=MethodTrait::Wiedemann())
template<class Field, class Blackbox, class Polynomial> Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const Field &F, RingCategories::IntegerTag tag, const MethodTrait::Wiedemann &M=MethodTrait::Wiedemann())
template<class Field, class Blackbox, class Polynomial, class FieldCategoryTag> Polynomial &	minpolySymmetric (Polynomial &P, const Blackbox &A, const Field &F, FieldCategoryTag tag, const MethodTrait::Wiedemann &M=MethodTrait::Wiedemann())
template<class Field, class Blackbox, class Polynomial> Polynomial &	minpolySymmetric (Polynomial &P, const Blackbox &A, const Field &F, const MethodTrait::Wiedemann &M=MethodTrait::Wiedemann())
template<class Field, class Blackbox, class Polynomial> Polynomial &	minpolySymmetric (Polynomial &P, const Blackbox &A, const Field &F, RingCategories::IntegerTag tag, const MethodTrait::Wiedemann &M=MethodTrait::Wiedemann())
template<class Field, class Blackbox, class Polynomial> Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const Field &F, RingCategories::ModularTag tag, const MethodTrait::Wiedemann &M=MethodTrait::Wiedemann()) >>>>>>> 1.19
template<class Blackbox, class Polynomial> Polynomial &	minpolySymmetrize (Polynomial &P, const Blackbox &A, const MethodTrait::Wiedemann &M=MethodTrait::Wiedemann())
template<class Blackbox, class Polynomial> Polynomial &	minpoly (Polynomial &P, const Blackbox &A, const CRA_MethodTrait< IntegerRing > &M=CRA_MethodTrait< IntegerRing >())
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 T, template< class T > class Container> std::ostream &	operator<< (std::ostream &o, const Container< T > &C)
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 Vector> long	degree (const Vector &v)
template<class Poly, class Realring> size_t	alternations (const Poly &p, const Realring &R)
template<class Symmbox> Signature &	signature (Signature &s, Symmbox &A, LPM_Method M=LPM_Method())
template<class Symmbox> Signature &	signature (Signature &s, Symmbox &A, MinpolyMethod M)
template<class Blackbox, class SolutionMethod, class DomainCategory> BOUTPUT &	SOLUTION (BOUTPUT &r, const Blackbox &A, const DomainCategory &tag, const SolutionMethod &M)
template<class Blackbox, class MyMethod> BOUTPUT &	SOLUTION (BOUTPUT &r, const Blackbox &A, const MyMethod &M)
template<class Blackbox> BOUTPUT &	SOLUTION (BOUTPUT &r, const Blackbox &A)
template<class Blackbox> BOUTPUT &	SOLUTION (BOUTPUT &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Field> FOUTPUT &	SOLUTION (FOUTPUT &r, const DenseMatrix< Field > &A, const RingCategories::ModularTag &tag, const Method::Hybrid &M)
template<class Blackbox> BOUTPUT &	SOLUTION (BOUTPUT &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Elimination &M)
template<class Blackbox> BOUTPUT &	SOLUTION (BOUTPUT &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M)
template<class Blackbox> BOUTPUT &	SOLUTION (BOUTPUT &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Wiedemann &M)
template<class Blackbox> BOUTPUT &	SOLUTION (BOUTPUT &r, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M)
template<class Blackbox, class MyMethod> BOUTPUT &	SOLUTION (BOUTPUT &r, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M)
template<class Vector, class BB> Vector &	solve (Vector &x, const BB &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 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 DenseMatrix< 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 DenseMatrix< 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::IntegerTag tag, const BlasEliminationCRASpecifier &m)
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::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> Field::Element &	trace (typename Field::Element &t, const SparseMatrix< Field > &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)
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 string s1, const char *s2)
std::ostream &	operator<< (std::ostream &o, const BaseTimer &BT)
std::ostream &	operator<< (std::ostream &o, const Timer &T)
std::istream &	operator>> (std::istream &is, BitVector::reference &a)
std::ostream &	operator<< (std::ostream &os, BitVector::reference &a)
std::ostream &	operator<< (std::ostream &os, BitVector::const_reference &a)
template<class 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 char *	solverReturnString [] = {"OK", "FAILED", "SINGULAR", "INCONSISTENT", "BAD_PRECONDITIONER", "BAD_PRIME"}
const long	_DEGINFTY_ = -1
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 ParamFuzzy DoubleRealApproximation

typedef UnparametricField<integer> GMP_Integers

typedef signed __LINBOX_INT16 int16

typedef signed __LINBOX_INT32 int32

typedef signed __LINBOX_INT64 int64

typedef signed __LINBOX_INT8 int8

typedef Integer integer

@memo This is a representation of arbitrary integers. @doc It is a wrapper of GMP integers. Arithmetic operations are via C++ infix operator forms (eg. a*b) . It is for ``casual'' uses such as characteristics and cardinalities and when initializing field elements. For the integers as a LinBox ring for use in integer matrix computation, see gmp-rational.h or ntl-ZZ.h.

typedef GMPRationalElement rational

typedef unsigned __LINBOX_INT16 uint16

typedef unsigned __LINBOX_INT32 uint32

typedef unsigned __LINBOX_INT64 uint64

typedef unsigned __LINBOX_INT8 uint8

---

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

enum SolverLevel

Enumeration values: SL_MONTECARLO  SL_LASVEGAS  SL_CERTIFIED

enum SolverReturnStatus

Enumeration values: SS_OK  SS_FAILED  SS_SINGULAR  SS_INCONSISTENT  SS_BAD_PRECONDITIONER

---

Function Documentation

integer abs (  const integer &    n )  [inline]

T abs (  const T &    a )

size_t alternations (  const Poly &    p, const Realring &    R )

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

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]

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

void AXMYIN (  Matrix &   , const Matrix &   , const Matrix &    )

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

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

Out& BlackboxParallel (  Out &    out, const Matrix &    m, const In &    in, BBBase::BBType    type )

This is a matrix representation supporting a parallel matrix vector product.

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

size_t bound (  const long long    pi )

size_t bound_compute (  const long long    pi )

size_t bound_compute_centered (  const long long    pi )

void BoundBlackbox (  const Ring &    R, typename Ring::Element &    H_col_sqr, typename Ring::Element &    short_col_sqr, const Transpose< Matrix > &    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 SparseMatrix< Ring > &    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 DenseMatrixBase< typename Ring::Element > &    A )

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

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

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

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

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

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

Todo: a real hybrid for charpoly

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

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

...using default Method

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

...using an optional Method parameter ameter 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. ameter A - a blackbox matrix Optional ameter 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, const DomainCategory &    tag, const MyMethod &    M )

void checkAConjugacy (  const MatrixDomain< Field > &    MD, const Matrix &    AV, const Matrix &    V, Matrix &    T, size_t    AV_iter, size_t    V_iter )  [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

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

long degree (  const Vector &    v )

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

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

long density (  const Vector &    v )  [inline]

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

integer& det (  integer &    res, BlackboxFactory< Field, Blackbox > &    factory )

Compute the determinant over {\bf Z} or {\bf Q} Compute the determinant of a matrix, represented via a \ref{BlackboxFactory}. Perform the necessary modular reductions and reconstruct the result via Chinese remaindering or rational number reconstruction. Parameters: res  Element into which to store the result factory  \ref{BlacboxFactory} that represents the matrix

Field::Element& det (  typename Field::Element &    res, const Blackbox &    A, const Field &    F, const MethodTrait::Wiedemann &    M = MethodTrait::Wiedemann () )

Compute the determinant over a field. The determinant of a linear operator A, represented as a black box, is computed over the ring or field F. This implementation is essentially direct, in that it does not perform any modular reduction and reconstruction. Thus, it is not recommended that one use this function to compute the determinant of an integer or rational matrix. One should instead use the version indicated below that uses \ref{BlackboxFactory}. Parameters: res  Field element into which to store the result A  Black box of which to compute the determinant F  Field over which to compute the determinant M  Method traits

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

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

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

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

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

Field::Element& det (  typename Field::Element &    d, const DenseMatrix< Field > &    A, const RingCategories::ModularTag &    tag, const Method::Hybrid &    M )

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

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

Blackbox::Field::Element& det (  typename Blackbox::Field::Element &    d, const Blackbox &    A, const DomainCategory &    tag, const DetMethod &    M )

integer& det_cra (  integer &    res, const Blackbox &    A, const MethodTraits &    M )

Compute the determinant over {\bf Z} Compute the determinant of a matrix. Perform the necessary modular reductions and reconstruct the result via Chinese remaindering Parameters: res  Element into which to store the result factory  \ref{BlacboxFactory} that represents the matrix

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

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

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

Diagonal< Field, VectorCategories::DenseVectorTag >::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]

Diagonal< Field, VectorCategories::SparseAssociativeVectorTag >::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::SparseSequenceVectorTag >::Diagonal (  const Field    F, const std::vector< typename Field::Element > &    v )  [inline]

bool equalCaseInsensitive (  const string    s1, const char *    s2 )

void fieldTest (  const Field &    f, double *    array, long    iter = 1000000 )

int64 getOps (  int &    a, float &    b )

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

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

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

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

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

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

long isnpower (  long &    l, long    a )

int isone (  const integer &    a )  [inline]

bool isPosDef (  Matrix &    A, Minpoly_Method    m )

bool isPosDef (  Matrix &    A, BLAS_LPM_Method    m )

bool isPosDef (  Matrix &    A )

bool isPosDef (  Matrix &    A, Method    m )

this is for integer and rational matrices only

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

bool isPositiveDefinite (  const Blackbox &    A )

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

Compute the isPositiveDefinite of A The isPositiveDefinite of a linear operator A, represented as a black box, is computed over the ring or field of A. Parameters: r  OUTPUT instance into which to store the result r A  Black box of which to compute the isPositiveDefinite M  may be a Method::Hybrid (default), Method::Blackbox, Method::Elimination, or of other method type.

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

bool isPosSemidef (  Matrix &    A, Minpoly_Method    m )

bool isPosSemidef (  Matrix &    A, BLAS_LPM_Method    m )

bool isPosSemidef (  Matrix &    A )

bool isPosSemidef (  Matrix &    A, Method    m )

this is for integer and rational matrices only

int iszero (  const unsigned long    a )  [inline]

int iszero (  const unsigned int    a )  [inline]

int iszero (  const unsigned short int    a )  [inline]

int iszero (  const long    a )  [inline]

int iszero (  const int    a )  [inline]

int iszero (  const short int    a )  [inline]

int iszero (  const integer &    a )  [inline]

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

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

unsigned long length (  const integer &    a )  [inline]

void LL_MULIN (  Matrix &    M, const Matrix &    L )

void LU (  Submatrix< DenseMatrix< Field > > &    M )

void LU (  DenseMatrix< Field > &    M )

M <-- the LU decomposition of M. Parameters: M  is a dense matrix on input. require all principle minor are non-singular. Every leading principal minor must be nonzero. M is modified to represent the LU decomposition of the original M. L is unit lower triangular and occupies the strictly lower triangular part of M. The diagonal one's are implicit. U is upper triangular and occupies the rest of M.

bool LU_MUL_TEST (  const DenseMatrix< Field > &    M, const DenseMatrix< Field > &    L, const DenseMatrix< Field > &    U )

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

Polynomial& minpoly (  Polynomial &    P, const Blackbox &    A, const CRA_MethodTrait< IntegerRing > &    M = CRA_MethodTrait<IntegerRing>() )

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

Polynomial& minpoly (  Polynomial &    P, const Blackbox &    A, const Field &    F, RingCategories::IntegerTag    tag, const MethodTrait::Wiedemann &    M = MethodTrait::Wiedemann () )

Polynomial& minpoly (  Polynomial &    P, const Blackbox &    A, const MethodTrait::Wiedemann &    M = MethodTrait::Wiedemann () )

Polynomial& minpoly (  Polynomial &    P, const Blackbox &    A, const Field &    F, const FieldCategoryTag &    tag, const MethodTrait::Wiedemann &    M = MethodTrait::Wiedemann() )

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

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

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

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

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

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

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

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

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

...using default Method

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

...using an optional Method parameter ameter P - the output minimal polynomial. If the polynomial is of degree d, this random access container has size d+1, the 0-th entry is the constant coefficient and the d-th is 1 since the minpoly is monic. ameter A - a blackbox matrix Optional ameter 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& minpoly (  Polynomial &    P, const Blackbox &    A, const DomainCategory &    tag, const MyMethod &    M )

Polynomial& minpolySymmetric (  Polynomial &    P, const Blackbox &    A, const Field &    F, RingCategories::IntegerTag    tag, const MethodTrait::Wiedemann &    M = MethodTrait::Wiedemann () )

Polynomial& minpolySymmetric (  Polynomial &    P, const Blackbox &    A, const Field &    F, const MethodTrait::Wiedemann &    M = MethodTrait::Wiedemann () )

Polynomial& minpolySymmetric (  Polynomial &    P, const Blackbox &    A, const Field &    F, FieldCategoryTag    tag, const MethodTrait::Wiedemann &    M = MethodTrait::Wiedemann() )

Polynomial& minpolySymmetrize (  Polynomial &    P, const Blackbox &    A, const MethodTrait::Wiedemann &    M = MethodTrait::Wiedemann () )

size_t mul_bound (  const long long    pi )

size_t mul_bound_compute (  const long long    pi )

Element& noop (  Element &    a, const Element &    b )

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

integer operator * (  const integer &    n, const unsigned int    l )  [inline]

integer operator * (  const integer &    n, const int    l )  [inline]

integer operator * (  const unsigned long    l, const integer &    n )  [inline]

integer operator * (  const long    l, const integer &    n )  [inline]

integer operator * (  const unsigned int    l, const integer &    n )  [inline]

integer operator * (  const int    l, const integer &    n )  [inline]

integer& operator *= (  integer &    n, const unsigned int    l )  [inline]

integer& operator *= (  integer &    n, const int    l )  [inline]

int operator!= (  long    l, const integer &    n )  [inline]

int operator!= (  int    l, const integer &    n )  [inline]

int operator!= (  const integer &    a, const integer &    b )  [inline]

integer operator% (  const integer &    n, const unsigned int    l )  [inline]

integer operator% (  const integer &    n, const int    l )  [inline]

integer operator% (  const long    l, const integer &    n )  [inline]

integer operator% (  const int    l, const integer &    n )  [inline]

integer& operator%= (  integer &    n, const unsigned int    l )  [inline]

integer& operator%= (  integer &    n, const int    l )  [inline]

integer operator+ (  const integer &    n, const unsigned int    l )  [inline]

integer operator+ (  const integer &    n, const int    l )  [inline]

integer operator+ (  const unsigned long    l, const integer &    n )  [inline]

integer operator+ (  const long    l, const integer &    n )  [inline]

integer operator+ (  const unsigned int    l, const integer &    n )  [inline]

integer operator+ (  const int    l, const integer &    n )  [inline]

integer& operator+= (  integer &    n, const unsigned int    l )  [inline]

integer& operator+= (  integer &    n, const int    l )  [inline]

integer operator- (  const integer &    n, const unsigned int    l )  [inline]

integer operator- (  const integer &    n, const int    l )  [inline]

integer operator- (  const unsigned long    l, const integer &    n )  [inline]

integer operator- (  const long    l, const integer &    n )  [inline]

integer operator- (  const unsigned int    l, const integer &    n )  [inline]

integer operator- (  const int    l, const integer &    n )  [inline]

integer& operator-= (  integer &    n, const unsigned int    l )  [inline]

integer& operator-= (  integer &    n, const int    l )  [inline]

integer operator/ (  const integer &    n, const unsigned int    l )  [inline]

integer operator/ (  const integer &    n, const int    l )  [inline]

integer operator/ (  const long    l, const integer &    n )  [inline]

integer operator/ (  const int    l, const integer &    n )  [inline]

integer& operator/= (  integer &    n, const unsigned int    l )  [inline]

integer& operator/= (  integer &    n, const long    l )  [inline]

integer& operator/= (  integer &    n, const int    l )  [inline]

int operator< (  const long    l, const integer &    n )  [inline]

int operator< (  const int    l, const integer &    n )  [inline]

int operator< (  const integer &    a, const integer &    b )  [inline]

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

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

std::ostream& operator<< (  std::ostream &    o, const Timer &    T )  [inline]

std::ostream& operator<< (  std::ostream &    o, const BaseTimer &    BT )  [inline]

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

std::ostream& operator<< (  std::ostream &    o, const Container< T > &    C )

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

ostream& operator<< (  ostream &    o, const integer &    a )  [inline]

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

integer operator<<= (  integer &    n, unsigned long    l )  [inline]

integer operator<<= (  integer &    n, unsigned int    l )  [inline]

int operator<= (  long    l, const integer &    n )  [inline]

int operator<= (  int    l, const integer &    n )  [inline]

int operator<= (  const integer &    n, long    l )  [inline]

int operator<= (  const integer &    n, int    l )  [inline]

int operator<= (  const integer &    a, const integer &    b )  [inline]

int operator== (  const integer &    n, long    l )  [inline]

int operator== (  const integer &    n, int    l )  [inline]

int operator== (  long    l, const integer &    n )  [inline]

int operator== (  int    l, const integer &    n )  [inline]

int operator== (  const integer &    a, const integer &    b )  [inline]

int operator> (  long    l, const integer &    n )  [inline]

int operator> (  int    l, const integer &    n )  [inline]

int operator> (  const integer &    a, const integer &    b )  [inline]

int operator>= (  const integer &    n, long    l )  [inline]

int operator>= (  const integer &    n, int    l )  [inline]

int operator>= (  long    l, const integer &    n )  [inline]

int operator>= (  int    l, const integer &    n )  [inline]

int operator>= (  const integer &    a, const integer &    b )  [inline]

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

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

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

integer operator>>= (  integer &    n, unsigned long    l )  [inline]

integer operator>>= (  integer &    n, unsigned int    l )  [inline]

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

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

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

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

Random vector generator This templated function takes a field and a random field element generator and returns a vector of random field elements. The vector is dense in the field elements, even if the vector is a sparse LinBox vector. The funtion is templatized by the field and the vector types being used. This function calls another function by the same name with an additional parameter of the vector category of the vector it is called with. This mechanism is used because functions cannot have partial template specializations like classes can. This new, extended function can be specialized for specific fields and vectors to allow for better performance. Returns: v vector of random field elements Parameters: F  Field in which arithmetic is done n  integer number of elements in vector r  Random field element generator

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

unsigned long& rank (  unsigned long &    r, const Blackbox &    A, const RingCategories::ModularTag &    tag, const Method::BlasElimination &    M )

M may be Method::BlasElimination().

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.

unsigned long& rank (  unsigned long &    r, const SparseMatrix< Field, typename LinBox::Vector< Field >::SparseSeq > &    A, const RingCategories::ModularTag &    tag, const Method::SparseElimination &    M )

M may be Method::SparseElimination().

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

M may be Method::Wiedemann().

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

unsigned long& rank (  unsigned long &    r, const Blackbox &    A, const RingCategories::ModularTag &    tag, const Method::NonBlasElimination &    m )

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

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

unsigned long& rank (  unsigned long &    r, const Blackbox &    A, const RingCategories::ModularTag &    tag, const Method::Hybrid &    m )

unsigned long& rankin (  unsigned long &    r, BlasBlackbox< Field > &    A, const RingCategories::ModularTag &    tag, const Method::BlasElimination &    M )

A is modified.

unsigned long& rankin (  unsigned long &    r, Matrix &    A, const RingCategories::ModularTag &    tag, const Method::SparseElimination &    M )

A is modified.

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().

unsigned long& rankin (  unsigned long &    r, Matrix &    A )

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

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

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

void RU_MULIN (  Matrix &    R, const Matrix &    U )

void* runThread (  void *    arg )

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

int sign (  const integer &    a )  [inline]

Signature& signature (  Signature &    s, Symmbox &    A, MinpolyMethod    M )

Signature& signature (  Signature &    s, Symmbox &    A, LPM_Method    M = LPM_Method() )

BOUTPUT& SOLUTION (  BOUTPUT &    r, const Blackbox &    A, const RingCategories::IntegerTag &    tag, const MyMethod &    M )

BOUTPUT& SOLUTION (  BOUTPUT &    r, const Blackbox &    A, const RingCategories::ModularTag &    tag, const Method::BlasElimination &    M )

BOUTPUT& SOLUTION (  BOUTPUT &    r, const Blackbox &    A, const RingCategories::ModularTag &    tag, const Method::Wiedemann &    M )

BOUTPUT& SOLUTION (  BOUTPUT &    r, const Blackbox &    A, const RingCategories::ModularTag &    tag, const Method::Blackbox &    M )

BOUTPUT& SOLUTION (  BOUTPUT &    r, const Blackbox &    A, const RingCategories::ModularTag &    tag, const Method::Elimination &    M )

FOUTPUT& SOLUTION (  FOUTPUT &    r, const DenseMatrix< Field > &    A, const RingCategories::ModularTag &    tag, const Method::Hybrid &    M )

BOUTPUT& SOLUTION (  BOUTPUT &    r, const Blackbox &    A, const RingCategories::ModularTag &    tag, const Method::Hybrid &    M )

BOUTPUT& SOLUTION (  BOUTPUT &    r, const Blackbox &    A )

BOUTPUT& SOLUTION (  BOUTPUT &    r, const Blackbox &    A, const DomainCategory &    tag, const SolutionMethod &    M )

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

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

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

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

Vector& solve (  Vector &    x, const DenseMatrix< Field > &    A, const Vector &    b, const RingCategories::IntegerTag    tag, const BlasEliminationCRASpecifier &    m )

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

Vector& solve (  Vector &    x, const BB &    A, const Vector &    b, const RingCategories::IntegerTag    tag, const Method::BlasElimination &    m )

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

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

Vector& solve (  Vector &    x, const BB &    A, const Vector &    b, const Method::Elimination &    m )

Vector& solve (  Vector &    x, const BB &    A, const Vector &    b, const Method::Blackbox &    m )

Vector& solve (  Vector &    x, const BB &    A, const Vector &    b, const Method::Hybrid &    m )

Vector& solve (  Vector &    x, const BB &    A, const Vector &    b )

Vector& SparseMatrixBase< Element, Row, VectorCategories::SparseAssociativeVectorTag >::columnDensity (  Vector &    v )  const

const Element& SparseMatrixBase< Element, Row, VectorCategories::SparseAssociativeVectorTag >::getEntry (  size_t    i, size_t    j )  const

SparseMatrixBase<Element, Row, VectorCategories::SparseAssociativeVectorTag >& SparseMatrixBase< Element, Row, VectorCategories::SparseAssociativeVectorTag >::transpose (  SparseMatrixBase &    AT )  const

Vector& SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::columnDensity (  Vector &    v )  const

const Element& SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::getEntry (  size_t    i, size_t    j )  const

Element& SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::refEntry (  size_t    i, size_t    j )

void SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::setEntry (  size_t    i, size_t    j, const Element &    value )

SparseMatrixBase<Element, Row, VectorCategories::SparseParallelVectorTag >& SparseMatrixBase< Element, Row, VectorCategories::SparseParallelVectorTag >::transpose (  SparseMatrixBase &    AT )  const

Vector& SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::columnDensity (  Vector &    v )  const

const Element& SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::getEntry (  size_t    i, size_t    j )  const

Element& SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::refEntry (  size_t    i, size_t    j )

void SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::setEntry (  size_t    i, size_t    j, const Element &    value )

SparseMatrixBase<Element, Row, VectorCategories::SparseSequenceVectorTag >& SparseMatrixBase< Element, Row, VectorCategories::SparseSequenceVectorTag >::transpose (  SparseMatrixBase &    AT )  const

std::ostream& SparseMatrixWriteHelper< Element, Row, VectorCategories::SparseParallelVectorTag >::write (  const SparseMatrixBase< Element, Row > &    A, std::ostream &    os, const Field &    F, FileFormatTag    format )

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

Blackbox::Field::Element& trace (  typename Blackbox::Field::Element &    res, const Blackbox &    A, const Method::Blackbox &    m )

Compute the trace of a linear operator A, represented as a black box. This class is parameterized by the black box type so that it can be specialized for different black boxes.

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

our elimination (a fake in this case) Elimination method will go to blackbox.

Field::Element& trace (  typename Field::Element &    t, const ScalarMatrix< Field > &    A, const Method::Hybrid &    m )

Field::Element& trace (  typename Field::Element &    t, const SparseMatrix< Field > &    A, const Method::Hybrid &    m )

Field::Element& trace (  typename Field::Element &    t, const DenseMatrix< Field > &    A, const Method::Hybrid &    m )

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

our best guess Hybrid method will choose based on matrix size and type

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

sum of eigenvalues Also sum of diagonal entries. This is the generic one. testing multiple doc comments.

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

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

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

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

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

NTL::GF2E& UnparametricField< NTL::GF2E >::init (  NTL::GF2E &    x, const integer &    y )  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

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

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

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

integer& UnparametricField< NTL::RR >::convert (  integer &    x, const NTL::RR &    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.

NTL::RR& UnparametricField< NTL::RR >::init (  NTL::RR &    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. For now, this is done by converting the integer type to a C++ long and then to the element type through the use of static cast and NTL's to_RR function. This, of course, assumes such static casts are possible. This function should be changed in the future to avoid using long. Returns: reference to field element. Parameters: x  field element to contain output (reference returned). y  integer.

NTL::RR& UnparametricField< NTL::RR >::inv (  NTL::RR &    x, const NTL::RR &    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.

NTL::RR& UnparametricField< NTL::RR >::invin (  NTL::RR &    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).

bool UnparametricField< NTL::RR >::isOne (  const NTL::RR &    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.

bool UnparametricField< NTL::RR >::isZero (  const NTL::RR &    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.

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

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

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 >::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.

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.

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

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 string : inefficient but correct. 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 >::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.

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 string : inefficient but correct. Returns: reference to field element. Parameters: x  field element to contain output (reference returned). y  integer.

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 {\tt to\_zz\_p} function. Returns: reference to field element. Parameters: x  field element to contain output (reference returned). y  integer.

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.

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.

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).

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).

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.

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.

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 >::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.

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

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

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.

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.

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

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

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

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

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

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

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

NTL::zz_pE& UnparametricField< NTL::zz_pE >::init (  NTL::zz_pE &    x, const integer &    y )  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 >::inv (  NTL::zz_pE &    x, const NTL::zz_pE &    y )  const

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

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

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

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

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

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

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

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

NTL::RR& UnparametricRandIter< NTL::RR >::random (  NTL::RR &    elt )  const

Random field element creator. This returns a random field element from the information supplied at the creation of the generator. This generator uses the built-in C++ random number generator instead of NTL's random function because the NTL function does not allow as much control over the sampling size as the generic LinBox template. This specialization is included only to allow conversion to an NTL object. Returns: random field element

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

Random field element creator.

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

Random field element creator.

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

Constructor for random field element generator.

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

Constructor for random field element generator.

bool useBB (  const DenseMatrix< Field > &    A )

bool useBB (  const BB &    A )

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

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

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

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

---

Variable Documentation

const long _DEGINFTY_ = -1

const int BlasBound = 1 << 26

Commentator commentator

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

---