Eigen Namespace Reference

iterative scaling algorithm to equilibrate rows and column norms in matrices More...

Namespaces
	internal
	Applies the clock wise 2D rotation j to the set of 2D vectors of cordinates x and y: \( \left ( \begin{array}{cc} x \\ y \end{array} \right ) = J \left ( \begin{array}{cc} x \\ y \end{array} \right ) \)

Classes
class	aligned_allocator
	STL compatible allocator to use with with 16 byte aligned types. More...
class	aligned_allocator_indirection
class	AlignedBox
class	AMDOrdering
	Functor computing the approximate minimum degree ordering If the matrix is not structurally symmetric, an ordering of A^T+A is computed. More...
class	AngleAxis
class	ArpackGeneralizedSelfAdjointEigenSolver
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
	The type used to identify an array expression. More...
class	AutoDiffJacobian
class	AutoDiffScalar
	A scalar type replacement with automatic differentation capability. More...
class	AutoDiffVector
class	BDCSVD
	class Bidiagonal Divide and Conquer SVD More...
class	BenchTimer
	Elapsed time timer keeping the best try. 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, _Index >, BlockRows, BlockCols, true, Sparse >
class	BlockImpl< SparseMatrix< _Scalar, _Options, _Index >, BlockRows, BlockCols, true, Sparse >
class	BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Dense >
class	BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >
	Generic implementation of sparse Block expression. More...
class	BlockImpl< XprType, BlockRows, BlockCols, true, Sparse >
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	CoeffBasedProduct
class	COLAMDOrdering
	Functor computing the column approximate minimum degree ordering The matrix should be in column-major and compressed format (see SparseMatrix::makeCompressed()). More...
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	ComplexEigenSolver
class	ComplexSchur
class	Conjugate
class	ConjugateGradient
	A conjugate gradient solver for sparse self-adjoint problems. More...
class	Cross
class	Cwise
	Pseudo expression providing additional coefficient-wise operations. More...
class	CwiseBinaryOp
	Generic expression where a coefficient-wise binary operator is applied to two expressions. More...
class	CwiseBinaryOpImpl
class	CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Dense >
class	CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >
class	CwiseNullaryOp
	Generic expression of a matrix where all coefficients are defined by a functor. More...
class	CwiseUnaryOp
	Generic expression where a coefficient-wise unary operator is applied to an expression. More...
class	CwiseUnaryOpImpl
class	CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse >
class	CwiseUnaryOpImpl< UnaryOp, XprType, Dense >
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 >
class	CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse >
struct	Dense
	The type used to identify a dense storage. More...
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	DenseFunctor
struct	DenseSparseProductReturnType
struct	DenseSparseProductReturnType< Lhs, Rhs, 1 >
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	DenseTimeSparseSelfAdjointProduct
class	DGMRES
	A Restarted GMRES with deflation. More...
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
class	DiagonalWrapper
	Expression of a diagonal matrix. More...
class	DynamicSkylineMatrix
class	DynamicSparseMatrix
	A sparse matrix class designed for matrix assembly purpose. More...
struct	ei_cleantype
struct	ei_cleantype< const T & >
struct	ei_cleantype< const T * >
struct	ei_cleantype< const T >
struct	ei_cleantype< T & >
struct	ei_cleantype< T * >
struct	ei_is_same_type
struct	ei_is_same_type< T, T >
struct	ei_meta_false
struct	ei_meta_if
struct	ei_meta_if< false, Then, Else >
class	ei_meta_sqrt
class	ei_meta_sqrt< Y, InfX, SupX, true >
struct	ei_meta_true
struct	ei_quaternion_assign_impl
struct	ei_quaternion_assign_impl< Other, 3, 3 >
struct	ei_quaternion_assign_impl< Other, 4, 1 >
struct	ei_traits
struct	ei_traits< AngleAxis< _Scalar > >
struct	ei_traits< Quaternion< _Scalar > >
struct	ei_traits< Rotation2D< _Scalar > >
struct	ei_transform_product_impl
struct	ei_transform_product_impl< Other, Dim, HDim, Dim, 1 >
struct	ei_transform_product_impl< Other, Dim, HDim, Dim, Dim >
struct	ei_transform_product_impl< Other, Dim, HDim, HDim, 1 >
struct	ei_transform_product_impl< Other, Dim, HDim, HDim, HDim >
struct	ei_unconst
struct	ei_unconst< const T >
struct	ei_unconst< T const & >
struct	ei_unconst< T const * >
struct	ei_unpointer
struct	ei_unpointer< T * >
struct	ei_unpointer< T *const >
struct	ei_unref
struct	ei_unref< T & >
struct	eigen_assert_exception
struct	EigenBase
	Common base class for all classes T such that MatrixBase has an operator=(T) and a constructor MatrixBase(T). More...
class	EigenSolver
class	Flagged
	Expression with modified flags. More...
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
class	GeneralizedSelfAdjointEigenSolver
class	GeneralProduct
	Expression of the product of two general matrices or vectors. More...
class	GeneralProduct< Lhs, Rhs, GemmProduct >
class	GeneralProduct< Lhs, Rhs, GemvProduct >
class	GeneralProduct< Lhs, Rhs, InnerProduct >
class	GeneralProduct< Lhs, Rhs, OuterProduct >
struct	GenericNumTraits
class	GMRES
	A GMRES solver for sparse square problems. More...
struct	GslTraits
struct	GslTraits< Scalar, true >
class	HessenbergDecomposition
class	Homogeneous
class	HouseholderQR
	Householder QR decomposition of a matrix. More...
class	HouseholderSequence
class	HybridNonLinearSolver
	Finds a zero of a system of n nonlinear functions in n variables by a modification of the Powell hybrid method ("dogleg"). More...
class	Hyperplane
class	IdentityPreconditioner
	A naive preconditioner which approximates any matrix as the identity matrix. More...
class	IncompleteCholesky
	Modified Incomplete Cholesky with dual threshold. More...
class	IncompleteLU
class	IncompleteLUT
	Incomplete LU factorization with dual-threshold strategy. More...
class	InnerStride
	Convenience specialization of Stride to specify only an inner stride See class Map for some examples. More...
class	IOFormat
	Stores a set of parameters controlling the way matrices are printed. More...
class	IterationController
	Controls the iterations of the iterative solvers. More...
class	IterativeSolverBase
	Base class for linear iterative solvers. More...
class	IterScaling
class	JacobiRotation
class	JacobiSVD
	Two-sided Jacobi SVD decomposition of a rectangular matrix. More...
class	KdBVH
	A simple bounding volume hierarchy based on AlignedBox. More...
class	KroneckerProduct
	Kronecker tensor product helper class for dense matrices. More...
class	KroneckerProductSparse
	Kronecker tensor product helper class for sparse matrices. More...
struct	LazyProductReturnType
class	LDLT
	Robust Cholesky decomposition of a matrix with pivoting. More...
class	LevenbergMarquardt
	Performs non linear optimization over a non-linear function, using a variant of the Levenberg Marquardt algorithm. More...
class	LLT
	Standard Cholesky decomposition (LL^T) of a matrix and associated features. More...
class	LU
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< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, _PacketAccess >
class	Map< Quaternion< _Scalar >, _Options >
	Expression of a quaternion from a memory buffer. More...
class	Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, PacketAccess >
class	MapBase
	Base class for Map and Block expression with direct access. More...
class	MapBase< Derived, ReadOnlyAccessors >
class	MapBase< Derived, WriteAccessors >
class	MappedSkylineMatrix
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	MatrixExponential
	Class for computing the matrix exponential. More...
struct	MatrixExponentialReturnValue
	Proxy for the matrix exponential of some matrix (expression). More...
class	MatrixFunction
	Class for computing matrix functions. More...
class	MatrixFunction< MatrixType, AtomicType, 0 >
class	MatrixFunction< MatrixType, AtomicType, 1 >
class	MatrixFunctionAtomic
	Helper class for computing matrix functions of atomic matrices. More...
class	MatrixFunctionReturnValue
	Proxy for the matrix function of some matrix (expression). More...
class	MatrixLogarithmAtomic
	Helper class for computing matrix logarithm of atomic matrices. More...
class	MatrixLogarithmReturnValue
	Proxy for the matrix logarithm of some matrix (expression). More...
class	MatrixMarketIterator
	Iterator to browse matrices from a specified folder. More...
class	MatrixPower
	Class for computing matrix powers. More...
class	MatrixPowerAtomic
class	MatrixPowerProduct
class	MatrixPowerReturnValue
	Proxy for the matrix power of some matrix (expression). More...
class	MatrixPowerRetval
class	MatrixSquareRoot
	Class for computing matrix square roots of general matrices. More...
class	MatrixSquareRoot< MatrixType, 0 >
class	MatrixSquareRoot< MatrixType, 1 >
class	MatrixSquareRootQuasiTriangular
	Class for computing matrix square roots of upper quasi-triangular matrices. More...
class	MatrixSquareRootReturnValue
	Proxy for the matrix square root of some matrix (expression). More...
class	MatrixSquareRootTriangular
	Class for computing matrix square roots of upper triangular matrices. More...
class	MatrixWrapper
	Expression of an array as a mathematical vector or matrix. More...
struct	MatrixXpr
	The type used to identify a matrix expression. More...
class	MetisOrdering
	Get the fill-reducing ordering from the METIS package. More...
class	Minor
	Expression of a minor. More...
class	MINRES
	A minimal residual solver for sparse symmetric problems. More...
class	NaturalOrdering
	Functor computing the natural ordering (identity) More...
class	NestByValue
	Expression which must be nested by value. More...
class	NoAlias
	Pseudo expression providing an operator = assuming no aliasing. More...
class	NumericalDiff
	This class allows you to add a method df() to your functor, which will use numerical differentiation to compute an approximate of the derivative for the functor. More...
class	NumTraits
	Holds information about the various numeric (i.e. More...
struct	NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct	NumTraits< double >
struct	NumTraits< float >
struct	NumTraits< long double >
struct	NumTraits< std::complex< _Real > >
class	OuterStride
	Convenience specialization of Stride to specify only an outer stride See class Map for some examples. More...
class	ParametrizedLine
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	PermutationStorage
class	PermutationWrapper
	Class to view a vector of integers as a permutation matrix. More...
class	PermutedImpl
class	PlainObjectBase
	Dense storage base class for matrices and arrays. More...
class	PolynomialSolver
	A polynomial solver. More...
class	PolynomialSolver< _Scalar, 1 >
class	PolynomialSolverBase
	Defined to be inherited by polynomial solvers: it provides convenient methods such as. More...
class	ProductBase
class	ProductReturnType
	Helper class to get the correct and optimized returned type of operator*. More...
struct	ProductReturnType< Lhs, Rhs, CoeffBasedProductMode >
struct	ProductReturnType< Lhs, Rhs, LazyCoeffBasedProductMode >
class	QR
class	Quaternion
class	QuaternionBase
class	RandomSetter
	The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access. More...
class	RealQZ
class	RealSchur
class	Ref
	A matrix or vector expression mapping an existing expressions. More...
class	Ref< const TPlainObjectType, Options, StrideType >
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
class	RotationBase
	Common base class for compact rotation representations. More...
class	ScaledProduct
class	Scaling
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
struct	SelfadjointProductMatrix
struct	SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false >
struct	SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true >
struct	SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false >
class	SelfAdjointView
	Expression of a selfadjoint matrix from a triangular part of a dense matrix. More...
class	SelfCwiseBinaryOp
class	SimplicialCholesky
class	SimplicialCholeskyBase
	A 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...
class	SkylineInplaceLU
	Inplace LU decomposition of a skyline matrix and associated features. More...
class	SkylineMatrix
	The main skyline matrix class. More...
class	SkylineMatrixBase
	Base class of any skyline matrices or skyline expressions. More...
class	SkylineProduct
struct	SkylineProductReturnType
class	SkylineStorage
	Stores a skyline set of values in three structures : The diagonal elements The upper elements The lower elements. More...
class	SkylineVector
struct	SluMatrix
struct	SluMatrixMapHelper
struct	SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > >
struct	SluMatrixMapHelper< SparseMatrixBase< Derived > >
class	SparseDenseOuterProduct
struct	SparseDenseProductReturnType
struct	SparseDenseProductReturnType< Lhs, Rhs, 1 >
class	SparseDiagonalProduct
struct	SparseFunctor
class	SparseLU
	Sparse supernodal LU factorization for general matrices. More...
struct	SparseLUMatrixLReturnType
struct	SparseLUMatrixUReturnType
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	SparseSelfAdjointTimeDenseProduct
class	SparseSelfAdjointView
	Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix. More...
class	SparseSparseProduct
struct	SparseSparseProductReturnType
class	SparseSymmetricPermutationProduct
class	SparseTimeDenseProduct
class	SparseTriangularView
class	SparseVector
	a sparse vector class More...
class	SparseView
class	Spline
	A class representing multi-dimensional spline curves. More...
struct	SplineFitting
	Spline fitting methods. More...
struct	SplineTraits
struct	SplineTraits< Spline< _Scalar, _Dim, _Degree >, _DerivativeOrder >
	Compile-time attributes of the Spline class for fixed degree. More...
struct	SplineTraits< Spline< _Scalar, _Dim, _Degree >, Dynamic >
	Compile-time attributes of the Spline class for Dynamic degree. More...
class	SPQR
	Sparse QR factorization based on SuiteSparseQR library. More...
struct	SPQR_QProduct
struct	SPQRMatrixQReturnType
struct	SPQRMatrixQTransposeReturnType
struct	StdMapTraits
	Represents a std::map. More...
class	StdStemFunctions
	Stem functions corresponding to standard mathematical functions. More...
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	SVD
class	SVDBase
	Mother class of SVD classes algorithms. More...
class	SwapWrapper
class	Transform
class	Translation
class	Transpose
	Expression of the transpose of a matrix. More...
class	Transpose< PermutationBase< Derived > >
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
class	TranspositionsWrapper
class	TriangularBase
struct	TriangularProduct
struct	TriangularProduct< Mode, false, Lhs, true, Rhs, false >
struct	TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false >
struct	TriangularProduct< Mode, true, Lhs, false, Rhs, true >
class	TriangularView
	Base class for triangular part in a matrix. More...
class	Tridiagonalization
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 AngleAxis< float >	AngleAxisf
	single precision angle-axis type
typedef AngleAxis< double >	AngleAxisd
	double precision angle-axis type
typedef Quaternion< float >	Quaternionf
	single precision quaternion type
typedef Quaternion< double >	Quaterniond
	double precision quaternion type
typedef Rotation2D< float >	Rotation2Df
	single precision 2D rotation type
typedef Rotation2D< double >	Rotation2Dd
	double precision 2D rotation type
typedef Scaling< float, 2 >	Scaling2f
typedef Scaling< double, 2 >	Scaling2d
typedef Scaling< float, 3 >	Scaling3f
typedef Scaling< double, 3 >	Scaling3d
typedef Transform< float, 2 >	Transform2f
typedef Transform< float, 3 >	Transform3f
typedef Transform< double, 2 >	Transform2d
typedef Transform< double, 3 >	Transform3d
typedef Translation< float, 2 >	Translation2f
typedef Translation< double, 2 >	Translation2d
typedef Translation< float, 3 >	Translation3f
typedef Translation< double, 3 >	Translation3d
typedef Map< Quaternion< float >, 0 >	QuaternionMapf
	Map an unaligned array of single precision scalars as a quaternion.
typedef Map< Quaternion< double >, 0 >	QuaternionMapd
	Map an unaligned array of double precision scalars as a quaternion.
typedef Map< Quaternion< float >, Aligned >	QuaternionMapAlignedf
	Map a 16-byte aligned array of single precision scalars as a quaternion.
typedef Map< Quaternion< double >, Aligned >	QuaternionMapAlignedd
	Map a 16-byte aligned array of double precision scalars as a quaternion.
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 Spline< float, 2 >	Spline2f
	2D float B-spline with dynamic degree. More...
typedef Spline< float, 3 >	Spline3f
	3D float B-spline with dynamic degree. More...
typedef Spline< double, 2 >	Spline2d
	2D double B-spline with dynamic degree. More...
typedef Spline< double, 3 >	Spline3d
	3D double B-spline with dynamic degree. More...

Enumerations
enum	{ CPU_TIMER = 0, REAL_TIMER = 1 }
enum	CholmodMode { CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt }
enum	{ Large = 2, Small = 3 }
enum	{ DontAlignCols = 1 }
enum	{ StreamPrecision = -1, FullPrecision = -2 }
enum	{   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 containing possible values for the Mode parameter of MatrixBase::selfadjointView() and MatrixBase::triangularView(). More...
enum	{ Unaligned =0, Aligned =1 }
	Enum for indicating whether an object is aligned or not. More...
enum	CornerType { TopLeft, TopRight, BottomLeft, BottomRight }
	Enum used by DenseBase::corner() in Eigen2 compatibility mode. More...
enum	DirectionType { Vertical, Horizontal, BothDirections }
	Enum containing possible values for the Direction parameter of Reverse, PartialReduxExpr and VectorwiseOp. More...
enum	{   DefaultTraversal, LinearTraversal, InnerVectorizedTraversal, LinearVectorizedTraversal,   SliceVectorizedTraversal, InvalidTraversal, AllAtOnceTraversal }
enum	{ NoUnrolling, InnerUnrolling, CompleteUnrolling }
enum	{ Specialized, BuiltIn }
enum	{ ColMajor = 0, RowMajor = 0x1, AutoAlign = 0, DontAlign = 0x2 }
	Enum containing possible values for the _Options template parameter of Matrix, Array and BandMatrix. More...
enum	{ OnTheLeft = 1, OnTheRight = 2 }
	Enum for specifying whether to apply or solve on the left or right. More...
enum	NoChange_t { NoChange }
enum	Sequential_t { Sequential }
enum	Default_t { Default }
enum	{ IsDense = 0, IsSparse }
enum	AccessorLevels { ReadOnlyAccessors, WriteAccessors, DirectAccessors, DirectWriteAccessors }
	Used as template parameter in DenseCoeffBase and MapBase to indicate which accessors should be provided. More...
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 with options to give to various decompositions. More...
enum	QRPreconditioners { NoQRPreconditioner, HouseholderQRPreconditioner, ColPivHouseholderQRPreconditioner, FullPivHouseholderQRPreconditioner }
	Possible values for the QRPreconditioner template parameter of JacobiSVD. More...
enum	ComputationInfo { Success = 0, NumericalIssue = 1, NoConvergence = 2, InvalidInput = 3 }
	Enum for reporting the status of a computation. More...
enum	TransformTraits { Isometry = 0x1, Affine = 0x2, AffineCompact = 0x10 | Affine, Projective = 0x20 }
	Enum used to specify how a particular transformation is stored in a matrix. More...
enum	{   CoeffBasedProductMode, LazyCoeffBasedProductMode, OuterProduct, InnerProduct,   GemvProduct, GemmProduct }
enum	Action { GetAction, SetAction }
enum	SimplicialCholeskyMode { SimplicialCholeskyLLT, SimplicialCholeskyLDLT }
enum	NumericalDiffMode { Forward, Central }
enum	AdditionalProductEvaluationMode { SkylineTimeDenseProduct, SkylineTimeSkylineProduct, DenseTimeSkylineProduct }
enum	{ IsSkyline = SkylineBit }
enum	{ SPD = 0x100, NonSymmetric = 0x0 }

Functions
void	outputQuat (std::ostream &os, Quaterniond const &q)
std::ostream &	operator<< (std::ostream &os, Quaterniond const &q)
void	PrintTo (Eigen::Quaterniond const &quat, ::std::ostream *os)
void	PrintTo (Eigen::Vector3d const &vec, ::std::ostream *os)
std::string	to_string (Eigen::Quaterniond const &quat)
	Helper to convert to string for messages.
std::string	to_string (Eigen::Vector3d const &vec)
	Helper to convert to string for messages.
template<typename _Scalar , int _Options, typename _Index >
cholmod_sparse	viewAsCholmod (SparseMatrix< _Scalar, _Options, _Index > &mat)
	Wraps the Eigen sparse matrix mat into a Cholmod sparse matrix object. More...
template<typename _Scalar , int _Options, typename _Index >
const cholmod_sparse	viewAsCholmod (const SparseMatrix< _Scalar, _Options, _Index > &mat)
template<typename _Scalar , int _Options, typename _Index , unsigned int UpLo>
cholmod_sparse	viewAsCholmod (const SparseSelfAdjointView< SparseMatrix< _Scalar, _Options, _Index >, UpLo > &mat)
	Returns a view of the Eigen sparse matrix mat as Cholmod sparse matrix. More...
template<typename Derived >
cholmod_dense	viewAsCholmod (MatrixBase< Derived > &mat)
	Returns a view of the Eigen dense matrix mat as Cholmod dense matrix. More...
template<typename Scalar , int Flags, typename Index >
MappedSparseMatrix< Scalar, Flags, Index >	viewAsEigen (cholmod_sparse &cm)
	Returns a view of the Cholmod sparse matrix cm as an Eigen sparse matrix. More...
template<typename Derived >
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_pow_op< typename Derived::Scalar >, const Derived >	pow (const Eigen::ArrayBase< Derived > &x, const typename Derived::Scalar &exponent)
template<typename Derived >
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_binary_pow_op< typename Derived::Scalar, typename Derived::Scalar >, const Derived, const Derived >	pow (const Eigen::ArrayBase< Derived > &x, const Eigen::ArrayBase< Derived > &exponents)
template<typename Derived >
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_inverse_mult_op< typename Derived::Scalar >, const Derived >	operator/ (const typename Derived::Scalar &s, const Eigen::ArrayBase< Derived > &a)
	Component-wise division of a scalar by array elements.
template<typename Derived , typename PermutationDerived >
const internal::permut_matrix_product_retval< PermutationDerived, Derived, OnTheRight >	operator* (const MatrixBase< Derived > &matrix, const PermutationBase< PermutationDerived > &permutation)
template<typename Derived , typename PermutationDerived >
const internal::permut_matrix_product_retval< PermutationDerived, Derived, OnTheLeft >	operator* (const PermutationBase< PermutationDerived > &permutation, const MatrixBase< Derived > &matrix)
template<typename Derived , typename Lhs , typename Rhs >
const ScaledProduct< Derived >	operator* (const ProductBase< Derived, Lhs, Rhs > &prod, const typename Derived::Scalar &x)
template<typename Derived , typename Lhs , typename Rhs >
internal::enable_if<!internal::is_same< typename Derived::Scalar, typename Derived::RealScalar >::value, const ScaledProduct< Derived > >::type	operator* (const ProductBase< Derived, Lhs, Rhs > &prod, const typename Derived::RealScalar &x)
template<typename Derived , typename Lhs , typename Rhs >
const ScaledProduct< Derived >	operator* (const typename Derived::Scalar &x, const ProductBase< Derived, Lhs, Rhs > &prod)
template<typename Derived , typename Lhs , typename Rhs >
internal::enable_if<!internal::is_same< typename Derived::Scalar, typename Derived::RealScalar >::value, const ScaledProduct< Derived > >::type	operator* (const typename Derived::RealScalar &x, const ProductBase< Derived, Lhs, Rhs > &prod)
std::ptrdiff_t	l1CacheSize ()
std::ptrdiff_t	l2CacheSize ()
void	setCpuCacheSizes (std::ptrdiff_t l1, std::ptrdiff_t l2)
	Set the cpu L1 and L2 cache sizes (in bytes). More...
void	initParallel ()
	Must be call first when calling Eigen from multiple threads.
int	nbThreads ()
void	setNbThreads (int v)
	Sets the max number of threads reserved for Eigen. More...
template<typename Derived , typename TranspositionsDerived >
const internal::transposition_matrix_product_retval< TranspositionsDerived, Derived, OnTheRight >	operator* (const MatrixBase< Derived > &matrix, const TranspositionsBase< TranspositionsDerived > &transpositions)
template<typename Derived , typename TranspositionDerived >
const internal::transposition_matrix_product_retval< TranspositionDerived, Derived, OnTheLeft >	operator* (const TranspositionsBase< TranspositionDerived > &transpositions, const MatrixBase< Derived > &matrix)
template<typename ExpressionType >
EIGEN_STRONG_INLINE const	EIGEN_CWISE_UNOP_RETURN_TYPE (internal::scalar_abs_op) Cwise< ExpressionType >
template<typename ExpressionType >
const	EIGEN_CWISE_UNOP_RETURN_TYPE (internal::scalar_sqrt_op) Cwise< ExpressionType >
template<typename Scalar >
Quaternion< Scalar >	ei_quaternion_product (const Quaternion< Scalar > &a, const Quaternion< Scalar > &b)
template<typename VectorType >
void	linearRegression (int numPoints, VectorType **points, VectorType *result, int funcOfOthers)
template<typename VectorType , typename HyperplaneType >
void	fitHyperplane (int numPoints, VectorType **points, HyperplaneType *result, typename NumTraits< typename VectorType::Scalar >::Real *soundness=0)
template<typename T >
NumTraits< T >::Real	ei_real (const T &x)
template<typename T >
NumTraits< T >::Real	ei_imag (const T &x)
template<typename T >
T	ei_conj (const T &x)
template<typename T >
NumTraits< T >::Real	ei_abs (const T &x)
template<typename T >
NumTraits< T >::Real	ei_abs2 (const T &x)
template<typename T >
T	ei_sqrt (const T &x)
template<typename T >
T	ei_exp (const T &x)
template<typename T >
T	ei_log (const T &x)
template<typename T >
T	ei_sin (const T &x)
template<typename T >
T	ei_cos (const T &x)
template<typename T >
T	ei_atan2 (const T &x, const T &y)
template<typename T >
T	ei_pow (const T &x, const T &y)
template<typename T >
T	ei_random ()
template<typename T >
T	ei_random (const T &x, const T &y)
template<typename T >
T	precision ()
template<typename T >
T	machine_epsilon ()
template<typename Scalar , typename OtherScalar >
bool	ei_isMuchSmallerThan (const Scalar &x, const OtherScalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
template<typename Scalar >
bool	ei_isApprox (const Scalar &x, const Scalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
template<typename Scalar >
bool	ei_isApproxOrLessThan (const Scalar &x, const Scalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
void *	ei_aligned_malloc (size_t size)
void	ei_aligned_free (void *ptr)
void *	ei_aligned_realloc (void *ptr, size_t new_size, size_t old_size)
void *	ei_handmade_aligned_malloc (size_t size)
void	ei_handmade_aligned_free (void *ptr)
template<bool Align>
void *	ei_conditional_aligned_malloc (size_t size)
template<bool Align>
void	ei_conditional_aligned_free (void *ptr)
template<bool Align>
void *	ei_conditional_aligned_realloc (void *ptr, size_t new_size, size_t old_size)
template<typename T >
T *	ei_aligned_new (size_t size)
template<typename T >
void	ei_aligned_delete (T *ptr, size_t size)
template<typename Scalar >
std::complex< Scalar >	cdiv (const Scalar &xr, const Scalar &xi, const Scalar &yr, const Scalar &yi)
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)
template<typename OtherDerived , typename VectorsType , typename CoeffsType , int Side>
internal::matrix_type_times_scalar_type< typename VectorsType::Scalar, OtherDerived >::Type	operator* (const MatrixBase< OtherDerived > &other, const HouseholderSequence< VectorsType, CoeffsType, Side > &h)
	Computes the product of a matrix with a Householder sequence. More...
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType >	householderSequence (const VectorsType &v, const CoeffsType &h)
	\ More...
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType, OnTheRight >	rightHouseholderSequence (const VectorsType &v, const CoeffsType &h)
	\ More...
template<typename SparseDerived , typename PermDerived >
const internal::permut_sparsematrix_product_retval< PermutationBase< PermDerived >, SparseDerived, OnTheRight, false >	operator* (const SparseMatrixBase< SparseDerived > &matrix, const PermutationBase< PermDerived > &perm)
template<typename SparseDerived , typename PermDerived >
const internal::permut_sparsematrix_product_retval< PermutationBase< PermDerived >, SparseDerived, OnTheLeft, false >	operator* (const PermutationBase< PermDerived > &perm, const SparseMatrixBase< SparseDerived > &matrix)
template<typename SparseDerived , typename PermDerived >
const internal::permut_sparsematrix_product_retval< PermutationBase< PermDerived >, SparseDerived, OnTheRight, true >	operator* (const SparseMatrixBase< SparseDerived > &matrix, const Transpose< PermutationBase< PermDerived > > &tperm)
template<typename SparseDerived , typename PermDerived >
const internal::permut_sparsematrix_product_retval< PermutationBase< PermDerived >, SparseDerived, OnTheLeft, true >	operator* (const Transpose< PermutationBase< PermDerived > > &tperm, const SparseMatrixBase< SparseDerived > &matrix)
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])
template<typename MatrixType >
void	convert (const MatrixType &m, gsl_matrix *&res)
template<typename MatrixType >
void	convert (const gsl_matrix *m, MatrixType &res)
template<typename VectorType >
void	convert (const VectorType &m, gsl_vector *&res)
template<typename VectorType >
void	convert (const gsl_vector *m, VectorType &res)
template<typename MatrixType >
void	convert (const MatrixType &m, gsl_matrix_complex *&res)
template<typename MatrixType >
void	convert (const gsl_matrix_complex *m, MatrixType &res)
template<typename VectorType >
void	convert (const VectorType &m, gsl_vector_complex *&res)
template<typename VectorType >
void	convert (const gsl_vector_complex *m, VectorType &res)
template<typename T >
NumTraits< T >::Real	test_precision ()
template<>
int	test_precision< int > ()
template<>
float	test_precision< float > ()
template<>
double	test_precision< double > ()
template<>
float	test_precision< std::complex< float > > ()
template<>
double	test_precision< std::complex< double > > ()
template<>
long double	test_precision< long double > ()
bool	test_ei_isApprox (const int &a, const int &b)
bool	test_ei_isMuchSmallerThan (const int &a, const int &b)
bool	test_ei_isApproxOrLessThan (const int &a, const int &b)
bool	test_ei_isApprox (const float &a, const float &b)
bool	test_ei_isMuchSmallerThan (const float &a, const float &b)
bool	test_ei_isApproxOrLessThan (const float &a, const float &b)
bool	test_ei_isApprox (const double &a, const double &b)
bool	test_ei_isMuchSmallerThan (const double &a, const double &b)
bool	test_ei_isApproxOrLessThan (const double &a, const double &b)
bool	test_ei_isApprox (const std::complex< float > &a, const std::complex< float > &b)
bool	test_ei_isMuchSmallerThan (const std::complex< float > &a, const std::complex< float > &b)
bool	test_ei_isApprox (const std::complex< double > &a, const std::complex< double > &b)
bool	test_ei_isMuchSmallerThan (const std::complex< double > &a, const std::complex< double > &b)
bool	test_ei_isApprox (const long double &a, const long double &b)
bool	test_ei_isMuchSmallerThan (const long double &a, const long double &b)
bool	test_ei_isApproxOrLessThan (const long double &a, const long double &b)
template<typename Type1 , typename Type2 >
bool	test_ei_isApprox (const Type1 &a, const Type2 &b)
template<typename Derived1 , typename Derived2 >
bool	test_ei_isMuchSmallerThan (const MatrixBase< Derived1 > &m1, const MatrixBase< Derived2 > &m2)
template<typename Derived >
bool	test_ei_isMuchSmallerThan (const MatrixBase< Derived > &m, const typename NumTraits< typename ei_traits< Derived >::Scalar >::Real &s)
bool	test_isApprox (const int &a, const int &b)
bool	test_isMuchSmallerThan (const int &a, const int &b)
bool	test_isApproxOrLessThan (const int &a, const int &b)
bool	test_isApprox (const float &a, const float &b)
bool	test_isMuchSmallerThan (const float &a, const float &b)
bool	test_isApproxOrLessThan (const float &a, const float &b)
bool	test_isApprox (const double &a, const double &b)
bool	test_isMuchSmallerThan (const double &a, const double &b)
bool	test_isApproxOrLessThan (const double &a, const double &b)
bool	test_isApprox (const std::complex< float > &a, const std::complex< float > &b)
bool	test_isMuchSmallerThan (const std::complex< float > &a, const std::complex< float > &b)
bool	test_isApprox (const std::complex< double > &a, const std::complex< double > &b)
bool	test_isMuchSmallerThan (const std::complex< double > &a, const std::complex< double > &b)
bool	test_isApprox (const long double &a, const long double &b)
bool	test_isMuchSmallerThan (const long double &a, const long double &b)
bool	test_isApproxOrLessThan (const long double &a, const long double &b)
template<typename Type1 , typename Type2 >
bool	test_isApprox (const Type1 &a, const Type2 &b)
template<typename Scalar , typename ScalarRef >
bool	test_isApproxWithRef (const Scalar &a, const Scalar &b, const ScalarRef &ref)
template<typename Derived1 , typename Derived2 >
bool	test_isMuchSmallerThan (const MatrixBase< Derived1 > &m1, const MatrixBase< Derived2 > &m2)
template<typename Derived >
bool	test_isMuchSmallerThan (const MatrixBase< Derived > &m, const typename NumTraits< typename internal::traits< Derived >::Scalar >::Real &s)
template<typename Derived >
bool	test_isUnitary (const MatrixBase< Derived > &m)
template<typename T , typename U >
bool	test_is_equal (const T &actual, const U &expected)
template<typename MatrixType >
void	createRandomPIMatrixOfRank (typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType &m)
	Creates a random Partial Isometry matrix of given rank. More...
template<typename PermutationVectorType >
void	randomPermutationVector (PermutationVectorType &v, typename PermutationVectorType::Index size)
template<typename T >
bool	isNotNaN (const T &x)
template<typename T >
bool	isNaN (const T &x)
template<typename T >
bool	isInf (const T &x)
template<typename T >
bool	isMinusInf (const T &x)
template<typename DerType >
const AutoDiffScalar< DerType > &	conj (const AutoDiffScalar< DerType > &x)
template<typename DerType >
const AutoDiffScalar< DerType > &	real (const AutoDiffScalar< DerType > &x)
template<typename DerType >
DerType::Scalar	imag (const AutoDiffScalar< DerType > &)
template<typename DerType , typename T >
	AutoDiffScalar< DerType > (min)(const AutoDiffScalar< DerType > &x
template<typename DerType , typename T >
	AutoDiffScalar< DerType > (max)(const AutoDiffScalar< DerType > &x
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (abs, using std::abs;return ReturnType(abs(x.value()), x.derivatives() *(x.value()< 0 ? -1 :1));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2
return	ReturnType (abs2(x.value()), x.derivatives() *(Scalar(2) *x.value()))
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sqrt, using std::sqrt;Scalar sqrtx=sqrt(x.value());return ReturnType(sqrtx, x.derivatives() *(Scalar(0.5)/sqrtx));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos
return	ReturnType (cos(x.value()), x.derivatives() *(-sin(x.value())))
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sin, using std::sin;using std::cos;return ReturnType(sin(x.value()), x.derivatives() *cos(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp
return	ReturnType (expx, x.derivatives() *expx)
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (log, using std::log;return ReturnType(log(x.value()), x.derivatives() *(Scalar(1)/x.value()));) template< typename DerType > inline const Eigen
template<typename DerTypeA , typename DerTypeB >
const AutoDiffScalar< Matrix< typename internal::traits< DerTypeA >::Scalar, Dynamic, 1 > >	atan2 (const AutoDiffScalar< DerTypeA > &a, const AutoDiffScalar< DerTypeB > &b)
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (tan, using std::tan;using std::cos;return ReturnType(tan(x.value()), x.derivatives() *(Scalar(1)/numext::abs2(cos(x.value()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(asin
return	ReturnType (asin(x.value()), x.derivatives() *(Scalar(1)/sqrt(1-numext::abs2(x.value()))))
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (acos, using std::sqrt;using std::acos;return ReturnType(acos(x.value()), x.derivatives() *(Scalar(-1)/sqrt(1-numext::abs2(x.value()))));) template< typename DerType > struct NumTraits< AutoDiffScalar< DerType > >
template<typename BVH , typename Intersector >
void	BVIntersect (const BVH &tree, Intersector &intersector)
	Given a BVH, runs the query encapsulated by intersector. More...
template<typename BVH1 , typename BVH2 , typename Intersector >
void	BVIntersect (const BVH1 &tree1, const BVH2 &tree2, Intersector &intersector)
	Given two BVH's, runs the query on their Cartesian product encapsulated by intersector. More...
template<typename BVH , typename Minimizer >
Minimizer::Scalar	BVMinimize (const BVH &tree, Minimizer &minimizer)
	Given a BVH, runs the query encapsulated by minimizer. More...
template<typename BVH1 , typename BVH2 , typename Minimizer >
Minimizer::Scalar	BVMinimize (const BVH1 &tree1, const BVH2 &tree2, Minimizer &minimizer)
	Given two BVH's, runs the query on their cartesian product encapsulated by minimizer. More...
void	ssaupd_ (int *ido, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *info)
void	sseupd_ (int *rvec, char *All, int *select, float *d, float *z, int *ldz, float *sigma, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *ierr)
void	dsaupd_ (int *ido, char *bmat, int *n, char *which, int *nev, double *tol, double *resid, int *ncv, double *v, int *ldv, int *iparam, int *ipntr, double *workd, double *workl, int *lworkl, int *info)
void	dseupd_ (int *rvec, char *All, int *select, double *d, double *z, int *ldz, double *sigma, char *bmat, int *n, char *which, int *nev, double *tol, double *resid, int *ncv, double *v, int *ldv, int *iparam, int *ipntr, double *workd, double *workl, int *lworkl, int *ierr)
template<typename A , typename B >
KroneckerProduct< A, B >	kroneckerProduct (const MatrixBase< A > &a, const MatrixBase< B > &b)
template<typename A , typename B >
KroneckerProductSparse< A, B >	kroneckerProduct (const EigenBase< A > &a, const EigenBase< B > &b)
template<typename Polynomials , typename T >
T	poly_eval_horner (const Polynomials &poly, const T &x)
template<typename Polynomials , typename T >
T	poly_eval (const Polynomials &poly, const T &x)
template<typename Polynomial >
NumTraits< typename Polynomial::Scalar >::Real	cauchy_max_bound (const Polynomial &poly)
template<typename Polynomial >
NumTraits< typename Polynomial::Scalar >::Real	cauchy_min_bound (const Polynomial &poly)
template<typename RootVector , typename Polynomial >
void	roots_to_monicPolynomial (const RootVector &rv, Polynomial &poly)
	Given the roots of a polynomial compute the coefficients in the monomial basis of the monic polynomial with same roots and minimal degree. More...
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<typename SplineType , typename DerivativeType >
void	derivativesImpl (const SplineType &spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType &der)
template<typename SplineType , typename DerivativeType >
void	basisFunctionDerivativesImpl (const SplineType &spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType &N_)
template<typename KnotVectorType >
void	KnotAveraging (const KnotVectorType &parameters, DenseIndex degree, KnotVectorType &knots)
	Computes knot averages. More...
template<typename PointArrayType , typename KnotVectorType >
void	ChordLengths (const PointArrayType &pts, KnotVectorType &chord_lengths)
	Computes chord length parameters which are required for spline interpolation. More...
template<typename Scalar , int Dim>
AlignedBox< Scalar, Dim >	bounding_box (const Matrix< Scalar, Dim, 1 > &v)

Variables
const int	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. More...
const int	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.
const int	Infinity = -1
	This value means +Infinity; it is currently used only as the p parameter to MatrixBase::lpNorm<int>(). More...
const unsigned int	RowMajorBit = 0x1
	for a matrix, this means that the storage order is row-major. More...
const unsigned int	EvalBeforeNestingBit = 0x2
	means the expression should be evaluated by the calling expression
const unsigned int	EvalBeforeAssigningBit = 0x4
	means the expression should be evaluated before any assignment
const unsigned int	PacketAccessBit = 0x8
	Short version: means the expression might be vectorized. More...
const unsigned int	ActualPacketAccessBit = 0x0
const unsigned int	LinearAccessBit = 0x10
	Short version: means the expression can be seen as 1D vector. More...
const unsigned int	LvalueBit = 0x20
	Means the expression has a coeffRef() method, i.e. More...
const unsigned int	DirectAccessBit = 0x40
	Means that the underlying array of coefficients can be directly accessed as a plain strided array. More...
const unsigned int	AlignedBit = 0x80
	means the first coefficient packet is guaranteed to be aligned
const unsigned int	NestByRefBit = 0x100
const unsigned int	HereditaryBits
const unsigned int	UnitDiagBit = UnitDiag
const unsigned int	SelfAdjointBit = SelfAdjoint
const unsigned int	UpperTriangularBit = Upper
const unsigned int	LowerTriangularBit = Lower
const unsigned int	UpperTriangular = Upper
const unsigned int	LowerTriangular = Lower
const unsigned int	UnitUpperTriangular = UnitUpper
const unsigned int	UnitLowerTriangular = UnitLower
const int	CoherentAccessPattern = 0x1
const int	InnerRandomAccessPattern = 0x2 | CoherentAccessPattern
const int	OuterRandomAccessPattern = 0x4 | CoherentAccessPattern
const int	RandomAccessPattern = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern
const T &	y { return (x <= y ? x : y)
Scalar	expx = exp(x.value())
const unsigned int	SkylineBit = 0x1200

Detailed Description

iterative scaling algorithm to equilibrate rows and column norms in matrices

This class can be used as a preprocessing tool to accelerate the convergence of iterative methods

This feature is useful to limit the pivoting amount during LU/ILU factorization The scaling strategy as presented here preserves the symmetry of the problem NOTE It is assumed that the matrix does not have empty row or column,

Example with key steps

VectorXd x(n), b(n);
SparseMatrix<double> A;
// fill A and b;
IterScaling<SparseMatrix<double> > scal; 
// Compute the left and right scaling vectors. The matrix is equilibrated at output
scal.computeRef(A); 
// Scale the right hand side
b = scal.LeftScaling().cwiseProduct(b); 
// Now, solve the equilibrated linear system with any available solver

// Scale back the computed solution
x = scal.RightScaling().cwiseProduct(x); 

Template Parameters

_MatrixType

the type of the matrix. It should be a real square sparsematrix

References : D. Ruiz and B. Ucar, A Symmetry Preserving Algorithm for Matrix Scaling, INRIA Research report RR-7552

See also

IncompleteLUT

Typedef Documentation

Spline2d

typedef Spline<double,2> Eigen::Spline2d

2D double B-spline with dynamic degree.

Spline2f

typedef Spline<float,2> Eigen::Spline2f

2D float B-spline with dynamic degree.

Spline3d

typedef Spline<double,3> Eigen::Spline3d

3D double B-spline with dynamic degree.

Spline3f

typedef Spline<float,3> Eigen::Spline3f

3D float B-spline with dynamic degree.

Function Documentation

BVIntersect() [1/2]

template<typename BVH , typename Intersector >

void Eigen::BVIntersect	(	const BVH &	tree,
		Intersector &	intersector
	)

Given a BVH, runs the query encapsulated by intersector.

The Intersector type must provide the following members:

bool intersectVolume(const BVH::Volume &volume) //returns true if volume intersects the query
bool intersectObject(const BVH::Object &object) //returns true if the search should terminate immediately

BVIntersect() [2/2]

template<typename BVH1 , typename BVH2 , typename Intersector >

void Eigen::BVIntersect	(	const BVH1 &	tree1,
		const BVH2 &	tree2,
		Intersector &	intersector
	)

Given two BVH's, runs the query on their Cartesian product encapsulated by intersector.

The Intersector type must provide the following members:

bool intersectVolumeVolume(const BVH1::Volume &v1, const BVH2::Volume &v2) //returns true if product of volumes intersects the query
bool intersectVolumeObject(const BVH1::Volume &v1, const BVH2::Object &o2) //returns true if the volume-object product intersects the query
bool intersectObjectVolume(const BVH1::Object &o1, const BVH2::Volume &v2) //returns true if the volume-object product intersects the query
bool intersectObjectObject(const BVH1::Object &o1, const BVH2::Object &o2) //returns true if the search should terminate immediately

BVMinimize() [1/2]

template<typename BVH , typename Minimizer >

Minimizer::Scalar Eigen::BVMinimize	(	const BVH &	tree,
		Minimizer &	minimizer
	)

Given a BVH, runs the query encapsulated by minimizer.

Returns

the minimum value. The Minimizer type must provide the following members:

typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has one)
Scalar minimumOnVolume(const BVH::Volume &volume)
Scalar minimumOnObject(const BVH::Object &object)

BVMinimize() [2/2]

template<typename BVH1 , typename BVH2 , typename Minimizer >

Minimizer::Scalar Eigen::BVMinimize	(	const BVH1 &	tree1,
		const BVH2 &	tree2,
		Minimizer &	minimizer
	)

Given two BVH's, runs the query on their cartesian product encapsulated by minimizer.

Returns

the minimum value. The Minimizer type must provide the following members:

typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has one)
Scalar minimumOnVolumeVolume(const BVH1::Volume &v1, const BVH2::Volume &v2)
Scalar minimumOnVolumeObject(const BVH1::Volume &v1, const BVH2::Object &o2)
Scalar minimumOnObjectVolume(const BVH1::Object &o1, const BVH2::Volume &v2)
Scalar minimumOnObjectObject(const BVH1::Object &o1, const BVH2::Object &o2)

cauchy_max_bound()

template<typename Polynomial >

NumTraits<typename Polynomial::Scalar>::Real Eigen::cauchy_max_bound ( const Polynomial &  poly )

inline

Returns

a maximum bound for the absolute value of any root of the polynomial.

Parameters

[in]

poly

: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. \( 1 + 3x^2 \) is stored as a vector \( [ 1, 0, 3 ] \).

Precondition: the leading coefficient of the input polynomial poly must be non zero

cauchy_min_bound()

template<typename Polynomial >

NumTraits<typename Polynomial::Scalar>::Real Eigen::cauchy_min_bound ( const Polynomial &  poly )

inline

Returns

a minimum bound for the absolute value of any non zero root of the polynomial.

Parameters

[in]

poly

: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. \( 1 + 3x^2 \) is stored as a vector \( [ 1, 0, 3 ] \).

createRandomPIMatrixOfRank()

template<typename MatrixType >

void Eigen::createRandomPIMatrixOfRank	(	typename MatrixType::Index	desired_rank,
		typename MatrixType::Index	rows,
		typename MatrixType::Index	cols,
		MatrixType &	m
	)

Creates a random Partial Isometry matrix of given rank.

A partial isometry is a matrix all of whose singular values are either 0 or 1. This is very useful to test rank-revealing algorithms.

EIGEN_CWISE_UNOP_RETURN_TYPE() [1/2]

template<typename ExpressionType >

EIGEN_STRONG_INLINE const Eigen::EIGEN_CWISE_UNOP_RETURN_TYPE

(

internal::scalar_abs_op

)

Deprecated:

ArrayBase::abs()

Deprecated:

ArrayBase::abs2()

Deprecated:

ArrayBase::exp()

Deprecated:

ArrayBase::log()

Deprecated:

ArrayBase::operator*()

Deprecated:

ArrayBase::operator/()

Deprecated:

ArrayBase::operator*=()

EIGEN_CWISE_UNOP_RETURN_TYPE() [2/2]

template<typename ExpressionType >

const Eigen::EIGEN_CWISE_UNOP_RETURN_TYPE ( internal::scalar_sqrt_op  )

inline

Deprecated:

ArrayBase::sqrt()

Deprecated:

ArrayBase::cos()

Deprecated:

ArrayBase::sin()

Deprecated:

ArrayBase::log()

Deprecated:

ArrayBase::inverse()

Deprecated:

ArrayBase::square()

Deprecated:

ArrayBase::cube()

Deprecated:

ArrayBase::operator<()

Deprecated:

ArrayBase::<=()

Deprecated:

ArrayBase::operator>()

Deprecated:

ArrayBase::operator>=()

Deprecated:

ArrayBase::operator==()

Deprecated:

ArrayBase::operator!=()

Deprecated:

ArrayBase::operator<(Scalar)

Deprecated:

ArrayBase::operator<=(Scalar)

Deprecated:

ArrayBase::operator>(Scalar)

Deprecated:

ArrayBase::operator>=(Scalar)

Deprecated:

ArrayBase::operator==(Scalar)

Deprecated:

ArrayBase::operator!=(Scalar)

Deprecated:

ArrayBase::operator+(Scalar)

Deprecated:

ArrayBase::operator+=(Scalar)

fitHyperplane()

template<typename VectorType , typename HyperplaneType >

void Eigen::fitHyperplane	(	int	numPoints,
		VectorType **	points,
		HyperplaneType *	result,
		typename NumTraits< typename VectorType::Scalar >::Real *	soundness = 0
	)

This function is quite similar to linearRegression(), so we refer to the documentation of this function and only list here the differences.

The main difference from linearRegression() is that this function doesn't take a funcOfOthers argument. Instead, it finds a general equation of the form

\[ r_0 x_0 + \cdots + r_{n-1}x_{n-1} + r_n = 0, \]

where \(n=Size\), \(r_i=retCoefficients[i]\), and we denote by \(x_0,\ldots,x_{n-1}\) the n coordinates in the n-dimensional space.

Thus, the vector retCoefficients has size \(n+1\), which is another difference from linearRegression().

In practice, this function performs an hyper-plane fit in a total least square sense via the following steps: 1 - center the data to the mean 2 - compute the covariance matrix 3 - pick the eigenvector corresponding to the smallest eigenvalue of the covariance matrix The ratio of the smallest eigenvalue and the second one gives us a hint about the relevance of the solution. This value is optionally returned in soundness.

See also

linearRegression()

kroneckerProduct() [1/2]

template<typename A , typename B >

KroneckerProduct<A,B> Eigen::kroneckerProduct	(	const MatrixBase< A > &	a,
		const MatrixBase< B > &	b
	)

Computes Kronecker tensor product of two dense matrices

Warning

If you want to replace a matrix by its Kronecker product with some matrix, do NOT do this:

A = kroneckerProduct(A,B); // bug!!! caused by aliasing effect

instead, use eval() to work around this:

A = kroneckerProduct(A,B).eval();

Parameters

a	Dense matrix a
b	Dense matrix b

Returns

Kronecker tensor product of a and b

kroneckerProduct() [2/2]

template<typename A , typename B >

KroneckerProductSparse<A,B> Eigen::kroneckerProduct	(	const EigenBase< A > &	a,
		const EigenBase< B > &	b
	)

Computes Kronecker tensor product of two matrices, at least one of which is sparse

Parameters

a	Dense/sparse matrix a
b	Dense/sparse matrix b

Returns

Kronecker tensor product of a and b, stored in a sparse matrix

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

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

linearRegression()

template<typename VectorType >

void Eigen::linearRegression	(	int	numPoints,
		VectorType **	points,
		VectorType *	result,
		int	funcOfOthers
	)

For a set of points, this function tries to express one of the coords as a linear (affine) function of the other coords.

This is best explained by an example. This function works in full generality, for points in a space of arbitrary dimension, and also over the complex numbers, but for this example we will work in dimension 3 over the real numbers (doubles).

So let us work with the following set of 5 points given by their \((x,y,z)\) coordinates:

Vector3d points[5];
points[0] = Vector3d( 3.02, 6.89, -4.32 );
points[1] = Vector3d( 2.01, 5.39, -3.79 );
points[2] = Vector3d( 2.41, 6.01, -4.01 );
points[3] = Vector3d( 2.09, 5.55, -3.86 );
points[4] = Vector3d( 2.58, 6.32, -4.10 );

Suppose that we want to express the second coordinate ( \(y\)) as a linear expression in \(x\) and \(z\), that is,

\[ y=ax+bz+c \]

for some constants \(a,b,c\). Thus, we want to find the best possible constants \(a,b,c\) so that the plane of equation \(y=ax+bz+c\) fits best the five above points. To do that, call this function as follows:

Vector3d coeffs; // will store the coefficients a, b, c
linearRegression(
  5,
  &points,
  &coeffs,
  1 // the coord to express as a function of
    // the other ones. 0 means x, 1 means y, 2 means z.
);

Now the vector coeffs is approximately \(( 0.495 , -1.927 , -2.906 )\). Thus, we get \(a=0.495, b = -1.927, c = -2.906\). Let us check for instance how near points[0] is from the plane of equation \(y=ax+bz+c\). Looking at the coords of points[0], we see that:

\[ax+bz+c = 0.495 * 3.02 + (-1.927) * (-4.32) + (-2.906) = 6.91.\]

On the other hand, we have \(y=6.89\). We see that the values \(6.91\) and \(6.89\) are near, so points[0] is very near the plane of equation \(y=ax+bz+c\).

Let's now describe precisely the parameters:

Parameters

numPoints	the number of points
points	the array of pointers to the points on which to perform the linear regression
result	pointer to the vector in which to store the result. This vector must be of the same type and size as the data points. The meaning of its coords is as follows. For brevity, let \(n=Size\), \(r_i=result[i]\), and \(f=funcOfOthers\). Denote by \(x_0,\ldots,x_{n-1}\) the n coordinates in the n-dimensional space. Then the resulting equation is: \[ x_f = r_0 x_0 + \cdots + r_{f-1}x_{f-1} + r_{f+1}x_{f+1} + \cdots + r_{n-1}x_{n-1} + r_n. \]
funcOfOthers	Determines which coord to express as a function of the others. Coords are numbered starting from 0, so that a value of 0 means \(x\), 1 means \(y\), 2 means \(z\), ...

See also

fitHyperplane()

nbThreads()

int Eigen::nbThreads ( )

inline

Returns

the max number of threads reserved for Eigen

See also

setNbThreads

operator*() [1/9]

template<typename SparseDerived , typename PermDerived >

const internal::permut_sparsematrix_product_retval<PermutationBase<PermDerived>, SparseDerived, OnTheRight, false> Eigen::operator* ( const SparseMatrixBase< SparseDerived > &  matrix, const PermutationBase< PermDerived > &  perm  )

inline

Returns

the matrix with the permutation applied to the columns

operator*() [2/9]

template<typename SparseDerived , typename PermDerived >

const internal::permut_sparsematrix_product_retval<PermutationBase<PermDerived>, SparseDerived, OnTheLeft, false> Eigen::operator* ( const PermutationBase< PermDerived > &  perm, const SparseMatrixBase< SparseDerived > &  matrix  )

inline

Returns

the matrix with the permutation applied to the rows

operator*() [3/9]

template<typename SparseDerived , typename PermDerived >

const internal::permut_sparsematrix_product_retval<PermutationBase<PermDerived>, SparseDerived, OnTheRight, true> Eigen::operator* ( const SparseMatrixBase< SparseDerived > &  matrix, const Transpose< PermutationBase< PermDerived > > &  tperm  )

inline

Returns

the matrix with the inverse permutation applied to the columns.

operator*() [4/9]

template<typename SparseDerived , typename PermDerived >

const internal::permut_sparsematrix_product_retval<PermutationBase<PermDerived>, SparseDerived, OnTheLeft, true> Eigen::operator* ( const Transpose< PermutationBase< PermDerived > > &  tperm, const SparseMatrixBase< SparseDerived > &  matrix  )

inline

Returns

the matrix with the inverse permutation applied to the rows.

operator*() [5/9]

template<typename Derived , typename TranspositionsDerived >

const internal::transposition_matrix_product_retval<TranspositionsDerived, Derived, OnTheRight> Eigen::operator* ( const MatrixBase< Derived > &  matrix, const TranspositionsBase< TranspositionsDerived > &  transpositions  )

inline

Returns

the matrix with the transpositions applied to the columns.

operator*() [6/9]

template<typename Derived , typename TranspositionDerived >

const internal::transposition_matrix_product_retval<TranspositionDerived, Derived, OnTheLeft> Eigen::operator* ( const TranspositionsBase< TranspositionDerived > &  transpositions, const MatrixBase< Derived > &  matrix  )

inline

Returns

the matrix with the transpositions applied to the rows.

operator*() [7/9]

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

internal::matrix_type_times_scalar_type<typename VectorsType::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 \( MH \) where \( M \) is the matrix other and \( H \) is the Householder sequence represented by h.

operator*() [8/9]

template<typename Derived , typename PermutationDerived >

const internal::permut_matrix_product_retval<PermutationDerived, Derived, OnTheRight> Eigen::operator* ( const MatrixBase< Derived > &  matrix, const PermutationBase< PermutationDerived > &  permutation  )

inline

Returns

the matrix with the permutation applied to the columns.

operator*() [9/9]

template<typename Derived , typename PermutationDerived >

const internal::permut_matrix_product_retval<PermutationDerived, Derived, OnTheLeft> Eigen::operator* ( const PermutationBase< PermutationDerived > &  permutation, const MatrixBase< Derived > &  matrix  )

inline

Returns

the matrix with the permutation applied to the rows.

poly_eval()

template<typename Polynomials , typename T >

T Eigen::poly_eval ( const Polynomials &  poly, const T &  x  )

inline

Returns

the evaluation of the polynomial at x using stabilized Horner algorithm.

Parameters

[in]	poly	: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. \( 1 + 3x^2 \) is stored as a vector \( [ 1, 0, 3 ] \).
[in]	x	: the value to evaluate the polynomial at.

poly_eval_horner()

template<typename Polynomials , typename T >

T Eigen::poly_eval_horner ( const Polynomials &  poly, const T &  x  )

inline

Returns

the evaluation of the polynomial at x using Horner algorithm.

Parameters

[in]	poly	: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. \( 1 + 3x^2 \) is stored as a vector \( [ 1, 0, 3 ] \).
[in]	x	: the value to evaluate the polynomial at.

Note for stability: \( |x| \le 1 \)

roots_to_monicPolynomial()

template<typename RootVector , typename Polynomial >

void Eigen::roots_to_monicPolynomial	(	const RootVector &	rv,
		Polynomial &	poly
	)

Given the roots of a polynomial compute the coefficients in the monomial basis of the monic polynomial with same roots and minimal degree.

If RootVector is a vector of complexes, Polynomial should also be a vector of complexes.

Parameters

[in]	rv	: a vector containing the roots of a polynomial.
[out]	poly	: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. \( 3 + x^2 \) is stored as a vector \( [ 3, 0, 1 ] \).

setCpuCacheSizes()

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

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

setNbThreads()

void Eigen::setNbThreads ( int  v )

inline

Sets the max number of threads reserved for Eigen.

See also

nbThreads

viewAsCholmod() [1/3]

template<typename _Scalar , int _Options, typename _Index >

cholmod_sparse Eigen::viewAsCholmod

(

SparseMatrix< _Scalar, _Options, _Index > &

mat

)

Wraps the Eigen sparse matrix mat into a Cholmod sparse matrix object.

Note that the data are shared.

viewAsCholmod() [2/3]

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

cholmod_sparse Eigen::viewAsCholmod

(

const SparseSelfAdjointView< 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.

viewAsCholmod() [3/3]

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.

viewAsEigen()

template<typename Scalar , int Flags, typename Index >

MappedSparseMatrix<Scalar,Flags,Index> 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.

Variable Documentation

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.

HereditaryBits

const unsigned int Eigen::HereditaryBits

Initial value:

= RowMajorBit
                                  | EvalBeforeNestingBit
                                  | EvalBeforeAssigningBit

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.