methods.h File Reference

#include <linbox/field/field-traits.h>
#include <linbox/matrix/dense-matrix.h>
#include <linbox/solutions/constants.h>
#include <linbox/util/mpicpp.h>
#include <string>

Data Structures
struct	ShapeFlags
struct	MethodBase
	Holds everything a method needs to know about the problem. More...
struct	Method
	Define which method to use when working on a system. More...
struct	Method::Auto
struct	Method::Elimination
struct	Method::DenseElimination
struct	Method::SparseElimination
struct	Method::Dixon
struct	Method::CRA< IterationMethod >
struct	Method::SymbolicNumericOverlap
struct	Method::SymbolicNumericNorm
struct	Method::Blackbox
struct	Method::Wiedemann
struct	Method::Lanczos
struct	Method::BlockLanczos
struct	Method::WiedemannExtension
struct	Method::BlockWiedemann
struct	Method::Coppersmith
struct	Method::BlockHankel

Namespaces
namespace	LinBox
	Namespace in which all linbox code resides.
namespace	LinBox::Rank
	Rank of the system, if known.
namespace	LinBox::Shape
	Flags decribing the shape of the matrix.

Macros
#define	DEFINE_METHOD_CONTENT(MethodName)
	These macros are used to define methods.
#define	DEFINE_METHOD(_MethodName, _CategoryTag)
#define	DEFINE_COMPOUND_METHOD(_MethodName, _CategoryTag)

Enumerations
enum	Value : int16_t { Unknown = -1 }
enum class	Singularity { Unknown , Singular , NonSingular }
	Singularity of the system. More...
enum class	Dispatch {   Auto , Sequential , SMP , Distributed ,   Combined }
	For integer-based methods that evaluate multiple times the system at different moduli, decides how to dispatch each sub-computations. More...
enum class	SingularSolutionType { Deterministic , Random , Diophantine }
	For Dixon method, which solution type to get when the system is singular. More...
enum class	Preconditioner {   None , Butterfly , Sparse , Toeplitz ,   Symmetrize , PartialDiagonal , PartialDiagonalSymmetrize , FullDiagonal ,   Dense }
	Preconditioner to ensure generic rank profile. More...
enum	Value : uint16_t {   Unknown = 0x00 , Symmetric = 0x01 , Diagonal = 0x02 , Toeplitz = 0x04 ,   Hankel = 0x08 , Unimodular = 0x10 , UpperTriangular = 0x20 , LowerTriangular = 0x40 }
enum class	PivotStrategy { None , Linear }
	Pivoting strategy for elimination-based methods. More...

Functions
template<class Matrix>
bool	useBlackboxMethod (const Matrix &A)
template<class Field>
bool	useBlackboxMethod (const LinBox::DenseMatrix< Field > &A)

Macro Definition Documentation

DEFINE_METHOD_CONTENT

#define DEFINE_METHOD_CONTENT

(

MethodName

)

Value:

    MethodName() = default;                                                                                                      \
    MethodName(const MethodName&) = default;                                                                                     \
    MethodName(const MethodBase& methodBase)                                                                                     \
        : MethodBase(methodBase)                                                                                                 \
    {                                                                                                                            \
    }

These macros are used to define methods.

The CategoryTag is used to differenciate what the method is used for. For instance, Method::Dixon has its CategoryTag set to RingCategories::IntegerTag, expressing it is used only for non-modular computations. Setting CategoryTag to void means that we don't care.

A compound method is something like Method::CRA<Method::Auto> telling the method CRA which method to use.

DEFINE_METHOD

#define DEFINE_METHOD	(		_MethodName,
			_CategoryTag )

Value:

    struct _MethodName : public MethodBase {                                                                                     \
        using CategoryTag = _CategoryTag;                                                                                        \
        static std::string name() { return std::string("Method::") + #_MethodName; }                                             \
        DEFINE_METHOD_CONTENT(_MethodName)                                                                                       \
    };

DEFINE_COMPOUND_METHOD

#define DEFINE_COMPOUND_METHOD	(		_MethodName,
			_CategoryTag )

Value:

    template <class IterationMethod>                                                                                             \
    struct _MethodName : public MethodBase {                                                                                     \
        using CategoryTag = _CategoryTag;                                                                                        \
        IterationMethod iterationMethod;                                                                                         \
        static std::string name() { return std::string("Method::") + #_MethodName "<" + IterationMethod::name() + ">"; }         \
        DEFINE_METHOD_CONTENT(_MethodName)                                                                                       \
    };                                                                                                                           \
    using _MethodName##Auto = _MethodName<Method::Auto>;