Namespaces
namespace	Architecture
namespace	internal
namespace	numext
Classes
class	LDLT
	Robust Cholesky decomposition of a matrix with pivoting. More...
class	LLT
	Standard Cholesky decomposition (LL^T) of a matrix and associated features. More...
class	CholmodBase
	The base class for the direct Cholesky factorization of Cholmod. More...
class	CholmodSimplicialLLT
	A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod. More...
class	CholmodSimplicialLDLT
	A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod. More...
class	CholmodSupernodalLLT
	A supernodal Cholesky (LLT) factorization and solver based on Cholmod. More...
class	CholmodDecomposition
	A general Cholesky factorization and solver based on Cholmod. 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...
class	MatrixWrapper
	Expression of an array as a mathematical vector or matrix. More...
class	Block
	Expression of a fixed-size or dynamic-size block. More...
class	BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Dense >
class	CommaInitializer
	Helper class used by the comma initializer operator. More...
class	InnerIterator
	An InnerIterator allows to loop over the element of any matrix expression. More...
class	CwiseBinaryOp
	Generic expression where a coefficient-wise binary operator is applied to two expressions. More...
class	CwiseBinaryOpImpl
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	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	DenseBase
	Base class for all dense matrices, vectors, 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...
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	DenseStorage
	Stores the data of a matrix. More...
class	DenseStorage< T, 0, _Rows, _Cols, _Options >
class	DenseStorage< T, 0, Dynamic, Dynamic, _Options >
class	DenseStorage< T, 0, _Rows, Dynamic, _Options >
class	DenseStorage< T, 0, Dynamic, _Cols, _Options >
class	DenseStorage< T, Size, Dynamic, Dynamic, _Options >
class	DenseStorage< T, Size, Dynamic, _Cols, _Options >
class	DenseStorage< T, Size, _Rows, Dynamic, _Options >
class	DenseStorage< T, Dynamic, Dynamic, Dynamic, _Options >
class	DenseStorage< T, Dynamic, _Rows, Dynamic, _Options >
class	DenseStorage< T, Dynamic, Dynamic, _Cols, _Options >
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	DiagonalWrapper
	Expression of a diagonal matrix. More...
class	EigenBase
class	ForceAlignedAccess
	Enforce aligned packet loads and stores regardless of what is requested. More...
class	Inverse
	Expression of the inverse of another expression. More...
class	InverseImpl
class	IOFormat
	Stores a set of parameters controlling the way matrices are printed. More...
class	WithFormat
	Pseudo expression providing matrix output with given format. More...
class	Map
	A matrix or vector expression mapping an existing array of data. More...
class	MapBase< Derived, ReadOnlyAccessors >
class	MapBase< Derived, WriteAccessors >
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	NestByValue
	Expression which must be nested by value. More...
class	NoAlias
	Pseudo expression providing an operator = assuming no aliasing. More...
struct	GenericNumTraits
class	NumTraits
	Holds information about the various numeric (i.e. scalar) types allowed by Eigen. More...
struct	NumTraits< float >
struct	NumTraits< double >
struct	NumTraits< long double >
struct	NumTraits< std::complex< _Real > >
struct	NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
class	PermutationBase
	Base class for permutations. More...
class	PermutationMatrix
	Permutation matrix. More...
class	Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >, _PacketAccess >
class	PermutationWrapper
	Class to view a vector of integers as a permutation matrix. More...
class	InverseImpl< PermutationType, PermutationStorage >
class	PlainObjectBase
	Dense storage base class for matrices and arrays. More...
class	Product
	Expression of the product of two arbitrary matrices or vectors. More...
class	ProductImpl
class	ProductImpl< Lhs, Rhs, Option, Dense >
struct	general_product_to_triangular_selector< MatrixType, ProductType, UpLo, true >
struct	general_product_to_triangular_selector< MatrixType, ProductType, UpLo, false >
struct	selfadjoint_rank1_update< Scalar, Index, ColMajor, UpLo, ConjLhs, ConjRhs >
struct	selfadjoint_rank1_update< Scalar, Index, RowMajor, UpLo, ConjLhs, ConjRhs >
struct	selfadjoint_product_selector< MatrixType, OtherType, UpLo, true >
struct	selfadjoint_product_selector< MatrixType, OtherType, UpLo, false >
class	RefBase
class	Ref
	A matrix or vector expression mapping an existing expression. More...
class	Ref< const TPlainObjectType, Options, StrideType >
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	Select
	Expression of a coefficient wise version of the C++ ternary operator ?: More...
