bogus Namespace Reference

Main namespace for bogus and So-bogus. More...

Namespaces
	admm
	Options for ADMM solvers.
	flags
	Flags for compile-time tuning of the behavior of objects such as SparseBlockMatrix.
	krylov
	Krylov methods implementation.
	local_soc_solver
	Configuration properties of local Second Order Cone solver.
	mkl
	Specializations using mkl.
	projected_gradient
	Options for ProjectedGradient solvers.

Classes
struct	BlockTranspose
	Defines the transpose type of a BlockType using self-introspection. More...
struct	BlockTranspose< BlockType, true, DCT, DTT >
struct	BlockTranspose< BlockType, false, true, DTT >
struct	BlockTranspose< BlockType, false, false, true >
struct	IsTransposable
struct	TransposeIf
	Utility struct for expressing a compile-time conditional transpose of a block. More...
struct	TransposeIf< true >
struct	BlockTransposeOption
	Utility struct to handle both compile-time and runtime optionally transposed ops. More...
struct	BlockTransposeOption< false, CompileTimeTranspose >
struct	BlockDims
	Access to the dimensions of a block. More...
struct	Segmenter
	Access to segment of a vector corresponding to a given block-row. More...
struct	Segmenter< internal::DYNAMIC, VectorType, Index >
class	BlockMatrixBase
	Base class for dense and sparse block matrices, thought dense don't exist yet. More...
struct	BlockObjectBase
	Base class for anything block. More...
struct	BlockMatrixTraits< BlockObjectBase< Derived > >
	Default specialization of traits for BlockMatrices. More...
class	CompoundBlockMatrix
	A matrix made by concatenating two other matrices of possibly different types. More...
struct	BlockMatrixTraits< CompoundBlockMatrix< ColWise, MatrixT1, MatrixT2 > >
class	CompoundBlockMatrix< false, MatrixT1, MatrixT2 >
struct	CompoundSparseBlockIndex
struct	SparseBlockIndexTraits< CompoundSparseBlockIndex< FirstIndexType, SecondIndexType, NativeOrder > >
struct	SparseBlockIndex< true, Index_, BlockPtr_, ArrayType >
	Compressed index, compatible with usual BSR/BSC formats. More...
struct	SparseBlockIndexTraits< SparseBlockIndex< true, Index_, BlockPtr_, ArrayType > >
struct	NarySum
	Sum of n similar expressions. More...
struct	BlockMatrixTraits< NarySum< Expression > >
struct	Evaluator
	Evaluates an expression inside a temporary if necessary, otherwise returns directly a matrix reference. More...
struct	Evaluator< Src, Src >
struct	Evaluator< Transpose< Src >, Dest >
struct	Transpose
	Base class for Transpose views of a BlockObjectBase. More...
struct	BlockMatrixTraits< Transpose< MatrixT > >
struct	BlockStorage
struct	BlockStorage< ObjectT, true >
struct	BlockOperand
struct	BinaryBlockOp
struct	Product
struct	BlockMatrixTraits< Product< LhsMatrixT, RhsMatrixT > >
struct	Addition
struct	BlockMatrixTraits< Addition< LhsMatrixT, RhsMatrixT > >
struct	Scaling
struct	BlockMatrixTraits< Scaling< MatrixT > >
struct	BlockOperand< Scaling< ObjectT > >
class	IterableBlockObject
	Base class for matrix-like objects that define a block structure, but not a block type. More...
struct	BlockMatrixTraits< MappedSparseBlockMatrix< BlockT, Flags, Index_ > >
	Specialization of BlockMatrixTraits for SparseBlockMatrix. More...
class	MappedSparseBlockMatrix
	Mapped Sparse Block Matrix. More...
struct	BlockTraits< MappedSparseBlockMatrix< BlockT, Flags, Index_ > >
struct	SparseBlockMatrixOpProxy< true, true, double, MKL_INT >
struct	BlockTraits< double >
struct	BlockTraits< float >
struct	BlockTraits< int >
struct	BlockTraits< char >
struct	SparseBlockIndexTraits
struct	SparseBlockIndexBase
struct	SparseBlockIndex
	Uncompressed sparse block index. More...
struct	SparseBlockIndexTraits< SparseBlockIndex< Compressed, Index_, BlockPtr_, ArrayType > >
struct	SparseBlockIndexGetter
struct	SparseBlockIndexGetter< Derived, true >
struct	SparseBlockIndexComputer
struct	SparseBlockIndexComputer< MatrixType, ColWise, Transpose, true >
struct	BlockMatrixTraits< SparseBlockMatrix< BlockT, Flags > >
	Specialization of BlockMatrixTraits for SparseBlockMatrix. More...
class	SparseBlockMatrix
	Sparse Block Matrix. More...
struct	BlockTraits< SparseBlockMatrix< BlockT, Flags > >
struct	SparseBlockMatrixFinalizer
class	SparseBlockMatrixBase
	Base class for SparseBlockMatrix. More...
struct	BlockMatrixTraits
struct	ResizableSequenceContainer
	Default container type, that should resizable and use contiguous storage. More...
struct	BlockTraits
struct	BlockTransposeTraits
	Defines the return type of an associated transpose_block( const BlockType& ) function. More...
struct	BlockVectorProductTraits
	Defines the type of the vectors resulting from the multiplication of a BlockMatrix and an instance of VectorTypea. More...
struct	BlockBlockProductTraits
	Defines the return type of the product of two blocks potentially transposed. More...
