Eigen Namespace Reference

Namespace containing all symbols from the Eigen library. More...

Namespaces
	Architecture
	bfloat16_impl
	half_impl
	HybridNonLinearSolverSpace
	indexing
	internal
	LevenbergMarquardtSpace
	numext
	placeholders
	symbolic
	TensorSycl
	test

Classes
class	aligned_allocator
	STL compatible allocator to use with types requiring a non standrad alignment. More...
class	aligned_allocator_indirection
class	AlignedBox
	An axis aligned box. More...
class	AMDOrdering
class	AngleAxis
	Represents a 3D rotation as a rotation angle around an arbitrary 3D axis. More...
struct	AntiHermiticity
struct	AntiSymmetry
class	ArithmeticSequence
class	ArpackGeneralizedSelfAdjointEigenSolver
class	array
class	Array
	General-purpose arrays with easy API for coefficient-wise operations. More...
class	array< T, 0 >
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
class	AutoDiffJacobian
class	AutoDiffScalar
	A scalar type replacement with automatic differentiation capability. More...
class	AutoDiffVector
struct	BandShape
class	Barrier
class	BDCSVD
	class Bidiagonal Divide and Conquer SVD More...
class	BenchTimer
struct	bfloat16
class	BiCGSTAB
	A bi conjugate gradient stabilized solver for sparse square problems. More...
class	Block
	Expression of a fixed-size or dynamic-size block. More...
class	BlockImpl
class	BlockImpl< const SparseMatrix< _Scalar, _Options, _StorageIndex >, BlockRows, BlockCols, true, Sparse >
class	BlockImpl< SparseMatrix< _Scalar, _Options, _StorageIndex >, BlockRows, BlockCols, true, Sparse >
class	BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Dense >
class	BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >
class	BlockImpl< XprType, BlockRows, BlockCols, true, Sparse >
class	BlockSparseMatrix
	A versatile sparse matrix representation where each element is a block. More...
class	BlockSparseMatrixView
class	BlockSparseTimeDenseProduct
class	BlockVectorReturn
class	BlockVectorView
class	CholmodBase
	The base class for the direct Cholesky factorization of Cholmod. More...
class	CholmodDecomposition
	A general Cholesky factorization and solver based on Cholmod. More...
class	CholmodSimplicialLDLT
	A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod. More...
class	CholmodSimplicialLLT
	A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod. More...
class	CholmodSupernodalLLT
	A supernodal Cholesky (LLT) factorization and solver based on Cholmod. More...
struct	CleanedUpDerType
class	COLAMDOrdering
class	ColPivHouseholderQR
	Householder rank-revealing QR decomposition of a matrix with column-pivoting. More...
class	CommaInitializer
	Helper class used by the comma initializer operator. More...
class	CompleteOrthogonalDecomposition
	Complete orthogonal decomposition (COD) of a matrix. More...
class	ComplexEigenSolver
	Computes eigenvalues and eigenvectors of general complex matrices. More...
class	ComplexSchur
	Performs a complex Schur decomposition of a real or complex square matrix. More...
struct	Cond
class	Conjugate
class	ConjugateGradient
	A conjugate gradient solver for sparse (or dense) self-adjoint problems. More...
struct	ConversionSubExprEval
struct	ConversionSubExprEval< true, Eval, EvalPointerType >
class	Cross
class	CwiseBinaryOp
	Generic expression where a coefficient-wise binary operator is applied to two expressions. More...
class	CwiseBinaryOpImpl
class	CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >
class	CwiseNullaryOp
	Generic expression of a matrix where all coefficients are defined by a functor. More...
class	CwiseTernaryOp
	Generic expression where a coefficient-wise ternary operator is applied to two expressions. More...
class	CwiseTernaryOpImpl
class	CwiseUnaryOp
	Generic expression where a coefficient-wise unary operator is applied to an expression. More...
class	CwiseUnaryOpImpl
class	CwiseUnaryView
	Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector. More...
class	CwiseUnaryViewImpl
class	CwiseUnaryViewImpl< ViewOp, MatrixType, Dense >
struct	DefaultDevice
struct	Dense
class	DenseBase
	Base class for all dense matrices, vectors, and arrays. More...
class	DenseCoeffsBase
class	DenseCoeffsBase< Derived, DirectAccessors >
	Base class providing direct read-only coefficient access to matrices and arrays. More...
class	DenseCoeffsBase< Derived, DirectWriteAccessors >
	Base class providing direct read/write coefficient access to matrices and arrays. More...
class	DenseCoeffsBase< Derived, ReadOnlyAccessors >
	Base class providing read-only coefficient access to matrices and arrays. More...
class	DenseCoeffsBase< Derived, WriteAccessors >
	Base class providing read/write coefficient access to matrices and arrays. More...
struct	DenseFunctor
struct	DenseShape
struct	DenseSparseProductReturnType
class	DenseStorage
class	DenseStorage< T, 0, _Rows, _Cols, _Options >
class	DenseStorage< T, 0, _Rows, Dynamic, _Options >
class	DenseStorage< T, 0, Dynamic, _Cols, _Options >
class	DenseStorage< T, 0, Dynamic, Dynamic, _Options >
class	DenseStorage< T, Dynamic, _Rows, Dynamic, _Options >
class	DenseStorage< T, Dynamic, Dynamic, _Cols, _Options >
class	DenseStorage< T, Dynamic, Dynamic, Dynamic, _Options >
class	DenseStorage< T, Size, _Rows, Dynamic, _Options >
class	DenseStorage< T, Size, Dynamic, _Cols, _Options >
class	DenseStorage< T, Size, Dynamic, Dynamic, _Options >
class	DenseTimeSparseProduct
class	DGMRES
	A Restarted GMRES with deflation. This class implements a modification of the GMRES solver for sparse linear systems. The basis is built with modified Gram-Schmidt. At each restart, a few approximated eigenvectors corresponding to the smallest eigenvalues are used to build a preconditioner for the next cycle. This preconditioner for deflation can be combined with any other preconditioner, the IncompleteLUT for instance. The preconditioner is applied at right of the matrix and the combination is multiplicative. 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
struct	DiagonalShape
class	DiagonalWrapper
	Expression of a diagonal matrix. More...
struct	DimensionList
struct	DSizes
class	DynamicSGroup
	Dynamic symmetry group. More...
class	DynamicSGroupFromTemplateArgs
class	DynamicSkylineMatrix
class	DynamicSparseMatrix
	A sparse matrix class designed for matrix assembly purpose. More...
struct	eigen_assert_exception
struct	eigen_static_assert_exception
class	EigenBase
struct	EigenConvolutionKernel
struct	EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV1D >
struct	EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV2D >
struct	EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV3D >
class	EigenSolver
	Computes eigenvalues and eigenvectors of general matrices. More...
class	EigenTest
class	EulerAngles
	Represents a rotation in a 3 dimensional space as three Euler angles. More...
class	EulerSystem
	Represents a fixed Euler rotation system. More...
class	EventCount
class	Flagged
class	ForceAlignedAccess
	Enforce aligned packet loads and stores regardless of what is requested. More...
class	FullPivHouseholderQR
	Householder rank-revealing QR decomposition of a matrix with full pivoting. More...
class	FullPivLU
	LU decomposition of a matrix with complete pivoting, and related features. More...
struct	general_product_to_triangular_selector
struct	general_product_to_triangular_selector< MatrixType, ProductType, UpLo, false >
struct	general_product_to_triangular_selector< MatrixType, ProductType, UpLo, true >
class	GeneralizedEigenSolver
	Computes the generalized eigenvalues and eigenvectors of a pair of general matrices. More...
class	GeneralizedSelfAdjointEigenSolver
	Computes eigenvalues and eigenvectors of the generalized selfadjoint eigen problem. More...
struct	GenericNumTraits
class	GMRES
	A GMRES solver for sparse square problems. More...
struct	half
struct	Hermiticity
class	HessenbergDecomposition
	Reduces a square matrix to Hessenberg form by an orthogonal similarity transformation. More...
class	Homogeneous
	Expression of one (or a set of) homogeneous vector(s) More...
struct	HomogeneousShape
class	HouseholderQR
	Householder QR decomposition of a matrix. More...
class	HouseholderSequence
	Sequence of Householder reflections acting on subspaces with decreasing size. More...
class	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
	A hyperplane. More...
class	IdentityPreconditioner
	A naive preconditioner which approximates any matrix as the identity matrix. More...
class	IDRS
	The Induced Dimension Reduction method (IDR(s)) is a short-recurrences Krylov method for sparse square problems. More...
class	IncompleteCholesky
	Modified Incomplete Cholesky with dual threshold. More...
class	IncompleteLU
class	IncompleteLUT
	Incomplete LU factorization with dual-threshold strategy. More...
class	IndexedView
	Expression of a non-sequential sub-matrix defined by arbitrary sequences of row and column indices. More...
class	IndexedViewImpl
struct	IndexPair
class	InnerIterator
	An InnerIterator allows to loop over the element of any matrix expression. More...
class	InnerStride
	Convenience specialization of Stride to specify only an inner stride See class Map for some examples. More...
class	Inverse
	Expression of the inverse of another expression. More...
class	InverseImpl
class	InverseImpl< PermutationType, PermutationStorage >
class	IOFormat
	Stores a set of parameters controlling the way matrices are printed. More...
class	IterationController
	Controls the iterations of the iterative solvers. More...
class	IterativeSolverBase
	Base class for linear iterative solvers. More...
class	IterScaling
	iterative scaling algorithm to equilibrate rows and column norms in matrices More...
class	JacobiRotation
	Rotation given by a cosine-sine pair. More...
class	JacobiSVD
	Two-sided Jacobi SVD decomposition of a rectangular matrix. More...
class	KdBVH
	A simple bounding volume hierarchy based on AlignedBox. More...
class	KLU
class	KroneckerProduct
	Kronecker tensor product helper class for dense matrices. More...
class	KroneckerProductBase
	The base class of dense and sparse Kronecker product. 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	LeastSquareDiagonalPreconditioner
	Jacobi preconditioner for LeastSquaresConjugateGradient. More...
class	LeastSquaresConjugateGradient
	A conjugate gradient solver for sparse (or dense) least-square problems. 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...
struct	MakeComplex
struct	MakeComplex< false >
struct	MakeComplex< true >
struct	MakePointer
class	Map
	A matrix or vector expression mapping an existing array of data. More...
class	Map< const Quaternion< _Scalar >, _Options >
	Quaternion expression mapping a constant memory buffer. More...
class	Map< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
class	Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >, _PacketAccess >
class	Map< Quaternion< _Scalar >, _Options >
	Expression of a quaternion from a memory buffer. More...
class	Map< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
	Specialization of class Map for SparseMatrix-like storage. More...
class	Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >, PacketAccess >
class	MapBase
class	MapBase< Derived, ReadOnlyAccessors >
	Base class for dense Map and Block expression with direct access. More...
class	MapBase< Derived, WriteAccessors >
	Base class for non-const dense Map and Block expression with direct access. More...
class	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	MatrixComplexPowerReturnValue
	Proxy for the matrix power of some matrix (expression). More...
struct	MatrixExponentialReturnValue
	Proxy for the matrix exponential of some matrix (expression). More...
class	MatrixFunctionReturnValue
	Proxy for the matrix function of some matrix (expression). 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 for computing matrix powers. More...
class	MatrixPowerParenthesesReturnValue
	Proxy for the matrix power of some matrix. More...
class	MatrixPowerReturnValue
	Proxy for the matrix power of some matrix (expression). More...
class	MatrixSquareRootReturnValue
	Proxy for the matrix square root of some matrix (expression). More...
class	MatrixWrapper
	Expression of an array as a mathematical vector or matrix. More...
struct	MatrixXpr
struct	max_n_1
struct	max_n_1< 0 >
class	MaxSizeVector
	The MaxSizeVector class. More...
class	MetisOrdering
class	MINRES
	A minimal residual solver for sparse symmetric problems. More...
struct	MovableScalar
class	NaturalOrdering
class	NestByValue
	Expression which must be nested by value. More...
class	NoAlias
	Pseudo expression providing an operator = assuming no aliasing. More...
struct	NoOpOutputKernel
struct	Notification
class	NumericalDiff
class	NumTraits
	Holds information about the various numeric (i.e. scalar) types allowed by Eigen. More...
struct	NumTraits< AnnoyingScalar >
struct	NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct	NumTraits< AutoDiffScalar< DerType > >
struct	NumTraits< bool >
struct	NumTraits< boost::multiprecision::detail::expression< T1, T2, T3, T4, T5 > >
struct	NumTraits< ceres::Jet< T, N > >
struct	NumTraits< double >
struct	NumTraits< Eigen::bfloat16 >
struct	NumTraits< Eigen::half >
struct	NumTraits< float >
struct	NumTraits< long double >
struct	NumTraits< MovableScalar< float > >
struct	NumTraits< Real >
struct	NumTraits< std::complex< _Real > >
struct	NumTraits< std::string >
struct	NumTraits< void >
class	OuterStride
	Convenience specialization of Stride to specify only an outer stride See class Map for some examples. More...
struct	PacketConverter
struct	PacketConverter< TensorEvaluator, SrcPacket, TgtPacket, 1, 1 >
struct	PacketConverter< TensorEvaluator, SrcPacket, TgtPacket, 1, TgtCoeffRatio >
struct	PacketConverter< TensorEvaluator, SrcPacket, TgtPacket, 2, 1 >
struct	PacketConverter< TensorEvaluator, SrcPacket, TgtPacket, 4, 1 >
struct	PacketConverter< TensorEvaluator, SrcPacket, TgtPacket, 8, 1 >
struct	PacketType
class	ParametrizedLine
	A parametrized line. More...
class	PardisoImpl
class	PardisoLDLT
	A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library. More...
class	PardisoLLT
	A sparse direct Cholesky (LLT) factorization and solver based on the PARDISO library. More...
class	PardisoLU
	A sparse direct LU factorization and solver based on the PARDISO library. More...
struct	partial_redux_dummy_func
class	PartialPivLU
	LU decomposition of a matrix with partial pivoting, and related features. More...
class	PartialReduxExpr
	Generic expression of a partially reduxed matrix. More...
struct	PartOf
struct	PartOf< ImagPart >
struct	PartOf< RealPart >
class	PastixBase
class	PastixLDLT
	A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library. More...
class	PastixLLT
	A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library. More...
class	PastixLU
	Interface to the PaStix solver. More...
class	PermutationBase
	Base class for permutations. More...
class	PermutationMatrix
	Permutation matrix. More...
struct	PermutationShape
struct	PermutationStorage
class	PermutationWrapper
	Class to view a vector of integers as a permutation matrix. More...
class	PlainObjectBase
class	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	Product
	Expression of the product of two arbitrary matrices or vectors. More...
class	ProductImpl
class	ProductImpl< Lhs, Rhs, Option, Dense >
struct	ProductReturnType
class	Quaternion
	The quaternion class used to represent 3D orientations and rotations. More...
class	QuaternionBase
	Base class for quaternion expressions. More...
class	RandomSetter
	The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access. More...
class	RealQZ
	Performs a real QZ decomposition of a pair of square matrices. More...
class	RealSchur
	Performs a real Schur decomposition of a square matrix. More...
class	Ref
	A matrix or vector expression mapping an existing expression. More...
class	Ref< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
class	Ref< const SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType >
class	Ref< const TPlainObjectType, Options, StrideType >
class	Ref< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >
	A sparse matrix expression referencing an existing sparse expression. More...
class	Ref< SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType >
	A sparse vector expression referencing an existing sparse vector expression. More...
class	RefBase
class	Replicate
	Expression of the multiple replication of a matrix or vector. More...
class	Reshaped
	Expression of a fixed-size or dynamic-size reshape. More...
class	ReshapedImpl
class	ReshapedImpl< XprType, Rows, Cols, Order, Dense >
class	ReturnByValue
class	Reverse
	Expression of the reverse of a vector or matrix. More...
class	Rotation2D
	Represents a rotation/orientation in a 2 dimensional space. More...
class	RotationBase
	Common base class for compact rotation representations. More...
class	RunQueue
class	ScalarBinaryOpTraits
	Determines whether the given binary operation of two numeric types is allowed and what the scalar return type is. More...
struct	ScalarBinaryOpTraits< AutoDiffScalar< DerType >, typename DerType::Scalar, BinOp >
struct	ScalarBinaryOpTraits< T, T, BinaryOp >
struct	ScalarBinaryOpTraits< T, typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, BinaryOp >
struct	ScalarBinaryOpTraits< T, void, BinaryOp >
struct	ScalarBinaryOpTraits< typename DerType::Scalar, AutoDiffScalar< DerType >, BinOp >
struct	ScalarBinaryOpTraits< typename NumTraits< typename internal::enable_if< NumTraits< T >::IsComplex, T >::type >::Real, T, BinaryOp >
struct	ScalarBinaryOpTraits< void, T, BinaryOp >
struct	ScalarBinaryOpTraits< void, void, BinaryOp >
class	Select
	Expression of a coefficient wise version of the C++ ternary operator ?: More...
struct	selfadjoint_product_selector
struct	selfadjoint_product_selector< MatrixType, OtherType, UpLo, false >
struct	selfadjoint_product_selector< MatrixType, OtherType, UpLo, true >
struct	selfadjoint_rank1_update
struct	selfadjoint_rank1_update< Scalar, Index, ColMajor, UpLo, ConjLhs, ConjRhs >
struct	selfadjoint_rank1_update< Scalar, Index, RowMajor, UpLo, ConjLhs, ConjRhs >
class	SelfAdjointEigenSolver
	Computes eigenvalues and eigenvectors of selfadjoint matrices. More...
struct	SelfAdjointShape
class	SelfAdjointView
	Expression of a selfadjoint matrix from a triangular part of a dense matrix. More...
class	SGroup
	Symmetry group, initialized from template arguments. More...
class	SimplicialCholesky
class	SimplicialCholeskyBase
	A base class for direct sparse Cholesky factorizations. More...
class	SimplicialLDLT
	A direct sparse LDLT Cholesky factorizations without square root. More...
class	SimplicialLLT
	A direct sparse LLT Cholesky factorizations. More...
struct	Sizes
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
class	SkylineVector
struct	SluMatrix
struct	SluMatrixMapHelper
struct	SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > >
struct	SluMatrixMapHelper< SparseMatrixBase< Derived > >
class	Solve
	Pseudo expression representing a solving operation. More...
class	SolveImpl
class	SolveImpl< Decomposition, RhsType, Dense >
class	SolverBase
	A base class for matrix decomposition and solvers. More...
struct	SolverShape
struct	SolverStorage
class	SolveWithGuess
	Pseudo expression representing a solving operation. More...
struct	Sparse
class	SparseCompressedBase
	Common base class for sparse [compressed]-{row|column}-storage format. More...
class	SparseDenseOuterProduct
struct	SparseDenseProductReturnType
class	SparseDiagonalProduct
struct	SparseFunctor
class	SparseLU
	Sparse supernodal LU factorization for general matrices. More...
struct	SparseLUMatrixLReturnType
struct	SparseLUMatrixUReturnType
class	SparseLUTransposeView
class	SparseMapBase
class	SparseMapBase< Derived, ReadOnlyAccessors >
	Common base class for Map and Ref instance of sparse matrix and vector. More...
class	SparseMapBase< Derived, WriteAccessors >
	Common base class for writable Map and Ref instance of sparse matrix and vector. More...
class	SparseMatrix
	A versatible sparse matrix representation. More...
class	SparseMatrixBase
	Base class of any sparse matrices or sparse expressions. More...
class	SparseQR
	Sparse left-looking QR factorization with numerical column pivoting. More...
struct	SparseQR_QProduct
struct	SparseQRMatrixQReturnType
struct	SparseQRMatrixQTransposeReturnType
class	SparseSelfAdjointView
	Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix. More...
struct	SparseShape
class	SparseSolverBase
	A base class for sparse solvers. More...
class	SparseSparseProduct
struct	SparseSparseProductReturnType
class	SparseSymmetricPermutationProduct
class	SparseTimeDenseProduct
class	SparseVector
	a sparse vector class More...
class	SparseView
	Expression of a dense or sparse matrix with zero or too small values removed. More...
class	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
class	StaticSGroup
	Static symmetry group. More...
struct	StdMapTraits
struct	StlThreadEnvironment
struct	StorageMemory
class	Stride
	Holds strides information for Map. More...
class	SuperLU
	A sparse direct LU factorization and solver based on the SuperLU library. More...
class	SuperLUBase
	The base class for the direct and incomplete LU factorization of SuperLU. More...
class	SVDBase
	Base class of SVD algorithms. More...
class	SwapWrapper
struct	Symmetry
class	Tensor
	The tensor class. More...
class	TensorAssignOp
class	TensorAsyncDevice
	Pseudo expression providing an operator = that will evaluate its argument asynchronously on the specified device. Currently only ThreadPoolDevice implements proper asynchronous execution, while the default and GPU devices just run the expression synchronously and call m_done() on completion.. More...
class	TensorBase
	The tensor base class. More...
class	TensorBase< Derived, ReadOnlyAccessors >
class	TensorBroadcastingOp
class	TensorChippingOp
class	TensorConcatenationOp
	Tensor concatenation class. More...
struct	TensorContractionEvaluatorBase
class	TensorContractionOp
struct	TensorContractionParams
class	TensorConversionOp
	Tensor conversion class. This class makes it possible to vectorize type casting operations when the number of scalars per packet in the source and the destination type differ. More...
class	TensorConvolutionOp
class	TensorCostModel
class	TensorCustomBinaryOp
	Tensor custom class. More...
class	TensorCustomUnaryOp
	Tensor custom class. More...
class	TensorCwiseBinaryOp
class	TensorCwiseNullaryOp
class	TensorCwiseTernaryOp
class	TensorCwiseUnaryOp
class	TensorDevice
	Pseudo expression providing an operator = that will evaluate its argument on the specified computing 'device' (GPU, thread pool, ...) More...
class	TensorEvalToOp
class	TensorEvaluator
	A cost model used to limit the number of threads used for evaluating tensor expression. More...
struct	TensorEvaluator< const Derived, Device >
struct	TensorEvaluator< const TensorAssignOp< LeftArgType, RightArgType >, Device >
struct	TensorEvaluator< const TensorBroadcastingOp< Broadcast, ArgType >, Device >
struct	TensorEvaluator< const TensorChippingOp< DimId, ArgType >, Device >
struct	TensorEvaluator< const TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >
struct	TensorEvaluator< const TensorContractionOp< Indices, LeftArgType, RightArgType, OutputKernelType >, Device >
struct	TensorEvaluator< const TensorContractionOp< Indices, LeftArgType, RightArgType, OutputKernelType >, Eigen::SyclDevice >
struct	TensorEvaluator< const TensorConversionOp< TargetType, ArgType >, Device >
struct	TensorEvaluator< const TensorConvolutionOp< Indices, InputArgType, KernelArgType >, Device >
struct	TensorEvaluator< const TensorConvolutionOp< Indices, InputArgType, KernelArgType >, Eigen::SyclDevice >
struct	TensorEvaluator< const TensorCustomBinaryOp< CustomBinaryFunc, LhsXprType, RhsXprType >, Device >
struct	TensorEvaluator< const TensorCustomUnaryOp< CustomUnaryFunc, XprType >, Device >
struct	TensorEvaluator< const TensorCwiseBinaryOp< BinaryOp, LeftArgType, RightArgType >, Device >
struct	TensorEvaluator< const TensorCwiseNullaryOp< NullaryOp, ArgType >, Device >
struct	TensorEvaluator< const TensorCwiseTernaryOp< TernaryOp, Arg1Type, Arg2Type, Arg3Type >, Device >
struct	TensorEvaluator< const TensorCwiseUnaryOp< UnaryOp, ArgType >, Device >
struct	TensorEvaluator< const TensorEvalToOp< ArgType, MakePointer_ >, Device >
struct	TensorEvaluator< const TensorFFTOp< FFT, ArgType, FFTResultType, FFTDir >, Device >
struct	TensorEvaluator< const TensorForcedEvalOp< ArgType_ >, Device >
struct	TensorEvaluator< const TensorGeneratorOp< Generator, ArgType >, Device >
struct	TensorEvaluator< const TensorImagePatchOp< Rows, Cols, ArgType >, Device >
struct	TensorEvaluator< const TensorIndexTupleOp< ArgType >, Device >
struct	TensorEvaluator< const TensorInflationOp< Strides, ArgType >, Device >
struct	TensorEvaluator< const TensorLayoutSwapOp< ArgType >, Device >
struct	TensorEvaluator< const TensorPaddingOp< PaddingDimensions, ArgType >, Device >
struct	TensorEvaluator< const TensorPatchOp< PatchDim, ArgType >, Device >
struct	TensorEvaluator< const TensorReductionOp< Op, Dims, ArgType, MakePointer_ >, Device >
struct	TensorEvaluator< const TensorReductionOp< Op, Dims, ArgType, MakePointer_ >, Eigen::SyclDevice >
struct	TensorEvaluator< const TensorRef< Derived >, Device >
struct	TensorEvaluator< const TensorReshapingOp< NewDimensions, ArgType >, Device >
struct	TensorEvaluator< const TensorReverseOp< ReverseDimensions, ArgType >, Device >
struct	TensorEvaluator< const TensorScanOp< Op, ArgType >, Device >
struct	TensorEvaluator< const TensorSelectOp< IfArgType, ThenArgType, ElseArgType >, Device >
struct	TensorEvaluator< const TensorShufflingOp< Shuffle, ArgType >, Device >
struct	TensorEvaluator< const TensorSlicingOp< StartIndices, Sizes, ArgType >, Device >
struct	TensorEvaluator< const TensorStridingOp< Strides, ArgType >, Device >
struct	TensorEvaluator< const TensorStridingSlicingOp< StartIndices, StopIndices, Strides, ArgType >, Device >
struct	TensorEvaluator< const TensorTraceOp< Dims, ArgType >, Device >
struct	TensorEvaluator< const TensorTupleReducerOp< ReduceOp, Dims, ArgType >, Device >
struct	TensorEvaluator< const TensorVolumePatchOp< Planes, Rows, Cols, ArgType >, Device >
struct	TensorEvaluator< TensorChippingOp< DimId, ArgType >, Device >
struct	TensorEvaluator< TensorConcatenationOp< Axis, LeftArgType, RightArgType >, Device >
struct	TensorEvaluator< TensorLayoutSwapOp< ArgType >, Device >
struct	TensorEvaluator< TensorRef< Derived >, Device >
struct	TensorEvaluator< TensorReshapingOp< NewDimensions, ArgType >, Device >
struct	TensorEvaluator< TensorReverseOp< ReverseDimensions, ArgType >, Device >
struct	TensorEvaluator< TensorShufflingOp< Shuffle, ArgType >, Device >
struct	TensorEvaluator< TensorSlicingOp< StartIndices, Sizes, ArgType >, Device >
struct	TensorEvaluator< TensorStridingOp< Strides, ArgType >, Device >
struct	TensorEvaluator< TensorStridingSlicingOp< StartIndices, StopIndices, Strides, ArgType >, Device >
class	TensorFFTOp
class	TensorFixedSize
	The fixed sized version of the tensor class. More...
class	TensorForcedEvalOp
class	TensorGeneratorOp
	Tensor generator class. More...
class	TensorImagePatchOp
class	TensorIndexTupleOp
class	TensorInflationOp
class	TensorLayoutSwapOp
class	TensorMap
	A tensor expression mapping an existing array of data. More...
class	TensorOpCost
class	TensorPaddingOp
class	TensorPatchOp
struct	TensorReductionEvaluatorBase
struct	TensorReductionEvaluatorBase< const TensorReductionOp< Op, Dims, ArgType, MakePointer_ >, Device >
class	TensorReductionOp
class	TensorRef
	A reference to a tensor expression The expression will be evaluated lazily (as much as possible). More...
class	TensorReshapingOp
class	TensorReverseOp
class	TensorScanOp
class	TensorSelectOp
class	TensorShufflingOp
class	TensorSlicingOp
class	TensorStorage
class	TensorStorage< T, DSizes< IndexType, NumIndices_ >, Options_ >
class	TensorStridingOp
class	TensorStridingSlicingOp
class	TensorTraceOp
class	TensorTupleReducerOp
class	TensorVolumePatchOp
class	ThreadLocal
class	ThreadPoolInterface
class	ThreadPoolTempl
class	Transform
	Represents an homogeneous transformation in a N dimensional space. More...
class	Translation
	Represents a translation transformation. More...
class	Transpose
	Expression of the transpose of a matrix. More...
class	Transpose< TranspositionsBase< TranspositionsDerived > >
class	TransposeImpl
class	TransposeImpl< MatrixType, Dense >
class	TransposeImpl< MatrixType, Sparse >
class	Transpositions
	Represents a sequence of transpositions (row/column interchange) More...
class	TranspositionsBase
struct	TranspositionsShape
struct	TranspositionsStorage
class	TranspositionsWrapper
class	TriangularBase
	Base class for triangular part in a matrix. More...
struct	TriangularShape
class	TriangularView
	Expression of a triangular part in a matrix. More...
class	TriangularViewImpl
class	TriangularViewImpl< _MatrixType, _Mode, Dense >
	Base class for a triangular part in a dense matrix. More...
class	TriangularViewImpl< MatrixType, Mode, Sparse >
	Base class for a triangular part in a sparse matrix. More...
class	Tridiagonalization
	Tridiagonal decomposition of a selfadjoint matrix. More...
class	Triplet
	A small structure to hold a non zero as a triplet (i,j,value). More...
