linbox
1
|
Namespaces | |
namespace | MatrixHom |
Limited doc so far. Used in RationalSolver. | |
Classes | |
class | BlackboxBlockContainerBase |
A base class for BlackboxBlockContainer. The primary member function is begin(). More... | |
class | BlackboxContainerBase |
A base class for BlackboxContainer. The primary member function is begin(). More... | |
class | BlackboxContainerSymmetric |
See base class for doc. More... | |
class | BlackboxContainerSymmetrize |
Symmetrizing iterator (for rank computations). More... | |
class | BlackboxContainer |
Limited doc so far. More... | |
class | BlasMatrixDomainMulAdd |
class | BlockLanczosSolver |
Block Lanczos iteration. More... | |
class | BlockMasseyDomain |
Compute the linear generator of a sequence of matrices. More... | |
class | DenseContainer |
Limited doc so far. More... | |
class | DiophantineSolver |
DiophantineSolver<QSolver> creates a diophantine solver using a QSolver to generate rational solutions. More... | |
class | Eliminator |
class | GaussDomain |
Repository of functions for rank by elimination on sparse matrices. More... | |
class | LABlockLanczosSolver |
class | LanczosSolver |
Solve a linear system using the conjugate Lanczos iteration. More... | |
class | LastInvariantFactor |
This is used in a Smith Form algorithm. More... | |
class | MasseyDomain |
Berlekamp/Massey algorithm. More... | |
class | MatrixRank |
class | MGBlockLanczosSolver |
Block Lanczos iteration. More... | |
class | OneInvariantFactor |
Limited doc so far. More... | |
struct | RationalRemainder |
Chinese remainder of rationals. More... | |
class | RationalReconstruction |
Limited doc so far. Used, for instance, after LiftingContainer. More... | |
class | RationalSolver |
interface for the different specialization of p-adic lifting based solvers. More... | |
class | RationalSolver< Ring, Field, RandomPrime, WiedemannTraits > |
partial specialization of p-adic based solver with Wiedemann algorithm More... | |
class | RationalSolver< Ring, Field, RandomPrime, BlockWiedemannTraits > |
partial specialization of p-adic based solver with block Wiedemann algorithm More... | |
class | RationalSolver< Ring, Field, RandomPrime, DixonTraits > |
partial specialization of p-adic based solver with Dixon algorithm More... | |
class | RationalSolver< Ring, Field, RandomPrime, NumericalTraits > |
partial specialization of p-adic based solver with a hybrid Numeric/Symbolic computation More... | |
class | SmithFormBinary |
Compute Smith form. More... | |
class | SmithFormIliopoulos |
This is Iliopoulos' algorithm do diagonalize. More... | |
class | SmithFormLocal |
Smith normal form (invariant factors) of a matrix over a local ring. More... | |
class | PowerGaussDomain |
Repository of functions for rank modulo a prime power by elimination on sparse matrices. More... | |
class | VectorFraction |
VectorFraction<Domain> is a vector of rational elements with common reduced denominator. Here Domain is a ring supporting the gcd, eg NTL_ZZ or PID_integer For compatability with the return type of rationalSolver, it allows conversion from/to std::vector<std::pair<Domain::Element> >. All functions will return the fraction in reduced form, calling reduce() if necessary. More... | |
class | WiedemannSolver |
Linear system solvers based on Wiedemann's method. More... | |
class | BlackboxArchetype |
showing the member functions provided by all blackbox matrix classes. More... | |
class | BlackboxInterface |
This blackbox base class exists solely to aid documentation organization. More... | |
class | BlasBlackbox |
dense matrix representation for BLAS based elimination.A BlasBlackbox can be constructed from any blackbox matrix. This costs n blackbox matrix vector products in general, but is efficiently done from a DenseMatrix or SparseMatrix. More... | |
class | Butterfly |
Switching Network based BlackBox Matrix. A good preconditioner. More... | |
struct | Companion |
Companion matrix of a monic polynomial. More... | |
class | Compose |
Blackbox of a product: C := AB, i.e. Cx := A(Bx). More... | |
class | Compose< _Blackbox, _Blackbox > |
specialization for _Blackbox1 = _Blackbox2 More... | |
class | ComposeTraits |
used in ..., for example More... | |
class | ComposeTraits< DenseMatrix< Field > > |
used in smith-binary, for example More... | |
class | DenseMatrix |
Blackbox interface to dense matrix representation. More... | |
class | DenseMatrixFactory |
class | Diagonal |
Random diagonal matrices are used heavily as preconditioners. More... | |
class | Diagonal< _Field, VectorCategories::DenseVectorTag > |
Specialization of Diagonal for application to dense vectors. More... | |
class | Diagonal< Field, VectorCategories::SparseSequenceVectorTag > |
Specialization of Diagonal for application to sparse sequence vectors. More... | |
class | Diagonal< Field, VectorCategories::SparseAssociativeVectorTag > |
Specialization of Diagonal for application to sparse associative vectors. More... | |
class | Dif |
Blackbox of a difference: C := A - B, i.e. Cx = Ax - Bx. More... | |
class | DirectSum |
If C = DirectSum(A, B) and y = xA and z = wB, then (y,z) = (x,w)C. More... | |
class | BlackboxFactory |
A tool for computations with integer and rational matrices. More... | |
class | Hilbert_JIT_Entry |
The object needed to build a Hilbert matrix as a JIT matrix. More... | |
class | Hilbert |
Example of a blackbox that is space efficient, though not time efficient. More... | |
class | Inverse |
A Blackbox for the inverse. Not efficient if many applications are used.The matrix itself is not stored in memory. Rather, its apply methods use a vector of field elements, which are used to "multiply" the matrix to a vector. More... | |
class | JIT_Matrix |
Example of a blackbox that is space efficient, though not time efficient. More... | |
class | MoorePenrose |
Generalized inverse of a blackbox. Efficiency concerns when many applications are used. More... | |
class | Sylvester |
class | NullMatrix |
This is a representation of the 0 by 0 empty matrix which does not occupy memory. It has it's uses! More... | |
class | Permutation |
size is n. More... | |
class | PolynomialBB |
represent the matrix P(A) where A is a blackbox and P a polynomial More... | |
class | ScalarMatrix |
Blackbox for aI . Use particularly for representing 0 and I . More... | |
class | SparseMatrix |
vector of sparse rows. More... | |
class | SparseMatrixFactory |
class | Submatrix |
leading principal minor of existing matrix without copying. More... | |
class | Submatrix< Blackbox, VectorCategories::DenseVectorTag > |
class | Submatrix< DenseMatrix< _Field >, VectorCategories::DenseVectorTag > |
class | Sum |
blackbox of a matrix sum without copying. More... | |
class | Toeplitz |
This is the blackbox representation of a Toeplitz matrix. More... | |
class | Toeplitz< typename _PField::CoeffField, _PField > |
class | Transpose |
transpose matrix without copying. More... | |
class | TriplesBB |
wrapper for NAG Sparse Matrix format. More... | |
class | ZeroOne |
Time and space efficient representation of sparse {0,1}-matrices. More... | |
class | ElementAbstract |
Abstract element base class, a technicality. More... | |
class | ElementArchetype |
Field and Ring element interface specification and archetypical instance class.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 | GivPolynomial |
Polynomials over a domain. More... | |
class | GMPRationalElement |
elements of GMP_Rationals. More... | |
class | FieldAbstract |
field base class.Found in the file {linbox/field/abstract.h}. Abstract base class used to implement the field archetype to minimize code bloat. All public member functions of this class are purely virtual and must be implemented by all derived classes. More... | |
class | FieldArchetype |
field specification and archetypical instance.The FieldArchetype and its encapsulated element class contain pointers to the FieldAbstract and its encapsulated field element, respectively. FieldAbstract then uses virtual member functions to define operations on its encapsulated field element. This field element has no knowledge of the field properties being used on it which means the field object must supply these operations. More... | |
class | BlockRing |
class | FieldEnvelope |
Derived class used to implement the field archetypeHelps to minimize code bloat. This class implements all purely virtual member functions of the abstract base class. This class is used to wrap a LinBox field so that it might be used with the Field archetype. More... | |
class | FieldInterface |
This field base class exists solely to aid documentation organization. More... | |
struct | GivaroField |
give LinBox fields an allure of Givaro FieldsThis class adds the necessary requirements allowing the construction of an extension of a LinBox field. More... | |
class | GivaroExtension |
class | GivaroExtension< GivaroGfq > |
class | GivaroGfq |
class | GivaroMontg |
wrapper of Givaro's Montgomery<Std32>.This class is a modular representation with a Montgomery reduction More... | |
class | GivaroZpz |
wrapper of Givaro's ZpzDom.Most methods are inherited from ZpzDom<Std16>, ZpzDom<Std32> and ZpzDom<log16> classes of Givaro. These classes allow to construct only finite field with a prime modulus. More... | |
class | NoHomError |
Error object for attempt to establish a Hom that cannot exist. More... | |
class | Hom |
map element of source ring(field) to target ringAn instance of Hom is a homomorphism from a ring of type Source to a ring (usually field) of type Target. The intended use is that it will be a natural mapping. For instance: More... | |
class | LidiaGfq |
defines the Galois Field GF(pk). More... | |
struct | Local2_32 |
Fast arithmetic mod 2^32, including gcd. More... | |
class | Modular< int32 > |
Specialization of Modular to int32 element type with efficient dot product. More... | |
class | Modular< int8 > |
Specialization of Modular to signed 8 bit element type with efficient dot product. More... | |
class | Modular< int16 > |
Specialization of Modular to short element type with efficient dot product. More... | |
class | Modular |
Prime fields of positive characteristic implemented directly in LinBox. More... | |
class | Modular< uint8 > |
Allows compact storage when the modulus is less than 2^8. More... | |
class | Modular< uint16 > |
Specialization of class Modular for uint16 element type. More... | |
class | Modular< uint32 > |
Specialization of class Modular for uint32 element type. More... | |
struct | NTL_zz_p |
long ints modulo a positive integer. More... | |
class | NTL_zz_pE |
for large cardinality, small prime. More... | |
class | NTL_zz_pX |
struct | NTL_PID_zz_p |
extend Wrapper of zz_p from NTL. Add PID functions More... | |
class | NTL_ZZ |
the integer ring. More... | |
class | NTL_ZZ_pX |
class | ParamFuzzy |
class | PIR_ntl_ZZ_p |
extend Wrapper of ZZ_p from NTL. Add PIR functions More... | |
struct | Rebind |
used in support of Hom, MatrixHom More... | |
class | MatrixArchetype |
Directly-represented matrix archetype. More... | |
class | indexDomain |
class | DenseRowsMatrix |
class | DenseSubmatrix |
class | DenseMatrixBase |
struct | MatrixCategories |
For specializing matrix arithmetic. More... | |
class | MVProductDomain |
Helper class to allow specializations of certain matrix-vector products. More... | |
class | MatrixDomain |
Class of matrix arithmetic functions. More... | |
class | InvalidMatrixInput |
class | FieldIO |
Dummy field for conceptually unclear io. More... | |
class | SparseMatrixBase |
class | TransposeMatrix |
class | RandIterAbstract |
class | RandIterArchetype |
Random field element generator archetype. More... | |
class | RandIterEnvelope |
class | GmpRandomPrime |
generating random prime integers, using the gmp library. More... | |
class | ModularBalancedRandIter |
class | ModularRandIter |
class | NonzeroRandIter |
class | UnparametricRandIter |
class | RingAbstract |
Abstract ring base class.Found in the file {linbox/ring/abstract.h}. Abstract base class used to implement the ring archetype to minimize code bloat. All public member functions of this class are purely virtual and must be implemented by all derived classes. More... | |
class | RingArchetype |
specification and archetypic instance for the ring interfaceThe {RingArchetype} and its encapsulated element class contain pointers to the {RingAbstract} and its encapsulated ring element, respectively. {RingAbstract} then uses virtual member functions to define operations on its encapsulated ring element. This ring element has no knowledge of the ring properties being used on it which means the ring object must supply these operations. More... | |
class | RingEnvelope |
implement the ring archetype to minimize code bloat.This class implements all purely virtual member functions of the abstract base class. This class is used to wrap a {LinBox} ring so that it might be used with the Ring archetype. More... | |
class | GivPolynomialRing |
polynomials with coefficients modulo some power of two More... | |
class | PowerOfTwoModular |
Ring of elements modulo some power of two. More... | |
class | RingInterface |
This ring base class exists solely to aid documentation organization. More... | |
struct | Method |
Method specifiers for controlling algorithm choice. More... | |
struct | SolverTraits |
class | SolveFailed |
class | InconsistentSystem |
class | BooleanSwitch |
class | BooleanSwitchFactory |
class | CekstvSwitch |
class | CekstvSwitchFactory |
class | ActivityState |
used by commentator More... | |
class | Commentator |
give information to user during runtimeThis object is used for reporting information about a computation to the user. Such information includes errors and warnings, descriptions of internal progress, performance measurements, and timing estimates. It also includes facilities for controlling the type and amount of information displayed. More... | |
class | MessageClass |
class | LinboxError |
class | FieldAXPY |
class | MatrixStreamReader |
class | PrimeStream |
class | BaseTimer |
base for class RealTimer; class SysTimer; class UserTimer; More... | |
class | BitVector |
class | ReverseVector |
class | Sparse_Vector |
vector< Pair<T> > and actualsize More... | |
class | VectorStream |
Vector factory. More... | |
class | ConstantVectorStream |
class | RandomDenseStream |
class | RandomSparseStream |
class | StandardBasisStream |
class | Subiterator |
Subvector iterator class provides striding iterators.A Subiterator steps by a fixed stride thru the underlying container. Subiter<Iterator> requires that Iterator be a random access iterator class and then itself provides the full functionality of a random access iterator class. See STL documentation for that functionality. Documented here is only the constructor from (1) an iterator of an underlying container and (2) a stride amount. More... | |
class | Subvector |
Dense subvectorThis class provides a statically sized subvector of a random access container (such as std::vector, deque). It does not work on sparse linbox vectors. It implements all of the types and methods of a std::vector except for those that invalidate iterators, i.e., those (potentially) involving vector resizing, such as push_back(), insert(), resize(). More... | |
struct | VectorCategories |
List of vector categories. More... | |
struct | VectorTraits |
struct | RawVector |
Typedefs | |
typedef Integer | integer |
This is a representation of arbitrary integers. | |
typedef signed __LINBOX_INT32 | int32 |
typedef unsigned __LINBOX_INT32 | uint32 |
Enumerations | |
enum | SolverReturnStatus |
define the different return status of the p-adic based solver's computation. | |
enum | SolverLevel |
define the different strategy which can be used in the p-adic based solver. More... | |
enum | FileFormatTag |
tags for SparseMatrixBase::read() and write() | |
Functions | |
template<class Blackbox , class MyMethod > | |
Blackbox::Field::Element & | lif_cra_det (typename Blackbox::Field::Element &d, const Blackbox &A, const RingCategories::IntegerTag &tag, const MyMethod &M) |
Compute the determinant of A over the integers. | |
template<class Ring , class ItMatrix > | |
void | SpecialBound (const Ring &R, typename Ring::Element &H_col_sqr, typename Ring::Element &short_col_sqr, const ItMatrix &A) |
template<class Ring , class ItMatrix > | |
void | ApplyBound (const Ring &R, typename Ring::Element &bound_A, const ItMatrix &A) |
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 Domain , class IMatrix > | |
void | create_MatrixQadic (const Domain &D, const IMatrix &M, double *chunks, size_t num_chunks, const integer &shift=0) |
split an integer matrix into a padic chunk representation | |
template<class Domain , class Vector > | |
void | create_VectorQadic (const Domain &D, const Vector &V, double *chunks, size_t num_chunks) |
split an integer vector into a padic chunk representation | |
template<class Domain , class Vector > | |
void | create_VectorQadic_32 (const Domain &D, const Vector &V, double *chunks, size_t num_chunks) |
split an integer vector into a padic chunk representation | |
template<class Blackbox , class Polynomial , class MyMethod > | |
Polynomial & | charpoly (Polynomial &P, const Blackbox &A, const MyMethod &M) |
...using an optional Method parameter | |
template<class Blackbox , class Polynomial > | |
Polynomial & | charpoly (Polynomial &P, const Blackbox &A) |
...using default method | |
template<class Polynomial , class Blackbox > | |
Polynomial & | charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M) |
Compute the characteristic polynomial over <bold>Z</bold>p | |
template<class Polynomial , class Blackbox > | |
Polynomial & | charpoly (Polynomial &P, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Blackbox &M) |
template<class Blackbox , class DetMethod , class DomainCategory > | |
Blackbox::Field::Element & | det (typename Blackbox::Field::Element &d, const Blackbox &A, const DomainCategory &tag, const DetMethod &M) |
Compute the determinant of A. | |
template<class Field > | |
Field::Element & | detin (typename Field::Element &d, BlasBlackbox< Field > &A) |
A will be modified. | |
template<class BB > | |
BB::Field::Element & | getEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j) |
Getting the i,j entry of the blackbox. | |
template<class BB > | |
BB::Field::Element & | getEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j, const Method::Hybrid &m) |
our best guess | |
template<class BB > | |
BB::Field::Element & | getEntry (typename BB::Field::Element &x, const BB &A, const size_t i, const size_t j, const Method::Elimination &m) |
our elimination (a fake in this case) | |
template<class Blackbox > | |
Blackbox::Field::Element & | getEntry (typename Blackbox::Field::Element &res, const Blackbox &A, const size_t i, const size_t j, const Method::Blackbox &m) |
template<class Blackbox , class MyMethod > | |
bool | isPositiveDefinite (const Blackbox &A, const MyMethod &M) |
template<class Blackbox , class MyMethod > | |
bool | isPositiveSemiDefinite (const Blackbox &A, 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 Blackbox , class Method , class DomainCategory > | |
unsigned long & | rank (unsigned long &r, const Blackbox &A, const DomainCategory &tag, const Method &M) |
template<class Blackbox > | |
unsigned long & | rank (unsigned long &r, const Blackbox &A) |
template<class Matrix > | |
unsigned long & | rankin (unsigned long &r, Matrix &A) |
template<class Blackbox , class Method > | |
unsigned long & | rank (unsigned long &r, const Blackbox &A, const Method &M) |
template<class Blackbox > | |
unsigned long & | rank (unsigned long &res, const Blackbox &A, const RingCategories::ModularTag &tag, const Method::Wiedemann &M) |
M may be Method::Wiedemann() . | |
template<class Field > | |
unsigned long & | rank (unsigned long &r, const SparseMatrix< Field, typename LinBox::Vector< Field >::SparseSeq > &A, const RingCategories::ModularTag &tag, const Method::SparseElimination &M) |
M may be Method::SparseElimination() . | |
template<class Field > | |
unsigned long & | rankin (unsigned long &r, BlasBlackbox< Field > &A, const RingCategories::ModularTag &tag, const Method::BlasElimination &M) |
A is modified. | |
template<class Output , class Blackbox , class MyMethod > | |
Output & | smithForm (Output &S, const Blackbox &A, const MyMethod &M) |
template<class Vector , class Blackbox , class SolveMethod > | |
Vector & | solve (Vector &x, const Blackbox &A, const Vector &b, const SolveMethod &M) |
Solve Ax = b, for x. | |
template<class Vector , class Ring > | |
Vector & | solve (Vector &x, typename Ring::Element &d, const BlasBlackbox< Ring > &A, const Vector &b, const RingCategories::IntegerTag tag, Method::Dixon &m) |
solver specialization with the 2nd API and DixonTraits over integer (no copying) | |
template<class Vector , class Ring > | |
Vector & | solve (Vector &x, typename Ring::Element &d, const DenseMatrix< Ring > &A, const Vector &b, const RingCategories::IntegerTag tag, Method::Dixon &m) |
solver specialization with the 2nd API and DixonTraits over integer (no copying) | |
template<class 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 BB > | |
BB::Field::Element & | trace (typename BB::Field::Element &t, const BB &A, const Method::Elimination &m) |
our elimination (a fake in this case) | |
template<class Blackbox > | |
Blackbox::Field::Element & | trace (typename Blackbox::Field::Element &res, const Blackbox &A, const Method::Blackbox &m) |
template<class Blackbox , class MyMethod > | |
Blackbox::Field::Element & | valence (typename Blackbox::Field::Element &v, const Blackbox &A, const MyMethod &M) |
Compute the valence of A. | |
template<class Field , class Vector > | |
Vector | randomVector (Field &F, size_t n, typename Field::RandIter &r) |
Butterfly | |
Butterfly preconditioner and supporting function | |
std::vector< bool > | setButterfly (const std::vector< bool > &x, size_t j=0) |
linbox/field/ntl-lzz_pX.h Daniel Roche, August 2005
linbox/field/ntl-ZZ_pX.h Daniel Roche, August 2005
typedef signed __LINBOX_INT32 int32 |
This is a representation of 32 bit ints, usually equivalent to `int'.
The use of `int32' ensures you are working with 32 bit signed ints, [-2^31..2^31). Similarly, int8, int16, and int64 are defined.
typedef unsigned __LINBOX_INT32 uint32 |
This is a representation of 32 bit unsigned ints, usually equivalent to `unsigned int'.
The use of `uint32' ensures you are working with 32 bit unsigned ints, [0..2^32). Similarly, uint8, uint16, and uint64 are defined.
void LinBox::SpecialBound | ( | const Ring & | R, |
typename Ring::Element & | H_col_sqr, | ||
typename Ring::Element & | short_col_sqr, | ||
const ItMatrix & | A | ||
) |
BoundBlackbox: Sets H_col_sqr <- H_col(A)^2, short_col_sqr <- short_col(A)^2 where H_col(A) is prod_j sqrt(sum_i a_ij^2) ('Hadamard column bound') short_col(A) is min_j sqrt(sum_i a_ij^2) ('shortest column')
note: H_col is not actually a norm! but it is what we need for lifting bound computation
void LinBox::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]
void LinBox::reduceIn | ( | Domain & | D, |
std::pair< typename Domain::Element, typename Domain::Element > & | frac | ||
) |
utility function to reduce a rational pair to lowest form
void LinBox::vectorGcdIn | ( | typename Domain::Element & | result, |
Domain & | D, | ||
Vector & | v | ||
) |
utility function to gcd-in a vector of elements over a domain
Domain::Element LinBox::vectorGcd | ( | Domain & | D, |
Vector & | v | ||
) |
utility function, returns gcd of a vector of elements over a domain
void create_MatrixQadic | ( | const Domain & | D, |
const IMatrix & | M, | ||
double * | chunks, | ||
size_t | num_chunks, | ||
const integer & | shift = 0 |
||
) |
split an integer matrix into a padic chunk representation
void LinBox::create_VectorQadic | ( | const Domain & | D, |
const Vector & | V, | ||
double * | chunks, | ||
size_t | num_chunks | ||
) |
split an integer vector into a padic chunk representation
void LinBox::create_VectorQadic_32 | ( | const Domain & | D, |
const Vector & | V, | ||
double * | chunks, | ||
size_t | num_chunks | ||
) |
split an integer vector into a padic chunk representation
std::vector<bool> LinBox::setButterfly | ( | const std::vector< bool > & | x, |
size_t | j = 0 |
||
) |
A function used with Butterfly Blackbox Matrices. This function takes an STL vector x of booleans, and returns a vector y of booleans such that setting the switches marked by true flags in y to be on (or to swap elements) the true elements x will be switched to a given contiguous block through the use of a Butterfly switching network. The integer parameter j marks where this block is to begin. If x has r true elements, the Butterfly switching network will place these elements in a contiguous block starting at j and ending at j + r - 1. Wrap around shall be considered to preserve contiguity. The value of j is defaulted to be zero, and it is only allowed to be non-zero is the size of x is a power of 2.
x | vector of booleans marking elements to switch into contiguous block |
j | offset of contiguous block |
log | reference to ostream for logging |
Polynomial& LinBox::charpoly | ( | Polynomial & | P, |
const Blackbox & | A, | ||
const MyMethod & | M | ||
) |
...using an optional Method parameter
P | - the output characteristic polynomial. If the polynomial is of degree d, this random access container has size d+1, the 0-th entry is the constant coefficient and the d-th is 1 since the charpoly is monic. |
A | - a blackbox matrix Optional |
M | - the method object. Generally, the default object suffices and the algorithm used is determined by the class of M. Basic methods are Method::Blackbox, Method::Elimination, and Method::Hybrid (the default). See methods.h for more options. |
Polynomial& LinBox::charpoly | ( | Polynomial & | P, |
const Blackbox & | A, | ||
const RingCategories::ModularTag & | tag, | ||
const Method::BlasElimination & | M | ||
) |
Compute the characteristic polynomial over <bold>Z</bold>p
Compute the characteristic polynomial of a matrix using dense elimination methods
P | Polynomial where to store the result |
A | Blackbox representing the matrix |
Polynomial& LinBox::charpoly | ( | Polynomial & | P, |
const Blackbox & | A, | ||
const RingCategories::ModularTag & | tag, | ||
const Method::Blackbox & | M | ||
) |
Compute the characteristic polynomial over <bold>Z</bold>p.
Compute the characteristic polynomial of a matrix, represented via a blackBox.
P | Polynomial where to store the result |
A | Blackbox representing the matrix |
BB::Field::Element& LinBox::getEntry | ( | typename BB::Field::Element & | x, |
const BB & | A, | ||
const size_t | i, | ||
const size_t | j, | ||
const Method::Hybrid & | m | ||
) |
our best guess
Hybrid method will choose based on matrix size and type
BB::Field::Element& LinBox::getEntry | ( | typename BB::Field::Element & | x, |
const BB & | A, | ||
const size_t | i, | ||
const size_t | j, | ||
const Method::Elimination & | m | ||
) |
our elimination (a fake in this case)
Elimination method will go to blackbox.
Blackbox::Field::Element& LinBox::getEntry | ( | typename Blackbox::Field::Element & | res, |
const Blackbox & | A, | ||
const size_t | i, | ||
const size_t | j, | ||
const Method::Blackbox & | m | ||
) |
Compute the getEntry 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.
bool LinBox::isPositiveDefinite | ( | const Blackbox & | A, |
const MyMethod & | M | ||
) |
Compute the isPositiveDefinite of A
The isPositiveDefinite of a linear operator A, represented as a black box, is computed over the ring or field of A.
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 LinBox::isPositiveSemiDefinite | ( | const Blackbox & | A, |
const MyMethod & | M | ||
) |
Compute the isPositiveSemiDefinite of A
The isPositiveSemiDefinite of a linear operator A, represented as a black box, is computed over the ring or field of A.
r | OUTPUT instance into which to store the result r |
A | Black box of which to compute the isPositiveSemiDefinite |
M | may be a Method::Hybrid (SemiDefault), Method::Blackbox, Method::Elimination, or of other method type. |
Polynomial& LinBox::minpoly | ( | Polynomial & | P, |
const Blackbox & | A, | ||
const MyMethod & | M | ||
) |
...using an optional Method parameter
P | - the output minimal polynomial. If the polynomial is of degree d, this random access container has size d+1, the 0-th entry is the constant coefficient and the d-th is 1 since the minpoly is monic. |
A | - a blackbox matrix Optional |
M | - the method object. Generally, the default object suffices and the algorithm used is determined by the class of M. Basic methods are Method::Blackbox, Method::Elimination, and Method::Hybrid (the default). See methods.h for more options. |
unsigned long& LinBox::rankin | ( | unsigned long & | r, |
Matrix & | A | ||
) |
A may be modified
BB::Field::Element& LinBox::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.
BB::Field::Element& LinBox::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& LinBox::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.
Blackbox::Field::Element& LinBox::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.