class	Zero
	Representation of the null matrix. More...
struct	BlockMatrixTraits< Zero< Scalar_ > >
class	ADMM
	ADMM (Alternating Direction Method of Multipliers ) iterative solver. More...
struct	QuadraticProxOp
	Evaluation of prox_{1/c} J with J(x) = 1/2 xM'x + f'x. More...
class	DualAMA
	Dual AMA iterative solver (Alternating Minimization Algorithm on dual formuation of quadratic optimization problem). More...
class	BlockSolverBase
	Base class for solvers that operate on BlockMatrixBase matrices. More...
struct	Coloring
	Coloring algorithm to determine which rows of a matrix can be treated in parallel. More...
class	ConstrainedSolverBase
class	GaussSeidel
	Projected Gauss-Seidel iterative solver. More...
class	GaussSeidelBase
	Abstract Gauss-Seidel interface . More...
class	Krylov
	Preconditionned Krylov Solvers. More...
struct	LinearSolverTraits< krylov::solvers::CG< Matrix, Preconditioner, Traits > >
struct	BlockBlockProductTraits< krylov::solvers::CG< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >
struct	LinearSolverTraits< krylov::solvers::BiCG< Matrix, Preconditioner, Traits > >
struct	BlockBlockProductTraits< krylov::solvers::BiCG< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >
struct	LinearSolverTraits< krylov::solvers::BiCGSTAB< Matrix, Preconditioner, Traits > >
struct	BlockBlockProductTraits< krylov::solvers::BiCGSTAB< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >
struct	LinearSolverTraits< krylov::solvers::CGS< Matrix, Preconditioner, Traits > >
struct	BlockBlockProductTraits< krylov::solvers::CGS< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >
struct	LinearSolverTraits< krylov::solvers::GMRES< Matrix, Preconditioner, Traits > >
struct	BlockBlockProductTraits< krylov::solvers::GMRES< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >
struct	LinearSolverTraits< krylov::solvers::TFQMR< Matrix, Preconditioner, Traits > >
struct	BlockBlockProductTraits< krylov::solvers::TFQMR< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >
class	LCPLaw
	LCP local solver that can be used within GaussSeidel and ProjectedGradient solvers. More...
class	TrivialPreconditioner
	Trivial ( identity ) preconditioner. Does nothing. More...
class	DiagonalPreconditioner
	Diagonal preconditioner. More...
class	DiagonalLUPreconditioner
	Diagonal Block-LU preconditioner. More...
class	DiagonalLDLTPreconditioner
	Diagonal Block-LDLT preconditioner. More...
struct	MatrixPreconditioner
	Matrix preconditioner. More...
class	ProductGaussSeidel
	Matrix-free version of the GaussSeidel iterative solver. More...
class	ProjectedGradient
	Projected Gradient iterative solver. More...
class	PyramidLaw
	Experimental and incomplete pyramidal local solver that can be used within GaussSeidel and ProjectedGradient solvers. More...
struct	ProblemTraits
struct	BlockTransposeTraits< Eigen::SparseMatrixBase< BlockT > >
struct	BlockTransposeTraits< Eigen::SparseMatrix< _Scalar, _Flags, _Index > >
struct	BlockTransposeTraits< Eigen::SparseVector< _Scalar, _Flags, _Index > >
struct	BlockTransposeTraits< Eigen::MappedSparseMatrix< _Scalar, _Flags, _Index > >
struct	BlockTraits< Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >
struct	BlockBlockProductTraits< Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Eigen::Matrix< _Scalar2, _Rows2, _Cols2, _Options2, _MaxRows2, _MaxCols2 >, TransposeLhs, TransposeRhs >
struct	ResizableSequenceContainer< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct	EigenSolveResult
struct	LinearSolverTraits< LU< Eigen::MatrixBase< Derived > > >
struct	LU< Eigen::MatrixBase< Derived > >
struct	DenseLU
struct	LinearSolverTraits< LDLT< Eigen::MatrixBase< Derived > > >
struct	LDLT< Eigen::MatrixBase< Derived > >
struct	DenseLDLT
struct	MatrixTraits
struct	MatrixTraits< Eigen::SparseMatrix< _Scalar, _Options, _Index > >
struct	MatrixTraits< double >
struct	MatrixTraits< float >
struct	MatrixTraits< int >
struct	MatrixTraits< char >
struct	LocalProblemTraits
struct	LocalProblemTraits< Eigen::Dynamic, Scalar >
struct	TypeSwapIf
struct	TypeSwapIf< true, First_, Second_ >
struct	SwapIf
struct	SwapIf< true, First_, Second_ >
struct	IsSame
struct	IsSame< T1, T1 >
struct	EnableIf
struct	EnableIf< true, ReturnType_ >
struct	DisableIf
struct	DisableIf< false, ReturnType_ >
struct	HasReturnType
struct	HasConstTransposeReturnType
struct	HasBase
struct	StaticAssert
struct	StaticAssert< false >
class	ConstMappedArray
	Const mapped array, used for Mapped Block Matrices. More...
struct	ConstantArray
struct	LinearSolverTraits
struct	LinearSolverBase
	Base class for linear solvers on base ( i.e. non-block ) matrices. More...
struct	LU
	Base class for LU factorizations. More...
struct	LDLT
	Base class for LDLT factorizations. More...
struct	BlockBlockProductTraits< LU< LhsBlockT >, RhsBlockT, TransposeLhs, TransposeRhs >
	Block product type deductions. More...
struct	BlockBlockProductTraits< LDLT< LhsBlockT >, RhsBlockT, TransposeLhs, TransposeRhs >
class	Lock
class	NaiveSharedPtr
	Naive reference-counting Shared Pointer. More...
class	NonSmoothNewton
	Dense, naive Newton implementation. More...
struct	NumTraits
struct	SignalTraits
struct	Signal
	Signal class, to which an arbitrary number of listeners can be connected. More...
class	SignalBase
	Base class for Signal of different arities. More...
struct	SignalTraits< Signal< Arg1, Arg2, Arg3 > >
struct	SignalTraits< Signal< Arg1, Arg2 > >
struct	SignalTraits< Signal< Arg, void > >
struct	Signal< Arg1, Arg2, void >
struct	Signal< Arg, void, void >
struct	WithMaxThreads
class	Timer
	Simple timer class. Starts when constructed. More...
class	SOCLaw
	Non-smooth laws based on Second Order Cone complementarity. To be used within as the first argument to GaussSeidel::solve(). More...
struct	FBBaseFunction
	Binary Fischer-Burmeister function and jacobian computation. More...
class	FischerBurmeister
	Fischer-Burmeister function and jacobian computation, with optional change of variable. More...
struct	LocalSOCSolver
struct	PrimalFrictionProblem
	Primal Coulomb friction problem for a block-diagonal mass matrix M with dense blocks. More...
struct	DualFrictionProblem
	Dual representation of a Coulomb friction problem, with explicit Delassus operator. More...
class	MecheFrictionProblem

Typedefs
typedef int	DenseIndexType
typedef SOCLaw< 2, double, true >	Coulomb2D
	Predefined non-smooth law for 2D Coulomb friction.
typedef SOCLaw< 3, double, true >	Coulomb3D
	Predefined non-smooth law for 3D Coulomb friction.
typedef SOCLaw< 2, double, false >	SOC2D
	Predefined non-smooth law for 2D SOC complementarity.
typedef SOCLaw< 3, double, false >	SOC3D
	Predefined non-smooth law for 3D SOC complementarity.

Functions
template<typename SelfTransposeT >
EnableIf< BlockTraits < SelfTransposeT > ::is_self_transpose, const SelfTransposeT & >::ReturnType	transpose_block (const SelfTransposeT &block)
	Specialization of transpose_block() for self-adjoint types.
template<typename BlockType >
EnableIf< !BlockTraits < BlockType > ::is_self_transpose, typename BlockType::ConstTransposeReturnType > ::ReturnType	transpose_block (const BlockType &block)
	Specialization of transpose_block() for types that define a ConstTransposeReturnType.
template<typename LhsT , typename RhsT >
Addition< LhsT, RhsT >	operator+ (const BlockObjectBase< LhsT > &lhs, const BlockObjectBase< RhsT > &rhs)
template<typename LhsT , typename RhsT >
Addition< LhsT, RhsT >	operator- (const BlockObjectBase< LhsT > &lhs, const BlockObjectBase< RhsT > &rhs)
template<typename Derived >
Scaling< Derived >	operator* (const BlockObjectBase< Derived > &lhs, typename Derived::Scalar rhs)
template<typename Derived >
Scaling< Derived >	operator* (typename Derived::Scalar lhs, const BlockObjectBase< Derived > &rhs)
template<typename LhsT , typename RhsT >
Product< LhsT, RhsT >	operator* (const BlockObjectBase< LhsT > &lhs, const BlockObjectBase< RhsT > &rhs)
template<typename Derived >
Scaling< Derived >	operator/ (const BlockObjectBase< Derived > &lhs, typename Derived::Scalar rhs)
bool	is_zero (double s, double precision)
void	set_zero (double &s)
void	set_identity (double &s)
void	resize (double &, int, int)
const double *	data_pointer (const double &s)
bool	is_zero (float s, float precision)
void	set_zero (float &s)
void	set_identity (float &s)
void	resize (float &, int, int)
const float *	data_pointer (const float &s)
bool	is_zero (int s, int precision)
void	set_zero (int &s)
void	set_identity (int &s)
void	resize (int &, int, int)
const int *	data_pointer (const int &s)
bool	is_zero (char s, char precision)
void	set_zero (char &s)
void	set_identity (char &s)
void	resize (char &, int, int)
const char *	data_pointer (const char &s)
template<typename EigenDerived >
bool	is_zero (const Eigen::MatrixBase< EigenDerived > &block, typename EigenDerived::Scalar precision)
template<typename EigenDerived >
void	set_zero (Eigen::MatrixBase< EigenDerived > &block)
template<typename EigenDerived >
void	set_identity (Eigen::MatrixBase< EigenDerived > &block)
template<typename EigenDerived >
void	resize (Eigen::MatrixBase< EigenDerived > &block, int rows, int cols)
template<typename EigenDerived >
const EigenDerived::Scalar *	data_pointer (const Eigen::MatrixBase< EigenDerived > &block)
template<typename EigenDerived >
const Eigen::Transpose< const EigenDerived >	transpose_block (const Eigen::SparseMatrixBase< EigenDerived > &block)
template<typename EigenDerived >
bool	is_zero (const Eigen::SparseMatrixBase< EigenDerived > &block, typename EigenDerived::Scalar precision)
template<typename Scalar , int Options, typename Index >
void	set_identity (Eigen::SparseMatrix< Scalar, Options, Index > &block)
template<typename Scalar , int Options, typename Index >
void	resize (Eigen::SparseMatrix< Scalar, Options, Index > &block, Index rows, Index cols)
template<typename Derived >
Eigen::internal::plain_matrix_type < Derived >::type	get_mutable_vector (const Eigen::MatrixBase< Derived > &)
template<typename Derived , typename EigenDerived >
mv_impl::BlockEigenProduct < mv_impl::EigenBlockWrapper < Derived >, EigenDerived >	operator* (const BlockObjectBase< Derived > &lhs, const Eigen::MatrixBase< EigenDerived > &rhs)
template<typename Derived , typename EigenDerived >
mv_impl::BlockEigenProduct < mv_impl::EigenBlockWrapper < Derived >, EigenDerived >	operator* (const Scaling< Derived > &lhs, const Eigen::MatrixBase< EigenDerived > &rhs)
template<typename Derived , typename EigenDerived >
mv_impl::BlockEigenProduct < EigenDerived, mv_impl::EigenBlockWrapper < Derived > >	operator* (const Eigen::MatrixBase< EigenDerived > &lhs, const BlockObjectBase< Derived > &rhs)
template<typename Derived , typename EigenDerived >
mv_impl::BlockEigenProduct < EigenDerived, mv_impl::EigenBlockWrapper < Derived > >	operator* (const Eigen::MatrixBase< EigenDerived > &lhs, const Scaling< Derived > &rhs)
template<typename Derived , typename RhsT >
LinearSolverTraits< Derived > ::template Result < Eigen::MatrixBase< RhsT > >::Type	operator* (const LinearSolverBase< Derived > &solver, const Eigen::MatrixBase< RhsT > &rhs)
template<typename EigenDerived , typename BogusDerived >
void	convert (const Eigen::SparseMatrixBase< EigenDerived > &source, SparseBlockMatrixBase< BogusDerived > &dest, int destRowsPerBlock=0, int destColsPerBlock=0)
template<typename BogusDerived , typename EigenScalar , int EigenOptions, typename EigenIndex >
void	convert (const SparseBlockMatrixBase< BogusDerived > &source, Eigen::SparseMatrix< EigenScalar, EigenOptions, EigenIndex > &dest)
template<typename Element >
const Element *	data_pointer (const ConstMappedArray< Element > &vec)
template<typename T , typename Allocator >
const T *	data_pointer (const std::vector< T, Allocator > &vec)
	Accessing std::vector data pointer without undefined behavior.
template<typename T , typename Allocator >
T *	data_pointer (std::vector< T, Allocator > &vec)
	Accessing std::vector data pointer without undefined behavior – mutable version.
template<typename Scalar >
ConstantArray< Scalar >	make_constant_array (Scalar s)

Detailed Description

Main namespace for bogus and So-bogus.

---

Class Documentation

struct bogus::BlockTranspose

template<typename BlockType, bool IsSelfTranspose = BlockTraits< BlockType >::is_self_transpose, bool DefinesConstTranspose = HasConstTransposeReturnType< BlockType >::Value, bool DefinesTransposeTraits = HasReturnType< BlockTransposeTraits< BlockType > >::Value>
struct bogus::BlockTranspose< BlockType, IsSelfTranspose, DefinesConstTranspose, DefinesTransposeTraits >

Defines the transpose type of a BlockType using self-introspection.

Process af follow:

• If the BlockType is self transpose, the transpose type is the BlockType itself
• If the BlockType defines a ConstTransposeReturnType, use it
• If BlockTransposeTraits< BlockType > defines a ReturnType, use it
• If the BlockType defines a Base, retry with this Base

Class Members
	__unnamed__

struct bogus::BlockTranspose< BlockType, true, DCT, DTT >

template<typename BlockType, bool DCT, bool DTT>
struct bogus::BlockTranspose< BlockType, true, DCT, DTT >

Class Members
typedef const BlockType &	ReturnType

Class Members
	__unnamed__

struct bogus::BlockTranspose< BlockType, false, true, DTT >

template<typename BlockType, bool DTT>
struct bogus::BlockTranspose< BlockType, false, true, DTT >

Class Members
typedef ConstTransposeReturnType	ReturnType

Class Members
	__unnamed__

struct bogus::BlockTranspose< BlockType, false, false, true >

template<typename BlockType>
struct bogus::BlockTranspose< BlockType, false, false, true >

Class Members
typedef BlockTransposeTraits < BlockType >::ReturnType	ReturnType

Class Members
	__unnamed__

struct bogus::IsTransposable

template<typename BlockType>
struct bogus::IsTransposable< BlockType >

Class Members
	__unnamed__

struct bogus::BlockDims

template<typename BlockT, bool Transpose_ = false>
struct bogus::BlockDims< BlockT, Transpose_ >

Access to the dimensions of a block.

Class Members
typedef SwapIf< Transpose_, RowsAtCompileTime, ColsAtCompileTime >	Dims
typedef BlockTraits< BlockT >	Traits

Class Members
	__unnamed__

struct bogus::BlockMatrixTraits< BlockObjectBase< Derived > >

template<typename Derived>
struct bogus::BlockMatrixTraits< BlockObjectBase< Derived > >

Default specialization of traits for BlockMatrices.

Re-specialized for derived classes, see e.g. BlockMatrixTraits< SparseBlockMatrix >

Class Members
typedef TransposeObjectType	ConstTransposeReturnType	Type returned by the transpose() method. Generally a TransposeObjectType or a const reference to it
typedef int	Index	Index type – for accessing elements, defining offsets, etc.
typedef Derived	PlainObjectType	Type in which the expression may be evaluated into.
typedef Transpose< Derived >	TransposeObjectType	Type representing the transpose of this object.

Class Members
	__unnamed__
	__unnamed__

struct bogus::SparseBlockIndexTraits< CompoundSparseBlockIndex< FirstIndexType, SecondIndexType, NativeOrder > >

template<typename FirstIndexType, typename SecondIndexType, bool NativeOrder>
struct bogus::SparseBlockIndexTraits< CompoundSparseBlockIndex< FirstIndexType, SecondIndexType, NativeOrder > >

Class Members
typedef BlockPtr	BlockPtr
typedef Index	Index
typedef CompoundSparseBlockIndex < FirstIndexType, SecondIndexType, NativeOrder >	SparseBlockIndexType

struct bogus::SparseBlockIndexTraits< SparseBlockIndex< true, Index_, BlockPtr_, ArrayType > >

template<typename Index_, typename BlockPtr_, template< typename > class ArrayType>
struct bogus::SparseBlockIndexTraits< SparseBlockIndex< true, Index_, BlockPtr_, ArrayType > >

Class Members
typedef BlockPtr_	BlockPtr
typedef Index_	Index
typedef SparseBlockIndex< true, Index_, BlockPtr_, ArrayType >	SparseBlockIndexType

struct bogus::BlockMatrixTraits< Transpose< MatrixT > >

template<typename MatrixT>
struct bogus::BlockMatrixTraits< Transpose< MatrixT > >

Class Members
typedef const PlainObjectType &	ConstTransposeReturnType
typedef Index	Index
typedef BlockMatrixTraits < MatrixT >	OrigTraits
typedef PlainObjectType	PlainObjectType
typedef Scalar	Scalar
typedef PlainObjectType	TransposeObjectType

Class Members
	__unnamed__
	__unnamed__

struct bogus::BlockStorage

template<typename ObjectT, bool IsTemporary>
struct bogus::BlockStorage< ObjectT, IsTemporary >

Class Members
typedef const ObjectT &	ConstValue

struct bogus::BlockStorage< ObjectT, true >

template<typename ObjectT>
struct bogus::BlockStorage< ObjectT, true >

Class Members
typedef const ObjectT	ConstValue

struct bogus::BlockMatrixTraits< Product< LhsMatrixT, RhsMatrixT > >

template<typename LhsMatrixT, typename RhsMatrixT>
struct bogus::BlockMatrixTraits< Product< LhsMatrixT, RhsMatrixT > >

Class Members
typedef Product< typename BlockOperand< RhsMatrixT > ::TransposeObjectType, typename BlockOperand < LhsMatrixT > ::TransposeObjectType >	ConstTransposeReturnType
typedef Index	Index
typedef BlockType	LhsBlockType
typedef BlockMatrixTraits < LhsMatrixT >	LhsTraits
typedef template MutableImpl < ResBlockType, false >::Type	PlainObjectType
typedef Product< LhsMatrixT, RhsMatrixT >	ProductType
typedef BlockBlockProductTraits < LhsBlockType, RhsBlockType, is_transposed, is_transposed > ::ReturnType	ResBlockType
typedef BlockType	RhsBlockType
typedef BlockMatrixTraits < RhsMatrixT >	RhsTraits
typedef Scalar	Scalar
typedef ConstTransposeReturnType	TransposeObjectType

Class Members
	__unnamed__
	__unnamed__

struct bogus::BlockMatrixTraits< Addition< LhsMatrixT, RhsMatrixT > >

template<typename LhsMatrixT, typename RhsMatrixT>
struct bogus::BlockMatrixTraits< Addition< LhsMatrixT, RhsMatrixT > >

Class Members
typedef Addition< typename BlockOperand< LhsMatrixT > ::TransposeObjectType, typename BlockOperand < RhsMatrixT > ::TransposeObjectType >	ConstTransposeReturnType
typedef Index	Index
typedef BlockMatrixTraits < LhsMatrixT >	OrigTraits
typedef template MutableImpl < ResBlockType, false >::Type	PlainObjectType
typedef BlockType	ResBlockType
typedef Scalar	Scalar
typedef ConstTransposeReturnType	TransposeObjectType

Class Members
	__unnamed__
	__unnamed__

struct bogus::BlockMatrixTraits< Scaling< MatrixT > >

template<typename MatrixT>
struct bogus::BlockMatrixTraits< Scaling< MatrixT > >

Class Members
typedef Scaling< typename BlockOperand< MatrixT > ::TransposeObjectType >	ConstTransposeReturnType
typedef Index	Index
typedef BlockMatrixTraits < MatrixT >	OrigTraits
typedef PlainObjectType	PlainObjectType
typedef Scalar	Scalar
typedef ConstTransposeReturnType	TransposeObjectType

Class Members
	__unnamed__
	__unnamed__

struct bogus::BlockTraits< MappedSparseBlockMatrix< BlockT, Flags, Index_ > >

template<typename BlockT, int Flags, typename Index_>
struct bogus::BlockTraits< MappedSparseBlockMatrix< BlockT, Flags, Index_ > >

Class Members
typedef MappedSparseBlockMatrix < BlockT, Flags, Index_ >	BlockType
typedef Scalar	Scalar
typedef MappedSparseBlockMatrix < typename TransposeBlockType, Flags^COL_MAJOR, Index_ >	TransposeStorageType

Class Members
	__unnamed__

struct bogus::BlockTraits< double >

template<>
struct bogus::BlockTraits< double >

Class Members
typedef double	Scalar
typedef double	TransposeStorageType

Class Members
	__unnamed__

struct bogus::BlockTraits< float >

template<>
struct bogus::BlockTraits< float >

Class Members
typedef float	Scalar
typedef float	TransposeStorageType

Class Members
	__unnamed__

struct bogus::BlockTraits< int >

template<>
struct bogus::BlockTraits< int >

Class Members
typedef int	Scalar
typedef int	TransposeStorageType

Class Members
	__unnamed__

struct bogus::BlockTraits< char >

template<>
struct bogus::BlockTraits< char >

Class Members
typedef char	Scalar
typedef char	TransposeStorageType

Class Members
	__unnamed__

struct bogus::SparseBlockIndexTraits

template<typename Derived>
struct bogus::SparseBlockIndexTraits< Derived >

struct bogus::SparseBlockIndexTraits< SparseBlockIndex< Compressed, Index_, BlockPtr_, ArrayType > >

template<bool Compressed, typename Index_, typename BlockPtr_, template< typename > class ArrayType>
struct bogus::SparseBlockIndexTraits< SparseBlockIndex< Compressed, Index_, BlockPtr_, ArrayType > >

Class Members
typedef BlockPtr_	BlockPtr
typedef Index_	Index
typedef SparseBlockIndex < Compressed, Index_, BlockPtr_, ArrayType >	SparseBlockIndexType

struct bogus::BlockTraits< SparseBlockMatrix< BlockT, Flags > >

template<typename BlockT, int Flags>
struct bogus::BlockTraits< SparseBlockMatrix< BlockT, Flags > >

Class Members
typedef SparseBlockMatrix < BlockT, Flags >	BlockType
typedef Scalar	Scalar
typedef SparseBlockMatrix < typename TransposeBlockType, Flags^COL_MAJOR >	TransposeStorageType

Class Members
	__unnamed__

struct bogus::SparseBlockMatrixFinalizer

template<bool Symmetric>
struct bogus::SparseBlockMatrixFinalizer< Symmetric >

struct bogus::BlockMatrixTraits

template<typename Derived>
struct bogus::BlockMatrixTraits< Derived >

struct bogus::ResizableSequenceContainer

template<typename ElementType>
struct bogus::ResizableSequenceContainer< ElementType >

Default container type, that should resizable and use contiguous storage.

Class Members
typedef vector< ElementType >	Type

Class Members
	__unnamed__

struct bogus::BlockTraits

template<typename BlockType>
struct bogus::BlockTraits< BlockType >

Class Members
typedef Scalar	Scalar
typedef BlockType	TransposeStorageType	Type for storing the result of transpose_block( BlockType ), useful for cacheTranspose()

Class Members
	__unnamed__

struct bogus::BlockTransposeTraits

template<typename BlockType>
struct bogus::BlockTransposeTraits< BlockType >

Defines the return type of an associated transpose_block( const BlockType& ) function.

struct bogus::BlockVectorProductTraits

template<typename VectorType>
struct bogus::BlockVectorProductTraits< VectorType >

Defines the type of the vectors resulting from the multiplication of a BlockMatrix and an instance of VectorTypea.

Should be the return type of an associated get_mutable_vector( const VectorType & ) function

struct bogus::BlockBlockProductTraits

template<typename LhsBlockType, typename RhsBlockType, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< LhsBlockType, RhsBlockType, TransposeLhs, TransposeRhs >

Defines the return type of the product of two blocks potentially transposed.

Class Members
typedef LhsBlockType	ReturnType

struct bogus::LinearSolverTraits< krylov::solvers::CG< Matrix, Preconditioner, Traits > >

template<typename Matrix, typename Preconditioner, class Traits>
struct bogus::LinearSolverTraits< krylov::solvers::CG< Matrix, Preconditioner, Traits > >

Class Members
typedef Matrix	MatrixType

struct bogus::BlockBlockProductTraits< krylov::solvers::CG< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

template<typename Matrix, typename Preconditioner, class Traits, typename RhsBlockT, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< krylov::solvers::CG< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

Class Members
typedef BlockBlockProductTraits < Matrix, RhsBlockT, TransposeLhs, TransposeRhs > ::ReturnType	ReturnType

struct bogus::LinearSolverTraits< krylov::solvers::BiCG< Matrix, Preconditioner, Traits > >

template<typename Matrix, typename Preconditioner, class Traits>
struct bogus::LinearSolverTraits< krylov::solvers::BiCG< Matrix, Preconditioner, Traits > >

Class Members
typedef Matrix	MatrixType

struct bogus::BlockBlockProductTraits< krylov::solvers::BiCG< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

template<typename Matrix, typename Preconditioner, class Traits, typename RhsBlockT, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< krylov::solvers::BiCG< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

Class Members
typedef BlockBlockProductTraits < Matrix, RhsBlockT, TransposeLhs, TransposeRhs > ::ReturnType	ReturnType

struct bogus::LinearSolverTraits< krylov::solvers::BiCGSTAB< Matrix, Preconditioner, Traits > >

template<typename Matrix, typename Preconditioner, class Traits>
struct bogus::LinearSolverTraits< krylov::solvers::BiCGSTAB< Matrix, Preconditioner, Traits > >

Class Members
typedef Matrix	MatrixType

struct bogus::BlockBlockProductTraits< krylov::solvers::BiCGSTAB< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

template<typename Matrix, typename Preconditioner, class Traits, typename RhsBlockT, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< krylov::solvers::BiCGSTAB< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

Class Members
typedef BlockBlockProductTraits < Matrix, RhsBlockT, TransposeLhs, TransposeRhs > ::ReturnType	ReturnType

struct bogus::LinearSolverTraits< krylov::solvers::CGS< Matrix, Preconditioner, Traits > >

template<typename Matrix, typename Preconditioner, class Traits>
struct bogus::LinearSolverTraits< krylov::solvers::CGS< Matrix, Preconditioner, Traits > >

Class Members
typedef Matrix	MatrixType

struct bogus::BlockBlockProductTraits< krylov::solvers::CGS< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

template<typename Matrix, typename Preconditioner, class Traits, typename RhsBlockT, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< krylov::solvers::CGS< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

Class Members
typedef BlockBlockProductTraits < Matrix, RhsBlockT, TransposeLhs, TransposeRhs > ::ReturnType	ReturnType

struct bogus::LinearSolverTraits< krylov::solvers::GMRES< Matrix, Preconditioner, Traits > >

template<typename Matrix, typename Preconditioner, class Traits>
struct bogus::LinearSolverTraits< krylov::solvers::GMRES< Matrix, Preconditioner, Traits > >

Class Members
typedef Matrix	MatrixType

struct bogus::BlockBlockProductTraits< krylov::solvers::GMRES< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

template<typename Matrix, typename Preconditioner, class Traits, typename RhsBlockT, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< krylov::solvers::GMRES< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

Class Members
typedef BlockBlockProductTraits < Matrix, RhsBlockT, TransposeLhs, TransposeRhs > ::ReturnType	ReturnType

struct bogus::LinearSolverTraits< krylov::solvers::TFQMR< Matrix, Preconditioner, Traits > >

template<typename Matrix, typename Preconditioner, class Traits>
struct bogus::LinearSolverTraits< krylov::solvers::TFQMR< Matrix, Preconditioner, Traits > >

Class Members
typedef Matrix	MatrixType

struct bogus::BlockBlockProductTraits< krylov::solvers::TFQMR< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

template<typename Matrix, typename Preconditioner, class Traits, typename RhsBlockT, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< krylov::solvers::TFQMR< Matrix, Preconditioner, Traits >, RhsBlockT, TransposeLhs, TransposeRhs >

Class Members
typedef BlockBlockProductTraits < Matrix, RhsBlockT, TransposeLhs, TransposeRhs > ::ReturnType	ReturnType

class bogus::DiagonalPreconditioner

template<typename MatrixType>
class bogus::DiagonalPreconditioner< MatrixType >

Diagonal preconditioner.

Defines the preconditioner matrix as a diagonal matrix where each of the coefficient is the scalar inverse of the corresponding diagonal coefficient in the system matrix Works well for diagonally dominant matrices.

class bogus::DiagonalLUPreconditioner

template<typename MatrixType>
class bogus::DiagonalLUPreconditioner< MatrixType >

Diagonal Block-LU preconditioner.

Defines the preconditioner matrix as a block-diagonal matrix where each diagonal block is the LU factorization of the corresponding diagonal block in the system matrix

class bogus::DiagonalLDLTPreconditioner

template<typename MatrixType>
class bogus::DiagonalLDLTPreconditioner< MatrixType >

Diagonal Block-LDLT preconditioner.

Defines the preconditioner matrix as a block-diagonal matrix where each diagonal block is the LDLT factorization of the corresponding diagonal block in the system matrix

struct bogus::MatrixPreconditioner

template<typename PreconditionerMatrixType>
struct bogus::MatrixPreconditioner< PreconditionerMatrixType >

Matrix preconditioner.

Explicitely define the preconditioner with an arbitray matrix

struct bogus::ProblemTraits

template<typename MatrixType>
struct bogus::ProblemTraits< MatrixType >

Class Members
typedef Matrix< Scalar, Dynamic, Dynamic >	DynMatrix
typedef Matrix< Scalar, Dynamic, 1 >	DynVector
typedef Scalar_	Scalar

struct bogus::BlockTransposeTraits< Eigen::SparseMatrixBase< BlockT > >

template<typename BlockT>
struct bogus::BlockTransposeTraits< Eigen::SparseMatrixBase< BlockT > >

Class Members
typedef const Transpose< const BlockT >	ReturnType

struct bogus::BlockTraits< Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >

template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
struct bogus::BlockTraits< Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >

Class Members
typedef _Scalar	Scalar
typedef Matrix< _Scalar, _Cols, _Rows,(_Options|((_Cols==1 &&_Rows!=1)?RowMajor:0))&~((_Rows==1 &&_Cols!=1)?RowMajor:0), _MaxCols, _MaxRows >	TransposeStorageType

Class Members
	__unnamed__

struct bogus::BlockBlockProductTraits< Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Eigen::Matrix< _Scalar2, _Rows2, _Cols2, _Options2, _MaxRows2, _MaxCols2 >, TransposeLhs, TransposeRhs >

template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename _Scalar2, int _Rows2, int _Cols2, int _Options2, int _MaxRows2, int _MaxCols2, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Eigen::Matrix< _Scalar2, _Rows2, _Cols2, _Options2, _MaxRows2, _MaxCols2 >, TransposeLhs, TransposeRhs >

Class Members
typedef Matrix< _Scalar, SwapIf< TransposeLhs, _Rows, _Cols >::First, SwapIf < TransposeRhs, _Rows2, _Cols2 > ::Second, _Options, SwapIf < TransposeLhs, _MaxRows, _MaxCols >::First, SwapIf < TransposeRhs, _MaxRows2, _MaxCols2 >::Second >	ReturnType

struct bogus::ResizableSequenceContainer< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >

template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
struct bogus::ResizableSequenceContainer< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >

Class Members
typedef Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols >	BlockType
typedef TypeSwapIf< Rows==Dynamic||Cols==Dynamic||0!=(static_cast < size_t > Rows *Cols *sizeof(Scalar))&0xf), vector< BlockType, aligned_allocator< BlockType > >, vector< BlockType > >::First	Type

struct bogus::EigenSolveResult

template<typename Decomposition, typename RhsType>
struct bogus::EigenSolveResult< Decomposition, RhsType >

Class Members
typedef solve_retval < Decomposition, RhsType >	Type

struct bogus::LinearSolverTraits< LU< Eigen::MatrixBase< Derived > > >

template<typename Derived>
struct bogus::LinearSolverTraits< LU< Eigen::MatrixBase< Derived > > >

Class Members
typedef FullPivLU< MatrixType >	FactType
typedef PlainObject	MatrixType

struct bogus::LinearSolverTraits< LDLT< Eigen::MatrixBase< Derived > > >

template<typename Derived>
struct bogus::LinearSolverTraits< LDLT< Eigen::MatrixBase< Derived > > >

Class Members
typedef LDLT< MatrixType >	FactType
typedef PlainObject	MatrixType

struct bogus::TypeSwapIf

template<bool DoSwap, typename First_, typename Second_>
struct bogus::TypeSwapIf< DoSwap, First_, Second_ >

Class Members
typedef First_	First
typedef Second_	Second

struct bogus::TypeSwapIf< true, First_, Second_ >

template<typename First_, typename Second_>
struct bogus::TypeSwapIf< true, First_, Second_ >

Class Members
typedef Second_	First
typedef First_	Second

struct bogus::SwapIf

template<bool DoSwap, int First_, int Second_>
struct bogus::SwapIf< DoSwap, First_, Second_ >

Class Members
	__unnamed__

struct bogus::SwapIf< true, First_, Second_ >

template<int First_, int Second_>
struct bogus::SwapIf< true, First_, Second_ >

Class Members
	__unnamed__

struct bogus::IsSame

template<typename T1, typename T2>
struct bogus::IsSame< T1, T2 >

Class Members
	__unnamed__

struct bogus::IsSame< T1, T1 >

template<typename T1>
struct bogus::IsSame< T1, T1 >

Class Members
	__unnamed__

struct bogus::EnableIf

template<bool Condition, typename ReturnType_ = void>
struct bogus::EnableIf< Condition, ReturnType_ >

struct bogus::EnableIf< true, ReturnType_ >

template<typename ReturnType_>
struct bogus::EnableIf< true, ReturnType_ >

Class Members
typedef ReturnType_	ReturnType

struct bogus::DisableIf

template<bool Condition, typename ReturnType_ = void>
struct bogus::DisableIf< Condition, ReturnType_ >

struct bogus::DisableIf< false, ReturnType_ >

template<typename ReturnType_>
struct bogus::DisableIf< false, ReturnType_ >

Class Members
typedef ReturnType_	ReturnType

struct bogus::StaticAssert

template<bool Assertion>
struct bogus::StaticAssert< Assertion >

Class Members
	__unnamed__

struct bogus::StaticAssert< false >

template<>
struct bogus::StaticAssert< false >

struct bogus::LinearSolverTraits

template<typename LSDerived>
struct bogus::LinearSolverTraits< LSDerived >

struct bogus::BlockBlockProductTraits< LU< LhsBlockT >, RhsBlockT, TransposeLhs, TransposeRhs >

template<typename LhsBlockT, typename RhsBlockT, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< LU< LhsBlockT >, RhsBlockT, TransposeLhs, TransposeRhs >

Block product type deductions.

Class Members
typedef LinearSolverTraits< LU < LhsBlockT > >::MatrixType	LhsMatrixT
typedef BlockBlockProductTraits < LhsMatrixT, RhsBlockT, TransposeLhs, TransposeRhs > ::ReturnType	ReturnType

struct bogus::BlockBlockProductTraits< LDLT< LhsBlockT >, RhsBlockT, TransposeLhs, TransposeRhs >

template<typename LhsBlockT, typename RhsBlockT, bool TransposeLhs, bool TransposeRhs>
struct bogus::BlockBlockProductTraits< LDLT< LhsBlockT >, RhsBlockT, TransposeLhs, TransposeRhs >

Class Members
typedef LinearSolverTraits < LDLT< LhsBlockT > >::MatrixType	LhsMatrixT
typedef BlockBlockProductTraits < LhsMatrixT, RhsBlockT, TransposeLhs, TransposeRhs > ::ReturnType	ReturnType

struct bogus::SignalTraits

template<typename Derived>
struct bogus::SignalTraits< Derived >

struct bogus::SignalTraits< Signal< Arg1, Arg2, Arg3 > >

template<typename Arg1, typename Arg2, typename Arg3>
struct bogus::SignalTraits< Signal< Arg1, Arg2, Arg3 > >

struct bogus::SignalTraits< Signal< Arg1, Arg2 > >

template<typename Arg1, typename Arg2>
struct bogus::SignalTraits< Signal< Arg1, Arg2 > >

struct bogus::SignalTraits< Signal< Arg, void > >

template<typename Arg>
struct bogus::SignalTraits< Signal< Arg, void > >