struct	Tuple
class	UmfPackLU
	A sparse LU factorization and solver based on UmfPack. More...
class	UniformScaling
	Represents a generic uniform scaling transformation. More...
class	VectorBlock
	Expression of a fixed-size or dynamic-size sub-vector. More...
class	VectorwiseOp
	Pseudo expression providing broadcasting and partial reduction operations. More...
class	WithFormat
	Pseudo expression providing matrix output with given format. More...

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

Enumerations
enum	{ NegationFlag = 0x01, ConjugationFlag = 0x02 }
enum	{ GlobalRealFlag = 0x01, GlobalImagFlag = 0x02, GlobalZeroFlag = 0x03 }
enum	{ IsSkyline = SkylineBit }
enum	{ SPD = 0x100, NonSymmetric = 0x0 }
enum	{ Large = 2, Small = 3 }
enum	{ DontAlignCols = 1 }
enum	{ StreamPrecision = -1, FullPrecision = -2 }
enum	{ StandardCompressedFormat = 2 }
enum	{ CPU_TIMER = 0, REAL_TIMER = 1 }
enum	AccessorLevels { ReadOnlyAccessors, WriteAccessors, DirectAccessors, DirectWriteAccessors }
enum	Action { GetAction, SetAction }
enum	AdditionalProductEvaluationMode { SkylineTimeDenseProduct, SkylineTimeSkylineProduct, DenseTimeSkylineProduct }
enum	AlignmentType {   Unaligned =0, Aligned8 =8, Aligned16 =16, Aligned32 =32,   Aligned64 =64, Aligned128 =128, AlignedMask =255, Aligned =16,   AlignedMax = Unaligned }
enum	AmbiVectorMode { IsDense = 0, IsSparse }
enum	AutoSize_t { AutoSize }
enum	CholmodMode { CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt }
enum	ComputationInfo { Success = 0, NumericalIssue = 1, NoConvergence = 2, InvalidInput = 3 }
enum	convolution_type { convolution_type::CONV1D, convolution_type::CONV2D, convolution_type::CONV3D }
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	Default_t { Default }
enum	DirectionType { Vertical, Horizontal, BothDirections }
enum	EulerAxis { EULER_X = 1, EULER_Y = 2, EULER_Z = 3 }
	Representation of a fixed signed rotation axis for EulerSystem. More...
enum	FFTDirection { FFT_FORWARD = 0, FFT_REVERSE = 1 }
enum	FFTResultType { RealPart = 0, ImagPart = 1, BothParts = 2 }
enum	NaNPropagationOptions { PropagateFast = 0, PropagateNaN, PropagateNumbers }
enum	NoChange_t { NoChange }
enum	NumericalDiffMode { Forward, Central }
enum	PaddingType { PADDING_VALID = 1, PADDING_SAME = 2 }
enum	ProductImplType {   DefaultProduct =0, LazyProduct, AliasFreeProduct, CoeffBasedProductMode,   LazyCoeffBasedProductMode, OuterProduct, InnerProduct, GemvProduct,   GemmProduct }
enum	QRPreconditioners { NoQRPreconditioner, HouseholderQRPreconditioner, ColPivHouseholderQRPreconditioner, FullPivHouseholderQRPreconditioner }
enum	Sequential_t { Sequential }
enum	SideType { OnTheLeft = 1, OnTheRight = 2 }
enum	SimplicialCholeskyMode { SimplicialCholeskyLLT, SimplicialCholeskyLDLT }
enum	SpecializedType { Specialized, BuiltIn }
enum	StorageOptions { ColMajor = 0, RowMajor = 0x1, AutoAlign = 0, DontAlign = 0x2 }
enum	TransformTraits { Isometry = 0x1, Affine = 0x2, AffineCompact = 0x10 | Affine, Projective = 0x20 }
enum	TraversalType {   DefaultTraversal, LinearTraversal, InnerVectorizedTraversal, LinearVectorizedTraversal,   SliceVectorizedTraversal, InvalidTraversal, AllAtOnceTraversal }
enum	UnrollingType { NoUnrolling, InnerUnrolling, CompleteUnrolling }
enum	UpLoType {   Lower =0x1, Upper =0x2, UnitDiag =0x4, ZeroDiag =0x8,   UnitLower =UnitDiag|Lower, UnitUpper =UnitDiag|Upper, StrictlyLower =ZeroDiag|Lower, StrictlyUpper =ZeroDiag|Upper,   SelfAdjoint =0x10, Symmetric =0x20 }

Functions
template<typename DstXprType , typename SrcXprType >
void	add_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
template<typename DerTypeA , typename DerTypeB >
const AutoDiffScalar< Matrix< typename internal::traits< typename internal::remove_all< DerTypeA >::type >::Scalar, Dynamic, 1 > >	atan2 (const AutoDiffScalar< DerTypeA > &a, const AutoDiffScalar< DerTypeB > &b)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0_op< typename Derived::Scalar >, const Derived >	bessel_i0 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0e_op< typename Derived::Scalar >, const Derived >	bessel_i0e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1_op< typename Derived::Scalar >, const Derived >	bessel_i1 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1e_op< typename Derived::Scalar >, const Derived >	bessel_i1e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j0_op< typename Derived::Scalar >, const Derived >	bessel_j0 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j1_op< typename Derived::Scalar >, const Derived >	bessel_j1 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0_op< typename Derived::Scalar >, const Derived >	bessel_k0 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0e_op< typename Derived::Scalar >, const Derived >	bessel_k0e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1_op< typename Derived::Scalar >, const Derived >	bessel_k1 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1e_op< typename Derived::Scalar >, const Derived >	bessel_k1e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y0_op< typename Derived::Scalar >, const Derived >	bessel_y0 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y1_op< typename Derived::Scalar >, const Derived >	bessel_y1 (const Eigen::ArrayBase< Derived > &x)
template<typename ADerived , typename BDerived , typename XDerived >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorCwiseTernaryOp< internal::scalar_betainc_op< typename XDerived::Scalar >, const ADerived, const BDerived, const XDerived >	betainc (const ADerived &a, const BDerived &b, const XDerived &x)
template<typename ArgADerived , typename ArgBDerived , typename ArgXDerived >
EIGEN_STRONG_INLINE const Eigen::CwiseTernaryOp< Eigen::internal::scalar_betainc_op< typename ArgXDerived::Scalar >, const ArgADerived, const ArgBDerived, const ArgXDerived >	betainc (const Eigen::ArrayBase< ArgADerived > &a, const Eigen::ArrayBase< ArgBDerived > &b, const Eigen::ArrayBase< ArgXDerived > &x)
Box2d	bounding_box (const Vector2d &v)
template<typename Scalar , int Dim>
AlignedBox< Scalar, Dim >	bounding_box (const Matrix< Scalar, Dim, 1 > &v)
template<typename BVH , typename Intersector >
void	BVIntersect (const BVH &tree, Intersector &intersector)
template<typename BVH1 , typename BVH2 , typename Intersector >
void	BVIntersect (const BVH1 &tree1, const BVH2 &tree2, Intersector &intersector)
template<typename BVH , typename Minimizer >
Minimizer::Scalar	BVMinimize (const BVH &tree, Minimizer &minimizer)
template<typename BVH1 , typename BVH2 , typename Minimizer >
Minimizer::Scalar	BVMinimize (const BVH1 &tree1, const BVH2 &tree2, Minimizer &minimizer)
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 T1 , typename T2 >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T1 &	choose (Cond< true >, const T1 &first, const T2 &)
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T2 &	choose (Cond< false >, const T1 &, const T2 &second)
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 DerType >
const AutoDiffScalar< DerType > &	conj (const AutoDiffScalar< DerType > &x)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T *	constCast (const T *data)
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType &	copy_using_evaluator (const EigenBase< DstXprType > &dst, const SrcXprType &src)
template<typename DstXprType , template< typename > class StorageBase, typename SrcXprType >
EIGEN_STRONG_INLINE const DstXprType &	copy_using_evaluator (const NoAlias< DstXprType, StorageBase > &dst, const SrcXprType &src)
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType &	copy_using_evaluator (const PlainObjectBase< DstXprType > &dst, const SrcXprType &src)
template<typename MatrixType >
void	createRandomPIMatrixOfRank (Index desired_rank, Index rows, Index cols, MatrixType &m)
template<typename SplineType , typename DerivativeType >
void	derivativesImpl (const SplineType &spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType &der)
template<typename Dims1 , typename Dims2 >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool	dimensions_match (Dims1 dims1, Dims2 dims2)
template<typename DstXprType , typename SrcXprType >
void	divide_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
template<typename T , typename X , typename Y >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	divup (const X x, const Y y)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T	divup (const T x, const T y)
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)
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (abs, using std::abs;return Eigen::MakeAutoDiffScalar(abs(x.value()), x.derivatives() *(x.value()< 0 ? -1 :1));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sqrt, using std::sqrt;Scalar sqrtx=sqrt(x.value());return Eigen::MakeAutoDiffScalar(sqrtx, x.derivatives() *(Scalar(0.5)/sqrtx));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sin, using std::sin;using std::cos;return Eigen::MakeAutoDiffScalar(sin(x.value()), x.derivatives() *cos(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (log, using std::log;return Eigen::MakeAutoDiffScalar(log(x.value()), x.derivatives() *(Scalar(1)/x.value()));) template< typename DerType > inline const Eigen
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (tan, using std::tan;using std::cos;return Eigen::MakeAutoDiffScalar(tan(x.value()), x.derivatives() *(Scalar(1)/numext::abs2(cos(x.value()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(asin
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (acos, using std::sqrt;using std::acos;return Eigen::MakeAutoDiffScalar(acos(x.value()), x.derivatives() *(Scalar(-1)/sqrt(1-numext::abs2(x.value()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(tanh
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sinh, using std::sinh;using std::cosh;return Eigen::MakeAutoDiffScalar(sinh(x.value()), x.derivatives() *cosh(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cosh
template<int N>
internal::FixedInt< N >	fix ()
template<int N, typename T >
internal::VariableAndFixedInt< N >	fix (T val)
template<typename AlphaDerived , typename SampleDerived >
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_gamma_sample_der_alpha_op< typename AlphaDerived::Scalar >, const AlphaDerived, const SampleDerived >	gamma_sample_der_alpha (const Eigen::ArrayBase< AlphaDerived > &alpha, const Eigen::ArrayBase< SampleDerived > &sample)
template<typename T >
NumTraits< typename T::Scalar >::Real	get_test_precision (const T &, const typename T::Scalar *=0)
template<typename T >
NumTraits< T >::Real	get_test_precision (const T &, typename internal::enable_if< internal::is_arithmetic< typename NumTraits< T >::Real >::value, T >::type *=0)
bool	getMarketHeader (const std::string &filename, int &sym, bool &iscomplex, bool &isvector)
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType >	householderSequence (const VectorsType &v, const CoeffsType &h)
	Convenience function for constructing a Householder sequence. More...
template<typename Derived , typename ExponentDerived >
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_igamma_op< typename Derived::Scalar >, const Derived, const ExponentDerived >	igamma (const Eigen::ArrayBase< Derived > &a, const Eigen::ArrayBase< ExponentDerived > &x)
template<typename Derived , typename ExponentDerived >
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_igamma_der_a_op< typename Derived::Scalar >, const Derived, const ExponentDerived >	igamma_der_a (const Eigen::ArrayBase< Derived > &a, const Eigen::ArrayBase< ExponentDerived > &x)
template<typename Derived , typename ExponentDerived >
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_igammac_op< typename Derived::Scalar >, const Derived, const ExponentDerived >	igammac (const Eigen::ArrayBase< Derived > &a, const Eigen::ArrayBase< ExponentDerived > &x)
template<typename DerType >
DerType::Scalar	imag (const AutoDiffScalar< DerType > &)
void	initParallel ()
template<typename T1 , typename T2 >
internal::enable_if< internal::is_same< T1, T2 >::value, bool >::type	is_same_type (const T1 &, const T2 &)
template<typename T >
bool	isMinusInf (const T &x)
template<typename T >
bool	isNotNaN (const T &x)
template<typename T >
bool	isPlusInf (const T &x)
klu_numeric *	klu_factor (int Ap [], int Ai [], double Ax [], klu_symbolic *Symbolic, klu_common *Common, double)
klu_numeric *	klu_factor (int Ap[], int Ai[], std::complex< double > Ax[], klu_symbolic *Symbolic, klu_common *Common, std::complex< double >)
int	klu_solve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B [], klu_common *Common, double)
	A sparse LU factorization and solver based on KLU. More...
int	klu_solve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex< double >B[], klu_common *Common, std::complex< double >)
int	klu_tsolve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B[], klu_common *Common, double)
int	klu_tsolve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex< double >B[], klu_common *Common, std::complex< double >)
template<typename KnotVectorType >
void	KnotAveraging (const KnotVectorType &parameters, DenseIndex degree, KnotVectorType &knots)
	Computes knot averages.The knots are computed as where is the degree and the number knots of the desired interpolating spline. More...
template<typename KnotVectorType , typename ParameterVectorType , typename IndexArray >
void	KnotAveragingWithDerivatives (const ParameterVectorType &parameters, const unsigned int degree, const IndexArray &derivativeIndices, KnotVectorType &knots)
	Computes knot averages when derivative constraints are present. Note that this is a technical interpretation of the referenced article since the algorithm contained therein is incorrect as written. More...
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)
std::ptrdiff_t	l1CacheSize ()
std::ptrdiff_t	l2CacheSize ()
std::ptrdiff_t	l3CacheSize ()
static const symbolic::AddExpr< symbolic::SymbolExpr< internal::symbolic_last_tag >, symbolic::ValueExpr< Eigen::internal::FixedInt< 1 > > >	lastp1 (last+fix< 1 >())
template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs, LazyProduct >	lazyprod (const Lhs &lhs, const Rhs &rhs)
template<typename SparseMatrixType >
bool	loadMarket (SparseMatrixType &mat, const std::string &filename)
template<typename VectorType >
bool	loadMarketVector (VectorType &vec, const std::string &filename)
template<typename NewDerType >
AutoDiffScalar< NewDerType >	MakeAutoDiffScalar (const typename NewDerType::Scalar &value, const NewDerType &der)
template<typename MatrixType , typename ResultType >
void	matrix_sqrt_quasi_triangular (const MatrixType &arg, ResultType &result)
	Compute matrix square root of quasi-triangular matrix. More...
template<typename MatrixType , typename ResultType >
void	matrix_sqrt_triangular (const MatrixType &arg, ResultType &result)
	Compute matrix square root of triangular matrix. More...
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type()	max (const AutoDiffScalar< DerType > &x, const T &y)
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type()	max (const T &x, const AutoDiffScalar< DerType > &y)
template<typename DerType >
CleanedUpDerType< DerType >::type()	max (const AutoDiffScalar< DerType > &x, const AutoDiffScalar< DerType > &y)
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type()	min (const AutoDiffScalar< DerType > &x, const T &y)
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type()	min (const T &x, const AutoDiffScalar< DerType > &y)
template<typename DerType >
CleanedUpDerType< DerType >::type()	min (const AutoDiffScalar< DerType > &x, const AutoDiffScalar< DerType > &y)
template<typename DstXprType , typename SrcXprType >
void	multiply_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
int	nbThreads ()
template<typename U , typename V >
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool	operator!= (const Tuple< U, V > &x, const Tuple< U, V > &y)
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)
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 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 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)
template<typename DenseDerived , typename SparseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator+ (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
template<typename SparseDerived , typename DenseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator+ (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
template<typename DenseDerived , typename SparseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator- (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
template<typename SparseDerived , typename DenseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator- (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
template<typename T >
std::ostream &	operator<< (std::ostream &os, const TensorBase< T, ReadOnlyAccessors > &expr)
template<typename IndexType , int NumDims>
std::ostream &	operator<< (std::ostream &os, const DSizes< IndexType, NumDims > &dims)
template<class T , std::size_t N>
EIGEN_DEVICE_FUNC bool	operator== (const array< T, N > &lhs, const array< T, N > &rhs)
template<typename U , typename V >
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool	operator== (const Tuple< U, V > &x, const Tuple< U, V > &y)
template<typename Polynomials , typename T >
T	poly_eval (const Polynomials &poly, const T &x)
template<typename Polynomials , typename T >
T	poly_eval_horner (const Polynomials &poly, const T &x)
template<typename DerivedN , typename DerivedX >
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_polygamma_op< typename DerivedX::Scalar >, const DerivedN, const DerivedX >	polygamma (const Eigen::ArrayBase< DerivedN > &n, const Eigen::ArrayBase< DerivedX > &x)
template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs >	prod (const Lhs &lhs, const Rhs &rhs)
template<typename PermutationVectorType >
void	randomPermutationVector (PermutationVectorType &v, Index size)
template<typename DerType >
const AutoDiffScalar< DerType > &	real (const AutoDiffScalar< DerType > &x)
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType, OnTheRight >	rightHouseholderSequence (const VectorsType &v, const CoeffsType &h)
	Convenience function for constructing a Householder sequence. More...
template<typename RootVector , typename Polynomial >
void	roots_to_monicPolynomial (const RootVector &rv, Polynomial &poly)
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)
UniformScaling< float >	Scaling (float s)
UniformScaling< double >	Scaling (double s)
template<typename RealScalar >
UniformScaling< std::complex< RealScalar > >	Scaling (const std::complex< RealScalar > &s)
template<typename Scalar >
DiagonalMatrix< Scalar, 2 >	Scaling (const Scalar &sx, const Scalar &sy)
template<typename Scalar >
DiagonalMatrix< Scalar, 3 >	Scaling (const Scalar &sx, const Scalar &sy, const Scalar &sz)
template<typename Derived >
const DiagonalWrapper< const Derived >	Scaling (const MatrixBase< Derived > &coeffs)
template<typename FirstType , typename LastType >
internal::enable_if<!(symbolic::is_symbolic< FirstType >::value||symbolic::is_symbolic< LastType >::value), ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, Index > >::type	seq (FirstType f, LastType l)
template<typename FirstTypeDerived , typename LastType >
internal::enable_if<!symbolic::is_symbolic< LastType >::value, ArithmeticSequence< FirstTypeDerived, symbolic::AddExpr< symbolic::AddExpr< symbolic::NegateExpr< FirstTypeDerived >, symbolic::ValueExpr<> >, symbolic::ValueExpr< internal::FixedInt< 1 > > > > >::type	seq (const symbolic::BaseExpr< FirstTypeDerived > &f, LastType l)
template<typename FirstType , typename LastTypeDerived >
internal::enable_if<!symbolic::is_symbolic< FirstType >::value, ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, symbolic::AddExpr< symbolic::AddExpr< LastTypeDerived, symbolic::ValueExpr<> >, symbolic::ValueExpr< internal::FixedInt< 1 > > > > >::type	seq (FirstType f, const symbolic::BaseExpr< LastTypeDerived > &l)
template<typename FirstTypeDerived , typename LastTypeDerived >
ArithmeticSequence< FirstTypeDerived, symbolic::AddExpr< symbolic::AddExpr< LastTypeDerived, symbolic::NegateExpr< FirstTypeDerived > >, symbolic::ValueExpr< internal::FixedInt< 1 > > > >	seq (const symbolic::BaseExpr< FirstTypeDerived > &f, const symbolic::BaseExpr< LastTypeDerived > &l)
template<typename FirstType , typename LastType , typename IncrType >
internal::enable_if<!(symbolic::is_symbolic< FirstType >::value||symbolic::is_symbolic< LastType >::value), ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, Index, typename internal::cleanup_seq_incr< IncrType >::type > >::type	seq (FirstType f, LastType l, IncrType incr)
template<typename FirstTypeDerived , typename LastType , typename IncrType >
internal::enable_if<!symbolic::is_symbolic< LastType >::value, ArithmeticSequence< FirstTypeDerived, symbolic::QuotientExpr< symbolic::AddExpr< symbolic::AddExpr< symbolic::NegateExpr< FirstTypeDerived >, symbolic::ValueExpr<> >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, typename internal::cleanup_seq_incr< IncrType >::type > >::type	seq (const symbolic::BaseExpr< FirstTypeDerived > &f, LastType l, IncrType incr)
template<typename FirstType , typename LastTypeDerived , typename IncrType >
internal::enable_if<!symbolic::is_symbolic< FirstType >::value, ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, symbolic::QuotientExpr< symbolic::AddExpr< symbolic::AddExpr< LastTypeDerived, symbolic::ValueExpr<> >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, typename internal::cleanup_seq_incr< IncrType >::type > >::type	seq (FirstType f, const symbolic::BaseExpr< LastTypeDerived > &l, IncrType incr)
template<typename FirstTypeDerived , typename LastTypeDerived , typename IncrType >
ArithmeticSequence< FirstTypeDerived, symbolic::QuotientExpr< symbolic::AddExpr< symbolic::AddExpr< LastTypeDerived, symbolic::NegateExpr< FirstTypeDerived > >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, typename internal::cleanup_seq_incr< IncrType >::type >	seq (const symbolic::BaseExpr< FirstTypeDerived > &f, const symbolic::BaseExpr< LastTypeDerived > &l, IncrType incr)
template<typename FirstType , typename SizeType , typename IncrType >
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type, typename internal::cleanup_seq_incr< IncrType >::type >	seqN (FirstType first, SizeType size, IncrType incr)
template<typename FirstType , typename SizeType >
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type >	seqN (FirstType first, SizeType size)
void	setCpuCacheSizes (std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
void	setNbThreads (int v)
static const char *	SimdInstructionSetsInUse (void)
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)
template<typename DstXprType , typename SrcXprType >
void	subtract_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
template<typename DstXprType , typename SrcXprType >
void	swap_using_evaluator (const DstXprType &dst, const SrcXprType &src)
template<typename T , typename U >
bool	test_is_equal (const T &actual, const U &expected, bool expect_equal=true)
bool	test_isApprox (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_isApprox (const std::complex< long double > &a, const std::complex< long double > &b)
bool	test_isApprox (const long double &a, const long double &b)
template<typename Type1 , typename Type2 >
bool	test_isApprox (const Type1 &a, const Type2 &b, typename Type1::Scalar *=0)
bool	test_isApproxOrLessThan (const long double &a, const long double &b)
template<typename Scalar , typename ScalarRef >
bool	test_isApproxWithRef (const Scalar &a, const Scalar &b, const ScalarRef &ref)
bool	test_isMuchSmallerThan (const std::complex< float > &a, const std::complex< float > &b)
bool	test_isMuchSmallerThan (const std::complex< double > &a, const std::complex< double > &b)
bool	test_isMuchSmallerThan (const std::complex< long double > &a, const std::complex< long double > &b)
bool	test_isMuchSmallerThan (const long double &a, const long double &b)
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 >
NumTraits< T >::Real	test_precision ()
template<>
AnnoyingScalar	test_precision< AnnoyingScalar > ()
template<>
double	test_precision< double > ()
template<>
float	test_precision< float > ()
template<>
long double	test_precision< long double > ()
template<>
Real	test_precision< Real > ()
template<>
double	test_precision< std::complex< double > > ()
template<>
float	test_precision< std::complex< float > > ()
template<>
long double	test_precision< std::complex< long double > > ()
template<typename T , typename Derived >
T	test_relative_error (const AlignedVector3< T > &a, const MatrixBase< Derived > &b)
template<typename T1 , typename T2 >
NumTraits< typename T1::RealScalar >::NonInteger	test_relative_error (const EigenBase< T1 > &a, const EigenBase< T2 > &b)
template<typename T1 , typename T2 >
T1::RealScalar	test_relative_error (const T1 &a, const T2 &b, const typename T1::Coefficients *=0)
template<typename T1 , typename T2 >
T1::Scalar	test_relative_error (const T1 &a, const T2 &b, const typename T1::MatrixType *=0)
template<typename S , int D>
S	test_relative_error (const Translation< S, D > &a, const Translation< S, D > &b)
template<typename S , int D, int O>
S	test_relative_error (const ParametrizedLine< S, D, O > &a, const ParametrizedLine< S, D, O > &b)
template<typename S , int D>
S	test_relative_error (const AlignedBox< S, D > &a, const AlignedBox< S, D > &b)
template<typename T1 , typename T2 >
T1::RealScalar	test_relative_error (const MatrixBase< T1 > &a, const SparseMatrixBase< T2 > &b)
template<typename T1 , typename T2 >
T1::RealScalar	test_relative_error (const SparseMatrixBase< T1 > &a, const MatrixBase< T2 > &b)
template<typename T1 , typename T2 >
T1::RealScalar	test_relative_error (const SparseMatrixBase< T1 > &a, const SparseMatrixBase< T2 > &b)
template<typename T1 , typename T2 >
NumTraits< typename NumTraits< T1 >::Real >::NonInteger	test_relative_error (const T1 &a, const T2 &b, typename internal::enable_if< internal::is_arithmetic< typename NumTraits< T1 >::Real >::value, T1 >::type *=0)
template<typename T >
T	test_relative_error (const Rotation2D< T > &a, const Rotation2D< T > &b)
template<typename T >
T	test_relative_error (const AngleAxis< T > &a, const AngleAxis< T > &b)
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. More...
void	umfpack_defaults (double control[UMFPACK_CONTROL], double, int)
void	umfpack_defaults (double control[UMFPACK_CONTROL], std::complex< double >, int)
void	umfpack_defaults (double control[UMFPACK_CONTROL], double, SuiteSparse_long)
void	umfpack_defaults (double control[UMFPACK_CONTROL], std::complex< double >, SuiteSparse_long)
void	umfpack_free_numeric (void **Numeric, double, int)
void	umfpack_free_numeric (void **Numeric, std::complex< double >, int)
void	umfpack_free_numeric (void **Numeric, double, SuiteSparse_long)
void	umfpack_free_numeric (void **Numeric, std::complex< double >, SuiteSparse_long)
void	umfpack_free_symbolic (void **Symbolic, double, int)
void	umfpack_free_symbolic (void **Symbolic, std::complex< double >, int)
void	umfpack_free_symbolic (void **Symbolic, double, SuiteSparse_long)
void	umfpack_free_symbolic (void **Symbolic, std::complex< double >, SuiteSparse_long)
int	umfpack_get_determinant (double *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], int)
int	umfpack_get_determinant (std::complex< double > *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], int)
SuiteSparse_long	umfpack_get_determinant (double *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], SuiteSparse_long)
SuiteSparse_long	umfpack_get_determinant (std::complex< double > *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], SuiteSparse_long)
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 >)
SuiteSparse_long	umfpack_get_lunz (SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col, SuiteSparse_long *nz_udiag, void *Numeric, double)
SuiteSparse_long	umfpack_get_lunz (SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col, SuiteSparse_long *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)
SuiteSparse_long	umfpack_get_numeric (SuiteSparse_long Lp[], SuiteSparse_long Lj[], double Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], double Ux[], SuiteSparse_long P[], SuiteSparse_long Q[], double Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
SuiteSparse_long	umfpack_get_numeric (SuiteSparse_long Lp[], SuiteSparse_long Lj[], std::complex< double > Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], std::complex< double > Ux[], SuiteSparse_long P[], SuiteSparse_long Q[], std::complex< double > Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
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])
SuiteSparse_long	umfpack_numeric (const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info [UMFPACK_INFO])
SuiteSparse_long	umfpack_numeric (const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex< double > Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info [UMFPACK_INFO])
void	umfpack_report_control (double control[UMFPACK_CONTROL], double, int)
void	umfpack_report_control (double control[UMFPACK_CONTROL], std::complex< double >, int)
void	umfpack_report_control (double control[UMFPACK_CONTROL], double, SuiteSparse_long)
void	umfpack_report_control (double control[UMFPACK_CONTROL], std::complex< double >, SuiteSparse_long)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, int)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex< double >, int)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, SuiteSparse_long)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex< double >, SuiteSparse_long)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, double, int)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, std::complex< double >, int)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, double, SuiteSparse_long)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, std::complex< double >, SuiteSparse_long)
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])
SuiteSparse_long	umfpack_solve (int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], double X[], const double B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
SuiteSparse_long	umfpack_solve (int sys, const SuiteSparse_long Ap[], const SuiteSparse_long 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_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])
SuiteSparse_long	umfpack_symbolic (SuiteSparse_long n_row, SuiteSparse_long n_col, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], void **Symbolic, const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
SuiteSparse_long	umfpack_symbolic (SuiteSparse_long n_row, SuiteSparse_long n_col, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex< double > Ax[], void **Symbolic, const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
template<typename Type1 , typename Type2 >
bool	verifyIsApprox (const Type1 &a, const Type2 &b)
template<typename _Scalar , int _Options, typename _StorageIndex >
cholmod_sparse	viewAsCholmod (Ref< SparseMatrix< _Scalar, _Options, _StorageIndex > > mat)
template<typename _Scalar , int _Options, typename _Index >
const cholmod_sparse	viewAsCholmod (const SparseMatrix< _Scalar, _Options, _Index > &mat)
template<typename _Scalar , int _Options, typename _Index >
const cholmod_sparse	viewAsCholmod (const SparseVector< _Scalar, _Options, _Index > &mat)
template<typename _Scalar , int _Options, typename _Index , unsigned int UpLo>
cholmod_sparse	viewAsCholmod (const SparseSelfAdjointView< const SparseMatrix< _Scalar, _Options, _Index >, UpLo > &mat)
template<typename Derived >
cholmod_dense	viewAsCholmod (MatrixBase< Derived > &mat)
template<typename Scalar , int Flags, typename StorageIndex >
MappedSparseMatrix< Scalar, Flags, StorageIndex >	viewAsEigen (cholmod_sparse &cm)
template<typename DerivedX , typename DerivedQ >
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_zeta_op< typename DerivedX::Scalar >, const DerivedX, const DerivedQ >	zeta (const Eigen::ArrayBase< DerivedX > &x, const Eigen::ArrayBase< DerivedQ > &q)

Variables
const unsigned int	ActualPacketAccessBit = 0x0
EIGEN_DEPRECATED const unsigned int	AlignedBit = 0x80
static const Eigen::internal::all_t	all
const int	AutoOrder = 2
const int	CoherentAccessPattern = 0x1
const unsigned int	CompressedAccessBit = 0x400
const unsigned int	DirectAccessBit = 0x40
const int	Dynamic = -1
const int	DynamicIndex = 0xffffff
EIGEN_DEPRECATED const unsigned int	EvalBeforeAssigningBit = 0x4
const unsigned int	EvalBeforeNestingBit = 0x2
EIGEN_DEVICE_FUNC const Eigen::ArrayBase< Derived > &	exponents
Scalar	expx = exp(x.value())
static bool	g_has_set_repeat = false
static bool	g_has_set_seed = false
static int	g_repeat = 1
static unsigned int	g_seed = 0
static int	g_test_level = 0
static std::vector< std::string >	g_test_stack
const unsigned int	HereditaryBits
const int	HugeCost = 10000
const int	Infinity = -1
const int	InnerRandomAccessPattern = 0x2 | CoherentAccessPattern
static const symbolic::SymbolExpr< internal::symbolic_last_tag >	last
const unsigned int	LinearAccessBit = 0x10
const unsigned int	LvalueBit = 0x20
const unsigned int	NestByRefBit = 0x100
static bool	no_more_assert = false
const unsigned int	NoPreferredStorageOrderBit = 0x200
const int	OuterRandomAccessPattern = 0x4 | CoherentAccessPattern
const unsigned int	PacketAccessBit = 0x8
const int	RandomAccessPattern = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern
static bool	report_on_cerr_on_assert_failure = true
const unsigned int	RowMajorBit = 0x1
static const bool	should_raise_an_assert = false
const unsigned int	SkylineBit = 0x1200
const int	UndefinedIncr = 0xfffffe

Detailed Description

Namespace containing all symbols from the Eigen library.

Typedef Documentation

BlasIndex

typedef int Eigen::BlasIndex

Definition at line 131 of file MKL_support.h.

dcomplex

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

Definition at line 125 of file MKL_support.h.

DenseIndex

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Eigen::DenseIndex

Definition at line 66 of file Meta.h.

Index

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Eigen::Index

The Index type as used for the API.

To change this, #define the preprocessor symbol EIGEN_DEFAULT_DENSE_INDEX_TYPE.

See also

Preprocessor directives, StorageIndex.

Examples:

/tmp/ws/src/gtsam/gtsam/3rdparty/Eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h.

Definition at line 74 of file Meta.h.

scomplex

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

Definition at line 126 of file MKL_support.h.

Spline2d

typedef Spline<double,2> Eigen::Spline2d

2D double B-spline with dynamic degree.

Definition at line 87 of file SplineFwd.h.

Spline2f

typedef Spline<float,2> Eigen::Spline2f

2D float B-spline with dynamic degree.

Definition at line 81 of file SplineFwd.h.

Spline3d

typedef Spline<double,3> Eigen::Spline3d

3D double B-spline with dynamic degree.

Definition at line 90 of file SplineFwd.h.

Spline3f

typedef Spline<float,3> Eigen::Spline3f

3D float B-spline with dynamic degree.

Definition at line 84 of file SplineFwd.h.

ThreadPool

typedef ThreadPoolTempl<StlThreadEnvironment> Eigen::ThreadPool

Definition at line 482 of file NonBlockingThreadPool.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
NegationFlag
ConjugationFlag

Definition at line 15 of file Symmetry.h.

anonymous enum

anonymous enum

Enumerator
GlobalRealFlag
GlobalImagFlag
GlobalZeroFlag

Definition at line 20 of file Symmetry.h.

anonymous enum

anonymous enum

Enumerator
IsSkyline

Definition at line 24 of file SkylineUtil.h.

anonymous enum

anonymous enum

Enumerator
SPD
NonSymmetric

Definition at line 16 of file MatrixMarketIterator.h.

anonymous enum

anonymous enum

Enumerator
Large
Small

Definition at line 16 of file GeneralProduct.h.

anonymous enum

anonymous enum

Enumerator
DontAlignCols

Definition at line 16 of file IO.h.

anonymous enum

anonymous enum

Enumerator
StreamPrecision
FullPrecision

Definition at line 17 of file IO.h.

anonymous enum

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.

anonymous enum

anonymous enum

Enumerator
CPU_TIMER
REAL_TIMER

Definition at line 47 of file BenchTimer.h.

Action

enum Eigen::Action

Enumerator
GetAction
SetAction

Definition at line 504 of file Constants.h.

AdditionalProductEvaluationMode

enum Eigen::AdditionalProductEvaluationMode

Enumerator
SkylineTimeDenseProduct
SkylineTimeSkylineProduct
DenseTimeSkylineProduct

Definition at line 23 of file SkylineUtil.h.

AmbiVectorMode

enum Eigen::AmbiVectorMode

Enumerator
IsDense
IsSparse

Definition at line 366 of file Constants.h.

AutoSize_t

enum Eigen::AutoSize_t

Enumerator
AutoSize

Definition at line 16 of file ReshapedHelper.h.

CholmodMode

enum Eigen::CholmodMode

Enumerator
CholmodAuto
CholmodSimplicialLLt
CholmodSupernodalLLt
CholmodLDLt

Definition at line 203 of file CholmodSupport.h.

convolution_type

enum Eigen::convolution_type

strong

Enumerator
CONV1D
CONV2D
CONV3D

Definition at line 28 of file TensorConvolutionSycl.h.

Default_t

enum Eigen::Default_t

Enumerator
Default

Definition at line 362 of file Constants.h.

EulerAxis

enum Eigen::EulerAxis

Representation of a fixed signed rotation axis for EulerSystem.

Values here represent:

• The axis of the rotation: X, Y or Z.
• The sign (i.e. direction of the rotation along the axis): positive(+) or negative(-)

Therefore, this could express all the axes {+X,+Y,+Z,-X,-Y,-Z}

For positive axis, use +EULER_{axis}, and for negative axis use -EULER_{axis}.

Enumerator
EULER_X	the X axis
EULER_Y	the Y axis
EULER_Z	the Z axis

Definition at line 61 of file EulerSystem.h.

FFTDirection

enum Eigen::FFTDirection

Enumerator
FFT_FORWARD
FFT_REVERSE

Definition at line 138 of file TensorForwardDeclarations.h.

FFTResultType

enum Eigen::FFTResultType

Enumerator
RealPart
ImagPart
BothParts

Definition at line 132 of file TensorForwardDeclarations.h.

NoChange_t

enum Eigen::NoChange_t

Enumerator
NoChange

Definition at line 360 of file Constants.h.

NumericalDiffMode

enum Eigen::NumericalDiffMode

Enumerator
Forward
Central

Definition at line 18 of file NumericalDiff.h.

PaddingType

enum Eigen::PaddingType

Enumerator
PADDING_VALID
PADDING_SAME

Definition at line 257 of file TensorTraits.h.

ProductImplType

enum Eigen::ProductImplType

Enumerator
DefaultProduct
LazyProduct
AliasFreeProduct
CoeffBasedProductMode
LazyCoeffBasedProductMode
OuterProduct
InnerProduct
GemvProduct
GemmProduct

Definition at line 499 of file Constants.h.

Sequential_t

enum Eigen::Sequential_t

Enumerator
Sequential

Definition at line 361 of file Constants.h.

SimplicialCholeskyMode

enum Eigen::SimplicialCholeskyMode

Enumerator
SimplicialCholeskyLLT
SimplicialCholeskyLDLT

Definition at line 15 of file SimplicialCholesky.h.

SpecializedType

enum Eigen::SpecializedType

Enumerator
Specialized
BuiltIn

Definition at line 309 of file Constants.h.

TraversalType

enum Eigen::TraversalType

Enumerator
DefaultTraversal
LinearTraversal
InnerVectorizedTraversal
LinearVectorizedTraversal
SliceVectorizedTraversal
InvalidTraversal
AllAtOnceTraversal

Definition at line 275 of file Constants.h.

UnrollingType

enum Eigen::UnrollingType

Enumerator
NoUnrolling
InnerUnrolling
CompleteUnrolling

Definition at line 297 of file Constants.h.

Function Documentation

add_assign_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::add_assign_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

Definition at line 53 of file evaluators.cpp.

atan2()

template<typename DerTypeA , typename DerTypeB >

const AutoDiffScalar<Matrix<typename internal::traits<typename internal::remove_all<DerTypeA>::type>::Scalar,Dynamic,1> > Eigen::atan2 ( const AutoDiffScalar< DerTypeA > &  a, const AutoDiffScalar< DerTypeB > &  b  )

inline

Definition at line 654 of file AutoDiffScalar.h.

bessel_i0()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i0

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise i0(x) to the given arrays.

It returns the modified Bessel function of the first kind of order zero.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i0(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_i0()

Definition at line 32 of file BesselFunctionsArrayAPI.h.

bessel_i0e()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i0e

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise i0e(x) to the given arrays.

It returns the exponentially scaled modified Bessel function of the first kind of order zero.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i0e(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_i0e()

Definition at line 55 of file BesselFunctionsArrayAPI.h.

bessel_i1()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i1

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise i1(x) to the given arrays.

It returns the modified Bessel function of the first kind of order one.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i1(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_i1()

Definition at line 77 of file BesselFunctionsArrayAPI.h.

bessel_i1e()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i1e

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise i1e(x) to the given arrays.

It returns the exponentially scaled modified Bessel function of the first kind of order one.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i1e(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_i1e()

Definition at line 100 of file BesselFunctionsArrayAPI.h.

bessel_j0()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_j0

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise j0(x) to the given arrays.

It returns the Bessel function of the first kind of order zero.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of j0(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_j0()

Definition at line 212 of file BesselFunctionsArrayAPI.h.

bessel_j1()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_j1

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise j1(x) to the given arrays.

It returns the modified Bessel function of the first kind of order one.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of j1(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_j1()

Definition at line 256 of file BesselFunctionsArrayAPI.h.

bessel_k0()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k0

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise k0(x) to the given arrays.

It returns the modified Bessel function of the second kind of order zero.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k0(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_k0()

Definition at line 122 of file BesselFunctionsArrayAPI.h.

bessel_k0e()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k0e

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise k0e(x) to the given arrays.

It returns the exponentially scaled modified Bessel function of the second kind of order zero.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k0e(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_k0e()

Definition at line 145 of file BesselFunctionsArrayAPI.h.

bessel_k1()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k1

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise k1(x) to the given arrays.

It returns the modified Bessel function of the second kind of order one.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k1(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_k1()

Definition at line 167 of file BesselFunctionsArrayAPI.h.

bessel_k1e()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k1e

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise k1e(x) to the given arrays.

It returns the exponentially scaled modified Bessel function of the second kind of order one.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k1e(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_k1e()

Definition at line 190 of file BesselFunctionsArrayAPI.h.

bessel_y0()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_y0

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise y0(x) to the given arrays.

It returns the Bessel function of the second kind of order zero.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of y0(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_y0()

Definition at line 234 of file BesselFunctionsArrayAPI.h.

bessel_y1()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_y1

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

an expression of the coefficient-wise y1(x) to the given arrays.

It returns the Bessel function of the second kind of order one.

Parameters

x	is the argument

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of y1(T) for any scalar type T to be supported.

See also

ArrayBase::bessel_y1()

Definition at line 278 of file BesselFunctionsArrayAPI.h.

betainc() [1/2]

template<typename ADerived , typename BDerived , typename XDerived >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorCwiseTernaryOp<internal::scalar_betainc_op<typename XDerived::Scalar>, const ADerived, const BDerived, const XDerived> Eigen::betainc	(	const ADerived &	a,
		const BDerived &	b,
		const XDerived &	x
	)

Returns

an expression of the coefficient-wise betainc(x, a, b) to the given tensors.

This function computes the regularized incomplete beta function (integral).

Definition at line 24 of file TensorGlobalFunctions.h.

betainc() [2/2]

template<typename ArgADerived , typename ArgBDerived , typename ArgXDerived >

EIGEN_STRONG_INLINE const Eigen::CwiseTernaryOp<Eigen::internal::scalar_betainc_op<typename ArgXDerived::Scalar>, const ArgADerived, const ArgBDerived, const ArgXDerived> Eigen::betainc	(	const Eigen::ArrayBase< ArgADerived > &	a,
		const Eigen::ArrayBase< ArgBDerived > &	b,
		const Eigen::ArrayBase< ArgXDerived > &	x
	)

Returns

an expression of the coefficient-wise betainc(x, a, b) to the given arrays.

This function computes the regularized incomplete beta function (integral).

Note

This function supports only float and double scalar types in c++11 mode. To support other scalar types, or float/double in non c++11 mode, the user has to provide implementations of betainc(T,T,T) for any scalar type T to be supported.

See also

Eigen::betainc(), Eigen::lgamma()

Definition at line 132 of file SpecialFunctionsArrayAPI.h.

bounding_box() [1/2]

Box2d Eigen::bounding_box

(

const Vector2d &

v

)

Definition at line 9 of file BVH_Example.cpp.

bounding_box() [2/2]

template<typename Scalar , int Dim>

AlignedBox<Scalar, Dim> Eigen::bounding_box

(

const Matrix< Scalar, Dim, 1 > &

v

)

Definition at line 17 of file BVH.cpp.

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

Definition at line 79 of file BVAlgorithms.h.

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

Definition at line 93 of file BVAlgorithms.h.

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)

Definition at line 219 of file BVAlgorithms.h.

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)

Definition at line 235 of file BVAlgorithms.h.

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. is stored as a vector .

Precondition

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

Definition at line 75 of file PolynomialUtils.h.

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. is stored as a vector .

Definition at line 98 of file PolynomialUtils.h.

choose() [1/2]

template<typename T1 , typename T2 >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T1& Eigen::choose	(	Cond< true >	,
		const T1 &	first,
		const T2 &
	)

Definition at line 18 of file TensorMeta.h.

choose() [2/2]

template<typename T1 , typename T2 >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T2& Eigen::choose	(	Cond< false >	,
		const T1 &	,
		const T2 &	second
	)

Definition at line 23 of file TensorMeta.h.

conj()

template<typename DerType >

const AutoDiffScalar<DerType>& Eigen::conj ( const AutoDiffScalar< DerType > &  x )

inline

Definition at line 574 of file AutoDiffScalar.h.

constCast()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T* Eigen::constCast

(

const T *

data

)

Examples:

/tmp/ws/src/gtsam/gtsam/3rdparty/Eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h.

Definition at line 27 of file TensorForwardDeclarations.h.

copy_using_evaluator() [1/3]

template<typename DstXprType , typename SrcXprType >

EIGEN_STRONG_INLINE DstXprType& Eigen::copy_using_evaluator	(	const EigenBase< DstXprType > &	dst,
		const SrcXprType &	src
	)

Definition at line 22 of file evaluators.cpp.

copy_using_evaluator() [2/3]

template<typename DstXprType , template< typename > class StorageBase, typename SrcXprType >

EIGEN_STRONG_INLINE const DstXprType& Eigen::copy_using_evaluator	(	const NoAlias< DstXprType, StorageBase > &	dst,
		const SrcXprType &	src
	)

Definition at line 30 of file evaluators.cpp.

copy_using_evaluator() [3/3]

template<typename DstXprType , typename SrcXprType >

EIGEN_STRONG_INLINE DstXprType& Eigen::copy_using_evaluator	(	const PlainObjectBase< DstXprType > &	dst,
		const SrcXprType &	src
	)

Definition at line 38 of file evaluators.cpp.

createRandomPIMatrixOfRank()

template<typename MatrixType >

void Eigen::createRandomPIMatrixOfRank	(	Index	desired_rank,
		Index	rows,
		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.

Definition at line 653 of file main.h.

derivativesImpl()

template<typename SplineType , typename DerivativeType >

void Eigen::derivativesImpl	(	const SplineType &	spline,
		typename SplineType::Scalar	u,
		DenseIndex	order,
		DerivativeType &	der
	)

Definition at line 311 of file Spline.h.

dimensions_match()

template<typename Dims1 , typename Dims2 >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool Eigen::dimensions_match	(	Dims1	dims1,
		Dims2	dims2
	)

Definition at line 484 of file TensorDimensions.h.

divide_assign_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::divide_assign_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

Definition at line 74 of file evaluators.cpp.

divup() [1/2]

template<typename T , typename X , typename Y >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::divup	(	const X	x,
		const Y	y
	)

Definition at line 30 of file TensorMeta.h.

divup() [2/2]

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::divup	(	const T	x,
		const T	y
	)

Definition at line 36 of file TensorMeta.h.

dsaupd_()

void Eigen::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
	)

dseupd_()

void Eigen::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
	)

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [1/7]

Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY	(	abs	,
		using std::abs;return Eigen::MakeAutoDiffScalar(abs(x.value()), x.derivatives() *(x.value()< 0 ? -1 :1));
	)

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [2/7]

Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY	(	sqrt	,
		using std::sqrt;Scalar	sqrtx = sqrt(x.value()); return Eigen::MakeAutoDiffScalar(sqrtx,x.derivatives() * (Scalar(0.5) / sqrtx));
	)

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [3/7]

Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY	(	sin	,
		using std::sin;using std::cos;return Eigen::MakeAutoDiffScalar(sin(x.value()), x.derivatives() *cos(x.value()));
	)

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [4/7]

Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY	(	log	,
		using std::log;return Eigen::MakeAutoDiffScalar(log(x.value()), x.derivatives() *(Scalar(1)/x.value()));
	)		const

Definition at line 637 of file AutoDiffScalar.h.

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [5/7]

Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY	(	tan	,
		using std::tan;using std::cos;return Eigen::MakeAutoDiffScalar(tan(x.value()), x.derivatives() *(Scalar(1)/numext::abs2(cos(x.value()))));
	)

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [6/7]

Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY	(	acos	,
		using std::sqrt;using std::acos;return Eigen::MakeAutoDiffScalar(acos(x.value()), x.derivatives() *(Scalar(-1)/sqrt(1-numext::abs2(x.value()))));
	)

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [7/7]

Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY	(	sinh	,
		using std::sinh;using std::cosh;return Eigen::MakeAutoDiffScalar(sinh(x.value()), x.derivatives() *cosh(x.value()));
	)

fix() [1/2]

template<int N>

internal::FixedInt<N> Eigen::fix ( )

inline

Definition at line 192 of file IntegralConstant.h.

fix() [2/2]

template<int N, typename T >

internal::VariableAndFixedInt<N> Eigen::fix ( T  val )

inline

Definition at line 197 of file IntegralConstant.h.

gamma_sample_der_alpha()

template<typename AlphaDerived , typename SampleDerived >

EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_gamma_sample_der_alpha_op<typename AlphaDerived::Scalar>, const AlphaDerived, const SampleDerived> Eigen::gamma_sample_der_alpha	(	const Eigen::ArrayBase< AlphaDerived > &	alpha,
		const Eigen::ArrayBase< SampleDerived > &	sample
	)

Returns

an expression of the coefficient-wise gamma_sample_der_alpha(alpha, sample) to the given arrays.

This function computes the coefficient-wise derivative of the sample of a Gamma(alpha, 1) random variable with respect to the parameter alpha.

Note

This function supports only float and double scalar types in c++11 mode. To support other scalar types, or float/double in non c++11 mode, the user has to provide implementations of gamma_sample_der_alpha(T,T) for any scalar type T to be supported.

See also

Eigen::igamma(), Eigen::lgamma()

Definition at line 72 of file SpecialFunctionsArrayAPI.h.

get_test_precision() [1/2]

template<typename T >

NumTraits<typename T::Scalar>::Real Eigen::get_test_precision	(	const T &	,
		const typename T::Scalar *	= 0
	)

Definition at line 572 of file main.h.

get_test_precision() [2/2]

template<typename T >

NumTraits<T>::Real Eigen::get_test_precision	(	const T &	,
		typename internal::enable_if< internal::is_arithmetic< typename NumTraits< T >::Real >::value, T >::type *	= 0
	)

Definition at line 578 of file main.h.

getMarketHeader()

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

inline

Definition at line 109 of file MarketIO.h.

igamma()

template<typename Derived , typename ExponentDerived >

EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_op<typename Derived::Scalar>, const Derived, const ExponentDerived> Eigen::igamma	(	const Eigen::ArrayBase< Derived > &	a,
		const Eigen::ArrayBase< ExponentDerived > &	x
	)

Returns

an expression of the coefficient-wise igamma(a, x) to the given arrays.

This function computes the coefficient-wise incomplete gamma function.

Note

This function supports only float and double scalar types in c++11 mode. To support other scalar types, or float/double in non c++11 mode, the user has to provide implementations of igammac(T,T) for any scalar type T to be supported.

See also

Eigen::igammac(), Eigen::lgamma()

Definition at line 28 of file SpecialFunctionsArrayAPI.h.

igamma_der_a()

template<typename Derived , typename ExponentDerived >

EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_der_a_op<typename Derived::Scalar>, const Derived, const ExponentDerived> Eigen::igamma_der_a	(	const Eigen::ArrayBase< Derived > &	a,
		const Eigen::ArrayBase< ExponentDerived > &	x
	)

Returns

an expression of the coefficient-wise igamma_der_a(a, x) to the given arrays.

This function computes the coefficient-wise derivative of the incomplete gamma function with respect to the parameter a.

Note

This function supports only float and double scalar types in c++11 mode. To support other scalar types, or float/double in non c++11 mode, the user has to provide implementations of igamma_der_a(T,T) for any scalar type T to be supported.

See also

Eigen::igamma(), Eigen::lgamma()

Definition at line 51 of file SpecialFunctionsArrayAPI.h.

igammac()

template<typename Derived , typename ExponentDerived >

EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igammac_op<typename Derived::Scalar>, const Derived, const ExponentDerived> Eigen::igammac	(	const Eigen::ArrayBase< Derived > &	a,
		const Eigen::ArrayBase< ExponentDerived > &	x
	)

Returns

an expression of the coefficient-wise igammac(a, x) to the given arrays.

This function computes the coefficient-wise complementary incomplete gamma function.

Note

This function supports only float and double scalar types in c++11 mode. To support other scalar types, or float/double in non c++11 mode, the user has to provide implementations of igammac(T,T) for any scalar type T to be supported.

See also

Eigen::igamma(), Eigen::lgamma()

Definition at line 90 of file SpecialFunctionsArrayAPI.h.

imag()

template<typename DerType >

DerType::Scalar Eigen::imag ( const AutoDiffScalar< DerType > &  )

inline

Definition at line 578 of file AutoDiffScalar.h.

initParallel()

void Eigen::initParallel ( )

inline

Must be call first when calling Eigen from multiple threads

Definition at line 53 of file Parallelizer.h.

is_same_type()

template<typename T1 , typename T2 >

internal::enable_if<internal::is_same<T1,T2>::value,bool>::type Eigen::is_same_type	(	const T1 &	,
		const T2 &
	)

Definition at line 410 of file main.h.

isMinusInf()

template<typename T >

bool Eigen::isMinusInf

(

const T &

x

)

Definition at line 718 of file main.h.

isNotNaN()

template<typename T >

bool Eigen::isNotNaN

(

const T &

x

)

Definition at line 708 of file main.h.

isPlusInf()

template<typename T >

bool Eigen::isPlusInf

(

const T &

x

)

Definition at line 713 of file main.h.

klu_factor() [1/2]

klu_numeric* Eigen::klu_factor ( int  Ap[], int  Ai[], double  Ax[], klu_symbolic *  Symbolic, klu_common *  Common, double    )

inline

Definition at line 50 of file KLUSupport.h.

klu_factor() [2/2]

klu_numeric* Eigen::klu_factor ( int  Ap[], int  Ai[], std::complex< double >  Ax[], klu_symbolic *  Symbolic, klu_common *  Common, std::complex< double >    )

inline

Definition at line 54 of file KLUSupport.h.

klu_solve() [1/2]

int Eigen::klu_solve ( klu_symbolic *  Symbolic, klu_numeric *  Numeric, Index  ldim, Index  nrhs, double  B[], klu_common *  Common, double    )

inline

A sparse LU factorization and solver based on KLU.

This class allows to solve for A.X = B sparse linear problems via a LU factorization using the KLU library. The sparse matrix A must be squared and full rank. The vectors or matrices X and B can be either dense or sparse.

Warning

The input matrix A should be in a compressed and column-major form. Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.

Template Parameters

_MatrixType

the type of the sparse matrix A, it must be a SparseMatrix<>

See also

Sparse solver concept, class UmfPackLU, class SparseLU

Definition at line 34 of file KLUSupport.h.

klu_solve() [2/2]

int Eigen::klu_solve ( klu_symbolic *  Symbolic, klu_numeric *  Numeric, Index  ldim, Index  nrhs, std::complex< double >  B[], klu_common *  Common, std::complex< double >    )

inline

Definition at line 38 of file KLUSupport.h.

klu_tsolve() [1/2]

int Eigen::klu_tsolve ( klu_symbolic *  Symbolic, klu_numeric *  Numeric, Index  ldim, Index  nrhs, double  B[], klu_common *  Common, double    )

inline

Definition at line 42 of file KLUSupport.h.

klu_tsolve() [2/2]

int Eigen::klu_tsolve ( klu_symbolic *  Symbolic, klu_numeric *  Numeric, Index  ldim, Index  nrhs, std::complex< double >  B[], klu_common *  Common, std::complex< double >    )

inline

Definition at line 46 of file KLUSupport.h.

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

Definition at line 271 of file KroneckerTensorProduct.h.

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

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/sparse matrix a
b	Dense/sparse matrix b

Returns

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

Definition at line 298 of file KroneckerTensorProduct.h.

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

Definition at line 2607 of file products/GeneralBlockPanelKernel.h.

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

Definition at line 2616 of file products/GeneralBlockPanelKernel.h.

l3CacheSize()

std::ptrdiff_t Eigen::l3CacheSize ( )

inline

Returns

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

See also

setCpuCacheSize

Definition at line 2626 of file products/GeneralBlockPanelKernel.h.

lastp1()

static const symbolic::AddExpr<symbolic::SymbolExpr<internal::symbolic_last_tag>,symbolic::ValueExpr<Eigen::internal::FixedInt<1> > > Eigen::lastp1 ( last+fix< 1 >  () )

static

lazyprod()

template<typename Lhs , typename Rhs >

const Product<Lhs,Rhs,LazyProduct> Eigen::lazyprod	(	const Lhs &	lhs,
		const Rhs &	rhs
	)

Definition at line 15 of file evaluators.cpp.

loadMarket()

template<typename SparseMatrixType >

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

Definition at line 134 of file MarketIO.h.

loadMarketVector()

template<typename VectorType >

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

Definition at line 200 of file MarketIO.h.

MakeAutoDiffScalar()

template<typename NewDerType >

AutoDiffScalar<NewDerType> Eigen::MakeAutoDiffScalar ( const typename NewDerType::Scalar &  value, const NewDerType &  der  )

inline

Definition at line 36 of file AutoDiffScalar.h.

matrix_sqrt_quasi_triangular()

template<typename MatrixType , typename ResultType >

void Eigen::matrix_sqrt_quasi_triangular	(	const MatrixType &	arg,
		ResultType &	result
	)

Compute matrix square root of quasi-triangular matrix.

Template Parameters

MatrixType	type of arg, the argument of matrix square root, expected to be an instantiation of the Matrix class template.
ResultType	type of result, where result is to be stored.

Parameters

[in]	arg	argument of matrix square root.
[out]	result	matrix square root of upper Hessenberg part of arg.

This function computes the square root of the upper quasi-triangular matrix stored in the upper Hessenberg part of arg. Only the upper Hessenberg part of result is updated, the rest is not touched. See MatrixBase::sqrt() for details on how this computation is implemented.

See also

MatrixSquareRoot, MatrixSquareRootQuasiTriangular

Definition at line 180 of file MatrixSquareRoot.h.

matrix_sqrt_triangular()

template<typename MatrixType , typename ResultType >

void Eigen::matrix_sqrt_triangular	(	const MatrixType &	arg,
		ResultType &	result
	)

Compute matrix square root of triangular matrix.

Template Parameters

MatrixType	type of arg, the argument of matrix square root, expected to be an instantiation of the Matrix class template.
ResultType	type of result, where result is to be stored.

Parameters

[in]	arg	argument of matrix square root.
[out]	result	matrix square root of upper triangular part of arg.

Only the upper triangular part (including the diagonal) of result is updated, the rest is not touched. See MatrixBase::sqrt() for details on how this computation is implemented.

See also

MatrixSquareRoot, MatrixSquareRootQuasiTriangular

Definition at line 204 of file MatrixSquareRoot.h.

max() [1/3]

template<typename DerType , typename T >

CleanedUpDerType<DerType>::type() Eigen::max ( const AutoDiffScalar< DerType > &  x, const T &  y  )

inline

Definition at line 585 of file AutoDiffScalar.h.

max() [2/3]

template<typename DerType , typename T >

CleanedUpDerType<DerType>::type() Eigen::max ( const T &  x, const AutoDiffScalar< DerType > &  y  )

inline

Definition at line 595 of file AutoDiffScalar.h.

max() [3/3]

template<typename DerType >

CleanedUpDerType<DerType>::type() Eigen::max ( const AutoDiffScalar< DerType > &  x, const AutoDiffScalar< DerType > &  y  )

inline

Definition at line 604 of file AutoDiffScalar.h.

min() [1/3]

template<typename DerType , typename T >

CleanedUpDerType<DerType>::type() Eigen::min ( const AutoDiffScalar< DerType > &  x, const T &  y  )

inline

Definition at line 580 of file AutoDiffScalar.h.

min() [2/3]

template<typename DerType , typename T >

CleanedUpDerType<DerType>::type() Eigen::min ( const T &  x, const AutoDiffScalar< DerType > &  y  )

inline

Definition at line 590 of file AutoDiffScalar.h.

min() [3/3]

template<typename DerType >

CleanedUpDerType<DerType>::type() Eigen::min ( const AutoDiffScalar< DerType > &  x, const AutoDiffScalar< DerType > &  y  )

inline

Definition at line 600 of file AutoDiffScalar.h.

multiply_assign_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::multiply_assign_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

Definition at line 67 of file evaluators.cpp.

nbThreads()

int Eigen::nbThreads ( )

inline

Returns

the max number of threads reserved for Eigen

See also

setNbThreads

Definition at line 63 of file Parallelizer.h.

operator!=()

template<typename U , typename V >

EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool Eigen::operator!=	(	const Tuple< U, V > &	x,
		const Tuple< U, V > &	y
	)

Definition at line 241 of file TensorMeta.h.

operator*() [1/9]

template<typename SparseDerived , typename PermDerived >

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

inline

Returns

the matrix with the permutation applied to the columns

Definition at line 147 of file SparsePermutation.h.

operator*() [2/9]

template<typename SparseDerived , typename PermDerived >

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

inline

Returns

the matrix with the permutation applied to the rows

Definition at line 154 of file SparsePermutation.h.

operator*() [3/9]

template<typename SparseDerived , typename PermutationType >

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

inline

Returns

the matrix with the inverse permutation applied to the columns.

Definition at line 162 of file SparsePermutation.h.

operator*() [4/9]

template<typename SparseDerived , typename PermutationType >

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

inline

Returns

the matrix with the inverse permutation applied to the rows.

Definition at line 171 of file SparsePermutation.h.

operator*() [5/9]

template<typename MatrixDerived , typename TranspositionsDerived >

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

Returns

the matrix with the transpositions applied to the columns.

Definition at line 313 of file Transpositions.h.

operator*() [6/9]

template<typename TranspositionsDerived , typename MatrixDerived >

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

Returns

the matrix with the transpositions applied to the rows.

Definition at line 325 of file Transpositions.h.

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 where is the matrix other and is the Householder sequence represented by h.

Definition at line 513 of file HouseholderSequence.h.

operator*() [8/9]

template<typename MatrixDerived , typename PermutationDerived >

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

Returns

the matrix with the permutation applied to the columns.

Definition at line 515 of file PermutationMatrix.h.

operator*() [9/9]

template<typename PermutationDerived , typename MatrixDerived >

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

Returns

the matrix with the permutation applied to the rows.

Definition at line 527 of file PermutationMatrix.h.

operator+() [1/2]

template<typename DenseDerived , typename SparseDerived >

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

Definition at line 694 of file SparseCwiseBinaryOp.h.

operator+() [2/2]

template<typename SparseDerived , typename DenseDerived >

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

Definition at line 701 of file SparseCwiseBinaryOp.h.

operator-() [1/2]

template<typename DenseDerived , typename SparseDerived >

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

Definition at line 708 of file SparseCwiseBinaryOp.h.

operator-() [2/2]

template<typename SparseDerived , typename DenseDerived >

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

Definition at line 715 of file SparseCwiseBinaryOp.h.

operator<<() [1/2]

template<typename T >

std::ostream& Eigen::operator<<	(	std::ostream &	os,
		const TensorBase< T, ReadOnlyAccessors > &	expr
	)

Definition at line 59 of file TensorIO.h.

operator<<() [2/2]

template<typename IndexType , int NumDims>

std::ostream& Eigen::operator<<	(	std::ostream &	os,
		const DSizes< IndexType, NumDims > &	dims
	)

Definition at line 387 of file TensorDimensions.h.

operator==() [1/2]

template<class T , std::size_t N>

EIGEN_DEVICE_FUNC bool Eigen::operator==	(	const array< T, N > &	lhs,
		const array< T, N > &	rhs
	)

Definition at line 189 of file EmulateArray.h.

operator==() [2/2]

template<typename U , typename V >

EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool Eigen::operator==	(	const Tuple< U, V > &	x,
		const Tuple< U, V > &	y
	)

Definition at line 235 of file TensorMeta.h.

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. is stored as a vector .
[in]	x	: the value to evaluate the polynomial at.

Definition at line 46 of file PolynomialUtils.h.

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. is stored as a vector .
[in]	x	: the value to evaluate the polynomial at.

Note

for stability:

Definition at line 28 of file PolynomialUtils.h.

polygamma()

template<typename DerivedN , typename DerivedX >

EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_polygamma_op<typename DerivedX::Scalar>, const DerivedN, const DerivedX> Eigen::polygamma	(	const Eigen::ArrayBase< DerivedN > &	n,
		const Eigen::ArrayBase< DerivedX > &	x
	)

Returns

an expression of the coefficient-wise polygamma(n, x) to the given arrays.

It returns the n -th derivative of the digamma(psi) evaluated at x.

Note

This function supports only float and double scalar types in c++11 mode. To support other scalar types, or float/double in non c++11 mode, the user has to provide implementations of polygamma(T,T) for any scalar type T to be supported.

See also

Eigen::digamma()

Definition at line 112 of file SpecialFunctionsArrayAPI.h.

prod()

template<typename Lhs , typename Rhs >

const Product<Lhs,Rhs> Eigen::prod	(	const Lhs &	lhs,
		const Rhs &	rhs
	)

Definition at line 8 of file evaluators.cpp.

randomPermutationVector()

template<typename PermutationVectorType >

void Eigen::randomPermutationVector	(	PermutationVectorType &	v,
		Index	size
	)

Definition at line 693 of file main.h.

real()

template<typename DerType >

const AutoDiffScalar<DerType>& Eigen::real ( const AutoDiffScalar< DerType > &  x )

inline

Definition at line 576 of file AutoDiffScalar.h.

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. is stored as a vector .

Definition at line 127 of file PolynomialUtils.h.

saveMarket()

template<typename SparseMatrixType >

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

Definition at line 232 of file MarketIO.h.

saveMarketVector()

template<typename VectorType >

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

Definition at line 258 of file MarketIO.h.

seq() [1/8]

template<typename FirstType , typename LastType >

internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value), ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index> >::type Eigen::seq	(	FirstType	f,
		LastType	l
	)

Definition at line 234 of file ArithmeticSequence.h.

seq() [2/8]

template<typename FirstTypeDerived , typename LastType >

internal::enable_if<!symbolic::is_symbolic<LastType>::value, ArithmeticSequence<FirstTypeDerived, symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>,symbolic::ValueExpr<> >, symbolic::ValueExpr<internal::FixedInt<1> > > > >::type Eigen::seq	(	const symbolic::BaseExpr< FirstTypeDerived > &	f,
		LastType	l
	)

Definition at line 244 of file ArithmeticSequence.h.

seq() [3/8]

template<typename FirstType , typename LastTypeDerived >

internal::enable_if<!symbolic::is_symbolic<FirstType>::value, ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type, symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >, symbolic::ValueExpr<internal::FixedInt<1> > > > >::type Eigen::seq	(	FirstType	f,
		const symbolic::BaseExpr< LastTypeDerived > &	l
	)

Definition at line 254 of file ArithmeticSequence.h.

seq() [4/8]

template<typename FirstTypeDerived , typename LastTypeDerived >

ArithmeticSequence<FirstTypeDerived, symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::NegateExpr<FirstTypeDerived> >,symbolic::ValueExpr<internal::FixedInt<1> > > > Eigen::seq	(	const symbolic::BaseExpr< FirstTypeDerived > &	f,
		const symbolic::BaseExpr< LastTypeDerived > &	l
	)

Definition at line 262 of file ArithmeticSequence.h.

seq() [5/8]

template<typename FirstType , typename LastType , typename IncrType >

internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value), ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index,typename internal::cleanup_seq_incr<IncrType>::type> >::type Eigen::seq	(	FirstType	f,
		LastType	l,
		IncrType	incr
	)

Definition at line 271 of file ArithmeticSequence.h.

seq() [6/8]

template<typename FirstTypeDerived , typename LastType , typename IncrType >

internal::enable_if<!symbolic::is_symbolic<LastType>::value, ArithmeticSequence<FirstTypeDerived, symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>, symbolic::ValueExpr<> >, symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, typename internal::cleanup_seq_incr<IncrType>::type> >::type Eigen::seq	(	const symbolic::BaseExpr< FirstTypeDerived > &	f,
		LastType	l,
		IncrType	incr
	)

Definition at line 286 of file ArithmeticSequence.h.

seq() [7/8]

template<typename FirstType , typename LastTypeDerived , typename IncrType >

internal::enable_if<!symbolic::is_symbolic<FirstType>::value, ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type, symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >, symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, typename internal::cleanup_seq_incr<IncrType>::type> >::type Eigen::seq	(	FirstType	f,
		const symbolic::BaseExpr< LastTypeDerived > &	l,
		IncrType	incr
	)

Definition at line 299 of file ArithmeticSequence.h.

seq() [8/8]

template<typename FirstTypeDerived , typename LastTypeDerived , typename IncrType >

ArithmeticSequence<FirstTypeDerived, symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived, symbolic::NegateExpr<FirstTypeDerived> >, symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >, typename internal::cleanup_seq_incr<IncrType>::type> Eigen::seq	(	const symbolic::BaseExpr< FirstTypeDerived > &	f,
		const symbolic::BaseExpr< LastTypeDerived > &	l,
		IncrType	incr
	)

Definition at line 313 of file ArithmeticSequence.h.

seqN() [1/2]

template<typename FirstType , typename SizeType , typename IncrType >

ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type, typename internal::cleanup_seq_incr< IncrType >::type > Eigen::seqN	(	FirstType	first,
		SizeType	size,
		IncrType	incr
	)

Returns

an ArithmeticSequence starting at first, of length size, and increment incr

See also

seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType)

Definition at line 162 of file ArithmeticSequence.h.

seqN() [2/2]

template<typename FirstType , typename SizeType >

ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type > Eigen::seqN	(	FirstType	first,
		SizeType	size
	)

Returns

an ArithmeticSequence starting at first, of length size, and unit increment

See also

seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType)

Definition at line 171 of file ArithmeticSequence.h.

setCpuCacheSizes()

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

inline

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

See also

computeProductBlockingSizes

Definition at line 2638 of file products/GeneralBlockPanelKernel.h.

setNbThreads()

void Eigen::setNbThreads ( int  v )

inline

Sets the max number of threads reserved for Eigen

See also

nbThreads

Definition at line 72 of file Parallelizer.h.

SimdInstructionSetsInUse()

static const char* Eigen::SimdInstructionSetsInUse ( void  )

inlinestatic

Definition at line 477 of file ConfigureVectorization.h.

ssaupd_()

void Eigen::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
	)

sseupd_()

void Eigen::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
	)

subtract_assign_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::subtract_assign_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

Definition at line 60 of file evaluators.cpp.

swap_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::swap_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

Definition at line 81 of file evaluators.cpp.

test_is_equal()

template<typename T , typename U >

bool Eigen::test_is_equal	(	const T &	actual,
		const U &	expected,
		bool	expect_equal = true
	)

Definition at line 633 of file main.h.

test_isApprox() [1/5]

bool Eigen::test_isApprox ( const std::complex< float > &  a, const std::complex< float > &  b  )

inline

Definition at line 449 of file main.h.

test_isApprox() [2/5]

bool Eigen::test_isApprox ( const std::complex< double > &  a, const std::complex< double > &  b  )

inline

Definition at line 454 of file main.h.

test_isApprox() [3/5]

bool Eigen::test_isApprox ( const std::complex< long double > &  a, const std::complex< long double > &  b  )

inline

Definition at line 460 of file main.h.

test_isApprox() [4/5]

bool Eigen::test_isApprox ( const long double &  a, const long double &  b  )

inline

Definition at line 468 of file main.h.

test_isApprox() [5/5]

template<typename Type1 , typename Type2 >

bool Eigen::test_isApprox ( const Type1 &  a, const Type2 &  b, typename Type1::Scalar *  = 0  )

inline

Definition at line 565 of file main.h.

test_isApproxOrLessThan()

bool Eigen::test_isApproxOrLessThan ( const long double &  a, const long double &  b  )

inline

Definition at line 479 of file main.h.

test_isApproxWithRef()

template<typename Scalar , typename ScalarRef >

bool Eigen::test_isApproxWithRef ( const Scalar &  a, const Scalar &  b, const ScalarRef &  ref  )

inline

Definition at line 603 of file main.h.

test_isMuchSmallerThan() [1/6]

bool Eigen::test_isMuchSmallerThan ( const std::complex< float > &  a, const std::complex< float > &  b  )

inline

Definition at line 451 of file main.h.

test_isMuchSmallerThan() [2/6]

bool Eigen::test_isMuchSmallerThan ( const std::complex< double > &  a, const std::complex< double > &  b  )

inline

Definition at line 456 of file main.h.

test_isMuchSmallerThan() [3/6]

bool Eigen::test_isMuchSmallerThan ( const std::complex< long double > &  a, const std::complex< long double > &  b  )

inline

Definition at line 462 of file main.h.

test_isMuchSmallerThan() [4/6]

bool Eigen::test_isMuchSmallerThan ( const long double &  a, const long double &  b  )

inline

Definition at line 477 of file main.h.

test_isMuchSmallerThan() [5/6]

template<typename Derived1 , typename Derived2 >

bool Eigen::test_isMuchSmallerThan ( const MatrixBase< Derived1 > &  m1, const MatrixBase< Derived2 > &  m2  )

inline

Definition at line 609 of file main.h.

test_isMuchSmallerThan() [6/6]

template<typename Derived >

bool Eigen::test_isMuchSmallerThan ( const MatrixBase< Derived > &  m, const typename NumTraits< typename internal::traits< Derived >::Scalar >::Real &  s  )

inline

Definition at line 616 of file main.h.

test_isUnitary()

template<typename Derived >

bool Eigen::test_isUnitary ( const MatrixBase< Derived > &  m )

inline

Definition at line 623 of file main.h.

test_precision()

template<typename T >

NumTraits<T>::Real Eigen::test_precision ( )

inline

Definition at line 415 of file main.h.

test_precision< AnnoyingScalar >()

template<>

AnnoyingScalar Eigen::test_precision< AnnoyingScalar > ( )

inline

Definition at line 137 of file AnnoyingScalar.h.

test_precision< double >()

template<>

double Eigen::test_precision< double > ( )

inline

Definition at line 417 of file main.h.

test_precision< float >()

template<>

float Eigen::test_precision< float > ( )

inline

Definition at line 416 of file main.h.

test_precision< long double >()

template<>

long double Eigen::test_precision< long double > ( )

inline

Definition at line 418 of file main.h.

test_precision< Real >()

template<>

Real Eigen::test_precision< Real >

(

)

Definition at line 89 of file boostmultiprec.cpp.

test_precision< std::complex< double > >()

template<>

double Eigen::test_precision< std::complex< double > > ( )

inline

Definition at line 420 of file main.h.

test_precision< std::complex< float > >()

template<>

float Eigen::test_precision< std::complex< float > > ( )

inline

Definition at line 419 of file main.h.

test_precision< std::complex< long double > >()

template<>

long double Eigen::test_precision< std::complex< long double > > ( )

inline

Definition at line 421 of file main.h.

test_relative_error() [1/13]

template<typename T , typename Derived >

T Eigen::test_relative_error	(	const AlignedVector3< T > &	a,
		const MatrixBase< Derived > &	b
	)

Definition at line 16 of file alignedvector3.cpp.

test_relative_error() [2/13]

template<typename T1 , typename T2 >

NumTraits<typename T1::RealScalar>::NonInteger Eigen::test_relative_error	(	const EigenBase< T1 > &	a,
		const EigenBase< T2 > &	b
	)

Definition at line 485 of file main.h.

test_relative_error() [3/13]

template<typename T1 , typename T2 >

T1::RealScalar Eigen::test_relative_error	(	const T1 &	a,
		const T2 &	b,
		const typename T1::Coefficients *	= 0
	)

Definition at line 495 of file main.h.

test_relative_error() [4/13]

template<typename T1 , typename T2 >

T1::Scalar Eigen::test_relative_error	(	const T1 &	a,
		const T2 &	b,
		const typename T1::MatrixType *	= 0
	)

Definition at line 501 of file main.h.

test_relative_error() [5/13]

template<typename S , int D>

S Eigen::test_relative_error	(	const Translation< S, D > &	a,
		const Translation< S, D > &	b
	)

Definition at line 507 of file main.h.

test_relative_error() [6/13]

template<typename S , int D, int O>

S Eigen::test_relative_error	(	const ParametrizedLine< S, D, O > &	a,
		const ParametrizedLine< S, D, O > &	b
	)

Definition at line 513 of file main.h.

test_relative_error() [7/13]

template<typename S , int D>

S Eigen::test_relative_error	(	const AlignedBox< S, D > &	a,
		const AlignedBox< S, D > &	b
	)

Definition at line 519 of file main.h.

test_relative_error() [8/13]

template<typename T1 , typename T2 >

T1::RealScalar Eigen::test_relative_error	(	const MatrixBase< T1 > &	a,
		const SparseMatrixBase< T2 > &	b
	)

Definition at line 526 of file main.h.

test_relative_error() [9/13]

template<typename T1 , typename T2 >

T1::RealScalar Eigen::test_relative_error	(	const SparseMatrixBase< T1 > &	a,
		const MatrixBase< T2 > &	b
	)

Definition at line 533 of file main.h.

test_relative_error() [10/13]

template<typename T1 , typename T2 >

T1::RealScalar Eigen::test_relative_error	(	const SparseMatrixBase< T1 > &	a,
		const SparseMatrixBase< T2 > &	b
	)

Definition at line 540 of file main.h.

test_relative_error() [11/13]

template<typename T1 , typename T2 >

NumTraits<typename NumTraits<T1>::Real>::NonInteger Eigen::test_relative_error	(	const T1 &	a,
		const T2 &	b,
		typename internal::enable_if< internal::is_arithmetic< typename NumTraits< T1 >::Real >::value, T1 >::type *	= 0
	)

Definition at line 546 of file main.h.

test_relative_error() [12/13]

template<typename T >

T Eigen::test_relative_error	(	const Rotation2D< T > &	a,
		const Rotation2D< T > &	b
	)

Definition at line 553 of file main.h.

test_relative_error() [13/13]

template<typename T >

T Eigen::test_relative_error	(	const AngleAxis< T > &	a,
		const AngleAxis< T > &	b
	)

Definition at line 559 of file main.h.

umfpack_defaults() [1/4]

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

inline

Definition at line 31 of file UmfPackSupport.h.

umfpack_defaults() [2/4]

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

inline

Definition at line 34 of file UmfPackSupport.h.

umfpack_defaults() [3/4]

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

inline

Definition at line 37 of file UmfPackSupport.h.

umfpack_defaults() [4/4]

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

inline

Definition at line 40 of file UmfPackSupport.h.

umfpack_free_numeric() [1/4]

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

inline

Definition at line 83 of file UmfPackSupport.h.

umfpack_free_numeric() [2/4]

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

inline

Definition at line 86 of file UmfPackSupport.h.

umfpack_free_numeric() [3/4]

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

inline

Definition at line 89 of file UmfPackSupport.h.

umfpack_free_numeric() [4/4]

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

inline

Definition at line 92 of file UmfPackSupport.h.

umfpack_free_symbolic() [1/4]

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

inline

Definition at line 96 of file UmfPackSupport.h.

umfpack_free_symbolic() [2/4]

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

inline

Definition at line 99 of file UmfPackSupport.h.

umfpack_free_symbolic() [3/4]

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

inline

Definition at line 102 of file UmfPackSupport.h.

umfpack_free_symbolic() [4/4]

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

inline

Definition at line 105 of file UmfPackSupport.h.

umfpack_get_determinant() [1/4]

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

inline

Definition at line 249 of file UmfPackSupport.h.

umfpack_get_determinant() [2/4]

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

inline

Definition at line 254 of file UmfPackSupport.h.

umfpack_get_determinant() [3/4]

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

inline

Definition at line 260 of file UmfPackSupport.h.

umfpack_get_determinant() [4/4]

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

inline

Definition at line 265 of file UmfPackSupport.h.

umfpack_get_lunz() [1/4]

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 194 of file UmfPackSupport.h.

umfpack_get_lunz() [2/4]

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 199 of file UmfPackSupport.h.

umfpack_get_lunz() [3/4]

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

inline

Definition at line 204 of file UmfPackSupport.h.

umfpack_get_lunz() [4/4]

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

inline

Definition at line 210 of file UmfPackSupport.h.

umfpack_get_numeric() [1/4]

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 217 of file UmfPackSupport.h.

umfpack_get_numeric() [2/4]

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 223 of file UmfPackSupport.h.

umfpack_get_numeric() [3/4]

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

inline

Definition at line 232 of file UmfPackSupport.h.

umfpack_get_numeric() [4/4]

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

inline

Definition at line 238 of file UmfPackSupport.h.

umfpack_numeric() [1/4]

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 137 of file UmfPackSupport.h.

umfpack_numeric() [2/4]

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 144 of file UmfPackSupport.h.

umfpack_numeric() [3/4]

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

inline

Definition at line 150 of file UmfPackSupport.h.

umfpack_numeric() [4/4]

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

inline

Definition at line 157 of file UmfPackSupport.h.

umfpack_report_control() [1/4]

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

inline

Definition at line 70 of file UmfPackSupport.h.

umfpack_report_control() [2/4]

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

inline

Definition at line 73 of file UmfPackSupport.h.

umfpack_report_control() [3/4]

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

inline

Definition at line 76 of file UmfPackSupport.h.

umfpack_report_control() [4/4]

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

inline

Definition at line 79 of file UmfPackSupport.h.

umfpack_report_info() [1/4]

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

inline

Definition at line 44 of file UmfPackSupport.h.

umfpack_report_info() [2/4]

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

inline

Definition at line 47 of file UmfPackSupport.h.

umfpack_report_info() [3/4]

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

inline

Definition at line 50 of file UmfPackSupport.h.

umfpack_report_info() [4/4]

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

inline

Definition at line 53 of file UmfPackSupport.h.

umfpack_report_status() [1/4]

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

inline

Definition at line 57 of file UmfPackSupport.h.

umfpack_report_status() [2/4]

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

inline

Definition at line 60 of file UmfPackSupport.h.

umfpack_report_status() [3/4]

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

inline

Definition at line 63 of file UmfPackSupport.h.

umfpack_report_status() [4/4]

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

inline

Definition at line 66 of file UmfPackSupport.h.

umfpack_solve() [1/4]

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 165 of file UmfPackSupport.h.

umfpack_solve() [2/4]

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 172 of file UmfPackSupport.h.

umfpack_solve() [3/4]

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

inline

Definition at line 179 of file UmfPackSupport.h.

umfpack_solve() [4/4]

SuiteSparse_long Eigen::umfpack_solve ( int  sys, const SuiteSparse_long  Ap[], const SuiteSparse_long  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 186 of file UmfPackSupport.h.

umfpack_symbolic() [1/4]

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 109 of file UmfPackSupport.h.

umfpack_symbolic() [2/4]

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 116 of file UmfPackSupport.h.

umfpack_symbolic() [3/4]

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

inline

Definition at line 122 of file UmfPackSupport.h.

umfpack_symbolic() [4/4]

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

inline

Definition at line 129 of file UmfPackSupport.h.

verifyIsApprox()

template<typename Type1 , typename Type2 >

bool Eigen::verifyIsApprox ( const Type1 &  a, const Type2 &  b  )

inline

Definition at line 585 of file main.h.

viewAsCholmod() [1/5]

template<typename _Scalar , int _Options, typename _StorageIndex >

cholmod_sparse Eigen::viewAsCholmod

(

Ref< SparseMatrix< _Scalar, _Options, _StorageIndex > >

mat

)

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

Definition at line 58 of file CholmodSupport.h.

viewAsCholmod() [2/5]

template<typename _Scalar , int _Options, typename _Index >

const cholmod_sparse Eigen::viewAsCholmod

(

const SparseMatrix< _Scalar, _Options, _Index > &

mat

)

Definition at line 105 of file CholmodSupport.h.

viewAsCholmod() [3/5]

template<typename _Scalar , int _Options, typename _Index >

const cholmod_sparse Eigen::viewAsCholmod

(

const SparseVector< _Scalar, _Options, _Index > &

mat

)

Definition at line 112 of file CholmodSupport.h.

viewAsCholmod() [4/5]

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

cholmod_sparse Eigen::viewAsCholmod

(

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

mat

)

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

Definition at line 121 of file CholmodSupport.h.

viewAsCholmod() [5/5]

template<typename Derived >

cholmod_dense Eigen::viewAsCholmod

(

MatrixBase< Derived > &

mat

)

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

Definition at line 137 of file CholmodSupport.h.

viewAsEigen()

template<typename Scalar , int Flags, typename StorageIndex >

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

(

cholmod_sparse &

cm

)

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

Definition at line 158 of file CholmodSupport.h.

zeta()

template<typename DerivedX , typename DerivedQ >

EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_zeta_op<typename DerivedX::Scalar>, const DerivedX, const DerivedQ> Eigen::zeta	(	const Eigen::ArrayBase< DerivedX > &	x,
		const Eigen::ArrayBase< DerivedQ > &	q
	)

Returns

an expression of the coefficient-wise zeta(x, q) to the given arrays.

It returns the Riemann zeta function of two arguments x and q:

Parameters

x	is the exponent, it must be > 1
q	is the shift, it must be > 0

Note

This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of zeta(T,T) for any scalar type T to be supported.

See also

ArrayBase::zeta()

Definition at line 156 of file SpecialFunctionsArrayAPI.h.

Variable Documentation

ActualPacketAccessBit

const unsigned int Eigen::ActualPacketAccessBit = 0x0

Definition at line 107 of file Constants.h.

AutoOrder

const int Eigen::AutoOrder = 2

Definition at line 17 of file ReshapedHelper.h.

CoherentAccessPattern

const int Eigen::CoherentAccessPattern = 0x1

Definition at line 47 of file SparseUtil.h.

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.

Definition at line 22 of file Constants.h.

DynamicIndex

const int Eigen::DynamicIndex = 0xffffff

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

Definition at line 27 of file Constants.h.

exponents

EIGEN_DEVICE_FUNC const Eigen::ArrayBase<Derived>& Eigen::exponents

Initial value:

{
    typedef typename internal::promote_scalar_arg<typename Derived::Scalar,Scalar,
                                                  EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type PromotedScalar

Definition at line 175 of file GlobalFunctions.h.

expx

Scalar Eigen::expx = exp(x.value())

Definition at line 634 of file AutoDiffScalar.h.

g_has_set_repeat

bool Eigen::g_has_set_repeat = false

static

Definition at line 171 of file main.h.

g_has_set_seed

bool Eigen::g_has_set_seed = false

static

Definition at line 171 of file main.h.

g_repeat

int Eigen::g_repeat = 1

static

Definition at line 169 of file main.h.

g_seed

unsigned int Eigen::g_seed = 0

static

Definition at line 170 of file main.h.

g_test_level

int Eigen::g_test_level = 0

static

Definition at line 168 of file main.h.

g_test_stack

std::vector<std::string> Eigen::g_test_stack

static

Definition at line 165 of file main.h.

HereditaryBits

const unsigned int Eigen::HereditaryBits

Initial value:

= RowMajorBit
                                  | EvalBeforeNestingBit

Definition at line 195 of file Constants.h.

HugeCost

const int Eigen::HugeCost = 10000

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

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

Definition at line 44 of file Constants.h.

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.

Definition at line 36 of file Constants.h.

InnerRandomAccessPattern

const int Eigen::InnerRandomAccessPattern = 0x2 | CoherentAccessPattern

Definition at line 48 of file SparseUtil.h.

NestByRefBit

const unsigned int Eigen::NestByRefBit = 0x100

Definition at line 169 of file Constants.h.

no_more_assert

bool Eigen::no_more_assert = false

static

Definition at line 225 of file main.h.

OuterRandomAccessPattern

const int Eigen::OuterRandomAccessPattern = 0x4 | CoherentAccessPattern

Definition at line 49 of file SparseUtil.h.

RandomAccessPattern

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

Definition at line 50 of file SparseUtil.h.

report_on_cerr_on_assert_failure

bool Eigen::report_on_cerr_on_assert_failure = true

static

Definition at line 226 of file main.h.

should_raise_an_assert

const bool Eigen::should_raise_an_assert = false

static

Definition at line 220 of file main.h.

SkylineBit

const unsigned int Eigen::SkylineBit = 0x1200

Definition at line 21 of file SkylineUtil.h.

UndefinedIncr

const int Eigen::UndefinedIncr = 0xfffffe

This value means that the increment to go from one value to another in a sequence is not constant for each step.

Definition at line 31 of file Constants.h.