class	SelfAdjointView
	Expression of a selfadjoint matrix from a triangular part of a dense matrix. More...
class	Solve
	Pseudo expression representing a solving operation. More...
class	SolveImpl< Decomposition, RhsType, Dense >
class	SolveImpl
class	SolverBase
	A base class for matrix decomposition and solvers. More...
class	Stride
	Holds strides information for Map. More...
class	InnerStride
	Convenience specialization of Stride to specify only an inner stride See class Map for some examples. More...
class	OuterStride
	Convenience specialization of Stride to specify only an outer stride See class Map for some examples. More...
class	Transpose
	Expression of the transpose of a matrix. More...
class	TransposeImpl
class	TransposeImpl< MatrixType, Dense >
class	TranspositionsBase
class	Transpositions
	Represents a sequence of transpositions (row/column interchange) More...
class	Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >, PacketAccess >
class	TranspositionsWrapper
class	Transpose< TranspositionsBase< TranspositionsDerived > >
class	TriangularBase
	Base class for triangular part in a matrix. More...
class	TriangularView
	Expression of a triangular part in a matrix. More...
class	TriangularViewImpl< _MatrixType, _Mode, Dense >
	Base class for a triangular part in a dense matrix. More...
struct	Dense
struct	Sparse
struct	SolverStorage
struct	PermutationStorage
struct	TranspositionsStorage
struct	MatrixXpr
struct	ArrayXpr
struct	DenseShape
struct	SolverShape
struct	HomogeneousShape
struct	DiagonalShape
struct	BandShape
struct	TriangularShape
struct	SelfAdjointShape
struct	PermutationShape
struct	TranspositionsShape
struct	SparseShape
class	aligned_allocator
	STL compatible allocator to use with with 16 byte aligned types. More...
class	VectorBlock
	Expression of a fixed-size or dynamic-size sub-vector. More...
class	PartialReduxExpr
	Generic expression of a partially reduxed matrix. More...
class	VectorwiseOp
	Pseudo expression providing partial reduction operations. 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	EigenSolver
	Computes eigenvalues and eigenvectors of general matrices. More...
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...
class	HessenbergDecomposition
	Reduces a square matrix to Hessenberg form by an orthogonal similarity transformation. 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	SelfAdjointEigenSolver
	Computes eigenvalues and eigenvectors of selfadjoint matrices. More...
class	Tridiagonalization
	Tridiagonal decomposition of a selfadjoint matrix. More...
class	AlignedBox
	An axis aligned box. More...
class	AngleAxis
	Represents a 3D rotation as a rotation angle around an arbitrary 3D axis. More...
class	Homogeneous
	Expression of one (or a set of) homogeneous vector(s) More...
class	Hyperplane
	A hyperplane. More...
class	ParametrizedLine
	A parametrized line. More...
class	QuaternionBase
	Base class for quaternion expressions. More...
class	Quaternion
	The quaternion class used to represent 3D orientations and rotations. More...
class	Map< const Quaternion< _Scalar >, _Options >
	Quaternion expression mapping a constant memory buffer. More...
class	Map< Quaternion< _Scalar >, _Options >
	Expression of a quaternion from a memory buffer. More...
class	Rotation2D
	Represents a rotation/orientation in a 2 dimensional space. More...
class	RotationBase
	Common base class for compact rotation representations. More...
class	UniformScaling
class	Transform
	Represents an homogeneous transformation in a N dimensional space. More...
class	Translation
	Represents a translation transformation. More...
class	HouseholderSequence
	Sequence of Householder reflections acting on subspaces with decreasing size. More...
class	DiagonalPreconditioner
	A preconditioner based on the digonal entries. More...
class	LeastSquareDiagonalPreconditioner
	Jacobi preconditioner for LeastSquaresConjugateGradient. More...
class	IdentityPreconditioner
	A naive preconditioner which approximates any matrix as the identity matrix. More...
class	BiCGSTAB
	A bi conjugate gradient stabilized solver for sparse square problems. More...
class	ConjugateGradient
	A conjugate gradient solver for sparse (or dense) self-adjoint problems. More...
class	IncompleteCholesky
	Modified Incomplete Cholesky with dual threshold. More...
class	IncompleteLUT
	Incomplete LU factorization with dual-threshold strategy. More...
class	IterativeSolverBase
	Base class for linear iterative solvers. More...
class	LeastSquaresConjugateGradient
	A conjugate gradient solver for sparse (or dense) least-square problems. More...
class	SolveWithGuess
	Pseudo expression representing a solving operation. More...
class	JacobiRotation
	Rotation given by a cosine-sine pair. More...
class	FullPivLU
	LU decomposition of a matrix with complete pivoting, and related features. More...
class	PartialPivLU
	LU decomposition of a matrix with partial pivoting, and related features. More...
class	MetisOrdering
class	AMDOrdering
class	NaturalOrdering
class	COLAMDOrdering
class	PardisoImpl
class	PardisoLU
	A sparse direct LU 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	PardisoLDLT
	A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library. More...
class	PastixBase
class	PastixLU
	Sparse direct LU solver based on PaStiX library. More...
class	PastixLLT
	A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library. More...
class	PastixLDLT
	A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library. More...
class	ColPivHouseholderQR
	Householder rank-revealing QR decomposition of a matrix with column-pivoting. More...
class	CompleteOrthogonalDecomposition
	Complete orthogonal decomposition (COD) of a matrix. More...
class	FullPivHouseholderQR
	Householder rank-revealing QR decomposition of a matrix with full pivoting. More...
class	HouseholderQR
	Householder QR decomposition of a matrix. More...
class	SimplicialCholeskyBase
	A base class for direct sparse Cholesky factorizations. More...
class	SimplicialLLT
	A direct sparse LLT Cholesky factorizations. More...
class	SimplicialLDLT
	A direct sparse LDLT Cholesky factorizations without square root. More...
class	SimplicialCholesky
class	MappedSparseMatrix
	Sparse matrix. More...
class	BlockImpl< XprType, BlockRows, BlockCols, true, Sparse >
class	BlockImpl< SparseMatrix< _Scalar, _Options, _StorageIndex >, BlockRows, BlockCols, true, Sparse >
class	BlockImpl< const SparseMatrix< _Scalar, _Options, _StorageIndex >, BlockRows, BlockCols, true, Sparse >
class	BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >
class	SparseCompressedBase
	Common base class for sparse [compressed]-{row\|column}-storage format. More...
class	CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >
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	Map< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
	Specialization of class Map for SparseMatrix-like storage. More...
class	Map< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
class	SparseMatrix
	A versatible sparse matrix representation. More...
class	SparseMatrixBase
	Base class of any sparse matrices or sparse expressions. More...
class	Ref< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
	A sparse matrix expression referencing an existing sparse expression. More...
class	Ref< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
class	Ref< SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType >
	A sparse vector expression referencing an existing sparse vector expression. More...
class	Ref< const SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType >
class	SparseSelfAdjointView
	Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix. More...
class	SparseSymmetricPermutationProduct
class	SparseSolverBase
	A base class for sparse solvers. More...
class	TransposeImpl< MatrixType, Sparse >
class	TriangularViewImpl< MatrixType, Mode, Sparse >
	Base class for a triangular part in a sparse matrix. More...
class	Triplet
	A small structure to hold a non zero as a triplet (i,j,value). More...
class	SparseVector
	a sparse vector class More...
class	SparseView
class	SparseLU
	Sparse supernodal LU factorization for general matrices. More...
struct	SparseLUMatrixLReturnType
struct	SparseLUMatrixUReturnType
class	SparseQR
	Sparse left-looking rank-revealing QR factorization. More...
struct	SparseQR_QProduct
struct	SparseQRMatrixQReturnType
struct	SparseQRMatrixQTransposeReturnType
class	SPQR
	Sparse QR factorization based on SuiteSparseQR library. More...
struct	SPQR_QProduct
struct	SPQRMatrixQReturnType
struct	SPQRMatrixQTransposeReturnType
class	aligned_allocator_indirection
struct	SluMatrix
struct	SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > >
struct	SluMatrixMapHelper< SparseMatrixBase< Derived > >
class	SuperLUBase
	The base class for the direct and incomplete LU factorization of SuperLU. More...
class	SuperLU
	A sparse direct LU factorization and solver based on the SuperLU library. More...
class	BDCSVD
	class Bidiagonal Divide and Conquer SVD More...
class	JacobiSVD
	Two-sided Jacobi SVD decomposition of a rectangular matrix. More...
class	SVDBase
	Base class of SVD algorithms. More...
class	UmfPackLU
	A sparse LU factorization and solver based on UmfPack. 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 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	{ 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	{ 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	{ DefaultTraversal, LinearTraversal, InnerVectorizedTraversal, LinearVectorizedTraversal, SliceVectorizedTraversal, InvalidTraversal, AllAtOnceTraversal }
enum	{ NoUnrolling, InnerUnrolling, CompleteUnrolling }
enum	{ Specialized, BuiltIn }
enum	{ ColMajor = 0, RowMajor = 0x1, AutoAlign = 0, DontAlign = 0x2 }
enum	{ OnTheLeft = 1, OnTheRight = 2 }
enum	NoChange_t { NoChange }
enum	Sequential_t { Sequential }
enum	Default_t { Default }
enum	{ 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	{ DefaultProduct = 0, LazyProduct, AliasFreeProduct, CoeffBasedProductMode, LazyCoeffBasedProductMode, OuterProduct, InnerProduct, GemvProduct, GemmProduct }
enum	Action { GetAction, SetAction }
enum	SimplicialCholeskyMode { SimplicialCholeskyLLT, SimplicialCholeskyLDLT }
enum	{ StandardCompressedFormat = 2 }
Functions
template<typename _Scalar , int _Options, typename _StorageIndex >
cholmod_sparse	viewAsCholmod (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 , 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::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 , typename ExponentDerived >
const Eigen::CwiseBinaryOp < Eigen::internal::scalar_binary_pow_op < typename Derived::Scalar, typename ExponentDerived::Scalar > , const Derived, const ExponentDerived >	pow (const Eigen::ArrayBase< Derived > &x, const Eigen::ArrayBase< ExponentDerived > &exponents)
template<typename Derived >
const Eigen::CwiseBinaryOp < Eigen::internal::scalar_binary_pow_op < typename Derived::Scalar, typename Derived::Scalar > , const typename Derived::ConstantReturnType, const Derived >	pow (const typename Derived::Scalar &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 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 ()
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)
template<typename Scalar >
std::complex< Scalar >	cdiv (const Scalar &xr, const Scalar &xi, const Scalar &yr, const Scalar &yi)
static UniformScaling< float >	Scaling (float s)
static UniformScaling< double >	Scaling (double s)
template<typename RealScalar >
static UniformScaling < std::complex< RealScalar > >	Scaling (const std::complex< RealScalar > &s)
template<typename Scalar >
static DiagonalMatrix< Scalar, 2 >	Scaling (const Scalar &sx, const Scalar &sy)
template<typename Scalar >
static DiagonalMatrix< Scalar, 3 >	Scaling (const Scalar &sx, const Scalar &sy, const Scalar &sz)
template<typename Derived >
static 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 < 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.
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 >, 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 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 >, 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 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_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])
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

Typedef Documentation

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Eigen::DenseIndex

Definition at line 27 of file XprHelper.h.

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:: TopicPreprocessorDirectives, StorageIndex.

Definition at line 35 of file XprHelper.h.

Enumeration Type Documentation

anonymous enum

Enumerator:

Large
Small

Definition at line 16 of file GeneralProduct.h.

     {
  Large = 2,
  Small = 3
};

anonymous enum

Enumerator:

DontAlignCols

Definition at line 16 of file IO.h.

{ DontAlignCols = 1 };

anonymous enum

Enumerator:

StreamPrecision
FullPrecision

Definition at line 17 of file IO.h.

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

anonymous enum

Enumerator:

StandardCompressedFormat

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

Definition at line 15 of file SparseRef.h.

     {
  StandardCompressedFormat = 2 
};

enum Eigen::CholmodMode

Enumerator:

CholmodAuto
CholmodSimplicialLLt
CholmodSupernodalLLt
CholmodLDLt

Definition at line 149 of file CholmodSupport.h.

                 {
  CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt
};

enum Eigen::Default_t

Enumerator:

Default

Definition at line 352 of file Constants.h.

{ Default };

enum Eigen::NoChange_t

Enumerator:

NoChange

Definition at line 350 of file Constants.h.

{ NoChange };

enum Eigen::Sequential_t

Enumerator:

Sequential

Definition at line 351 of file Constants.h.

{ Sequential };

enum Eigen::SimplicialCholeskyMode

Enumerator:

SimplicialCholeskyLLT
SimplicialCholeskyLDLT

Definition at line 15 of file SimplicialCholesky.h.

                            {
  SimplicialCholeskyLLT,
  SimplicialCholeskyLDLT
};

Function Documentation

template<typename Scalar >

std::complex<Scalar> Eigen::cdiv	(	const Scalar &	xr,
		const Scalar &	xi,
		const Scalar &	yr,
		const Scalar &	yi
	)

Definition at line 456 of file EigenSolver.h.

{
  using std::abs;
  Scalar r,d;
  if (abs(yr) > abs(yi))
  {
      r = yi/yr;
      d = yr + r*yi;
      return std::complex<Scalar>((xr + r*xi)/d, (xi - r*xr)/d);
  }
  else
  {
      r = yr/yi;
      d = yi + r*yr;
      return std::complex<Scalar>((r*xr + xi)/d, (r*xi - xr)/d);
  }
}

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.

Definition at line 452 of file HouseholderSequence.h.

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

void Eigen::initParallel ( ) [inline]

Must be call first when calling Eigen from multiple threads

Definition at line 48 of file Parallelizer.h.

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

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

Definition at line 2211 of file GeneralBlockPanelKernel.h.

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

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

Definition at line 2220 of file GeneralBlockPanelKernel.h.

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

int Eigen::nbThreads ( ) [inline]

Returns:: the max number of threads reserved for Eigen

See also:: setNbThreads

Definition at line 58 of file Parallelizer.h.

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

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

Definition at line 147 of file SparsePermutation.h.

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

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

Definition at line 154 of file SparsePermutation.h.

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

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.

Definition at line 162 of file SparsePermutation.h.

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

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.

Definition at line 171 of file SparsePermutation.h.

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

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.

Definition at line 338 of file Transpositions.h.

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

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.

Definition at line 350 of file Transpositions.h.

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

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.

Definition at line 439 of file HouseholderSequence.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;
}

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.

Definition at line 543 of file PermutationMatrix.h.

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

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.

Definition at line 555 of file PermutationMatrix.h.

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

template<typename DenseDerived , typename SparseDerived >

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

Definition at line 604 of file SparseCwiseBinaryOp.h.

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

template<typename SparseDerived , typename DenseDerived >

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

Definition at line 611 of file SparseCwiseBinaryOp.h.

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

template<typename DenseDerived , typename SparseDerived >

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

Definition at line 618 of file SparseCwiseBinaryOp.h.

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

template<typename SparseDerived , typename DenseDerived >

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

Definition at line 625 of file SparseCwiseBinaryOp.h.

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

template<typename Derived >

const Eigen::CwiseUnaryOp<Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>, const Derived> Eigen::operator/	(	const typename Derived::Scalar &	s,
		const Eigen::ArrayBase< Derived > &	a
	)		`[inline]`

Component-wise division of a scalar by array elements.

Definition at line 124 of file GlobalFunctions.h.

  {
    return Eigen::CwiseUnaryOp<Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>, const Derived>(
      a.derived(),
      Eigen::internal::scalar_inverse_mult_op<typename Derived::Scalar>(s)  
    );
  }

template<typename Derived >

const Eigen::CwiseUnaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar>, const Derived> Eigen::pow	(	const Eigen::ArrayBase< Derived > &	x,
		const typename Derived::Scalar &	exponent
	)		`[inline]`

Examples:: StructuredMeshSimple.cpp.

Definition at line 75 of file GlobalFunctions.h.

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

template<typename Derived , typename ExponentDerived >

const Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename ExponentDerived::Scalar>, const Derived, const ExponentDerived> Eigen::pow	(	const Eigen::ArrayBase< Derived > &	x,
		const Eigen::ArrayBase< ExponentDerived > &	exponents
	)		`[inline]`

Returns:: an expression of the coefficient-wise power of x to the given array of exponents.

This function computes the coefficient-wise power.

Example:

Output:

See also:: ArrayBase::pow()

Definition at line 90 of file GlobalFunctions.h.

  {
    return Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename ExponentDerived::Scalar>, const Derived, const ExponentDerived>(
      x.derived(),
      exponents.derived()
    );
  }

template<typename Derived >

const Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename Derived::Scalar>, const typename Derived::ConstantReturnType, const Derived> Eigen::pow	(	const typename Derived::Scalar &	x,
		const Eigen::ArrayBase< Derived > &	exponents
	)		`[inline]`

Returns:: an expression of the coefficient-wise power of the scalar x to the given array of exponents.

This function computes the coefficient-wise power between a scalar and an array of exponents. Beaware that the scalar type of the input scalar x and the exponents exponents must be the same.

Example:

Output:

See also:: ArrayBase::pow()

Definition at line 110 of file GlobalFunctions.h.

  {
    typename Derived::ConstantReturnType constant_x(exponents.rows(), exponents.cols(), x);
    return Eigen::CwiseBinaryOp<Eigen::internal::scalar_binary_pow_op<typename Derived::Scalar, typename Derived::Scalar>, const typename Derived::ConstantReturnType, const Derived>(
      constant_x,
      exponents.derived()
    );
  }

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.

Definition at line 464 of file HouseholderSequence.h.

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

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

Definition at line 2232 of file GeneralBlockPanelKernel.h.

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

void Eigen::setNbThreads ( int v ) [inline]

Sets the max number of threads reserved for Eigen

See also:: nbThreads

Definition at line 67 of file Parallelizer.h.

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

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

Definition at line 20 of file UmfPackSupport.h.

{ umfpack_di_defaults(control); }

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

Definition at line 23 of file UmfPackSupport.h.

{ umfpack_zi_defaults(control); }

void Eigen::umfpack_free_numeric	(	void **	Numeric,
		double
	)		`[inline]`

Definition at line 26 of file UmfPackSupport.h.

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

void Eigen::umfpack_free_numeric	(	void **	Numeric,
		std::complex< double >
	)		`[inline]`

Definition at line 29 of file UmfPackSupport.h.

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

void Eigen::umfpack_free_symbolic	(	void **	Symbolic,
		double
	)		`[inline]`

Definition at line 32 of file UmfPackSupport.h.

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

void Eigen::umfpack_free_symbolic	(	void **	Symbolic,
		std::complex< double >
	)		`[inline]`

Definition at line 35 of file UmfPackSupport.h.

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

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

Definition at line 106 of file UmfPackSupport.h.

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

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

Definition at line 111 of file UmfPackSupport.h.

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

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

Definition at line 80 of file UmfPackSupport.h.

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

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

Definition at line 85 of file UmfPackSupport.h.

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

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]`

Definition at line 90 of file UmfPackSupport.h.

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

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]`

Definition at line 96 of file UmfPackSupport.h.

{
  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);
}

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]`

Definition at line 52 of file UmfPackSupport.h.

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

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]`

Definition at line 59 of file UmfPackSupport.h.

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

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]`

Definition at line 66 of file UmfPackSupport.h.

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

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]`

Definition at line 73 of file UmfPackSupport.h.

{
  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);
}

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]`

Definition at line 38 of file UmfPackSupport.h.

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

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]`

Definition at line 45 of file UmfPackSupport.h.

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

template<typename _Scalar , int _Options, typename _StorageIndex >

cholmod_sparse Eigen::viewAsCholmod ( SparseMatrix< _Scalar, _Options, _StorageIndex > & mat )

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

Definition at line 52 of file CholmodSupport.h.

{
  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>(res);
  
  res.stype = 0;
  
  return res;
}

template<typename _Scalar , int _Options, typename _Index >

const cholmod_sparse Eigen::viewAsCholmod ( const SparseMatrix< _Scalar, _Options, _Index > & mat )

Definition at line 99 of file CholmodSupport.h.

{
  cholmod_sparse res = viewAsCholmod(mat.const_cast_derived());
  return res;
}

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.

Definition at line 108 of file CholmodSupport.h.

{
  cholmod_sparse res = viewAsCholmod(mat.matrix().const_cast_derived());
  
  if(UpLo==Upper) res.stype =  1;
  if(UpLo==Lower) res.stype = -1;

  return res;
}

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.

Definition at line 121 of file CholmodSupport.h.

{
  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>(res);

  return res;
}

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.

Definition at line 142 of file CholmodSupport.h.

{
  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

const unsigned int Eigen::ActualPacketAccessBit = 0x0

Definition at line 102 of file Constants.h.

const int Eigen::CoherentAccessPattern = 0x1

Definition at line 47 of file SparseUtil.h.

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.

Definition at line 21 of file Constants.h.

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.

Definition at line 26 of file Constants.h.

const unsigned int Eigen::HereditaryBits

Initial value:

 RowMajorBit
                                  | EvalBeforeNestingBit

Definition at line 190 of file Constants.h.

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.

Definition at line 39 of file Constants.h.

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.

Definition at line 31 of file Constants.h.

const int Eigen::InnerRandomAccessPattern = 0x2 | CoherentAccessPattern

Definition at line 48 of file SparseUtil.h.

const unsigned int Eigen::NestByRefBit = 0x100

Definition at line 164 of file Constants.h.

const int Eigen::OuterRandomAccessPattern = 0x4 | CoherentAccessPattern

Definition at line 49 of file SparseUtil.h.

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

Definition at line 50 of file SparseUtil.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation