Eigen Namespace Reference

Namespaces
namespace	Architecture
namespace	half_impl
namespace	internal
namespace	numext

Classes
class	aligned_allocator
	STL compatible allocator to use with types requiring a non standrad alignment. More...
class	aligned_allocator_indirection
class	AlignedBox
	An axis aligned box. More...
class	AMDOrdering
class	AngleAxis
	Represents a 3D rotation as a rotation angle around an arbitrary 3D axis. More...
class	Array
	General-purpose arrays with easy API for coefficient-wise operations. More...
class	ArrayBase
	Base class for all 1D and 2D array, and related expressions. More...
class	ArrayWrapper
	Expression of a mathematical vector or matrix as an array object. More...
struct	ArrayXpr
struct	BandShape
class	BDCSVD
	class Bidiagonal Divide and Conquer SVD More...
class	BiCGSTAB
	A bi conjugate gradient stabilized solver for sparse square problems. More...
class	Block
	Expression of a fixed-size or dynamic-size block. More...
class	BlockImpl
class	BlockImpl< const SparseMatrix< _Scalar, _Options, _StorageIndex >, BlockRows, BlockCols, true, Sparse >
class	BlockImpl< SparseMatrix< _Scalar, _Options, _StorageIndex >, BlockRows, BlockCols, true, Sparse >
class	BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Dense >
class	BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >
class	BlockImpl< XprType, BlockRows, BlockCols, true, Sparse >
class	BlockSparseMatrix
	A versatile sparse matrix representation where each element is a block. More...
class	BlockSparseMatrixView
class	BlockSparseTimeDenseProduct
class	BlockVectorReturn
class	BlockVectorView
class	CholmodBase
	The base class for the direct Cholesky factorization of Cholmod. More...
class	CholmodDecomposition
	A general Cholesky factorization and solver based on Cholmod. More...
class	CholmodSimplicialLDLT
	A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod. More...
class	CholmodSimplicialLLT
	A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod. More...
class	CholmodSupernodalLLT
	A supernodal Cholesky (LLT) factorization and solver based on Cholmod. More...
class	COLAMDOrdering
class	ColPivHouseholderQR
	Householder rank-revealing QR decomposition of a matrix with column-pivoting. More...
class	CommaInitializer
	Helper class used by the comma initializer operator. More...
class	CompleteOrthogonalDecomposition
	Complete orthogonal decomposition (COD) of a matrix. More...
class	ComplexEigenSolver
	Computes eigenvalues and eigenvectors of general complex matrices. More...
class	ComplexSchur
	Performs a complex Schur decomposition of a real or complex square matrix. More...
class	Conjugate
class	ConjugateGradient
	A conjugate gradient solver for sparse (or dense) self-adjoint problems. More...
class	Cross
class	CwiseBinaryOp
	Generic expression where a coefficient-wise binary operator is applied to two expressions. More...
class	CwiseBinaryOpImpl
class	CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >
class	CwiseNullaryOp
	Generic expression of a matrix where all coefficients are defined by a functor. More...
class	CwiseTernaryOp
	Generic expression where a coefficient-wise ternary operator is applied to two expressions. More...
class	CwiseTernaryOpImpl
class	CwiseUnaryOp
	Generic expression where a coefficient-wise unary operator is applied to an expression. More...
class	CwiseUnaryOpImpl
class	CwiseUnaryView
	Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector. More...
class	CwiseUnaryViewImpl
class	CwiseUnaryViewImpl< ViewOp, MatrixType, Dense >
struct	Dense
class	DenseBase
	Base class for all dense matrices, vectors, and arrays. More...
class	DenseCoeffsBase
class	DenseCoeffsBase< Derived, DirectAccessors >
	Base class providing direct read-only coefficient access to matrices and arrays. More...
class	DenseCoeffsBase< Derived, DirectWriteAccessors >
	Base class providing direct read/write coefficient access to matrices and arrays. More...
class	DenseCoeffsBase< Derived, ReadOnlyAccessors >
	Base class providing read-only coefficient access to matrices and arrays. More...
class	DenseCoeffsBase< Derived, WriteAccessors >
	Base class providing read/write coefficient access to matrices and arrays. More...
struct	DenseShape
struct	DenseSparseProductReturnType
class	DenseStorage
class	DenseStorage< T, 0, _Rows, _Cols, _Options >
class	DenseStorage< T, 0, _Rows, Dynamic, _Options >
class	DenseStorage< T, 0, Dynamic, _Cols, _Options >
class	DenseStorage< T, 0, Dynamic, Dynamic, _Options >
class	DenseStorage< T, Dynamic, _Rows, Dynamic, _Options >
class	DenseStorage< T, Dynamic, Dynamic, _Cols, _Options >
class	DenseStorage< T, Dynamic, Dynamic, Dynamic, _Options >
class	DenseStorage< T, Size, _Rows, Dynamic, _Options >
class	DenseStorage< T, Size, Dynamic, _Cols, _Options >
class	DenseStorage< T, Size, Dynamic, Dynamic, _Options >
class	DenseTimeSparseProduct
class	Diagonal
	Expression of a diagonal/subdiagonal/superdiagonal in a matrix. More...
class	DiagonalBase
class	DiagonalMatrix
	Represents a diagonal matrix with its storage. More...
class	DiagonalPreconditioner
	A preconditioner based on the digonal entries. More...
class	DiagonalProduct
struct	DiagonalShape
class	DiagonalWrapper
	Expression of a diagonal matrix. More...
class	DynamicSparseMatrix
	A sparse matrix class designed for matrix assembly purpose. More...
class	EigenBase
class	EigenSolver
	Computes eigenvalues and eigenvectors of general matrices. More...
class	Flagged
class	ForceAlignedAccess
	Enforce aligned packet loads and stores regardless of what is requested. More...
class	FullPivHouseholderQR
	Householder rank-revealing QR decomposition of a matrix with full pivoting. More...
class	FullPivLU
	LU decomposition of a matrix with complete pivoting, and related features. More...
struct	general_product_to_triangular_selector
struct	general_product_to_triangular_selector< MatrixType, ProductType, UpLo, false >
struct	general_product_to_triangular_selector< MatrixType, ProductType, UpLo, true >
class	GeneralizedEigenSolver
	Computes the generalized eigenvalues and eigenvectors of a pair of general matrices. More...
class	GeneralizedSelfAdjointEigenSolver
	Computes eigenvalues and eigenvectors of the generalized selfadjoint eigen problem. More...
struct	GenericNumTraits
struct	half
class	HessenbergDecomposition
	Reduces a square matrix to Hessenberg form by an orthogonal similarity transformation. More...
class	Homogeneous
	Expression of one (or a set of) homogeneous vector(s) More...
struct	HomogeneousShape
class	HouseholderQR
	Householder QR decomposition of a matrix. More...
class	HouseholderSequence
	Sequence of Householder reflections acting on subspaces with decreasing size. More...
class	Hyperplane
	A hyperplane. More...
class	IdentityPreconditioner
	A naive preconditioner which approximates any matrix as the identity matrix. More...
class	IncompleteCholesky
	Modified Incomplete Cholesky with dual threshold. More...
class	IncompleteLUT
	Incomplete LU factorization with dual-threshold strategy. More...
class	InnerIterator
	An InnerIterator allows to loop over the element of any matrix expression. More...
class	InnerStride
	Convenience specialization of Stride to specify only an inner stride See class Map for some examples. More...
class	Inverse
	Expression of the inverse of another expression. More...
class	InverseImpl
class	InverseImpl< PermutationType, PermutationStorage >
class	IOFormat
	Stores a set of parameters controlling the way matrices are printed. More...
class	IterativeSolverBase
	Base class for linear iterative solvers. More...
class	JacobiRotation
	Rotation given by a cosine-sine pair. More...
class	JacobiSVD
	Two-sided Jacobi SVD decomposition of a rectangular matrix. More...
struct	LazyProductReturnType
class	LDLT
	Robust Cholesky decomposition of a matrix with pivoting. More...
class	LeastSquareDiagonalPreconditioner
	Jacobi preconditioner for LeastSquaresConjugateGradient. More...
class	LeastSquaresConjugateGradient
	A conjugate gradient solver for sparse (or dense) least-square problems. More...
class	LLT
	Standard Cholesky decomposition (LL^T) of a matrix and associated features. More...
class	Map
	A matrix or vector expression mapping an existing array of data. More...
class	Map< const Quaternion< _Scalar >, _Options >
	Quaternion expression mapping a constant memory buffer. More...
class	Map< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
class	Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >, _PacketAccess >
class	Map< Quaternion< _Scalar >, _Options >
	Expression of a quaternion from a memory buffer. More...
class	Map< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
	Specialization of class Map for SparseMatrix-like storage. More...
class	Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >, PacketAccess >
class	MapBase
class	MapBase< Derived, ReadOnlyAccessors >
	Base class for dense Map and Block expression with direct access. More...
class	MapBase< Derived, WriteAccessors >
	Base class for non-const dense Map and Block expression with direct access. More...
class	MappedSparseMatrix
	Sparse matrix. More...
class	Matrix
	The matrix class, also used for vectors and row-vectors. More...
class	MatrixBase
	Base class for all dense matrices, vectors, and expressions. More...
class	MatrixComplexPowerReturnValue
struct	MatrixExponentialReturnValue
class	MatrixFunctionReturnValue
class	MatrixLogarithmReturnValue
class	MatrixMarketIterator
	Iterator to browse matrices from a specified folder. More...
class	MatrixPowerReturnValue
class	MatrixSquareRootReturnValue
class	MatrixWrapper
	Expression of an array as a mathematical vector or matrix. More...
struct	MatrixXpr
class	MetisOrdering
class	NaturalOrdering
class	NestByValue
	Expression which must be nested by value. More...
class	NoAlias
	Pseudo expression providing an operator = assuming no aliasing. More...
class	NumTraits
	Holds information about the various numeric (i.e. scalar) types allowed by Eigen. More...
struct	NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct	NumTraits< double >
struct	NumTraits< Eigen::half >
struct	NumTraits< float >
struct	NumTraits< long double >
struct	NumTraits< std::complex< _Real > >
struct	NumTraits< std::string >
struct	NumTraits< void >
class	OuterStride
	Convenience specialization of Stride to specify only an outer stride See class Map for some examples. More...
class	ParametrizedLine
	A parametrized line. More...
class	PardisoImpl
class	PardisoLDLT
	A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library. More...
class	PardisoLLT
	A sparse direct Cholesky (LLT) factorization and solver based on the PARDISO library. More...
class	PardisoLU
	A sparse direct LU factorization and solver based on the PARDISO library. More...
class	PartialPivLU
	LU decomposition of a matrix with partial pivoting, and related features. More...
class	PartialReduxExpr
	Generic expression of a partially reduxed matrix. More...
class	PastixBase
class	PastixLDLT
	A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library. More...
class	PastixLLT
	A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library. More...
class	PastixLU
	Interface to the PaStix solver. More...
class	PermutationBase
	Base class for permutations. More...
class	PermutationMatrix
	Permutation matrix. More...
struct	PermutationShape
struct	PermutationStorage
class	PermutationWrapper
	Class to view a vector of integers as a permutation matrix. More...
class	PlainObjectBase
class	Product
	Expression of the product of two arbitrary matrices or vectors. More...
class	ProductImpl
class	ProductImpl< Lhs, Rhs, Option, Dense >
struct	ProductReturnType
class	Quaternion
	The quaternion class used to represent 3D orientations and rotations. More...
class	QuaternionBase
	Base class for quaternion expressions. More...
class	RandomSetter
	The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access. More...
class	RealQZ
	Performs a real QZ decomposition of a pair of square matrices. More...
class	RealSchur
	Performs a real Schur decomposition of a square matrix. More...
class	Ref
	A matrix or vector expression mapping an existing expression. More...
class	Ref< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
class	Ref< const SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType >
class	Ref< const TPlainObjectType, Options, StrideType >
class	Ref< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
	A sparse matrix expression referencing an existing sparse expression. More...
class	Ref< SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType >
	A sparse vector expression referencing an existing sparse vector expression. More...
class	RefBase
class	Replicate
	Expression of the multiple replication of a matrix or vector. More...
class	ReturnByValue
class	Reverse
	Expression of the reverse of a vector or matrix. More...
class	Rotation2D
	Represents a rotation/orientation in a 2 dimensional space. More...
class	RotationBase
	Common base class for compact rotation representations. More...
class	ScalarBinaryOpTraits
	Determines whether the given binary operation of two numeric types is allowed and what the scalar return type is. More...
struct	ScalarBinaryOpTraits< T, T, BinaryOp >
struct	ScalarBinaryOpTraits< T, typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, BinaryOp >
struct	ScalarBinaryOpTraits< T, void, BinaryOp >
struct	ScalarBinaryOpTraits< typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, T, BinaryOp >
struct	ScalarBinaryOpTraits< void, T, BinaryOp >
struct	ScalarBinaryOpTraits< void, void, BinaryOp >
class	Select
	Expression of a coefficient wise version of the C++ ternary operator ?: More...
struct	selfadjoint_product_selector
struct	selfadjoint_product_selector< MatrixType, OtherType, UpLo, false >
struct	selfadjoint_product_selector< MatrixType, OtherType, UpLo, true >
struct	selfadjoint_rank1_update
struct	selfadjoint_rank1_update< Scalar, Index, ColMajor, UpLo, ConjLhs, ConjRhs >
struct	selfadjoint_rank1_update< Scalar, Index, RowMajor, UpLo, ConjLhs, ConjRhs >
class	SelfAdjointEigenSolver
	Computes eigenvalues and eigenvectors of selfadjoint matrices. More...
struct	SelfAdjointShape
class	SelfAdjointView
	Expression of a selfadjoint matrix from a triangular part of a dense matrix. More...
class	SimplicialCholesky
class	SimplicialCholeskyBase
	A base class for direct sparse Cholesky factorizations. More...
class	SimplicialLDLT
	A direct sparse LDLT Cholesky factorizations without square root. More...
class	SimplicialLLT
	A direct sparse LLT Cholesky factorizations. More...
struct	SluMatrix
struct	SluMatrix.storage
union	SluMatrix.storage.__unnamed638__
struct	SluMatrixMapHelper
struct	SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > >
struct	SluMatrixMapHelper< SparseMatrixBase< Derived > >
class	Solve
	Pseudo expression representing a solving operation. More...
class	SolveImpl
class	SolveImpl< Decomposition, RhsType, Dense >
class	SolverBase
	A base class for matrix decomposition and solvers. More...
struct	SolverShape
struct	SolverStorage
class	SolveWithGuess
	Pseudo expression representing a solving operation. More...
struct	Sparse
class	SparseCompressedBase
	Common base class for sparse [compressed]-{row|column}-storage format. More...
class	SparseDenseOuterProduct
struct	SparseDenseProductReturnType
class	SparseDiagonalProduct
class	SparseLU
	Sparse supernodal LU factorization for general matrices. More...
struct	SparseLUMatrixLReturnType
struct	SparseLUMatrixUReturnType
class	SparseMapBase
class	SparseMapBase< Derived, ReadOnlyAccessors >
	Common base class for Map and Ref instance of sparse matrix and vector. More...
class	SparseMapBase< Derived, WriteAccessors >
	Common base class for writable Map and Ref instance of sparse matrix and vector. More...
class	SparseMatrix
	A versatible sparse matrix representation. More...
class	SparseMatrixBase
	Base class of any sparse matrices or sparse expressions. More...
class	SparseQR
	Sparse left-looking rank-revealing QR factorization. More...
struct	SparseQR_QProduct
struct	SparseQRMatrixQReturnType
struct	SparseQRMatrixQTransposeReturnType
class	SparseSelfAdjointView
	Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix. More...
struct	SparseShape
class	SparseSolverBase
	A base class for sparse solvers. More...
class	SparseSparseProduct
struct	SparseSparseProductReturnType
class	SparseSymmetricPermutationProduct
class	SparseTimeDenseProduct
class	SparseVector
	a sparse vector class More...
class	SparseView
	Expression of a dense or sparse matrix with zero or too small values removed. More...
class	SPQR
	Sparse QR factorization based on SuiteSparseQR library. More...
struct	SPQR_QProduct
struct	SPQRMatrixQReturnType
struct	SPQRMatrixQTransposeReturnType
struct	StdMapTraits
class	Stride
	Holds strides information for Map. More...
class	SuperLU
	A sparse direct LU factorization and solver based on the SuperLU library. More...
class	SuperLUBase
	The base class for the direct and incomplete LU factorization of SuperLU. More...
class	SVDBase
	Base class of SVD algorithms. More...
class	SwapWrapper
class	Transform
	Represents an homogeneous transformation in a N dimensional space. More...
class	Translation
	Represents a translation transformation. More...
class	Transpose
	Expression of the transpose of a matrix. More...
class	Transpose< TranspositionsBase< TranspositionsDerived > >
class	TransposeImpl
class	TransposeImpl< MatrixType, Dense >
class	TransposeImpl< MatrixType, Sparse >
class	Transpositions
	Represents a sequence of transpositions (row/column interchange) More...
class	TranspositionsBase
struct	TranspositionsShape
struct	TranspositionsStorage
class	TranspositionsWrapper
class	TriangularBase
	Base class for triangular part in a matrix. More...
struct	TriangularShape
class	TriangularView
	Expression of a triangular part in a matrix. More...
class	TriangularViewImpl
class	TriangularViewImpl< _MatrixType, _Mode, Dense >
	Base class for a triangular part in a dense matrix. More...
class	TriangularViewImpl< MatrixType, Mode, Sparse >
	Base class for a triangular part in a sparse matrix. More...
class	Tridiagonalization
	Tridiagonal decomposition of a selfadjoint matrix. More...
class	Triplet
	A small structure to hold a non zero as a triplet (i,j,value). More...
class	UmfPackLU
	A sparse LU factorization and solver based on UmfPack. More...
class	UniformScaling
class	VectorBlock
	Expression of a fixed-size or dynamic-size sub-vector. More...
class	VectorwiseOp
	Pseudo expression providing partial reduction operations. More...
class	WithFormat
	Pseudo expression providing matrix output with given format. More...

Typedefs
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE	DenseIndex
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE	Index
	The Index type as used for the API.
typedef std::complex< double >	dcomplex
typedef std::complex< float >	scomplex
typedef int	BlasIndex
typedef AngleAxis< float >	AngleAxisf
typedef AngleAxis< double >	AngleAxisd
typedef Quaternion< float >	Quaternionf
typedef Quaternion< double >	Quaterniond
typedef Map< Quaternion< float >, 0 >	QuaternionMapf
typedef Map< Quaternion< double >, 0 >	QuaternionMapd
typedef Map< Quaternion< float >, Aligned >	QuaternionMapAlignedf
typedef Map< Quaternion< double >, Aligned >	QuaternionMapAlignedd
typedef Rotation2D< float >	Rotation2Df
typedef Rotation2D< double >	Rotation2Dd
typedef DiagonalMatrix< float, 2 >	AlignedScaling2f
typedef DiagonalMatrix< double, 2 >	AlignedScaling2d
typedef DiagonalMatrix< float, 3 >	AlignedScaling3f
typedef DiagonalMatrix< double, 3 >	AlignedScaling3d
typedef Transform< float, 2, Isometry >	Isometry2f
typedef Transform< float, 3, Isometry >	Isometry3f
typedef Transform< double, 2, Isometry >	Isometry2d
typedef Transform< double, 3, Isometry >	Isometry3d
typedef Transform< float, 2, Affine >	Affine2f
typedef Transform< float, 3, Affine >	Affine3f
typedef Transform< double, 2, Affine >	Affine2d
typedef Transform< double, 3, Affine >	Affine3d
typedef Transform< float, 2, AffineCompact >	AffineCompact2f
typedef Transform< float, 3, AffineCompact >	AffineCompact3f
typedef Transform< double, 2, AffineCompact >	AffineCompact2d
typedef Transform< double, 3, AffineCompact >	AffineCompact3d
typedef Transform< float, 2, Projective >	Projective2f
typedef Transform< float, 3, Projective >	Projective3f
typedef Transform< double, 2, Projective >	Projective2d
typedef Transform< double, 3, Projective >	Projective3d
typedef Translation< float, 2 >	Translation2f
typedef Translation< double, 2 >	Translation2d
typedef Translation< float, 3 >	Translation3f
typedef Translation< double, 3 >	Translation3d

Enumerations
enum	CholmodMode { CholmodAuto , CholmodSimplicialLLt , CholmodSupernodalLLt , CholmodLDLt }
enum	{ Large = 2 , Small = 3 }
enum	{ DontAlignCols = 1 }
enum	{ StreamPrecision = -1 , FullPrecision = -2 }
enum	UpLoType {   Lower =0x1 , Upper =0x2 , UnitDiag =0x4 , ZeroDiag =0x8 ,   UnitLower =UnitDiag|Lower , UnitUpper =UnitDiag|Upper , StrictlyLower =ZeroDiag|Lower , StrictlyUpper =ZeroDiag|Upper ,   SelfAdjoint =0x10 , Symmetric =0x20 }
enum	AlignmentType {   Unaligned =0 , Aligned8 =8 , Aligned16 =16 , Aligned32 =32 ,   Aligned64 =64 , Aligned128 =128 , AlignedMask =255 , Aligned =16 ,   AlignedMax = Unaligned }
enum	CornerType { TopLeft , TopRight , BottomLeft , BottomRight }
enum	DirectionType { Vertical , Horizontal , BothDirections }
enum	TraversalType {   DefaultTraversal , LinearTraversal , InnerVectorizedTraversal , LinearVectorizedTraversal ,   SliceVectorizedTraversal , InvalidTraversal , AllAtOnceTraversal }
enum	UnrollingType { NoUnrolling , InnerUnrolling , CompleteUnrolling }
enum	SpecializedType { Specialized , BuiltIn }
enum	StorageOptions { ColMajor = 0 , RowMajor = 0x1 , AutoAlign = 0 , DontAlign = 0x2 }
enum	SideType { OnTheLeft = 1 , OnTheRight = 2 }
enum	NoChange_t { NoChange }
enum	Sequential_t { Sequential }
enum	Default_t { Default }
enum	AmbiVectorMode { IsDense = 0 , IsSparse }
enum	AccessorLevels { ReadOnlyAccessors , WriteAccessors , DirectAccessors , DirectWriteAccessors }
enum	DecompositionOptions {   Pivoting = 0x01 , NoPivoting = 0x02 , ComputeFullU = 0x04 , ComputeThinU = 0x08 ,   ComputeFullV = 0x10 , ComputeThinV = 0x20 , EigenvaluesOnly = 0x40 , ComputeEigenvectors = 0x80 ,   EigVecMask = EigenvaluesOnly | ComputeEigenvectors , Ax_lBx = 0x100 , ABx_lx = 0x200 , BAx_lx = 0x400 ,   GenEigMask = Ax_lBx | ABx_lx | BAx_lx }
enum	QRPreconditioners { NoQRPreconditioner , HouseholderQRPreconditioner , ColPivHouseholderQRPreconditioner , FullPivHouseholderQRPreconditioner }
enum	ComputationInfo { Success = 0 , NumericalIssue = 1 , NoConvergence = 2 , InvalidInput = 3 }
enum	TransformTraits { Isometry = 0x1 , Affine = 0x2 , AffineCompact = 0x10 | Affine , Projective = 0x20 }
enum	ProductImplType {   DefaultProduct =0 , LazyProduct , AliasFreeProduct , CoeffBasedProductMode ,   LazyCoeffBasedProductMode , OuterProduct , InnerProduct , GemvProduct ,   GemmProduct }
enum	Action { GetAction , SetAction }
enum	SimplicialCholeskyMode { SimplicialCholeskyLLT , SimplicialCholeskyLDLT }
enum	{ StandardCompressedFormat = 2 }
enum	{ SPD = 0x100 , NonSymmetric = 0x0 }

Functions
template<typename _Scalar , int _Options, typename _StorageIndex >
cholmod_sparse	viewAsCholmod (Ref< SparseMatrix< _Scalar, _Options, _StorageIndex > > mat)
template<typename _Scalar , int _Options, typename _Index >
const cholmod_sparse	viewAsCholmod (const SparseMatrix< _Scalar, _Options, _Index > &mat)
template<typename _Scalar , int _Options, typename _Index >
const cholmod_sparse	viewAsCholmod (const SparseVector< _Scalar, _Options, _Index > &mat)
template<typename _Scalar , int _Options, typename _Index , unsigned int UpLo>
cholmod_sparse	viewAsCholmod (const SparseSelfAdjointView< const SparseMatrix< _Scalar, _Options, _Index >, UpLo > &mat)
template<typename Derived >
cholmod_dense	viewAsCholmod (MatrixBase< Derived > &mat)
template<typename Scalar , int Flags, typename StorageIndex >
MappedSparseMatrix< Scalar, Flags, StorageIndex >	viewAsEigen (cholmod_sparse &cm)
template<typename Derived >
const	EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE (Derived, typename Derived::Scalar, pow) pow(const Eigen
template<typename Derived >
const	EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE (typename Derived::Scalar, Derived, pow) pow(const typename Derived
template<typename MatrixDerived , typename PermutationDerived >
EIGEN_DEVICE_FUNC const Product< MatrixDerived, PermutationDerived, AliasFreeProduct >	operator* (const MatrixBase< MatrixDerived > &matrix, const PermutationBase< PermutationDerived > &permutation)
template<typename PermutationDerived , typename MatrixDerived >
EIGEN_DEVICE_FUNC const Product< PermutationDerived, MatrixDerived, AliasFreeProduct >	operator* (const PermutationBase< PermutationDerived > &permutation, const MatrixBase< MatrixDerived > &matrix)
std::ptrdiff_t	l1CacheSize ()
std::ptrdiff_t	l2CacheSize ()
std::ptrdiff_t	l3CacheSize ()
void	setCpuCacheSizes (std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
void	initParallel ()
int	nbThreads ()
void	setNbThreads (int v)
template<typename MatrixDerived , typename TranspositionsDerived >
EIGEN_DEVICE_FUNC const Product< MatrixDerived, TranspositionsDerived, AliasFreeProduct >	operator* (const MatrixBase< MatrixDerived > &matrix, const TranspositionsBase< TranspositionsDerived > &transpositions)
template<typename TranspositionsDerived , typename MatrixDerived >
EIGEN_DEVICE_FUNC const Product< TranspositionsDerived, MatrixDerived, AliasFreeProduct >	operator* (const TranspositionsBase< TranspositionsDerived > &transpositions, const MatrixBase< MatrixDerived > &matrix)
UniformScaling< float >	Scaling (float s)
UniformScaling< double >	Scaling (double s)
template<typename RealScalar >
UniformScaling< std::complex< RealScalar > >	Scaling (const std::complex< RealScalar > &s)
template<typename Scalar >
DiagonalMatrix< Scalar, 2 >	Scaling (const Scalar &sx, const Scalar &sy)
template<typename Scalar >
DiagonalMatrix< Scalar, 3 >	Scaling (const Scalar &sx, const Scalar &sy, const Scalar &sz)
template<typename Derived >
const DiagonalWrapper< const Derived >	Scaling (const MatrixBase< Derived > &coeffs)
template<typename Derived , typename OtherDerived >
internal::umeyama_transform_matrix_type< Derived, OtherDerived >::type	umeyama (const MatrixBase< Derived > &src, const MatrixBase< OtherDerived > &dst, bool with_scaling=true)
	Returns the transformation between two point sets.
template<typename OtherDerived , typename VectorsType , typename CoeffsType , int Side>
internal::matrix_type_times_scalar_type< typenameVectorsType::Scalar, OtherDerived >::Type	operator* (const MatrixBase< OtherDerived > &other, const HouseholderSequence< VectorsType, CoeffsType, Side > &h)
	Computes the product of a matrix with a Householder sequence.
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType >	householderSequence (const VectorsType &v, const CoeffsType &h)
	Convenience function for constructing a Householder sequence.
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType, OnTheRight >	rightHouseholderSequence (const VectorsType &v, const CoeffsType &h)
	Convenience function for constructing a Householder sequence.
template<typename DenseDerived , typename SparseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator+ (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
template<typename SparseDerived , typename DenseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator+ (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
template<typename DenseDerived , typename SparseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator- (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
template<typename SparseDerived , typename DenseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator- (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
template<typename SparseDerived , typename PermDerived >
const Product< SparseDerived, PermDerived, AliasFreeProduct >	operator* (const SparseMatrixBase< SparseDerived > &matrix, const PermutationBase< PermDerived > &perm)
template<typename SparseDerived , typename PermDerived >
const Product< PermDerived, SparseDerived, AliasFreeProduct >	operator* (const PermutationBase< PermDerived > &perm, const SparseMatrixBase< SparseDerived > &matrix)
template<typename SparseDerived , typename PermutationType >
const Product< SparseDerived, Inverse< PermutationType >, AliasFreeProduct >	operator* (const SparseMatrixBase< SparseDerived > &matrix, const InverseImpl< PermutationType, PermutationStorage > &tperm)
template<typename SparseDerived , typename PermutationType >
const Product< Inverse< PermutationType >, SparseDerived, AliasFreeProduct >	operator* (const InverseImpl< PermutationType, PermutationStorage > &tperm, const SparseMatrixBase< SparseDerived > &matrix)
void	umfpack_defaults (double control[UMFPACK_CONTROL], double)
void	umfpack_defaults (double control[UMFPACK_CONTROL], std::complex< double >)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex< double >)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, double)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, std::complex< double >)
void	umfpack_report_control (double control[UMFPACK_CONTROL], double)
void	umfpack_report_control (double control[UMFPACK_CONTROL], std::complex< double >)
void	umfpack_free_numeric (void **Numeric, double)
void	umfpack_free_numeric (void **Numeric, std::complex< double >)
void	umfpack_free_symbolic (void **Symbolic, double)
void	umfpack_free_symbolic (void **Symbolic, std::complex< double >)
int	umfpack_symbolic (int n_row, int n_col, const int Ap[], const int Ai[], const double Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_symbolic (int n_row, int n_col, const int Ap[], const int Ai[], const std::complex< double > Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_numeric (const int Ap[], const int Ai[], const double Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_numeric (const int Ap[], const int Ai[], const std::complex< double > Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_solve (int sys, const int Ap[], const int Ai[], const double Ax[], double X[], const double B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_solve (int sys, const int Ap[], const int Ai[], const std::complex< double > Ax[], std::complex< double > X[], const std::complex< double > B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_get_lunz (int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, double)
int	umfpack_get_lunz (int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, std::complex< double >)
int	umfpack_get_numeric (int Lp[], int Lj[], double Lx[], int Up[], int Ui[], double Ux[], int P[], int Q[], double Dx[], int *do_recip, double Rs[], void *Numeric)
int	umfpack_get_numeric (int Lp[], int Lj[], std::complex< double > Lx[], int Up[], int Ui[], std::complex< double > Ux[], int P[], int Q[], std::complex< double > Dx[], int *do_recip, double Rs[], void *Numeric)
int	umfpack_get_determinant (double *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO])
int	umfpack_get_determinant (std::complex< double > *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO])
bool	getMarketHeader (const std::string &filename, int &sym, bool &iscomplex, bool &isvector)
template<typename SparseMatrixType >
bool	loadMarket (SparseMatrixType &mat, const std::string &filename)
template<typename VectorType >
bool	loadMarketVector (VectorType &vec, const std::string &filename)
template<typename SparseMatrixType >
bool	saveMarket (const SparseMatrixType &mat, const std::string &filename, int sym=0)
template<typename VectorType >
bool	saveMarketVector (const VectorType &vec, const std::string &filename)
template<class T , int N, int M>
T *	begin (Slic3r::Mat< N, M, T > &mat)
template<class T , int N, int M>
T *	end (Slic3r::Mat< N, M, T > &mat)
template<class T , int N, int M>
const T *	begin (const Slic3r::Mat< N, M, T > &mat)
template<class T , int N, int M>
const T *	end (const Slic3r::Mat< N, M, T > &mat)

Variables
const int	Dynamic = -1
const int	DynamicIndex = 0xffffff
const int	Infinity = -1
const int	HugeCost = 10000
const unsigned int	RowMajorBit = 0x1
const unsigned int	EvalBeforeNestingBit = 0x2
EIGEN_DEPRECATED const unsigned int	EvalBeforeAssigningBit = 0x4
const unsigned int	PacketAccessBit = 0x8
const unsigned int	ActualPacketAccessBit = 0x0
const unsigned int	LinearAccessBit = 0x10
const unsigned int	LvalueBit = 0x20
const unsigned int	DirectAccessBit = 0x40
EIGEN_DEPRECATED const unsigned int	AlignedBit = 0x80
const unsigned int	NestByRefBit = 0x100
const unsigned int	NoPreferredStorageOrderBit = 0x200
const unsigned int	CompressedAccessBit = 0x400
const unsigned int	HereditaryBits
const int	CoherentAccessPattern = 0x1
const int	InnerRandomAccessPattern = 0x2 | CoherentAccessPattern
const int	OuterRandomAccessPattern = 0x4 | CoherentAccessPattern
const int	RandomAccessPattern = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern

---

Class Documentation

Eigen::ArrayXpr

struct Eigen::ArrayXpr

The type used to identify an array expression

Eigen::Conjugate

class Eigen::Conjugate

template<typename MatrixType>
class Eigen::Conjugate< MatrixType >

Eigen::Cross

class Eigen::Cross

template<typename Lhs, typename Rhs>
class Eigen::Cross< Lhs, Rhs >

Eigen::Dense

struct Eigen::Dense

The type used to identify a dense storage.

Eigen::DenseSparseProductReturnType

struct Eigen::DenseSparseProductReturnType

template<typename Lhs, typename Rhs, int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)>
struct Eigen::DenseSparseProductReturnType< Lhs, Rhs, InnerSize >

Eigen::DenseTimeSparseProduct

class Eigen::DenseTimeSparseProduct

template<typename Lhs, typename Rhs>
class Eigen::DenseTimeSparseProduct< Lhs, Rhs >

Eigen::DiagonalProduct

class Eigen::DiagonalProduct

template<typename MatrixType, typename DiagonalType, int ProductOrder>
class Eigen::DiagonalProduct< MatrixType, DiagonalType, ProductOrder >

Eigen::Flagged

class Eigen::Flagged

template<typename ExpressionType, unsigned int Added, unsigned int Removed>
class Eigen::Flagged< ExpressionType, Added, Removed >

Eigen::general_product_to_triangular_selector

struct Eigen::general_product_to_triangular_selector

template<typename MatrixType, typename ProductType, int UpLo, bool IsOuterProduct>
struct Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, IsOuterProduct >

Eigen::LazyProductReturnType

struct Eigen::LazyProductReturnType

template<typename Lhs, typename Rhs>
struct Eigen::LazyProductReturnType< Lhs, Rhs >

Eigen::MatrixComplexPowerReturnValue

class Eigen::MatrixComplexPowerReturnValue

template<typename Derived>
class Eigen::MatrixComplexPowerReturnValue< Derived >

Eigen::MatrixExponentialReturnValue

struct Eigen::MatrixExponentialReturnValue

template<typename Derived>
struct Eigen::MatrixExponentialReturnValue< Derived >

Eigen::MatrixFunctionReturnValue

class Eigen::MatrixFunctionReturnValue

template<typename Derived>
class Eigen::MatrixFunctionReturnValue< Derived >

Eigen::MatrixLogarithmReturnValue

class Eigen::MatrixLogarithmReturnValue

template<typename Derived>
class Eigen::MatrixLogarithmReturnValue< Derived >

Eigen::MatrixPowerReturnValue

class Eigen::MatrixPowerReturnValue

template<typename Derived>
class Eigen::MatrixPowerReturnValue< Derived >

Eigen::MatrixSquareRootReturnValue

class Eigen::MatrixSquareRootReturnValue

template<typename Derived>
class Eigen::MatrixSquareRootReturnValue< Derived >

Eigen::MatrixXpr

struct Eigen::MatrixXpr

The type used to identify a matrix expression

Eigen::NumTraits< void >

struct Eigen::NumTraits< void >

Eigen::PermutationStorage

struct Eigen::PermutationStorage

The type used to identify a permutation storage.

Eigen::ProductReturnType

struct Eigen::ProductReturnType

template<typename Lhs, typename Rhs, int ProductType = internal::product_type<Lhs,Rhs>::value>
struct Eigen::ProductReturnType< Lhs, Rhs, ProductType >

Eigen::ScalarBinaryOpTraits< T, T, BinaryOp >

struct Eigen::ScalarBinaryOpTraits< T, T, BinaryOp >

template<typename T, typename BinaryOp>
struct Eigen::ScalarBinaryOpTraits< T, T, BinaryOp >

Class Members
typedef T	ReturnType

Eigen::ScalarBinaryOpTraits< T, typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, BinaryOp >

struct Eigen::ScalarBinaryOpTraits< T, typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, BinaryOp >

template<typename T, typename BinaryOp>
struct Eigen::ScalarBinaryOpTraits< T, typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, BinaryOp >

Class Members
typedef T	ReturnType

Eigen::ScalarBinaryOpTraits< T, void, BinaryOp >

struct Eigen::ScalarBinaryOpTraits< T, void, BinaryOp >

template<typename T, typename BinaryOp>
struct Eigen::ScalarBinaryOpTraits< T, void, BinaryOp >

Class Members
typedef T	ReturnType

Eigen::ScalarBinaryOpTraits< typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, T, BinaryOp >

struct Eigen::ScalarBinaryOpTraits< typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, T, BinaryOp >

template<typename T, typename BinaryOp>
struct Eigen::ScalarBinaryOpTraits< typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, T, BinaryOp >

Class Members
typedef T	ReturnType

Eigen::ScalarBinaryOpTraits< void, T, BinaryOp >

struct Eigen::ScalarBinaryOpTraits< void, T, BinaryOp >

template<typename T, typename BinaryOp>
struct Eigen::ScalarBinaryOpTraits< void, T, BinaryOp >

Class Members
typedef T	ReturnType

Eigen::ScalarBinaryOpTraits< void, void, BinaryOp >

struct Eigen::ScalarBinaryOpTraits< void, void, BinaryOp >

template<typename BinaryOp>
struct Eigen::ScalarBinaryOpTraits< void, void, BinaryOp >

Class Members
typedef void	ReturnType

Eigen::selfadjoint_product_selector

struct Eigen::selfadjoint_product_selector

template<typename MatrixType, typename OtherType, int UpLo, bool OtherIsVector = OtherType::IsVectorAtCompileTime>
struct Eigen::selfadjoint_product_selector< MatrixType, OtherType, UpLo, OtherIsVector >

Eigen::selfadjoint_rank1_update

struct Eigen::selfadjoint_rank1_update

template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjLhs, bool ConjRhs>
struct Eigen::selfadjoint_rank1_update< Scalar, Index, StorageOrder, UpLo, ConjLhs, ConjRhs >

Eigen::SluMatrix.storage

struct Eigen::SluMatrix.storage

Class Members
union SluMatrix.storage.__unnamed638__	__unnamed__
int *	innerInd
int *	outerInd
void *	values

Eigen::SluMatrix.storage.__unnamed638__

union Eigen::SluMatrix.storage.__unnamed638__

Class Members
int	lda
int	nnz

Eigen::SluMatrixMapHelper

struct Eigen::SluMatrixMapHelper

template<typename MatrixType>
struct Eigen::SluMatrixMapHelper< MatrixType >

Eigen::SolverStorage

struct Eigen::SolverStorage

The type used to identify a general solver (factored) storage.

Eigen::Sparse

struct Eigen::Sparse

The type used to identify a general sparse storage.

Eigen::SparseDenseOuterProduct

class Eigen::SparseDenseOuterProduct

template<typename Lhs, typename Rhs, bool Transpose>
class Eigen::SparseDenseOuterProduct< Lhs, Rhs, Transpose >

Eigen::SparseDenseProductReturnType

struct Eigen::SparseDenseProductReturnType

template<typename Lhs, typename Rhs, int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)>
struct Eigen::SparseDenseProductReturnType< Lhs, Rhs, InnerSize >

Eigen::SparseDiagonalProduct

class Eigen::SparseDiagonalProduct

template<typename Lhs, typename Rhs>
class Eigen::SparseDiagonalProduct< Lhs, Rhs >

Eigen::SparseSparseProduct

class Eigen::SparseSparseProduct

template<typename Lhs, typename Rhs>
class Eigen::SparseSparseProduct< Lhs, Rhs >

Eigen::SparseSparseProductReturnType

struct Eigen::SparseSparseProductReturnType

template<typename Lhs, typename Rhs>
struct Eigen::SparseSparseProductReturnType< Lhs, Rhs >

Eigen::SparseTimeDenseProduct

class Eigen::SparseTimeDenseProduct

template<typename Lhs, typename Rhs>
class Eigen::SparseTimeDenseProduct< Lhs, Rhs >

Eigen::SwapWrapper

class Eigen::SwapWrapper

template<typename ExpressionType>
class Eigen::SwapWrapper< ExpressionType >

Eigen::TranspositionsStorage

struct Eigen::TranspositionsStorage

The type used to identify a permutation storage.

Eigen::TriangularViewImpl

class Eigen::TriangularViewImpl

template<typename _MatrixType, unsigned int _Mode, typename StorageKind>
class Eigen::TriangularViewImpl< _MatrixType, _Mode, StorageKind >

Inheritance diagram for Eigen::TriangularViewImpl< _MatrixType, _Mode, StorageKind >:

Typedef Documentation

AlignedScaling2d

typedef DiagonalMatrix<double,2> Eigen::AlignedScaling2d

AlignedScaling2f

typedef DiagonalMatrix<float, 2> Eigen::AlignedScaling2f

AlignedScaling3d

typedef DiagonalMatrix<double,3> Eigen::AlignedScaling3d

AlignedScaling3f

typedef DiagonalMatrix<float, 3> Eigen::AlignedScaling3f

BlasIndex

typedef int Eigen::BlasIndex

dcomplex

typedef std::complex<double> Eigen::dcomplex

DenseIndex

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Eigen::DenseIndex

Index

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Eigen::Index

The Index type as used for the API.

To change this, #define the preprocessor symbol EIGEN_DEFAULT_DENSE_INDEX_TYPE.

See also

\blank TopicPreprocessorDirectives, StorageIndex.

scomplex

typedef std::complex<float> Eigen::scomplex

Translation2d

typedef Translation<double,2> Eigen::Translation2d

Translation2f

typedef Translation<float, 2> Eigen::Translation2f

Translation3d

typedef Translation<double,3> Eigen::Translation3d

Translation3f

typedef Translation<float, 3> Eigen::Translation3f

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
DontAlignCols

{ DontAlignCols = 1 };

anonymous enum

anonymous enum

Enumerator
StreamPrecision
FullPrecision

     { StreamPrecision = -1,
       FullPrecision = -2 };

anonymous enum

anonymous enum

Enumerator
Large
Small

     {
  Large = 2,
  Small = 3
};

anonymous enum

anonymous enum

Enumerator
StandardCompressedFormat	used by Ref<SparseMatrix> to specify whether the input storage must be in standard compressed form

     {
  StandardCompressedFormat = 2 
};

anonymous enum

anonymous enum

Enumerator
SPD
NonSymmetric

     {
  SPD = 0x100,
  NonSymmetric = 0x0
}; 

Action

enum Eigen::Action

Enumerator
GetAction
SetAction

{GetAction, SetAction};

AmbiVectorMode

enum Eigen::AmbiVectorMode

Enumerator
IsDense
IsSparse

                    {
  IsDense         = 0,
  IsSparse
};

CholmodMode

enum Eigen::CholmodMode

Enumerator
CholmodAuto
CholmodSimplicialLLt
CholmodSupernodalLLt
CholmodLDLt

                 {
  CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt
};

Default_t

enum Eigen::Default_t

Enumerator
Default

{ Default };

NoChange_t

enum Eigen::NoChange_t

Enumerator
NoChange

{ NoChange };

ProductImplType

enum Eigen::ProductImplType

Enumerator
DefaultProduct
LazyProduct
AliasFreeProduct
CoeffBasedProductMode
LazyCoeffBasedProductMode
OuterProduct
InnerProduct
GemvProduct
GemmProduct

{ DefaultProduct=0, LazyProduct, AliasFreeProduct, CoeffBasedProductMode, LazyCoeffBasedProductMode, OuterProduct, InnerProduct, GemvProduct, GemmProduct };

Sequential_t

enum Eigen::Sequential_t

Enumerator
Sequential

{ Sequential };

SimplicialCholeskyMode

enum Eigen::SimplicialCholeskyMode

Enumerator
SimplicialCholeskyLLT
SimplicialCholeskyLDLT

                            {
  SimplicialCholeskyLLT,
  SimplicialCholeskyLDLT
};

SpecializedType

enum Eigen::SpecializedType

Enumerator
Specialized
BuiltIn

                     {
  Specialized,
  BuiltIn
};

TraversalType

enum Eigen::TraversalType

Enumerator
DefaultTraversal
LinearTraversal
InnerVectorizedTraversal
LinearVectorizedTraversal
SliceVectorizedTraversal
InvalidTraversal
AllAtOnceTraversal

                   {
  DefaultTraversal,
  LinearTraversal,
  InnerVectorizedTraversal,
  LinearVectorizedTraversal,
  SliceVectorizedTraversal,
  InvalidTraversal,
  AllAtOnceTraversal
};

UnrollingType

enum Eigen::UnrollingType

Enumerator
NoUnrolling
InnerUnrolling
CompleteUnrolling

                   {
  NoUnrolling,
  InnerUnrolling,
  CompleteUnrolling
};

Function Documentation

begin() [1/2]

template<class T , int N, int M>

const T * Eigen::begin

(

const Slic3r::Mat< N, M, T > &

mat

)

{ return mat.data(); }

References Eigen::PlainObjectBase< Derived >::data().

Here is the call graph for this function:

begin() [2/2]

template<class T , int N, int M>

T * Eigen::begin

(

Slic3r::Mat< N, M, T > &

mat

)

{ return mat.data(); }

References Eigen::PlainObjectBase< Derived >::data().

Referenced by Eigen::RandomSetter< SparseMatrixType, MapTraits, OuterPacketBits >::~RandomSetter(), Eigen::IncompleteCholesky< Scalar, _UpLo, _OrderingType >::factorize(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setFromTriplets().

Here is the call graph for this function:

Here is the caller graph for this function:

EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE()

template<typename Derived >

const Eigen::EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE ( Derived  , typename Derived::Scalar  , pow    ) const

inline

                                                                                {
    return x.derived().pow(exponent);
  }

EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE()

template<typename Derived >

const Eigen::EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE ( typename Derived::Scalar  , Derived  , pow    ) const

inline

  {
    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename Derived::Scalar,Derived,pow)(
      typename internal::plain_constant_type<Derived,typename Derived::Scalar>::type(exponents.rows(), exponents.cols(), x), exponents.derived() );
  }

References EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE.

end() [1/2]

template<class T , int N, int M>

const T * Eigen::end

(

const Slic3r::Mat< N, M, T > &

mat

)

{ return mat.data() + N * M; }

References Eigen::PlainObjectBase< Derived >::data().

Here is the call graph for this function:

end() [2/2]

template<class T , int N, int M>

T * Eigen::end

(

Slic3r::Mat< N, M, T > &

mat

)

{ return mat.data() + N * M; }

References Eigen::PlainObjectBase< Derived >::data().

Referenced by Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >::PermutationMatrix(), Eigen::RandomSetter< SparseMatrixType, MapTraits, OuterPacketBits >::~RandomSetter(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheLeft(), Eigen::internal::CompressedStorage< _Scalar, _StorageIndex >::atInRange(), Eigen::SparseMapBase< Derived, ReadOnlyAccessors >::coeff(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::coeff(), Eigen::SparseMapBase< Derived, WriteAccessors >::coeffRef(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::coeffRef(), Eigen::internal::computeFromTridiagonal_impl(), Eigen::internal::evaluator< SparseCompressedBase< Derived > >::find(), Eigen::BlockImpl< XprType, BlockRows, BlockCols, true, Sparse >::nonZeros(), Eigen::internal::sparse_matrix_block_impl< SparseMatrixType, BlockRows, BlockCols >::operator=(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::prune(), Eigen::internal::smart_copy_helper< T, true >::run(), Eigen::internal::smart_copy_helper< T, false >::run(), Eigen::internal::smart_memmove_helper< T, true >::run(), Eigen::internal::smart_memmove_helper< T, false >::run(), Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, true, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, Version >::run(), Eigen::internal::general_matrix_vector_product< Index, LhsScalar, LhsMapper, RowMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >::run(), Eigen::internal::general_matrix_vector_product< Index, LhsScalar, LhsMapper, ColMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs, Version >::run(), Eigen::internal::triangular_solve_matrix< Scalar, Index, OnTheLeft, Mode, Conjugate, TriStorageOrder, ColMajor >::run(), Eigen::internal::CompressedStorage< _Scalar, _StorageIndex >::searchLowerIndex(), Eigen::internal::AmbiVector< _Scalar, _StorageIndex >::setBounds(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setFromTriplets(), Eigen::internal::smart_copy(), Eigen::internal::smart_memmove(), and Eigen::internal::tridiagonal_qr_step().

Here is the call graph for this function:

Here is the caller graph for this function:

getMarketHeader()

bool Eigen::getMarketHeader ( const std::string &  filename, int &  sym, bool &  iscomplex, bool &  isvector  )

inline

{
  sym = 0; 
  iscomplex = false;
  isvector = false;
  std::ifstream in(filename.c_str(),std::ios::in);
  if(!in)
    return false;
  
  std::string line; 
  // The matrix header is always the first line in the file 
  std::getline(in, line); eigen_assert(in.good());
  
  std::stringstream fmtline(line); 
  std::string substr[5];
  fmtline>> substr[0] >> substr[1] >> substr[2] >> substr[3] >> substr[4];
  if(substr[2].compare("array") == 0) isvector = true;
  if(substr[3].compare("complex") == 0) iscomplex = true;
  if(substr[4].compare("symmetric") == 0) sym = Symmetric;
  else if (substr[4].compare("Hermitian") == 0) sym = SelfAdjoint;
  
  return true;
}

References eigen_assert, SelfAdjoint, and Symmetric.

Referenced by Eigen::MatrixMarketIterator< Scalar >::Getnextvalidmatrix().

Here is the caller graph for this function:

householderSequence()

template<typename VectorsType , typename CoeffsType >

HouseholderSequence< VectorsType, CoeffsType > Eigen::householderSequence	(	const VectorsType &	v,
		const CoeffsType &	h
	)

Convenience function for constructing a Householder sequence.

\

Returns

A HouseholderSequence constructed from the specified arguments.

{
  return HouseholderSequence<VectorsType,CoeffsType,OnTheLeft>(v, h);
}

Referenced by Eigen::ColPivHouseholderQR< _MatrixType >::_solve_impl(), and Eigen::CompleteOrthogonalDecomposition< _MatrixType >::_solve_impl().

Here is the caller graph for this function:

initParallel()

void Eigen::initParallel ( )

inline

Must be call first when calling Eigen from multiple threads

{
  int nbt;
  internal::manage_multi_threading(GetAction, &nbt);
  std::ptrdiff_t l1, l2, l3;
  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
}

References GetAction, Eigen::internal::manage_caching_sizes(), and Eigen::internal::manage_multi_threading().

Referenced by Eigen::internal::parallelize_gemm(), and Eigen::internal::sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar, RowMajor, true >::run().

Here is the call graph for this function:

Here is the caller graph for this function:

l1CacheSize()

std::ptrdiff_t Eigen::l1CacheSize ( )

inline

Returns

the currently set level 1 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.

See also

setCpuCacheSize

{
  std::ptrdiff_t l1, l2, l3;
  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
  return l1;
}

References GetAction, and Eigen::internal::manage_caching_sizes().

Referenced by Eigen::internal::CacheSizes::CacheSizes().

Here is the call graph for this function:

Here is the caller graph for this function:

l2CacheSize()

std::ptrdiff_t Eigen::l2CacheSize ( )

inline

Returns

the currently set level 2 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.

See also

setCpuCacheSize

{
  std::ptrdiff_t l1, l2, l3;
  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
  return l2;
}

References GetAction, and Eigen::internal::manage_caching_sizes().

Referenced by Eigen::internal::CacheSizes::CacheSizes().

Here is the call graph for this function:

Here is the caller graph for this function:

l3CacheSize()

std::ptrdiff_t Eigen::l3CacheSize ( )

inline

Returns

the currently set level 3 cpu cache size (in bytes) used to estimate the ideal blocking size paramete\ rs.

See also

setCpuCacheSize

{
  std::ptrdiff_t l1, l2, l3;
  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
  return l3;
}

References GetAction, and Eigen::internal::manage_caching_sizes().

Referenced by Eigen::internal::CacheSizes::CacheSizes().

Here is the call graph for this function:

Here is the caller graph for this function:

loadMarket()

template<typename SparseMatrixType >

bool Eigen::loadMarket	(	SparseMatrixType &	mat,
		const std::string &	filename
	)

{
  typedef typename SparseMatrixType::Scalar Scalar;
  typedef typename SparseMatrixType::StorageIndex StorageIndex;
  std::ifstream input(filename.c_str(),std::ios::in);
  if(!input)
    return false;
  
  const int maxBuffersize = 2048;
  char buffer[maxBuffersize];
  
  bool readsizes = false;
 
  typedef Triplet<Scalar,StorageIndex> T;
  std::vector<T> elements;
  
  StorageIndex M(-1), N(-1), NNZ(-1);
  StorageIndex count = 0;
  while(input.getline(buffer, maxBuffersize))
  {
    // skip comments   
    //NOTE An appropriate test should be done on the header to get the  symmetry
    if(buffer[0]=='%')
      continue;
    
    std::stringstream line(buffer);
    
    if(!readsizes)
    {
      line >> M >> N >> NNZ;
      if(M > 0 && N > 0 && NNZ > 0) 
      {
        readsizes = true;
        //std::cout << "sizes: " << M << "," << N << "," << NNZ << "\n";
        mat.resize(M,N);
        mat.reserve(NNZ);
      }
    }
    else
    { 
      StorageIndex i(-1), j(-1);
      Scalar value; 
      if( internal::GetMarketLine(line, M, N, i, j, value) ) 
      {
        ++ count;
        elements.push_back(T(i,j,value));
      }
      else 
        std::cerr << "Invalid read: " << i << "," << j << "\n";        
    }
  }
  mat.setFromTriplets(elements.begin(), elements.end());
  if(count!=NNZ)
    std::cerr << count << "!=" << NNZ << "\n";
  
  input.close();
  return true;
}

References Eigen::internal::GetMarketLine(), and input().

Referenced by Eigen::MatrixMarketIterator< Scalar >::matrix().

Here is the call graph for this function:

Here is the caller graph for this function:

loadMarketVector()

template<typename VectorType >

bool Eigen::loadMarketVector	(	VectorType &	vec,
		const std::string &	filename
	)

{
   typedef typename VectorType::Scalar Scalar;
  std::ifstream in(filename.c_str(), std::ios::in);
  if(!in)
    return false;
  
  std::string line; 
  int n(0), col(0); 
  do 
  { // Skip comments
    std::getline(in, line); eigen_assert(in.good());
  } while (line[0] == '%');
  std::istringstream newline(line);
  newline  >> n >> col; 
  eigen_assert(n>0 && col>0);
  vec.resize(n);
  int i = 0; 
  Scalar value; 
  while ( std::getline(in, line) && (i < n) ){
    internal::GetVectorElt(line, value); 
    vec(i++) = value; 
  }
  in.close();
  if (i!=n){
    std::cerr<< "Unable to read all elements from file " << filename << "\n";
    return false;
  }
  return true;
}

References col(), eigen_assert, and Eigen::internal::GetVectorElt().

Referenced by Eigen::MatrixMarketIterator< Scalar >::refX(), and Eigen::MatrixMarketIterator< Scalar >::rhs().

Here is the call graph for this function:

Here is the caller graph for this function:

nbThreads()

int Eigen::nbThreads ( )

inline

Returns

the max number of threads reserved for Eigen

See also

setNbThreads

{
  int ret;
  internal::manage_multi_threading(GetAction, &ret);
  return ret;
}

References GetAction, and Eigen::internal::manage_multi_threading().

Referenced by Eigen::internal::parallelize_gemm(), and Eigen::internal::sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar, RowMajor, true >::run().

Here is the call graph for this function:

Here is the caller graph for this function:

operator*() [1/9]

template<typename SparseDerived , typename PermutationType >

const Product< Inverse< PermutationType >, SparseDerived, AliasFreeProduct > Eigen::operator* ( const InverseImpl< PermutationType, PermutationStorage > &  tperm, const SparseMatrixBase< SparseDerived > &  matrix  )

inline

Returns

the matrix with the inverse permutation applied to the rows.

{
  return Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>(tperm.derived(), matrix.derived());
}

References AliasFreeProduct, and Eigen::SparseMatrixBase< Derived >::derived().

Here is the call graph for this function:

operator*() [2/9]

template<typename MatrixDerived , typename PermutationDerived >

EIGEN_DEVICE_FUNC const Product< MatrixDerived, PermutationDerived, AliasFreeProduct > Eigen::operator*	(	const MatrixBase< MatrixDerived > &	matrix,
		const PermutationBase< PermutationDerived > &	permutation
	)

Returns

the matrix with the permutation applied to the columns.

{
  return Product<MatrixDerived, PermutationDerived, AliasFreeProduct>
            (matrix.derived(), permutation.derived());
}

References Eigen::PermutationBase< Derived >::derived().

Here is the call graph for this function:

operator*() [3/9]

template<typename MatrixDerived , typename TranspositionsDerived >

EIGEN_DEVICE_FUNC const Product< MatrixDerived, TranspositionsDerived, AliasFreeProduct > Eigen::operator*	(	const MatrixBase< MatrixDerived > &	matrix,
		const TranspositionsBase< TranspositionsDerived > &	transpositions
	)

Returns

the matrix with the transpositions applied to the columns.

{
  return Product<MatrixDerived, TranspositionsDerived, AliasFreeProduct>
            (matrix.derived(), transpositions.derived());
}

References Eigen::TranspositionsBase< Derived >::derived().

Here is the call graph for this function:

operator*() [4/9]

template<typename OtherDerived , typename VectorsType , typename CoeffsType , int Side>

internal::matrix_type_times_scalar_type< typenameVectorsType::Scalar, OtherDerived >::Type Eigen::operator*	(	const MatrixBase< OtherDerived > &	other,
		const HouseholderSequence< VectorsType, CoeffsType, Side > &	h
	)

Computes the product of a matrix with a Householder sequence.

Parameters

[in]	other	Matrix being multiplied.
[in]	h	HouseholderSequence being multiplied.

Returns

Expression object representing the product.

This function computes where is the matrix other and is the Householder sequence represented by h.

{
  typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::Type
    res(other.template cast<typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::ResultScalar>());
  h.applyThisOnTheRight(res);
  return res;
}

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheRight(), and cast().

Here is the call graph for this function:

operator*() [5/9]

template<typename SparseDerived , typename PermDerived >

const Product< PermDerived, SparseDerived, AliasFreeProduct > Eigen::operator* ( const PermutationBase< PermDerived > &  perm, const SparseMatrixBase< SparseDerived > &  matrix  )

inline

Returns

the matrix with the permutation applied to the rows

{ return  Product<PermDerived, SparseDerived, AliasFreeProduct>(perm.derived(), matrix.derived()); }

References Eigen::PermutationBase< Derived >::derived(), and Eigen::SparseMatrixBase< Derived >::derived().

Here is the call graph for this function:

operator*() [6/9]

template<typename PermutationDerived , typename MatrixDerived >

EIGEN_DEVICE_FUNC const Product< PermutationDerived, MatrixDerived, AliasFreeProduct > Eigen::operator*	(	const PermutationBase< PermutationDerived > &	permutation,
		const MatrixBase< MatrixDerived > &	matrix
	)

Returns

the matrix with the permutation applied to the rows.

{
  return Product<PermutationDerived, MatrixDerived, AliasFreeProduct>
            (permutation.derived(), matrix.derived());
}

References Eigen::PermutationBase< Derived >::derived().

Here is the call graph for this function:

operator*() [7/9]

template<typename SparseDerived , typename PermutationType >

const Product< SparseDerived, Inverse< PermutationType >, AliasFreeProduct > Eigen::operator* ( const SparseMatrixBase< SparseDerived > &  matrix, const InverseImpl< PermutationType, PermutationStorage > &  tperm  )

inline

Returns

the matrix with the inverse permutation applied to the columns.

{
  return Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>(matrix.derived(), tperm.derived());
}

References AliasFreeProduct, and Eigen::SparseMatrixBase< Derived >::derived().

Here is the call graph for this function:

operator*() [8/9]

template<typename SparseDerived , typename PermDerived >

const Product< SparseDerived, PermDerived, AliasFreeProduct > Eigen::operator* ( const SparseMatrixBase< SparseDerived > &  matrix, const PermutationBase< PermDerived > &  perm  )

inline

Returns

the matrix with the permutation applied to the columns

{ return Product<SparseDerived, PermDerived, AliasFreeProduct>(matrix.derived(), perm.derived()); }

References Eigen::PermutationBase< Derived >::derived(), and Eigen::SparseMatrixBase< Derived >::derived().

Here is the call graph for this function:

operator*() [9/9]

template<typename TranspositionsDerived , typename MatrixDerived >

EIGEN_DEVICE_FUNC const Product< TranspositionsDerived, MatrixDerived, AliasFreeProduct > Eigen::operator*	(	const TranspositionsBase< TranspositionsDerived > &	transpositions,
		const MatrixBase< MatrixDerived > &	matrix
	)

Returns

the matrix with the transpositions applied to the rows.

{
  return Product<TranspositionsDerived, MatrixDerived, AliasFreeProduct>
            (transpositions.derived(), matrix.derived());
}

References Eigen::TranspositionsBase< Derived >::derived().

Here is the call graph for this function:

operator+() [1/2]

template<typename DenseDerived , typename SparseDerived >

EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived > Eigen::operator+	(	const MatrixBase< DenseDerived > &	a,
		const SparseMatrixBase< SparseDerived > &	b
	)

{
  return CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
}

operator+() [2/2]

template<typename SparseDerived , typename DenseDerived >

EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived > Eigen::operator+	(	const SparseMatrixBase< SparseDerived > &	a,
		const MatrixBase< DenseDerived > &	b
	)

{
  return CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
}

operator-() [1/2]

template<typename DenseDerived , typename SparseDerived >

EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived > Eigen::operator-	(	const MatrixBase< DenseDerived > &	a,
		const SparseMatrixBase< SparseDerived > &	b
	)

{
  return CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
}

operator-() [2/2]

template<typename SparseDerived , typename DenseDerived >

EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived > Eigen::operator-	(	const SparseMatrixBase< SparseDerived > &	a,
		const MatrixBase< DenseDerived > &	b
	)

{
  return CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
}

rightHouseholderSequence()

template<typename VectorsType , typename CoeffsType >

HouseholderSequence< VectorsType, CoeffsType, OnTheRight > Eigen::rightHouseholderSequence	(	const VectorsType &	v,
		const CoeffsType &	h
	)

Convenience function for constructing a Householder sequence.

\

Returns

A HouseholderSequence constructed from the specified arguments.

This function differs from householderSequence() in that the template argument OnTheSide of the constructed HouseholderSequence is set to OnTheRight, instead of the default OnTheLeft.

{
  return HouseholderSequence<VectorsType,CoeffsType,OnTheRight>(v, h);
}

saveMarket()

template<typename SparseMatrixType >

bool Eigen::saveMarket	(	const SparseMatrixType &	mat,
		const std::string &	filename,
		int	sym = 0
	)

{
  typedef typename SparseMatrixType::Scalar Scalar;
  std::ofstream out(filename.c_str(),std::ios::out);
  if(!out)
    return false;
  
  out.flags(std::ios_base::scientific);
  out.precision(64);
  std::string header; 
  internal::putMarketHeader<Scalar>(header, sym); 
  out << header << std::endl; 
  out << mat.rows() << " " << mat.cols() << " " << mat.nonZeros() << "\n";
  int count = 0;
  for(int j=0; j<mat.outerSize(); ++j)
    for(typename SparseMatrixType::InnerIterator it(mat,j); it; ++it)
    {
      ++ count;
      internal::PutMatrixElt(it.value(), it.row()+1, it.col()+1, out);
      // out << it.row()+1 << " " << it.col()+1 << " " << it.value() << "\n";
    }
  out.close();
  return true;
}

References Eigen::internal::PutMatrixElt().

Here is the call graph for this function:

saveMarketVector()

template<typename VectorType >

bool Eigen::saveMarketVector	(	const VectorType &	vec,
		const std::string &	filename
	)

{
 typedef typename VectorType::Scalar Scalar; 
 std::ofstream out(filename.c_str(),std::ios::out);
  if(!out)
    return false;
  
  out.flags(std::ios_base::scientific);
  out.precision(64);
  if(internal::is_same<Scalar, std::complex<float> >::value || internal::is_same<Scalar, std::complex<double> >::value)
      out << "%%MatrixMarket matrix array complex general\n"; 
  else
    out << "%%MatrixMarket matrix array real general\n"; 
  out << vec.size() << " "<< 1 << "\n";
  for (int i=0; i < vec.size(); i++){
    internal::putVectorElt(vec(i), out); 
  }
  out.close();
  return true; 
}

References Eigen::internal::putVectorElt().

Here is the call graph for this function:

Scaling() [1/6]

template<typename Derived >

const DiagonalWrapper< const Derived > Eigen::Scaling ( const MatrixBase< Derived > &  coeffs )

inline

Constructs an axis aligned scaling expression from vector expression coeffs This is an alias for coeffs.asDiagonal()

{ return coeffs.asDiagonal(); }

References Eigen::MatrixBase< Derived >::asDiagonal().

Here is the call graph for this function:

Scaling() [2/6]

template<typename Scalar >

DiagonalMatrix< Scalar, 2 > Eigen::Scaling ( const Scalar &  sx, const Scalar &  sy  )

inline

Constructs a 2D axis aligned scaling

{ return DiagonalMatrix<Scalar,2>(sx, sy); }

Scaling() [3/6]

template<typename Scalar >

DiagonalMatrix< Scalar, 3 > Eigen::Scaling ( const Scalar &  sx, const Scalar &  sy, const Scalar &  sz  )

inline

Constructs a 3D axis aligned scaling

{ return DiagonalMatrix<Scalar,3>(sx, sy, sz); }

Scaling() [4/6]

template<typename RealScalar >

UniformScaling< std::complex< RealScalar > > Eigen::Scaling ( const std::complex< RealScalar > &  s )

inline

Constructs a uniform scaling from scale factor s

{ return UniformScaling<std::complex<RealScalar> >(s); }

Scaling() [5/6]

UniformScaling< double > Eigen::Scaling ( double  s )

inline

Constructs a uniform scaling from scale factor s

{ return UniformScaling<double>(s); }

Scaling() [6/6]

UniformScaling< float > Eigen::Scaling ( float  s )

inline

Constructs a uniform scaling from scale factor s

{ return UniformScaling<float>(s); }

Referenced by igl::opengl::ViewerCore::draw(), and Slic3r::SLAPrint::sla_trafo().

Here is the caller graph for this function:

setCpuCacheSizes()

void Eigen::setCpuCacheSizes ( std::ptrdiff_t  l1, std::ptrdiff_t  l2, std::ptrdiff_t  l3  )

inline

Set the cpu L1 and L2 cache sizes (in bytes). These values are use to adjust the size of the blocks for the algorithms working per blocks.

See also

computeProductBlockingSizes

{
  internal::manage_caching_sizes(SetAction, &l1, &l2, &l3);
}

References Eigen::internal::manage_caching_sizes(), and SetAction.

Here is the call graph for this function:

setNbThreads()

void Eigen::setNbThreads ( int  v )

inline

Sets the max number of threads reserved for Eigen

See also

nbThreads

{
  internal::manage_multi_threading(SetAction, &v);
}

References Eigen::internal::manage_multi_threading(), and SetAction.

Here is the call graph for this function:

umfpack_defaults() [1/2]

void Eigen::umfpack_defaults ( double  control[UMFPACK_CONTROL], double    )

inline

{ umfpack_di_defaults(control); }

Referenced by Eigen::UmfPackLU< _MatrixType >::init().

Here is the caller graph for this function:

umfpack_defaults() [2/2]

void Eigen::umfpack_defaults ( double  control[UMFPACK_CONTROL], std::complex< double >    )

inline

{ umfpack_zi_defaults(control); }

umfpack_free_numeric() [1/2]

void Eigen::umfpack_free_numeric ( void **  Numeric, double    )

inline

{ umfpack_di_free_numeric(Numeric); *Numeric = 0; }

Referenced by Eigen::UmfPackLU< _MatrixType >::~UmfPackLU(), Eigen::UmfPackLU< _MatrixType >::analyzePattern(), Eigen::UmfPackLU< _MatrixType >::compute(), and Eigen::UmfPackLU< _MatrixType >::factorize().

Here is the caller graph for this function:

umfpack_free_numeric() [2/2]

void Eigen::umfpack_free_numeric ( void **  Numeric, std::complex< double >    )

inline

{ umfpack_zi_free_numeric(Numeric); *Numeric = 0; }

umfpack_free_symbolic() [1/2]

void Eigen::umfpack_free_symbolic ( void **  Symbolic, double    )

inline

{ umfpack_di_free_symbolic(Symbolic); *Symbolic = 0; }

Referenced by Eigen::UmfPackLU< _MatrixType >::~UmfPackLU(), Eigen::UmfPackLU< _MatrixType >::analyzePattern(), and Eigen::UmfPackLU< _MatrixType >::compute().

Here is the caller graph for this function:

umfpack_free_symbolic() [2/2]

void Eigen::umfpack_free_symbolic ( void **  Symbolic, std::complex< double >    )

inline

{ umfpack_zi_free_symbolic(Symbolic); *Symbolic = 0; }

umfpack_get_determinant() [1/2]

int Eigen::umfpack_get_determinant ( double *  Mx, double *  Ex, void *  NumericHandle, double  User_Info[UMFPACK_INFO]  )

inline

{
  return umfpack_di_get_determinant(Mx,Ex,NumericHandle,User_Info);
}

Referenced by Eigen::UmfPackLU< _MatrixType >::determinant().

Here is the caller graph for this function:

umfpack_get_determinant() [2/2]

int Eigen::umfpack_get_determinant ( std::complex< double > *  Mx, double *  Ex, void *  NumericHandle, double  User_Info[UMFPACK_INFO]  )

inline

{
  double& mx_real = numext::real_ref(*Mx);
  return umfpack_zi_get_determinant(&mx_real,0,Ex,NumericHandle,User_Info);
}

References Eigen::numext::real_ref().

Here is the call graph for this function:

umfpack_get_lunz() [1/2]

int Eigen::umfpack_get_lunz ( int *  lnz, int *  unz, int *  n_row, int *  n_col, int *  nz_udiag, void *  Numeric, double    )

inline

{
  return umfpack_di_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
}

Referenced by Eigen::UmfPackLU< _MatrixType >::extractData().

Here is the caller graph for this function:

umfpack_get_lunz() [2/2]

int Eigen::umfpack_get_lunz ( int *  lnz, int *  unz, int *  n_row, int *  n_col, int *  nz_udiag, void *  Numeric, std::complex< double >    )

inline

{
  return umfpack_zi_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
}

umfpack_get_numeric() [1/2]

int Eigen::umfpack_get_numeric ( int  Lp[], int  Lj[], double  Lx[], int  Up[], int  Ui[], double  Ux[], int  P[], int  Q[], double  Dx[], int *  do_recip, double  Rs[], void *  Numeric  )

inline

{
  return umfpack_di_get_numeric(Lp,Lj,Lx,Up,Ui,Ux,P,Q,Dx,do_recip,Rs,Numeric);
}

Referenced by Eigen::UmfPackLU< _MatrixType >::extractData().

Here is the caller graph for this function:

umfpack_get_numeric() [2/2]

int Eigen::umfpack_get_numeric ( int  Lp[], int  Lj[], std::complex< double >  Lx[], int  Up[], int  Ui[], std::complex< double >  Ux[], int  P[], int  Q[], std::complex< double >  Dx[], int *  do_recip, double  Rs[], void *  Numeric  )

inline

{
  double& lx0_real = numext::real_ref(Lx[0]);
  double& ux0_real = numext::real_ref(Ux[0]);
  double& dx0_real = numext::real_ref(Dx[0]);
  return umfpack_zi_get_numeric(Lp,Lj,Lx?&lx0_real:0,0,Up,Ui,Ux?&ux0_real:0,0,P,Q,
                                Dx?&dx0_real:0,0,do_recip,Rs,Numeric);
}

References Eigen::numext::real_ref().

Here is the call graph for this function:

umfpack_numeric() [1/2]

int Eigen::umfpack_numeric ( const int  Ap[], const int  Ai[], const double  Ax[], void *  Symbolic, void **  Numeric, const double  Control[UMFPACK_CONTROL], double  Info[UMFPACK_INFO]  )

inline

{
  return umfpack_di_numeric(Ap,Ai,Ax,Symbolic,Numeric,Control,Info);
}

Referenced by Eigen::UmfPackLU< _MatrixType >::factorize_impl().

Here is the caller graph for this function:

umfpack_numeric() [2/2]

int Eigen::umfpack_numeric ( const int  Ap[], const int  Ai[], const std::complex< double >  Ax[], void *  Symbolic, void **  Numeric, const double  Control[UMFPACK_CONTROL], double  Info[UMFPACK_INFO]  )

inline

{
  return umfpack_zi_numeric(Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Numeric,Control,Info);
}

References Eigen::numext::real_ref().

Here is the call graph for this function:

umfpack_report_control() [1/2]

void Eigen::umfpack_report_control ( double  control[UMFPACK_CONTROL], double    )

inline

{ umfpack_di_report_control(control);}

Referenced by Eigen::UmfPackLU< _MatrixType >::umfpackReportControl().

Here is the caller graph for this function:

umfpack_report_control() [2/2]

void Eigen::umfpack_report_control ( double  control[UMFPACK_CONTROL], std::complex< double >    )

inline

{ umfpack_zi_report_control(control);}

umfpack_report_info() [1/2]

void Eigen::umfpack_report_info ( double  control[UMFPACK_CONTROL], double  info[UMFPACK_INFO], double    )

inline

{ umfpack_di_report_info(control, info);}

Referenced by Eigen::UmfPackLU< _MatrixType >::umfpackReportInfo().

Here is the caller graph for this function:

umfpack_report_info() [2/2]

void Eigen::umfpack_report_info ( double  control[UMFPACK_CONTROL], double  info[UMFPACK_INFO], std::complex< double >    )

inline

{ umfpack_zi_report_info(control, info);}

umfpack_report_status() [1/2]

void Eigen::umfpack_report_status ( double  control[UMFPACK_CONTROL], int  status, double    )

inline

{ umfpack_di_report_status(control, status);}

Referenced by Eigen::UmfPackLU< _MatrixType >::umfpackReportStatus().

Here is the caller graph for this function:

umfpack_report_status() [2/2]

void Eigen::umfpack_report_status ( double  control[UMFPACK_CONTROL], int  status, std::complex< double >    )

inline

{ umfpack_zi_report_status(control, status);}

umfpack_solve() [1/2]

int Eigen::umfpack_solve ( int  sys, const int  Ap[], const int  Ai[], const double  Ax[], double  X[], const double  B[], void *  Numeric, const double  Control[UMFPACK_CONTROL], double  Info[UMFPACK_INFO]  )

inline

{
  return umfpack_di_solve(sys,Ap,Ai,Ax,X,B,Numeric,Control,Info);
}

Referenced by Eigen::UmfPackLU< _MatrixType >::_solve_impl().

Here is the caller graph for this function:

umfpack_solve() [2/2]

int Eigen::umfpack_solve ( int  sys, const int  Ap[], const int  Ai[], const std::complex< double >  Ax[], std::complex< double >  X[], const std::complex< double >  B[], void *  Numeric, const double  Control[UMFPACK_CONTROL], double  Info[UMFPACK_INFO]  )

inline

{
  return umfpack_zi_solve(sys,Ap,Ai,&numext::real_ref(Ax[0]),0,&numext::real_ref(X[0]),0,&numext::real_ref(B[0]),0,Numeric,Control,Info);
}

References Eigen::numext::real_ref().

Here is the call graph for this function:

umfpack_symbolic() [1/2]

int Eigen::umfpack_symbolic ( int  n_row, int  n_col, const int  Ap[], const int  Ai[], const double  Ax[], void **  Symbolic, const double  Control[UMFPACK_CONTROL], double  Info[UMFPACK_INFO]  )

inline

{
  return umfpack_di_symbolic(n_row,n_col,Ap,Ai,Ax,Symbolic,Control,Info);
}

Referenced by Eigen::UmfPackLU< _MatrixType >::analyzePattern_impl().

Here is the caller graph for this function:

umfpack_symbolic() [2/2]

int Eigen::umfpack_symbolic ( int  n_row, int  n_col, const int  Ap[], const int  Ai[], const std::complex< double >  Ax[], void **  Symbolic, const double  Control[UMFPACK_CONTROL], double  Info[UMFPACK_INFO]  )

inline

{
  return umfpack_zi_symbolic(n_row,n_col,Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Control,Info);
}

References Eigen::numext::real_ref().

Here is the call graph for this function:

viewAsCholmod() [1/5]

template<typename _Scalar , int _Options, typename _Index >

const cholmod_sparse Eigen::viewAsCholmod

(

const SparseMatrix< _Scalar, _Options, _Index > &

mat

)

{
  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
  return res;
}

References Eigen::SparseMatrixBase< Derived >::const_cast_derived(), and viewAsCholmod().

Here is the call graph for this function:

viewAsCholmod() [2/5]

template<typename _Scalar , int _Options, typename _Index , unsigned int UpLo>

cholmod_sparse Eigen::viewAsCholmod

(

const SparseSelfAdjointView< const SparseMatrix< _Scalar, _Options, _Index >, UpLo > &

mat

)

Returns a view of the Eigen sparse matrix mat as Cholmod sparse matrix. The data are not copied but shared.

{
  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.matrix().const_cast_derived()));
  
  if(UpLo==Upper) res.stype =  1;
  if(UpLo==Lower) res.stype = -1;
 
  return res;
}

References Lower, Upper, and viewAsCholmod().

Here is the call graph for this function:

viewAsCholmod() [3/5]

template<typename _Scalar , int _Options, typename _Index >

const cholmod_sparse Eigen::viewAsCholmod

(

const SparseVector< _Scalar, _Options, _Index > &

mat

)

{
  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
  return res;
}

References Eigen::SparseMatrixBase< Derived >::const_cast_derived(), and viewAsCholmod().

Here is the call graph for this function:

viewAsCholmod() [4/5]

template<typename Derived >

cholmod_dense Eigen::viewAsCholmod

(

MatrixBase< Derived > &

mat

)

Returns a view of the Eigen dense matrix mat as Cholmod dense matrix. The data are not copied but shared.

{
  EIGEN_STATIC_ASSERT((internal::traits<Derived>::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
  typedef typename Derived::Scalar Scalar;
 
  cholmod_dense res;
  res.nrow   = mat.rows();
  res.ncol   = mat.cols();
  res.nzmax  = res.nrow * res.ncol;
  res.d      = Derived::IsVectorAtCompileTime ? mat.derived().size() : mat.derived().outerStride();
  res.x      = (void*)(mat.derived().data());
  res.z      = 0;
 
  internal::cholmod_configure_matrix<Scalar>::run(res);
 
  return res;
}

References EIGEN_STATIC_ASSERT, and RowMajorBit.

viewAsCholmod() [5/5]

template<typename _Scalar , int _Options, typename _StorageIndex >

cholmod_sparse Eigen::viewAsCholmod

(

Ref< SparseMatrix< _Scalar, _Options, _StorageIndex > >

mat

)

Wraps the Eigen sparse matrix mat into a Cholmod sparse matrix object. Note that the data are shared.

{
  cholmod_sparse res;
  res.nzmax   = mat.nonZeros();
  res.nrow    = mat.rows();
  res.ncol    = mat.cols();
  res.p       = mat.outerIndexPtr();
  res.i       = mat.innerIndexPtr();
  res.x       = mat.valuePtr();
  res.z       = 0;
  res.sorted  = 1;
  if(mat.isCompressed())
  {
    res.packed  = 1;
    res.nz = 0;
  }
  else
  {
    res.packed  = 0;
    res.nz = mat.innerNonZeroPtr();
  }
 
  res.dtype   = 0;
  res.stype   = -1;
  
  if (internal::is_same<_StorageIndex,int>::value)
  {
    res.itype = CHOLMOD_INT;
  }
  else if (internal::is_same<_StorageIndex,long>::value)
  {
    res.itype = CHOLMOD_LONG;
  }
  else
  {
    eigen_assert(false && "Index type not supported yet");
  }
 
  // setup res.xtype
  internal::cholmod_configure_matrix<_Scalar>::run(res);
  
  res.stype = 0;
  
  return res;
}

References eigen_assert.

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::analyzePattern(), Eigen::SPQR< _MatrixType >::compute(), Eigen::SPQR_QProduct< SPQRType, Derived >::evalTo(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::factorize(), viewAsCholmod(), viewAsCholmod(), and viewAsCholmod().

Here is the caller graph for this function:

viewAsEigen()

template<typename Scalar , int Flags, typename StorageIndex >

MappedSparseMatrix< Scalar, Flags, StorageIndex > Eigen::viewAsEigen

(

cholmod_sparse &

cm

)

Returns a view of the Cholmod sparse matrix cm as an Eigen sparse matrix. The data are not copied but shared.

{
  return MappedSparseMatrix<Scalar,Flags,StorageIndex>
         (cm.nrow, cm.ncol, static_cast<StorageIndex*>(cm.p)[cm.ncol],
          static_cast<StorageIndex*>(cm.p), static_cast<StorageIndex*>(cm.i),static_cast<Scalar*>(cm.x) );
}

Variable Documentation

ActualPacketAccessBit

const unsigned int Eigen::ActualPacketAccessBit = 0x0

CoherentAccessPattern

const int Eigen::CoherentAccessPattern = 0x1

Dynamic

const int Eigen::Dynamic = -1

This value means that a positive quantity (e.g., a size) is not known at compile-time, and that instead the value is stored in some runtime variable.

Changing the value of Dynamic breaks the ABI, as Dynamic is often used as a template parameter for Matrix.

Referenced by Eigen::AlignedBox< _Scalar, _AmbientDim >::AlignedBox(), Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::Block(), Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::Block(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix(), Eigen::CwiseNullaryOp< NullaryOp, PlainObjectType >::CwiseNullaryOp(), Eigen::internal::evaluator< PartialReduxExpr< ArgType, MemberOp, Direction > >::evaluator(), Eigen::MapBase< Derived, ReadOnlyAccessors >::MapBase(), Eigen::MapBase< Derived, ReadOnlyAccessors >::MapBase(), Eigen::Replicate< MatrixType, RowFactor, ColFactor >::Replicate(), Eigen::Stride< _OuterStrideAtCompileTime, _InnerStrideAtCompileTime >::Stride(), Eigen::PlainObjectBase< Derived >::_check_template_params(), Eigen::DenseBase< Derived >::all(), Eigen::JacobiSVD< _MatrixType, QRPreconditioner >::allocate(), Eigen::SVDBase< Derived >::allocate(), Eigen::DenseBase< Derived >::any(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheLeft(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockInnerIndex(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockInnerSize(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockOuterIndex(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockOuterSize(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockPtr(), Eigen::internal::call_triangular_assignment_loop(), Eigen::MapBase< Derived, ReadOnlyAccessors >::checkSanity(), Eigen::internal::evaluator< SparseCompressedBase< Derived > >::coeff(), Eigen::internal::evaluator< SparseCompressedBase< Derived > >::coeffRef(), Eigen::CwiseBinaryOp< BinaryOp, LhsType, RhsType >::cols(), Eigen::CwiseTernaryOp< TernaryOp, Arg1Type, Arg2Type, Arg3Type >::cols(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockInnerIterator::cols(), Eigen::BDCSVD< _MatrixType >::deflation(), Eigen::AlignedBox< _Scalar, _AmbientDim >::dim(), Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >::dim(), Eigen::internal::homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs >::evalTo(), Eigen::internal::homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs >::evalTo(), Eigen::internal::kernel_retval< FullPivLU< _MatrixType > >::evalTo(), Eigen::internal::evaluator< SparseCompressedBase< Derived > >::find(), igl::hessian(), igl::hessian_energy(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerSize(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerToBlock(), Eigen::MatrixBase< Derived >::lazyProduct(), igl::copyleft::cgal::mesh_boolean(), Eigen::BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >::nonZeros(), Eigen::MatrixBase< Derived >::operator*(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=(), igl::copyleft::cgal::outer_hull(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerSize(), Eigen::Map< PlainObjectType, MapOptions, StrideType >::outerStride(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerToBlock(), Eigen::internal::product_evaluator< Product< Lhs, Rhs, LazyProduct >, ProductTag, DenseShape, DenseShape >::packet(), igl::copyleft::cgal::point_areas(), Eigen::DenseBase< Derived >::prod(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::reserve(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::CwiseBinaryOp< BinaryOp, LhsType, RhsType >::rows(), Eigen::CwiseTernaryOp< TernaryOp, Arg1Type, Arg2Type, Arg3Type >::rows(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockInnerIterator::rows(), Eigen::internal::determinant_impl< Derived, DeterminantType >::run(), Eigen::internal::LU_kernel_bmod< SegSizeAtCompileTime >::run(), Eigen::internal::lpNorm_selector< Derived, Infinity >::run(), Eigen::internal::apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >::run(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, GemmProduct >::scaleAndAddTo(), Eigen::internal::generic_product_impl< Lhs, Rhs, SparseShape, DenseShape, ProductType >::scaleAndAddTo(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, SparseShape, ProductType >::scaleAndAddTo(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockStructure(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setFromTriplets(), Eigen::DenseBase< Derived >::sum(), Eigen::PlainObjectBase< Derived >::swap(), Eigen::DenseBase< Derived >::transposeInPlace(), Eigen::internal::upperbidiagonalization_blocked_helper(), Eigen::internal::upperbidiagonalization_inplace_blocked(), and Eigen::DenseBase< Derived >::visit().

DynamicIndex

const int Eigen::DynamicIndex = 0xffffff

This value means that a signed quantity (e.g., a signed index) is not known at compile-time, and that instead its value has to be specified at runtime.

HereditaryBits

const unsigned int Eigen::HereditaryBits

Initial value:

= RowMajorBit
                                  | EvalBeforeNestingBit

HugeCost

const int Eigen::HugeCost = 10000

This value means that the cost to evaluate an expression coefficient is either very expensive or cannot be known at compile time.

This value has to be positive to (1) simplify cost computation, and (2) allow to distinguish between a very expensive and very very expensive expressions. It thus must also be large enough to make sure unrolling won't happen and that sub expressions will be evaluated, but not too large to avoid overflow.

Referenced by Eigen::internal::evaluator< PartialReduxExpr< ArgType, MemberOp, Direction > >::evaluator(), and Eigen::internal::call_triangular_assignment_loop().

Infinity

const int Eigen::Infinity = -1

This value means +Infinity; it is currently used only as the p parameter to MatrixBase::lpNorm<int>(). The value Infinity there means the L-infinity norm.

InnerRandomAccessPattern

const int Eigen::InnerRandomAccessPattern = 0x2 | CoherentAccessPattern

NestByRefBit

const unsigned int Eigen::NestByRefBit = 0x100

OuterRandomAccessPattern

const int Eigen::OuterRandomAccessPattern = 0x4 | CoherentAccessPattern

Referenced by Eigen::internal::assign_sparse_to_sparse().

RandomAccessPattern

const int Eigen::RandomAccessPattern = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern