Eigen

Namespace containing all symbols from the Eigen library.

Namespaces

Name
Eigen::Architecture
Eigen::bfloat16_impl
Eigen::half_impl
Eigen::indexing
Eigen::internal
Eigen::numext
Eigen::placeholders
Eigen::symbolic
Eigen::TensorSycl

Classes

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

Types

	Name
enum	CholmodMode
enum	@303
enum	@299
enum	@300
enum	UpLoType { Lower =0x1, Upper =0x2, UnitDiag =0x4, ZeroDiag =0x8, UnitLower =UnitDiag
enum	AlignmentType
enum	DirectionType
enum	TraversalType
enum	UnrollingType
enum	SpecializedType
enum	StorageOptions
enum	SideType
enum	NaNPropagationOptions
enum	NoChange_t
enum	Sequential_t
enum	Default_t
enum	AmbiVectorMode
enum	AccessorLevels
enum	DecompositionOptions { Pivoting = 0x01, NoPivoting = 0x02, ComputeFullU = 0x04, ComputeThinU = 0x08, ComputeFullV = 0x10, ComputeThinV = 0x20, EigenvaluesOnly = 0x40, ComputeEigenvectors = 0x80, EigVecMask = EigenvaluesOnly
enum	QRPreconditioners
enum	ComputationInfo
enum	TransformTraits { Isometry = 0x1, Affine = 0x2, AffineCompact = 0x10
enum	ProductImplType
enum	Action
enum	AutoSize_t
enum	SimplicialCholeskyMode
enum	@833
typedef Array< int, 2, 2 >	Array22i
typedef Array< int, 2, 1 >	Array2i
typedef Array< int, 3, 3 >	Array33i
typedef Array< int, 3, 1 >	Array3i
typedef Array< int, 4, 4 >	Array44i
typedef Array< int, 4, 1 >	Array4i
typedef Array< int, Dynamic, Dynamic >	ArrayXXi
typedef Array< int, Dynamic, 1 >	ArrayXi
typedef Array< int, 2, Dynamic >	Array2Xi
typedef Array< int, Dynamic, 2 >	ArrayX2i
typedef Array< int, 3, Dynamic >	Array3Xi
typedef Array< int, Dynamic, 3 >	ArrayX3i
typedef Array< int, 4, Dynamic >	Array4Xi
typedef Array< int, Dynamic, 4 >	ArrayX4i
typedef Array< float, 2, 2 >	Array22f
typedef Array< float, 2, 1 >	Array2f
typedef Array< float, 3, 3 >	Array33f
typedef Array< float, 3, 1 >	Array3f
typedef Array< float, 4, 4 >	Array44f
typedef Array< float, 4, 1 >	Array4f
typedef Array< float, Dynamic, Dynamic >	ArrayXXf
typedef Array< float, Dynamic, 1 >	ArrayXf
typedef Array< float, 2, Dynamic >	Array2Xf
typedef Array< float, Dynamic, 2 >	ArrayX2f
typedef Array< float, 3, Dynamic >	Array3Xf
typedef Array< float, Dynamic, 3 >	ArrayX3f
typedef Array< float, 4, Dynamic >	Array4Xf
typedef Array< float, Dynamic, 4 >	ArrayX4f
typedef Array< double, 2, 2 >	Array22d
typedef Array< double, 2, 1 >	Array2d
typedef Array< double, 3, 3 >	Array33d
typedef Array< double, 3, 1 >	Array3d
typedef Array< double, 4, 4 >	Array44d
typedef Array< double, 4, 1 >	Array4d
typedef Array< double, Dynamic, Dynamic >	ArrayXXd
typedef Array< double, Dynamic, 1 >	ArrayXd
typedef Array< double, 2, Dynamic >	Array2Xd
typedef Array< double, Dynamic, 2 >	ArrayX2d
typedef Array< double, 3, Dynamic >	Array3Xd
typedef Array< double, Dynamic, 3 >	ArrayX3d
typedef Array< double, 4, Dynamic >	Array4Xd
typedef Array< double, Dynamic, 4 >	ArrayX4d
typedef Array< std::complex< float >, 2, 2 >	Array22cf
typedef Array< std::complex< float >, 2, 1 >	Array2cf
typedef Array< std::complex< float >, 3, 3 >	Array33cf
typedef Array< std::complex< float >, 3, 1 >	Array3cf
typedef Array< std::complex< float >, 4, 4 >	Array44cf
typedef Array< std::complex< float >, 4, 1 >	Array4cf
typedef Array< std::complex< float >, Dynamic, Dynamic >	ArrayXXcf
typedef Array< std::complex< float >, Dynamic, 1 >	ArrayXcf
typedef Array< std::complex< float >, 2, Dynamic >	Array2Xcf
typedef Array< std::complex< float >, Dynamic, 2 >	ArrayX2cf
typedef Array< std::complex< float >, 3, Dynamic >	Array3Xcf
typedef Array< std::complex< float >, Dynamic, 3 >	ArrayX3cf
typedef Array< std::complex< float >, 4, Dynamic >	Array4Xcf
typedef Array< std::complex< float >, Dynamic, 4 >	ArrayX4cf
typedef Array< std::complex< double >, 2, 2 >	Array22cd
typedef Array< std::complex< double >, 2, 1 >	Array2cd
typedef Array< std::complex< double >, 3, 3 >	Array33cd
typedef Array< std::complex< double >, 3, 1 >	Array3cd
typedef Array< std::complex< double >, 4, 4 >	Array44cd
typedef Array< std::complex< double >, 4, 1 >	Array4cd
typedef Array< std::complex< double >, Dynamic, Dynamic >	ArrayXXcd
typedef Array< std::complex< double >, Dynamic, 1 >	ArrayXcd
typedef Array< std::complex< double >, 2, Dynamic >	Array2Xcd
typedef Array< std::complex< double >, Dynamic, 2 >	ArrayX2cd
typedef Array< std::complex< double >, 3, Dynamic >	Array3Xcd
typedef Array< std::complex< double >, Dynamic, 3 >	ArrayX3cd
typedef Array< std::complex< double >, 4, Dynamic >	Array4Xcd
typedef Array< std::complex< double >, Dynamic, 4 >	ArrayX4cd
typedef Matrix< int, 2, 2 >	Matrix2i
typedef Matrix< int, 2, 1 >	Vector2i
typedef Matrix< int, 1, 2 >	RowVector2i
typedef Matrix< int, 3, 3 >	Matrix3i
typedef Matrix< int, 3, 1 >	Vector3i
typedef Matrix< int, 1, 3 >	RowVector3i
typedef Matrix< int, 4, 4 >	Matrix4i
typedef Matrix< int, 4, 1 >	Vector4i
typedef Matrix< int, 1, 4 >	RowVector4i
typedef Matrix< int, Dynamic, Dynamic >	MatrixXi
typedef Matrix< int, Dynamic, 1 >	VectorXi
typedef Matrix< int, 1, Dynamic >	RowVectorXi
typedef Matrix< int, 2, Dynamic >	Matrix2Xi
typedef Matrix< int, Dynamic, 2 >	MatrixX2i
typedef Matrix< int, 3, Dynamic >	Matrix3Xi
typedef Matrix< int, Dynamic, 3 >	MatrixX3i
typedef Matrix< int, 4, Dynamic >	Matrix4Xi
typedef Matrix< int, Dynamic, 4 >	MatrixX4i
typedef Matrix< float, 2, 2 >	Matrix2f
typedef Matrix< float, 2, 1 >	Vector2f
typedef Matrix< float, 1, 2 >	RowVector2f
typedef Matrix< float, 3, 3 >	Matrix3f
typedef Matrix< float, 3, 1 >	Vector3f
typedef Matrix< float, 1, 3 >	RowVector3f
typedef Matrix< float, 4, 4 >	Matrix4f
typedef Matrix< float, 4, 1 >	Vector4f
typedef Matrix< float, 1, 4 >	RowVector4f
typedef Matrix< float, Dynamic, Dynamic >	MatrixXf
typedef Matrix< float, Dynamic, 1 >	VectorXf
typedef Matrix< float, 1, Dynamic >	RowVectorXf
typedef Matrix< float, 2, Dynamic >	Matrix2Xf
typedef Matrix< float, Dynamic, 2 >	MatrixX2f
typedef Matrix< float, 3, Dynamic >	Matrix3Xf
typedef Matrix< float, Dynamic, 3 >	MatrixX3f
typedef Matrix< float, 4, Dynamic >	Matrix4Xf
typedef Matrix< float, Dynamic, 4 >	MatrixX4f
typedef Matrix< double, 2, 2 >	Matrix2d
typedef Matrix< double, 2, 1 >	Vector2d
typedef Matrix< double, 1, 2 >	RowVector2d
typedef Matrix< double, 3, 3 >	Matrix3d
typedef Matrix< double, 3, 1 >	Vector3d
typedef Matrix< double, 1, 3 >	RowVector3d
typedef Matrix< double, 4, 4 >	Matrix4d
typedef Matrix< double, 4, 1 >	Vector4d
typedef Matrix< double, 1, 4 >	RowVector4d
typedef Matrix< double, Dynamic, Dynamic >	MatrixXd
typedef Matrix< double, Dynamic, 1 >	VectorXd
typedef Matrix< double, 1, Dynamic >	RowVectorXd
typedef Matrix< double, 2, Dynamic >	Matrix2Xd
typedef Matrix< double, Dynamic, 2 >	MatrixX2d
typedef Matrix< double, 3, Dynamic >	Matrix3Xd
typedef Matrix< double, Dynamic, 3 >	MatrixX3d
typedef Matrix< double, 4, Dynamic >	Matrix4Xd
typedef Matrix< double, Dynamic, 4 >	MatrixX4d
typedef Matrix< std::complex< float >, 2, 2 >	Matrix2cf
typedef Matrix< std::complex< float >, 2, 1 >	Vector2cf
typedef Matrix< std::complex< float >, 1, 2 >	RowVector2cf
typedef Matrix< std::complex< float >, 3, 3 >	Matrix3cf
typedef Matrix< std::complex< float >, 3, 1 >	Vector3cf
typedef Matrix< std::complex< float >, 1, 3 >	RowVector3cf
typedef Matrix< std::complex< float >, 4, 4 >	Matrix4cf
typedef Matrix< std::complex< float >, 4, 1 >	Vector4cf
typedef Matrix< std::complex< float >, 1, 4 >	RowVector4cf
typedef Matrix< std::complex< float >, Dynamic, Dynamic >	MatrixXcf
typedef Matrix< std::complex< float >, Dynamic, 1 >	VectorXcf
typedef Matrix< std::complex< float >, 1, Dynamic >	RowVectorXcf
typedef Matrix< std::complex< float >, 2, Dynamic >	Matrix2Xcf
typedef Matrix< std::complex< float >, Dynamic, 2 >	MatrixX2cf
typedef Matrix< std::complex< float >, 3, Dynamic >	Matrix3Xcf
typedef Matrix< std::complex< float >, Dynamic, 3 >	MatrixX3cf
typedef Matrix< std::complex< float >, 4, Dynamic >	Matrix4Xcf
typedef Matrix< std::complex< float >, Dynamic, 4 >	MatrixX4cf
typedef Matrix< std::complex< double >, 2, 2 >	Matrix2cd
typedef Matrix< std::complex< double >, 2, 1 >	Vector2cd
typedef Matrix< std::complex< double >, 1, 2 >	RowVector2cd
typedef Matrix< std::complex< double >, 3, 3 >	Matrix3cd
typedef Matrix< std::complex< double >, 3, 1 >	Vector3cd
typedef Matrix< std::complex< double >, 1, 3 >	RowVector3cd
typedef Matrix< std::complex< double >, 4, 4 >	Matrix4cd
typedef Matrix< std::complex< double >, 4, 1 >	Vector4cd
typedef Matrix< std::complex< double >, 1, 4 >	RowVector4cd
typedef Matrix< std::complex< double >, Dynamic, Dynamic >	MatrixXcd
typedef Matrix< std::complex< double >, Dynamic, 1 >	VectorXcd
typedef Matrix< std::complex< double >, 1, Dynamic >	RowVectorXcd
typedef Matrix< std::complex< double >, 2, Dynamic >	Matrix2Xcd
typedef Matrix< std::complex< double >, Dynamic, 2 >	MatrixX2cd
typedef Matrix< std::complex< double >, 3, Dynamic >	Matrix3Xcd
typedef Matrix< std::complex< double >, Dynamic, 3 >	MatrixX3cd
typedef Matrix< std::complex< double >, 4, Dynamic >	Matrix4Xcd
typedef Matrix< std::complex< double >, Dynamic, 4 >	MatrixX4cd
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE	DenseIndex
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE	Index The Index type as used for the API.
typedef std::complex< double >	dcomplex
typedef std::complex< float >	scomplex
typedef int	BlasIndex
typedef AlignedBox< int, 1 >	AlignedBox1i
typedef AlignedBox< int, 2 >	AlignedBox2i
typedef AlignedBox< int, 3 >	AlignedBox3i
typedef AlignedBox< int, 4 >	AlignedBox4i
typedef AlignedBox< int, Dynamic >	AlignedBoxXi
typedef AlignedBox< float, 1 >	AlignedBox1f
typedef AlignedBox< float, 2 >	AlignedBox2f
typedef AlignedBox< float, 3 >	AlignedBox3f
typedef AlignedBox< float, 4 >	AlignedBox4f
typedef AlignedBox< float, Dynamic >	AlignedBoxXf
typedef AlignedBox< double, 1 >	AlignedBox1d
typedef AlignedBox< double, 2 >	AlignedBox2d
typedef AlignedBox< double, 3 >	AlignedBox3d
typedef AlignedBox< double, 4 >	AlignedBox4d
typedef AlignedBox< double, Dynamic >	AlignedBoxXd
typedef AngleAxis< float >	AngleAxisf
typedef AngleAxis< double >	AngleAxisd
typedef Quaternion< float >	Quaternionf
typedef Quaternion< double >	Quaterniond
typedef Map< Quaternion< float >, 0 >	QuaternionMapf
typedef Map< Quaternion< double >, 0 >	QuaternionMapd
typedef Map< Quaternion< float >, Aligned >	QuaternionMapAlignedf
typedef Map< Quaternion< double >, Aligned >	QuaternionMapAlignedd
typedef Rotation2D< float >	Rotation2Df
typedef Rotation2D< double >	Rotation2Dd
typedef DiagonalMatrix< float, 2 >	AlignedScaling2f
typedef DiagonalMatrix< double, 2 >	AlignedScaling2d
typedef DiagonalMatrix< float, 3 >	AlignedScaling3f
typedef DiagonalMatrix< double, 3 >	AlignedScaling3d
typedef Transform< float, 2, Isometry >	Isometry2f
typedef Transform< float, 3, Isometry >	Isometry3f
typedef Transform< double, 2, Isometry >	Isometry2d
typedef Transform< double, 3, Isometry >	Isometry3d
typedef Transform< float, 2, Affine >	Affine2f
typedef Transform< float, 3, Affine >	Affine3f
typedef Transform< double, 2, Affine >	Affine2d
typedef Transform< double, 3, Affine >	Affine3d
typedef Transform< float, 2, AffineCompact >	AffineCompact2f
typedef Transform< float, 3, AffineCompact >	AffineCompact3f
typedef Transform< double, 2, AffineCompact >	AffineCompact2d
typedef Transform< double, 3, AffineCompact >	AffineCompact3d
typedef Transform< float, 2, Projective >	Projective2f
typedef Transform< float, 3, Projective >	Projective3f
typedef Transform< double, 2, Projective >	Projective2d
typedef Transform< double, 3, Projective >	Projective3d
typedef Translation< float, 2 >	Translation2f
typedef Translation< double, 2 >	Translation2d
typedef Translation< float, 3 >	Translation3f
typedef Translation< double, 3 >	Translation3d

Functions

	Name
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 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)
template <typename FirstType ,typename LastType > internal::enable_if<!(symbolic::is_symbolic< FirstType >::value
template <typename FirstTypeDerived ,typename LastType > internal::enable_if<< 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<< FirstType >::value, ArithmeticSequence< typenameinternal::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
template <typename FirstTypeDerived ,typename LastType ,typename IncrType > internal::enable_if<< LastType >::value, ArithmeticSequence< FirstTypeDerived, symbolic::QuotientExpr< symbolic::AddExpr< symbolic::AddExpr< symbolic::NegateExpr< FirstTypeDerived >, symbolic::ValueExpr<> >, symbolic::ValueExpr< typenameinternal::cleanup_seq_incr< IncrType >::type > >, symbolic::ValueExpr< typenameinternal::cleanup_seq_incr< IncrType >::type > >, typenameinternal::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<< FirstType >::value, ArithmeticSequence< typenameinternal::cleanup_index_type< FirstType >::type, symbolic::QuotientExpr< symbolic::AddExpr< symbolic::AddExpr< LastTypeDerived, symbolic::ValueExpr<> >, symbolic::ValueExpr< typenameinternal::cleanup_seq_incr< IncrType >::type > >, symbolic::ValueExpr< typenameinternal::cleanup_seq_incr< IncrType >::type > >, typenameinternal::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 Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_real_op< typename Derived::Scalar >, const Derived >(real ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_imag_op< typename Derived::Scalar >, const Derived >(imag ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_conjugate_op< typename Derived::Scalar >, const Derived >(conj ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_inverse_op< typename Derived::Scalar >, const Derived >(inverse ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_sin_op< typename Derived::Scalar >, const Derived >(sin ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_cos_op< typename Derived::Scalar >, const Derived >(cos ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_tan_op< typename Derived::Scalar >, const Derived >(tan ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_atan_op< typename Derived::Scalar >, const Derived >(atan ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_asin_op< typename Derived::Scalar >, const Derived >(asin ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_acos_op< typename Derived::Scalar >, const Derived >(acos ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_sinh_op< typename Derived::Scalar >, const Derived >(sinh ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_cosh_op< typename Derived::Scalar >, const Derived >(cosh ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_tanh_op< typename Derived::Scalar >, const Derived >(tanh ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_logistic_op< typename Derived::Scalar >, const Derived >(logistic ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_lgamma_op< typename Derived::Scalar >, const Derived >(lgamma ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_digamma_op< typename Derived::Scalar >, const Derived >(digamma ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_erf_op< typename Derived::Scalar >, const Derived >(erf ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_erfc_op< typename Derived::Scalar >, const Derived >(erfc ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_ndtri_op< typename Derived::Scalar >, const Derived >(ndtri ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_exp_op< typename Derived::Scalar >, const Derived >(exp ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_expm1_op< typename Derived::Scalar >, const Derived >(expm1 ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_log_op< typename Derived::Scalar >, const Derived >(log ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_log1p_op< typename Derived::Scalar >, const Derived >(log1p ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_log10_op< typename Derived::Scalar >, const Derived >(log10 ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_log2_op< typename Derived::Scalar >, const Derived >(log2 ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs_op< typename Derived::Scalar >, const Derived >(abs ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs2_op< typename Derived::Scalar >, const Derived >(abs2 ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_arg_op< typename Derived::Scalar >, const Derived >(arg ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_sqrt_op< typename Derived::Scalar >, const Derived >(sqrt ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_rsqrt_op< typename Derived::Scalar >, const Derived >(rsqrt ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_square_op< typename Derived::Scalar >, const Derived >(square ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_cube_op< typename Derived::Scalar >, const Derived >(cube ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_rint_op< typename Derived::Scalar >, const Derived >(rint ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_round_op< typename Derived::Scalar >, const Derived >(round ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_floor_op< typename Derived::Scalar >, const Derived >(floor ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_ceil_op< typename Derived::Scalar >, const Derived >(ceil ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_isnan_op< typename Derived::Scalar >, const Derived >(isnan ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_isinf_op< typename Derived::Scalar >, const Derived >(isinf ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_isfinite_op< typename Derived::Scalar >, const Derived >(isfinite ) const
template <typename Derived > const	Eigen::CwiseUnaryOp< Eigen::internal::scalar_sign_op< typename Derived::Scalar >, const Derived >(sign ) const
template <typename MatrixDerived ,typename PermutationDerived > EIGEN_DEVICE_FUNC const Product< MatrixDerived, PermutationDerived, AliasFreeProduct >	operator*(const MatrixBase< MatrixDerived > & matrix, const PermutationBase< PermutationDerived > & permutation)
template <typename PermutationDerived ,typename MatrixDerived > EIGEN_DEVICE_FUNC const Product< PermutationDerived, MatrixDerived, AliasFreeProduct >	operator*(const PermutationBase< PermutationDerived > & permutation, const MatrixBase< MatrixDerived > & matrix)
std::ptrdiff_t	l1CacheSize()
std::ptrdiff_t	l2CacheSize()
std::ptrdiff_t	l3CacheSize()
void	setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
void	initParallel()
int	nbThreads()
void	setNbThreads(int v)
template <typename MatrixDerived ,typename TranspositionsDerived > EIGEN_DEVICE_FUNC const Product< MatrixDerived, TranspositionsDerived, AliasFreeProduct >	operator*(const MatrixBase< MatrixDerived > & matrix, const TranspositionsBase< TranspositionsDerived > & transpositions)
template <typename TranspositionsDerived ,typename MatrixDerived > EIGEN_DEVICE_FUNC const Product< TranspositionsDerived, MatrixDerived, AliasFreeProduct >	operator*(const TranspositionsBase< TranspositionsDerived > & transpositions, const MatrixBase< MatrixDerived > & matrix)
const char *	SimdInstructionSetsInUse(void )
const symbolic::AddExpr< symbolic::SymbolExpr< internal::symbolic_last_tag >, symbolic::ValueExpr< Eigen::internal::FixedInt< 1 > > >	lastp1(last+fix< 1 > ())
template <int N> internal::FixedInt< N >	fix()
template <int N,typename T > internal::VariableAndFixedInt< N >	fix(T val)
UniformScaling< float >	Scaling(float s)
UniformScaling< double >	Scaling(double s)
template <typename RealScalar > UniformScaling< std::complex< RealScalar > >	Scaling(const std::complex< RealScalar > & s)
template <typename Scalar > DiagonalMatrix< Scalar, 2 >	Scaling(const Scalar & sx, const Scalar & sy)
template <typename Scalar > DiagonalMatrix< Scalar, 3 >	Scaling(const Scalar & sx, const Scalar & sy, const Scalar & sz)
template <typename Derived > const DiagonalWrapper< const Derived >	Scaling(const MatrixBase< Derived > & coeffs)
template <typename Derived ,typename OtherDerived > internal::umeyama_transform_matrix_type< Derived, OtherDerived >::type	umeyama(const MatrixBase< Derived > & src, const MatrixBase< OtherDerived > & dst, bool with_scaling =true) Returns the transformation between two point sets.
template <typename OtherDerived ,typename VectorsType ,typename CoeffsType ,int Side> internal::matrix_type_times_scalar_type< typenameVectorsType::Scalar, OtherDerived >::Type	operator*(const MatrixBase< OtherDerived > & other, const HouseholderSequence< VectorsType, CoeffsType, Side > & h) Computes the product of a matrix with a Householder sequence.
template <typename VectorsType ,typename CoeffsType > HouseholderSequence< VectorsType, CoeffsType >	householderSequence(const VectorsType & v, const CoeffsType & h) Convenience function for constructing a Householder sequence.
template <typename VectorsType ,typename CoeffsType > HouseholderSequence< VectorsType, CoeffsType, OnTheRight >	rightHouseholderSequence(const VectorsType & v, const CoeffsType & h) Convenience function for constructing a Householder sequence.
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.
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 > )
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 > )
template <typename DenseDerived ,typename SparseDerived > EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator+(const MatrixBase< DenseDerived > & a, const SparseMatrixBase< SparseDerived > & b)
template <typename SparseDerived ,typename DenseDerived > EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator+(const SparseMatrixBase< SparseDerived > & a, const MatrixBase< DenseDerived > & b)
template <typename DenseDerived ,typename SparseDerived > EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator-(const MatrixBase< DenseDerived > & a, const SparseMatrixBase< SparseDerived > & b)
template <typename SparseDerived ,typename DenseDerived > EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator-(const SparseMatrixBase< SparseDerived > & a, const MatrixBase< DenseDerived > & b)
template <typename SparseDerived ,typename PermDerived > const Product< SparseDerived, PermDerived, AliasFreeProduct >	operator*(const SparseMatrixBase< SparseDerived > & matrix, const PermutationBase< PermDerived > & perm)
template <typename SparseDerived ,typename PermDerived > const Product< PermDerived, SparseDerived, AliasFreeProduct >	operator*(const PermutationBase< PermDerived > & perm, const SparseMatrixBase< SparseDerived > & matrix)
template <typename SparseDerived ,typename PermutationType > const Product< SparseDerived, Inverse< PermutationType >, AliasFreeProduct >	operator*(const SparseMatrixBase< SparseDerived > & matrix, const InverseImpl< PermutationType, PermutationStorage > & tperm)
template <typename SparseDerived ,typename PermutationType > const Product< Inverse< PermutationType >, SparseDerived, AliasFreeProduct >	operator*(const InverseImpl< PermutationType, PermutationStorage > & tperm, const SparseMatrixBase< SparseDerived > & matrix)
void	sgssvx(superlu_options_t * , SuperMatrix * , int * , int * , int * , char * , float * , float * , SuperMatrix * , SuperMatrix * , void * , int , SuperMatrix * , SuperMatrix * , float * , float * , float * , float * , mem_usage_t * , SuperLUStat_t * , int * )
float	SuperLU_gssvx(superlu_options_t * options, SuperMatrix * A, int * perm_c, int * perm_r, int * etree, char * equed, float * R, float * C, SuperMatrix * L, SuperMatrix * U, void * work, int lwork, SuperMatrix * B, SuperMatrix * X, float * recip_pivot_growth, float * rcond, float * ferr, float * berr, SuperLUStat_t * stats, int * info, float )
void	cgssvx(superlu_options_t * , SuperMatrix * , int * , int * , int * , char * , float * , float * , SuperMatrix * , SuperMatrix * , void * , int , SuperMatrix * , SuperMatrix * , float * , float * , float * , float * , mem_usage_t * , SuperLUStat_t * , int * )
float	SuperLU_gssvx(superlu_options_t * options, SuperMatrix * A, int * perm_c, int * perm_r, int * etree, char * equed, float * R, float * C, SuperMatrix * L, SuperMatrix * U, void * work, int lwork, SuperMatrix * B, SuperMatrix * X, float * recip_pivot_growth, float * rcond, float * ferr, float * berr, SuperLUStat_t * stats, int * info, std::complex< float > )
void	dgssvx(superlu_options_t * , SuperMatrix * , int * , int * , int * , char * , double * , double * , SuperMatrix * , SuperMatrix * , void * , int , SuperMatrix * , SuperMatrix * , double * , double * , double * , double * , mem_usage_t * , SuperLUStat_t * , int * )
float	SuperLU_gssvx(superlu_options_t * options, SuperMatrix * A, int * perm_c, int * perm_r, int * etree, char * equed, double * R, double * C, SuperMatrix * L, SuperMatrix * U, void * work, int lwork, SuperMatrix * B, SuperMatrix * X, double * recip_pivot_growth, double * rcond, double * ferr, double * berr, SuperLUStat_t * stats, int * info, double )
void	zgssvx(superlu_options_t * , SuperMatrix * , int * , int * , int * , char * , double * , double * , SuperMatrix * , SuperMatrix * , void * , int , SuperMatrix * , SuperMatrix * , double * , double * , double * , double * , mem_usage_t * , SuperLUStat_t * , int * )
float	SuperLU_gssvx(superlu_options_t * options, SuperMatrix * A, int * perm_c, int * perm_r, int * etree, char * equed, double * R, double * C, SuperMatrix * L, SuperMatrix * U, void * work, int lwork, SuperMatrix * B, SuperMatrix * X, double * recip_pivot_growth, double * rcond, double * ferr, double * berr, SuperLUStat_t * stats, int * info, std::complex< double > )
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_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 )
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_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_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])
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])
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_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_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 )

Attributes

	Name
EIGEN_DEVICE_FUNC const Eigen::ArrayBase< Derived > &	exponents
const int	Dynamic
const int	DynamicIndex
const int	UndefinedIncr
const int	Infinity
const int	HugeCost
const unsigned int	RowMajorBit
const unsigned int	EvalBeforeNestingBit
EIGEN_DEPRECATED const unsigned int	EvalBeforeAssigningBit
const unsigned int	PacketAccessBit
const unsigned int	ActualPacketAccessBit
const unsigned int	LinearAccessBit
const unsigned int	LvalueBit
const unsigned int	DirectAccessBit
EIGEN_DEPRECATED const unsigned int	AlignedBit
const unsigned int	NestByRefBit
const unsigned int	NoPreferredStorageOrderBit
const unsigned int	CompressedAccessBit
const unsigned int	HereditaryBits
const symbolic::SymbolExpr< internal::symbolic_last_tag >	last
const Eigen::internal::all_t	all
const int	AutoOrder
const int	CoherentAccessPattern
const int	InnerRandomAccessPattern
const int	OuterRandomAccessPattern
const int	RandomAccessPattern

Types Documentation

enum CholmodMode

Enumerator	Value	Description
CholmodAuto
CholmodSimplicialLLt
CholmodSupernodalLLt
CholmodLDLt

enum @303

Enumerator	Value	Description
Large	2
Small	3

enum @299

Enumerator	Value	Description
DontAlignCols	1

enum @300

Enumerator	Value	Description
StreamPrecision	-1
FullPrecision	-2

enum UpLoType

Enumerator	Value	Description
Lower	=0x1	View matrix as a lower triangular matrix.
Upper	=0x2	View matrix as an upper triangular matrix.
UnitDiag	=0x4	Matrix has ones on the diagonal; to be used in combination with Lower or Upper.
ZeroDiag	=0x8	Matrix has zeros on the diagonal; to be used in combination with Lower or Upper.
UnitLower	=UnitDiag	Lower
UnitUpper	=UnitDiag	Upper
StrictlyLower	=ZeroDiag	Lower
StrictlyUpper	=ZeroDiag	Upper
SelfAdjoint	=0x10	Used in BandMatrix and SelfAdjointView to indicate that the matrix is self-adjoint.
Symmetric	=0x20	Used to support symmetric, non-selfadjoint, complex matrices.

Enum containing possible values for the Mode or UpLo parameter of MatrixBase::selfadjointView() and MatrixBase::triangularView(), and selfadjoint solvers.

enum AlignmentType

Enumerator	Value	Description
Unaligned	=0	Data pointer has no specific alignment.
Aligned8	=8	Data pointer is aligned on a 8 bytes boundary.
Aligned16	=16	Data pointer is aligned on a 16 bytes boundary.
Aligned32	=32	Data pointer is aligned on a 32 bytes boundary.
Aligned64	=64	Data pointer is aligned on a 64 bytes boundary.
Aligned128	=128	Data pointer is aligned on a 128 bytes boundary.
AlignedMask	=255
Aligned	=16
AlignedMax	Unaligned

Enum for indicating whether a buffer is aligned or not.

enum DirectionType

Enumerator	Value	Description
Vertical		For Reverse, all columns are reversed; for PartialReduxExpr and VectorwiseOp, act on columns.
Horizontal		For Reverse, all rows are reversed; for PartialReduxExpr and VectorwiseOp, act on rows.
BothDirections		For Reverse, both rows and columns are reversed; not used for PartialReduxExpr and VectorwiseOp.

Enum containing possible values for the Direction parameter of Reverse, PartialReduxExpr and VectorwiseOp.

enum TraversalType

Enumerator	Value	Description
DefaultTraversal
LinearTraversal
InnerVectorizedTraversal
LinearVectorizedTraversal
SliceVectorizedTraversal
InvalidTraversal
AllAtOnceTraversal

enum UnrollingType

Enumerator	Value	Description
NoUnrolling
InnerUnrolling
CompleteUnrolling

enum SpecializedType

Enumerator	Value	Description
Specialized
BuiltIn

enum StorageOptions

Enumerator	Value	Description
ColMajor	0	Storage order is column major (see TopicStorageOrders).
RowMajor	0x1	Storage order is row major (see TopicStorageOrders).
AutoAlign	0	Align the matrix itself if it is vectorizable fixed-size
DontAlign	0x2	Don't require alignment for the matrix itself (the array of coefficients, if dynamically allocated, may still be requested to be aligned)

Enum containing possible values for the _Options template parameter of Matrix, Array and BandMatrix.

enum SideType

Enumerator	Value	Description
OnTheLeft	1	Apply transformation on the left.
OnTheRight	2	Apply transformation on the right.

Enum for specifying whether to apply or solve on the left or right.

enum NaNPropagationOptions

Enumerator	Value	Description
PropagateFast	0	Implementation defined behavior if NaNs are present.
PropagateNaN		Always propagate NaNs.
PropagateNumbers		Always propagate not-NaNs.

Enum for specifying NaN-propagation behavior, e.g. for coeff-wise min/max.

enum NoChange_t

Enumerator	Value	Description
NoChange

enum Sequential_t

Enumerator	Value	Description
Sequential

enum Default_t

Enumerator	Value	Description
Default

enum AmbiVectorMode

Enumerator	Value	Description
IsDense	0
IsSparse

enum AccessorLevels

Enumerator	Value	Description
ReadOnlyAccessors		Read-only access via a member function.
WriteAccessors		Read/write access via member functions.
DirectAccessors		Direct read-only access to the coefficients.
DirectWriteAccessors		Direct read/write access to the coefficients.

Used as template parameter in DenseCoeffBase and MapBase to indicate which accessors should be provided.

enum DecompositionOptions

Enumerator	Value	Description
Pivoting	0x01
NoPivoting	0x02
ComputeFullU	0x04	Used in JacobiSVD to indicate that the square matrix U is to be computed.
ComputeThinU	0x08	Used in JacobiSVD to indicate that the thin matrix U is to be computed.
ComputeFullV	0x10	Used in JacobiSVD to indicate that the square matrix V is to be computed.
ComputeThinV	0x20	Used in JacobiSVD to indicate that the thin matrix V is to be computed.
EigenvaluesOnly	0x40	Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify that only the eigenvalues are to be computed and not the eigenvectors.
ComputeEigenvectors	0x80	Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify that both the eigenvalues and the eigenvectors are to be computed.
EigVecMask	EigenvaluesOnly	ComputeEigenvectors
Ax_lBx	0x100	Used in GeneralizedSelfAdjointEigenSolver to indicate that it should solve the generalized eigenproblem \( Ax = \lambda B x \).
ABx_lx	0x200	Used in GeneralizedSelfAdjointEigenSolver to indicate that it should solve the generalized eigenproblem \( ABx = \lambda x \).
BAx_lx	0x400	Used in GeneralizedSelfAdjointEigenSolver to indicate that it should solve the generalized eigenproblem \( BAx = \lambda x \).
GenEigMask	Ax_lBx	ABx_lx

Enum with options to give to various decompositions.

enum QRPreconditioners

Enumerator	Value	Description
NoQRPreconditioner		Do not specify what is to be done if the SVD of a non-square matrix is asked for.
HouseholderQRPreconditioner		Use a QR decomposition without pivoting as the first step.
ColPivHouseholderQRPreconditioner		Use a QR decomposition with column pivoting as the first step.
FullPivHouseholderQRPreconditioner		Use a QR decomposition with full pivoting as the first step.

Possible values for the QRPreconditioner template parameter of JacobiSVD.

enum ComputationInfo

Enumerator	Value	Description
Success	0	Computation was successful.
NumericalIssue	1	The provided data did not satisfy the prerequisites.
NoConvergence	2	Iterative procedure did not converge.
InvalidInput	3	The inputs are invalid, or the algorithm has been improperly called. When assertions are enabled, such errors trigger an assert.

Enum for reporting the status of a computation.

enum TransformTraits

Enumerator	Value	Description
Isometry	0x1	Transformation is an isometry.
Affine	0x2	Transformation is an affine transformation stored as a (Dim+1)^2 matrix whose last row is assumed to be [0 ... 0 1].
AffineCompact	0x10	Affine
Projective	0x20	Transformation is a general projective transformation stored as a (Dim+1)^2 matrix.

See: Transform, Hyperplane::transform().

Enum used to specify how a particular transformation is stored in a matrix.

enum ProductImplType

Enumerator	Value	Description
DefaultProduct	=0
LazyProduct
AliasFreeProduct
CoeffBasedProductMode
LazyCoeffBasedProductMode
OuterProduct
InnerProduct
GemvProduct
GemmProduct

enum Action

Enumerator	Value	Description
GetAction
SetAction

enum AutoSize_t

Enumerator	Value	Description
AutoSize

enum SimplicialCholeskyMode

Enumerator	Value	Description
SimplicialCholeskyLLT
SimplicialCholeskyLDLT

enum @833

Enumerator	Value	Description
StandardCompressedFormat	2	used by Ref to specify whether the input storage must be in standard compressed form

typedef Array22i

typedef Array< int , 2 , 2 > Array22i;

typedef Array2i

typedef Array< int , 2 , 1> Array2i;

typedef Array33i

typedef Array< int , 3 , 3 > Array33i;

typedef Array3i

typedef Array< int , 3 , 1> Array3i;

typedef Array44i

typedef Array< int , 4 , 4 > Array44i;

typedef Array4i

typedef Array< int , 4 , 1> Array4i;

typedef ArrayXXi

typedef Array< int , Dynamic , Dynamic > ArrayXXi;

typedef ArrayXi

typedef Array< int , Dynamic , 1> ArrayXi;

typedef Array2Xi

typedef Array< int , 2 , Dynamic> Array2Xi;

typedef ArrayX2i

typedef Array< int , Dynamic, 2 > ArrayX2i;

typedef Array3Xi

typedef Array< int , 3 , Dynamic> Array3Xi;

typedef ArrayX3i

typedef Array< int , Dynamic, 3 > ArrayX3i;

typedef Array4Xi

typedef Array< int , 4 , Dynamic> Array4Xi;

typedef ArrayX4i

typedef Array< int , Dynamic, 4 > ArrayX4i;

typedef Array22f

typedef Array< float , 2 , 2 > Array22f;

typedef Array2f

typedef Array< float , 2 , 1> Array2f;

typedef Array33f

typedef Array< float , 3 , 3 > Array33f;

typedef Array3f

typedef Array< float , 3 , 1> Array3f;

typedef Array44f

typedef Array< float , 4 , 4 > Array44f;

typedef Array4f

typedef Array< float , 4 , 1> Array4f;

typedef ArrayXXf

typedef Array< float , Dynamic , Dynamic > ArrayXXf;

typedef ArrayXf

typedef Array< float , Dynamic , 1> ArrayXf;

typedef Array2Xf

typedef Array< float , 2 , Dynamic> Array2Xf;

typedef ArrayX2f

typedef Array< float , Dynamic, 2 > ArrayX2f;

typedef Array3Xf

typedef Array< float , 3 , Dynamic> Array3Xf;

typedef ArrayX3f

typedef Array< float , Dynamic, 3 > ArrayX3f;

typedef Array4Xf

typedef Array< float , 4 , Dynamic> Array4Xf;

typedef ArrayX4f

typedef Array< float , Dynamic, 4 > ArrayX4f;

typedef Array22d

typedef Array< double , 2 , 2 > Array22d;

typedef Array2d

typedef Array< double , 2 , 1> Array2d;

typedef Array33d

typedef Array< double , 3 , 3 > Array33d;

typedef Array3d

typedef Array< double , 3 , 1> Array3d;

typedef Array44d

typedef Array< double , 4 , 4 > Array44d;

typedef Array4d

typedef Array< double , 4 , 1> Array4d;

typedef ArrayXXd

typedef Array< double , Dynamic , Dynamic > ArrayXXd;

typedef ArrayXd

typedef Array< double , Dynamic , 1> ArrayXd;

typedef Array2Xd

typedef Array< double , 2 , Dynamic> Array2Xd;

typedef ArrayX2d

typedef Array< double , Dynamic, 2 > ArrayX2d;

typedef Array3Xd

typedef Array< double , 3 , Dynamic> Array3Xd;

typedef ArrayX3d

typedef Array< double , Dynamic, 3 > ArrayX3d;

typedef Array4Xd

typedef Array< double , 4 , Dynamic> Array4Xd;

typedef ArrayX4d

typedef Array< double , Dynamic, 4 > ArrayX4d;

typedef Array22cf

typedef Array< std::complex<float> , 2 , 2 > Array22cf;

typedef Array2cf

typedef Array< std::complex<float> , 2 , 1> Array2cf;

typedef Array33cf

typedef Array< std::complex<float> , 3 , 3 > Array33cf;

typedef Array3cf

typedef Array< std::complex<float> , 3 , 1> Array3cf;

typedef Array44cf

typedef Array< std::complex<float> , 4 , 4 > Array44cf;

typedef Array4cf

typedef Array< std::complex<float> , 4 , 1> Array4cf;

typedef ArrayXXcf

typedef Array< std::complex<float> , Dynamic , Dynamic > ArrayXXcf;

typedef ArrayXcf

typedef Array< std::complex<float> , Dynamic , 1> ArrayXcf;

typedef Array2Xcf

typedef Array< std::complex<float> , 2 , Dynamic> Array2Xcf;

typedef ArrayX2cf

typedef Array< std::complex<float> , Dynamic, 2 > ArrayX2cf;

typedef Array3Xcf

typedef Array< std::complex<float> , 3 , Dynamic> Array3Xcf;

typedef ArrayX3cf

typedef Array< std::complex<float> , Dynamic, 3 > ArrayX3cf;

typedef Array4Xcf

typedef Array< std::complex<float> , 4 , Dynamic> Array4Xcf;

typedef ArrayX4cf

typedef Array< std::complex<float> , Dynamic, 4 > ArrayX4cf;

typedef Array22cd

typedef Array< std::complex<double> , 2 , 2 > Array22cd;

typedef Array2cd

typedef Array< std::complex<double> , 2 , 1> Array2cd;

typedef Array33cd

typedef Array< std::complex<double> , 3 , 3 > Array33cd;

typedef Array3cd

typedef Array< std::complex<double> , 3 , 1> Array3cd;

typedef Array44cd

typedef Array< std::complex<double> , 4 , 4 > Array44cd;

typedef Array4cd

typedef Array< std::complex<double> , 4 , 1> Array4cd;

typedef ArrayXXcd

typedef Array< std::complex<double> , Dynamic , Dynamic > ArrayXXcd;

typedef ArrayXcd

typedef Array< std::complex<double> , Dynamic , 1> ArrayXcd;

typedef Array2Xcd

typedef Array< std::complex<double> , 2 , Dynamic> Array2Xcd;

typedef ArrayX2cd

typedef Array< std::complex<double> , Dynamic, 2 > ArrayX2cd;

typedef Array3Xcd

typedef Array< std::complex<double> , 3 , Dynamic> Array3Xcd;

typedef ArrayX3cd

typedef Array< std::complex<double> , Dynamic, 3 > ArrayX3cd;

typedef Array4Xcd

typedef Array< std::complex<double> , 4 , Dynamic> Array4Xcd;

typedef ArrayX4cd

typedef Array< std::complex<double> , Dynamic, 4 > ArrayX4cd;

typedef Matrix2i

typedef Matrix< int , 2 , 2 > Matrix2i;

typedef Vector2i

typedef Matrix< int , 2 , 1> Vector2i;

typedef RowVector2i

typedef Matrix< int , 1, 2 > RowVector2i;

typedef Matrix3i

typedef Matrix< int , 3 , 3 > Matrix3i;

typedef Vector3i

typedef Matrix< int , 3 , 1> Vector3i;

typedef RowVector3i

typedef Matrix< int , 1, 3 > RowVector3i;

typedef Matrix4i

typedef Matrix< int , 4 , 4 > Matrix4i;

typedef Vector4i

typedef Matrix< int , 4 , 1> Vector4i;

typedef RowVector4i

typedef Matrix< int , 1, 4 > RowVector4i;

typedef MatrixXi

typedef Matrix< int , Dynamic , Dynamic > MatrixXi;

typedef VectorXi

typedef Matrix< int , Dynamic , 1> VectorXi;

typedef RowVectorXi

typedef Matrix< int , 1, Dynamic > RowVectorXi;

typedef Matrix2Xi

typedef Matrix< int , 2 , Dynamic> Matrix2Xi;

typedef MatrixX2i

typedef Matrix< int , Dynamic, 2 > MatrixX2i;

typedef Matrix3Xi

typedef Matrix< int , 3 , Dynamic> Matrix3Xi;

typedef MatrixX3i

typedef Matrix< int , Dynamic, 3 > MatrixX3i;

typedef Matrix4Xi

typedef Matrix< int , 4 , Dynamic> Matrix4Xi;

typedef MatrixX4i

typedef Matrix< int , Dynamic, 4 > MatrixX4i;

typedef Matrix2f

typedef Matrix< float , 2 , 2 > Matrix2f;

typedef Vector2f

typedef Matrix< float , 2 , 1> Vector2f;

typedef RowVector2f

typedef Matrix< float , 1, 2 > RowVector2f;

typedef Matrix3f

typedef Matrix< float , 3 , 3 > Matrix3f;

typedef Vector3f

typedef Matrix< float , 3 , 1> Vector3f;

typedef RowVector3f

typedef Matrix< float , 1, 3 > RowVector3f;

typedef Matrix4f

typedef Matrix< float , 4 , 4 > Matrix4f;

typedef Vector4f

typedef Matrix< float , 4 , 1> Vector4f;

typedef RowVector4f

typedef Matrix< float , 1, 4 > RowVector4f;

typedef MatrixXf

typedef Matrix< float , Dynamic , Dynamic > MatrixXf;

typedef VectorXf

typedef Matrix< float , Dynamic , 1> VectorXf;

typedef RowVectorXf

typedef Matrix< float , 1, Dynamic > RowVectorXf;

typedef Matrix2Xf

typedef Matrix< float , 2 , Dynamic> Matrix2Xf;

typedef MatrixX2f

typedef Matrix< float , Dynamic, 2 > MatrixX2f;

typedef Matrix3Xf

typedef Matrix< float , 3 , Dynamic> Matrix3Xf;

typedef MatrixX3f

typedef Matrix< float , Dynamic, 3 > MatrixX3f;

typedef Matrix4Xf

typedef Matrix< float , 4 , Dynamic> Matrix4Xf;

typedef MatrixX4f

typedef Matrix< float , Dynamic, 4 > MatrixX4f;

typedef Matrix2d

typedef Matrix< double , 2 , 2 > Matrix2d;

typedef Vector2d

typedef Matrix< double , 2 , 1> Vector2d;

typedef RowVector2d

typedef Matrix< double , 1, 2 > RowVector2d;

typedef Matrix3d

typedef Matrix< double , 3 , 3 > Matrix3d;

typedef Vector3d

typedef Matrix< double , 3 , 1> Vector3d;

typedef RowVector3d

typedef Matrix< double , 1, 3 > RowVector3d;

typedef Matrix4d

typedef Matrix< double , 4 , 4 > Matrix4d;

typedef Vector4d

typedef Matrix< double , 4 , 1> Vector4d;

typedef RowVector4d

typedef Matrix< double , 1, 4 > RowVector4d;

typedef MatrixXd

typedef Matrix< double , Dynamic , Dynamic > MatrixXd;

typedef VectorXd

typedef Matrix< double , Dynamic , 1> VectorXd;

typedef RowVectorXd

typedef Matrix< double , 1, Dynamic > RowVectorXd;

typedef Matrix2Xd

typedef Matrix< double , 2 , Dynamic> Matrix2Xd;

typedef MatrixX2d

typedef Matrix< double , Dynamic, 2 > MatrixX2d;

typedef Matrix3Xd

typedef Matrix< double , 3 , Dynamic> Matrix3Xd;

typedef MatrixX3d

typedef Matrix< double , Dynamic, 3 > MatrixX3d;

typedef Matrix4Xd

typedef Matrix< double , 4 , Dynamic> Matrix4Xd;

typedef MatrixX4d

typedef Matrix< double , Dynamic, 4 > MatrixX4d;

typedef Matrix2cf

typedef Matrix< std::complex<float> , 2 , 2 > Matrix2cf;

typedef Vector2cf

typedef Matrix< std::complex<float> , 2 , 1> Vector2cf;

typedef RowVector2cf

typedef Matrix< std::complex<float> , 1, 2 > RowVector2cf;

typedef Matrix3cf

typedef Matrix< std::complex<float> , 3 , 3 > Matrix3cf;

typedef Vector3cf

typedef Matrix< std::complex<float> , 3 , 1> Vector3cf;

typedef RowVector3cf

typedef Matrix< std::complex<float> , 1, 3 > RowVector3cf;

typedef Matrix4cf

typedef Matrix< std::complex<float> , 4 , 4 > Matrix4cf;

typedef Vector4cf

typedef Matrix< std::complex<float> , 4 , 1> Vector4cf;

typedef RowVector4cf

typedef Matrix< std::complex<float> , 1, 4 > RowVector4cf;

typedef MatrixXcf

typedef Matrix< std::complex<float> , Dynamic , Dynamic > MatrixXcf;

typedef VectorXcf

typedef Matrix< std::complex<float> , Dynamic , 1> VectorXcf;

typedef RowVectorXcf

typedef Matrix< std::complex<float> , 1, Dynamic > RowVectorXcf;

typedef Matrix2Xcf

typedef Matrix< std::complex<float> , 2 , Dynamic> Matrix2Xcf;

typedef MatrixX2cf

typedef Matrix< std::complex<float> , Dynamic, 2 > MatrixX2cf;

typedef Matrix3Xcf

typedef Matrix< std::complex<float> , 3 , Dynamic> Matrix3Xcf;

typedef MatrixX3cf

typedef Matrix< std::complex<float> , Dynamic, 3 > MatrixX3cf;

typedef Matrix4Xcf

typedef Matrix< std::complex<float> , 4 , Dynamic> Matrix4Xcf;

typedef MatrixX4cf

typedef Matrix< std::complex<float> , Dynamic, 4 > MatrixX4cf;

typedef Matrix2cd

typedef Matrix< std::complex<double> , 2 , 2 > Matrix2cd;

typedef Vector2cd

typedef Matrix< std::complex<double> , 2 , 1> Vector2cd;

typedef RowVector2cd

typedef Matrix< std::complex<double> , 1, 2 > RowVector2cd;

typedef Matrix3cd

typedef Matrix< std::complex<double> , 3 , 3 > Matrix3cd;

typedef Vector3cd

typedef Matrix< std::complex<double> , 3 , 1> Vector3cd;

typedef RowVector3cd

typedef Matrix< std::complex<double> , 1, 3 > RowVector3cd;

typedef Matrix4cd

typedef Matrix< std::complex<double> , 4 , 4 > Matrix4cd;

typedef Vector4cd

typedef Matrix< std::complex<double> , 4 , 1> Vector4cd;

typedef RowVector4cd

typedef Matrix< std::complex<double> , 1, 4 > RowVector4cd;

typedef MatrixXcd

typedef Matrix< std::complex<double> , Dynamic , Dynamic > MatrixXcd;

typedef VectorXcd

typedef Matrix< std::complex<double> , Dynamic , 1> VectorXcd;

typedef RowVectorXcd

typedef Matrix< std::complex<double> , 1, Dynamic > RowVectorXcd;

typedef Matrix2Xcd

typedef Matrix< std::complex<double> , 2 , Dynamic> Matrix2Xcd;

typedef MatrixX2cd

typedef Matrix< std::complex<double> , Dynamic, 2 > MatrixX2cd;

typedef Matrix3Xcd

typedef Matrix< std::complex<double> , 3 , Dynamic> Matrix3Xcd;

typedef MatrixX3cd

typedef Matrix< std::complex<double> , Dynamic, 3 > MatrixX3cd;

typedef Matrix4Xcd

typedef Matrix< std::complex<double> , 4 , Dynamic> Matrix4Xcd;

typedef MatrixX4cd

typedef Matrix< std::complex<double> , Dynamic, 4 > MatrixX4cd;

typedef DenseIndex

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex;

typedef Index

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Index;

The Index type as used for the API.

See: \blank TopicPreprocessorDirectives, StorageIndex.

To change this, #define the preprocessor symbol EIGEN_DEFAULT_DENSE_INDEX_TYPE.

typedef dcomplex

typedef std::complex<double> dcomplex;

typedef scomplex

typedef std::complex<float> scomplex;

typedef BlasIndex

typedef int BlasIndex;

typedef AlignedBox1i

typedef AlignedBox< int , 1 > AlignedBox1i;

typedef AlignedBox2i

typedef AlignedBox< int , 2 > AlignedBox2i;

typedef AlignedBox3i

typedef AlignedBox< int , 3 > AlignedBox3i;

typedef AlignedBox4i

typedef AlignedBox< int , 4 > AlignedBox4i;

typedef AlignedBoxXi

typedef AlignedBox< int , Dynamic > AlignedBoxXi;

typedef AlignedBox1f

typedef AlignedBox< float , 1 > AlignedBox1f;

typedef AlignedBox2f

typedef AlignedBox< float , 2 > AlignedBox2f;

typedef AlignedBox3f

typedef AlignedBox< float , 3 > AlignedBox3f;

typedef AlignedBox4f

typedef AlignedBox< float , 4 > AlignedBox4f;

typedef AlignedBoxXf

typedef AlignedBox< float , Dynamic > AlignedBoxXf;

typedef AlignedBox1d

typedef AlignedBox< double , 1 > AlignedBox1d;

typedef AlignedBox2d

typedef AlignedBox< double , 2 > AlignedBox2d;

typedef AlignedBox3d

typedef AlignedBox< double , 3 > AlignedBox3d;

typedef AlignedBox4d

typedef AlignedBox< double , 4 > AlignedBox4d;

typedef AlignedBoxXd

typedef AlignedBox< double , Dynamic > AlignedBoxXd;

typedef AngleAxisf

typedef AngleAxis<float> AngleAxisf;

single precision angle-axis type

typedef AngleAxisd

typedef AngleAxis<double> AngleAxisd;

double precision angle-axis type

typedef Quaternionf

typedef Quaternion<float> Quaternionf;

single precision quaternion type

typedef Quaterniond

typedef Quaternion<double> Quaterniond;

double precision quaternion type

typedef QuaternionMapf

typedef Map<Quaternion<float>, 0> QuaternionMapf;

Map an unaligned array of single precision scalars as a quaternion

typedef QuaternionMapd

typedef Map<Quaternion<double>, 0> QuaternionMapd;

Map an unaligned array of double precision scalars as a quaternion

typedef QuaternionMapAlignedf

typedef Map<Quaternion<float>, Aligned> QuaternionMapAlignedf;

Map a 16-byte aligned array of single precision scalars as a quaternion

typedef QuaternionMapAlignedd

typedef Map<Quaternion<double>, Aligned> QuaternionMapAlignedd;

Map a 16-byte aligned array of double precision scalars as a quaternion

typedef Rotation2Df

typedef Rotation2D<float> Rotation2Df;

single precision 2D rotation type

typedef Rotation2Dd

typedef Rotation2D<double> Rotation2Dd;

double precision 2D rotation type

typedef AlignedScaling2f

typedef DiagonalMatrix<float, 2> AlignedScaling2f;

typedef AlignedScaling2d

typedef DiagonalMatrix<double,2> AlignedScaling2d;

typedef AlignedScaling3f

typedef DiagonalMatrix<float, 3> AlignedScaling3f;

typedef AlignedScaling3d

typedef DiagonalMatrix<double,3> AlignedScaling3d;

typedef Isometry2f

typedef Transform<float,2,Isometry> Isometry2f;

typedef Isometry3f

typedef Transform<float,3,Isometry> Isometry3f;

typedef Isometry2d

typedef Transform<double,2,Isometry> Isometry2d;

typedef Isometry3d

typedef Transform<double,3,Isometry> Isometry3d;

typedef Affine2f

typedef Transform<float,2,Affine> Affine2f;

typedef Affine3f

typedef Transform<float,3,Affine> Affine3f;

typedef Affine2d

typedef Transform<double,2,Affine> Affine2d;

typedef Affine3d

typedef Transform<double,3,Affine> Affine3d;

typedef AffineCompact2f

typedef Transform<float,2,AffineCompact> AffineCompact2f;

typedef AffineCompact3f

typedef Transform<float,3,AffineCompact> AffineCompact3f;

typedef AffineCompact2d

typedef Transform<double,2,AffineCompact> AffineCompact2d;

typedef AffineCompact3d

typedef Transform<double,3,AffineCompact> AffineCompact3d;

typedef Projective2f

typedef Transform<float,2,Projective> Projective2f;

typedef Projective3f

typedef Transform<float,3,Projective> Projective3f;

typedef Projective2d

typedef Transform<double,2,Projective> Projective2d;

typedef Projective3d

typedef Transform<double,3,Projective> Projective3d;

typedef Translation2f

typedef Translation<float, 2> Translation2f;

typedef Translation2d

typedef Translation<double,2> Translation2d;

typedef Translation3f

typedef Translation<float, 3> Translation3f;

typedef Translation3d

typedef Translation<double,3> Translation3d;

Functions Documentation

function viewAsCholmod

template <typename _Scalar ,
int _Options,
typename _StorageIndex >
cholmod_sparse 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.

function viewAsCholmod

template <typename _Scalar ,
int _Options,
typename _Index >
const cholmod_sparse viewAsCholmod(
    const SparseMatrix< _Scalar, _Options, _Index > & mat
)

function viewAsCholmod

template <typename _Scalar ,
int _Options,
typename _Index >
const cholmod_sparse viewAsCholmod(
    const SparseVector< _Scalar, _Options, _Index > & mat
)

function viewAsCholmod

template <typename _Scalar ,
int _Options,
typename _Index ,
unsigned int UpLo>
cholmod_sparse 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.

function viewAsCholmod

template <typename Derived >
cholmod_dense viewAsCholmod(
    MatrixBase< Derived > & mat
)

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

function viewAsEigen

template <typename Scalar ,
int Flags,
typename StorageIndex >
MappedSparseMatrix< Scalar, Flags, StorageIndex > 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.

function seqN

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
)

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

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

function seqN

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
)

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

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

function seq

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

function seq

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
)

function seq

template <typename FirstType ,
typename LastTypeDerived >
internal::enable_if<!symbolic::is_symbolic< FirstType >::value, ArithmeticSequence< typenameinternal::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
)

function seq

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
)

function seq

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

function seq

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< typenameinternal::cleanup_seq_incr< IncrType >::type > >, symbolic::ValueExpr< typenameinternal::cleanup_seq_incr< IncrType >::type > >, typenameinternal::cleanup_seq_incr< IncrType >::type > >::type seq(
    const symbolic::BaseExpr< FirstTypeDerived > & f,
    LastType l,
    IncrType incr
)

function seq

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

function seq

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
)

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_real_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_real_op< typename Derived::Scalar >, const Derived >(
    real 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_imag_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_imag_op< typename Derived::Scalar >, const Derived >(
    imag 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_conjugate_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_conjugate_op< typename Derived::Scalar >, const Derived >(
    conj 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_inverse_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_inverse_op< typename Derived::Scalar >, const Derived >(
    inverse 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_sin_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sin_op< typename Derived::Scalar >, const Derived >(
    sin 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_cos_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cos_op< typename Derived::Scalar >, const Derived >(
    cos 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_tan_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_tan_op< typename Derived::Scalar >, const Derived >(
    tan 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_atan_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_atan_op< typename Derived::Scalar >, const Derived >(
    atan 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_asin_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_asin_op< typename Derived::Scalar >, const Derived >(
    asin 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_acos_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_acos_op< typename Derived::Scalar >, const Derived >(
    acos 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_sinh_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sinh_op< typename Derived::Scalar >, const Derived >(
    sinh 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_cosh_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cosh_op< typename Derived::Scalar >, const Derived >(
    cosh 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_tanh_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_tanh_op< typename Derived::Scalar >, const Derived >(
    tanh 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_logistic_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_logistic_op< typename Derived::Scalar >, const Derived >(
    logistic 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_lgamma_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_lgamma_op< typename Derived::Scalar >, const Derived >(
    lgamma 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_digamma_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_digamma_op< typename Derived::Scalar >, const Derived >(
    digamma 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_erf_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_erf_op< typename Derived::Scalar >, const Derived >(
    erf 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_erfc_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_erfc_op< typename Derived::Scalar >, const Derived >(
    erfc 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_ndtri_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_ndtri_op< typename Derived::Scalar >, const Derived >(
    ndtri 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_exp_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_exp_op< typename Derived::Scalar >, const Derived >(
    exp 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_expm1_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_expm1_op< typename Derived::Scalar >, const Derived >(
    expm1 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_log_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log_op< typename Derived::Scalar >, const Derived >(
    log 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_log1p_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log1p_op< typename Derived::Scalar >, const Derived >(
    log1p 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_log10_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log10_op< typename Derived::Scalar >, const Derived >(
    log10 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_log2_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log2_op< typename Derived::Scalar >, const Derived >(
    log2 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs_op< typename Derived::Scalar >, const Derived >(
    abs 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs2_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs2_op< typename Derived::Scalar >, const Derived >(
    abs2 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_arg_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_arg_op< typename Derived::Scalar >, const Derived >(
    arg 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_sqrt_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sqrt_op< typename Derived::Scalar >, const Derived >(
    sqrt 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_rsqrt_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_rsqrt_op< typename Derived::Scalar >, const Derived >(
    rsqrt 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_square_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_square_op< typename Derived::Scalar >, const Derived >(
    square 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_cube_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cube_op< typename Derived::Scalar >, const Derived >(
    cube 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_rint_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_rint_op< typename Derived::Scalar >, const Derived >(
    rint 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_round_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_round_op< typename Derived::Scalar >, const Derived >(
    round 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_floor_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_floor_op< typename Derived::Scalar >, const Derived >(
    floor 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_ceil_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_ceil_op< typename Derived::Scalar >, const Derived >(
    ceil 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_isnan_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isnan_op< typename Derived::Scalar >, const Derived >(
    isnan 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_isinf_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isinf_op< typename Derived::Scalar >, const Derived >(
    isinf 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_isfinite_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isfinite_op< typename Derived::Scalar >, const Derived >(
    isfinite 
) const

function Eigen::CwiseUnaryOp< Eigen::internal::scalar_sign_op< typename Derived::Scalar >, const Derived >

template <typename Derived >
inline const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sign_op< typename Derived::Scalar >, const Derived >(
    sign 
) const

function operator*

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

Return: the matrix with the permutation applied to the columns.

function operator*

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

Return: the matrix with the permutation applied to the rows.

function l1CacheSize

inline std::ptrdiff_t l1CacheSize()

See: setCpuCacheSize

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

function l2CacheSize

inline std::ptrdiff_t l2CacheSize()

See: setCpuCacheSize

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

function l3CacheSize

inline std::ptrdiff_t l3CacheSize()

See: setCpuCacheSize

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

function setCpuCacheSizes

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

See: computeProductBlockingSizes

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.

function initParallel

inline void initParallel()

Must be call first when calling Eigen from multiple threads

function nbThreads

inline int nbThreads()

See: setNbThreads

Return: the max number of threads reserved for Eigen

function setNbThreads

inline void setNbThreads(
    int v
)

See: nbThreads

Sets the max number of threads reserved for Eigen

function operator*

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

Return: the matrix with the transpositions applied to the columns.

function operator*

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

Return: the matrix with the transpositions applied to the rows.

function SimdInstructionSetsInUse

static inline const char * SimdInstructionSetsInUse(
    void 
)

function lastp1

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

function fix

template <int N>
inline internal::FixedInt< N > fix()

function fix

template <int N,
typename T >
inline internal::VariableAndFixedInt< N > fix(
    T val
)

function Scaling

inline UniformScaling< float > Scaling(
    float s
)

Constructs a uniform scaling from scale factor s

function Scaling

inline UniformScaling< double > Scaling(
    double s
)

Constructs a uniform scaling from scale factor s

function Scaling

template <typename RealScalar >
inline UniformScaling< std::complex< RealScalar > > Scaling(
    const std::complex< RealScalar > & s
)

Constructs a uniform scaling from scale factor s

function Scaling

template <typename Scalar >
inline DiagonalMatrix< Scalar, 2 > Scaling(
    const Scalar & sx,
    const Scalar & sy
)

Constructs a 2D axis aligned scaling

function Scaling

template <typename Scalar >
inline DiagonalMatrix< Scalar, 3 > Scaling(
    const Scalar & sx,
    const Scalar & sy,
    const Scalar & sz
)

Constructs a 3D axis aligned scaling

function Scaling

template <typename Derived >
inline const DiagonalWrapper< const Derived > Scaling(
    const MatrixBase< Derived > & coeffs
)

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

function umeyama

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.

Parameters:

• src Source points \( \mathbf{x} = \left( x_1, \hdots, x_n \right) \).
• dst Destination points \( \mathbf{y} = \left( y_1, \hdots, y_n \right) \).
• with_scaling Sets \( c=1 \) when false is passed.

Return: The homogeneous transformation minimizing the residual above. This transformation is always returned as an Eigen::Matrix.

Todo: Should the return type of umeyama() become a Transform?

\geometry_module

The algorithm is based on: "Least-squares estimation of transformation parameters between two point patterns", Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573

It estimates parameters \( c, \mathbf{R}, \) and \( \mathbf{t} \) such that is minimized.

The algorithm is based on the analysis of the covariance matrix \( \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \) of the input point sets \( \mathbf{x} \) and \( \mathbf{y} \) where \(d\) is corresponding to the dimension (which is typically small). The analysis is involving the SVD having a complexity of \(O(d^3)\) though the actual computational effort lies in the covariance matrix computation which has an asymptotic lower bound of \(O(dm)\) when the input point sets have dimension \(d \times m\).

Currently the method is working only for floating point matrices.

function operator*

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

Computes the product of a matrix with a Householder sequence.

Parameters:

• other Matrix being multiplied.
• h HouseholderSequence being multiplied.

Return: Expression object representing the product.

This function computes \( MH \) where \( M \) is the matrix other and \( H \) is the Householder sequence represented by h.

function householderSequence

template <typename VectorsType ,
typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType > householderSequence(
    const VectorsType & v,
    const CoeffsType & h
)

Convenience function for constructing a Householder sequence.

Return: A HouseholderSequence constructed from the specified arguments.

function rightHouseholderSequence

template <typename VectorsType ,
typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType, OnTheRight > rightHouseholderSequence(
    const VectorsType & v,
    const CoeffsType & h
)

Convenience function for constructing a Householder sequence.

Return: A HouseholderSequence constructed from the specified arguments.

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

function klu_solve

inline 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.

Template Parameters:

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

See: TutorialSparseSolverConcept, class UmfPackLU, class SparseLU

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.

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.

\implsparsesolverconcept

function klu_solve

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

function klu_tsolve

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

function klu_tsolve

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

function klu_factor

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

function klu_factor

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

function operator+

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
)

function operator+

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
)

function operator-

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
)

function operator-

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
)

function operator*

template <typename SparseDerived ,
typename PermDerived >
inline const Product< SparseDerived, PermDerived, AliasFreeProduct > operator*(
    const SparseMatrixBase< SparseDerived > & matrix,
    const PermutationBase< PermDerived > & perm
)

Return: the matrix with the permutation applied to the columns

function operator*

template <typename SparseDerived ,
typename PermDerived >
inline const Product< PermDerived, SparseDerived, AliasFreeProduct > operator*(
    const PermutationBase< PermDerived > & perm,
    const SparseMatrixBase< SparseDerived > & matrix
)

Return: the matrix with the permutation applied to the rows

function operator*

template <typename SparseDerived ,
typename PermutationType >
inline const Product< SparseDerived, Inverse< PermutationType >, AliasFreeProduct > operator*(
    const SparseMatrixBase< SparseDerived > & matrix,
    const InverseImpl< PermutationType, PermutationStorage > & tperm
)

Return: the matrix with the inverse permutation applied to the columns.

function operator*

template <typename SparseDerived ,
typename PermutationType >
inline const Product< Inverse< PermutationType >, SparseDerived, AliasFreeProduct > operator*(
    const InverseImpl< PermutationType, PermutationStorage > & tperm,
    const SparseMatrixBase< SparseDerived > & matrix
)

Return: the matrix with the inverse permutation applied to the rows.

function sgssvx

void sgssvx(
    superlu_options_t * ,
    SuperMatrix * ,
    int * ,
    int * ,
    int * ,
    char * ,
    float * ,
    float * ,
    SuperMatrix * ,
    SuperMatrix * ,
    void * ,
    int ,
    SuperMatrix * ,
    SuperMatrix * ,
    float * ,
    float * ,
    float * ,
    float * ,
    mem_usage_t * ,
    SuperLUStat_t * ,
    int * 
)

function SuperLU_gssvx

inline float SuperLU_gssvx(
    superlu_options_t * options,
    SuperMatrix * A,
    int * perm_c,
    int * perm_r,
    int * etree,
    char * equed,
    float * R,
    float * C,
    SuperMatrix * L,
    SuperMatrix * U,
    void * work,
    int lwork,
    SuperMatrix * B,
    SuperMatrix * X,
    float * recip_pivot_growth,
    float * rcond,
    float * ferr,
    float * berr,
    SuperLUStat_t * stats,
    int * info,
    float 
)

function cgssvx

void cgssvx(
    superlu_options_t * ,
    SuperMatrix * ,
    int * ,
    int * ,
    int * ,
    char * ,
    float * ,
    float * ,
    SuperMatrix * ,
    SuperMatrix * ,
    void * ,
    int ,
    SuperMatrix * ,
    SuperMatrix * ,
    float * ,
    float * ,
    float * ,
    float * ,
    mem_usage_t * ,
    SuperLUStat_t * ,
    int * 
)

function SuperLU_gssvx

inline float SuperLU_gssvx(
    superlu_options_t * options,
    SuperMatrix * A,
    int * perm_c,
    int * perm_r,
    int * etree,
    char * equed,
    float * R,
    float * C,
    SuperMatrix * L,
    SuperMatrix * U,
    void * work,
    int lwork,
    SuperMatrix * B,
    SuperMatrix * X,
    float * recip_pivot_growth,
    float * rcond,
    float * ferr,
    float * berr,
    SuperLUStat_t * stats,
    int * info,
    std::complex< float > 
)

function dgssvx

void dgssvx(
    superlu_options_t * ,
    SuperMatrix * ,
    int * ,
    int * ,
    int * ,
    char * ,
    double * ,
    double * ,
    SuperMatrix * ,
    SuperMatrix * ,
    void * ,
    int ,
    SuperMatrix * ,
    SuperMatrix * ,
    double * ,
    double * ,
    double * ,
    double * ,
    mem_usage_t * ,
    SuperLUStat_t * ,
    int * 
)

function SuperLU_gssvx

inline float SuperLU_gssvx(
    superlu_options_t * options,
    SuperMatrix * A,
    int * perm_c,
    int * perm_r,
    int * etree,
    char * equed,
    double * R,
    double * C,
    SuperMatrix * L,
    SuperMatrix * U,
    void * work,
    int lwork,
    SuperMatrix * B,
    SuperMatrix * X,
    double * recip_pivot_growth,
    double * rcond,
    double * ferr,
    double * berr,
    SuperLUStat_t * stats,
    int * info,
    double 
)

function zgssvx

void zgssvx(
    superlu_options_t * ,
    SuperMatrix * ,
    int * ,
    int * ,
    int * ,
    char * ,
    double * ,
    double * ,
    SuperMatrix * ,
    SuperMatrix * ,
    void * ,
    int ,
    SuperMatrix * ,
    SuperMatrix * ,
    double * ,
    double * ,
    double * ,
    double * ,
    mem_usage_t * ,
    SuperLUStat_t * ,
    int * 
)

function SuperLU_gssvx

inline float SuperLU_gssvx(
    superlu_options_t * options,
    SuperMatrix * A,
    int * perm_c,
    int * perm_r,
    int * etree,
    char * equed,
    double * R,
    double * C,
    SuperMatrix * L,
    SuperMatrix * U,
    void * work,
    int lwork,
    SuperMatrix * B,
    SuperMatrix * X,
    double * recip_pivot_growth,
    double * rcond,
    double * ferr,
    double * berr,
    SuperLUStat_t * stats,
    int * info,
    std::complex< double > 
)

function umfpack_defaults

inline void umfpack_defaults(
    double control[UMFPACK_CONTROL],
    double ,
    int 
)

function umfpack_defaults

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

function umfpack_defaults

inline void umfpack_defaults(
    double control[UMFPACK_CONTROL],
    double ,
    SuiteSparse_long 
)

function umfpack_defaults

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

function umfpack_report_info

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

function umfpack_report_info

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

function umfpack_report_info

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

function umfpack_report_info

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

function umfpack_report_status

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

function umfpack_report_status

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

function umfpack_report_status

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

function umfpack_report_status

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

function umfpack_report_control

inline void umfpack_report_control(
    double control[UMFPACK_CONTROL],
    double ,
    int 
)

function umfpack_report_control

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

function umfpack_report_control

inline void umfpack_report_control(
    double control[UMFPACK_CONTROL],
    double ,
    SuiteSparse_long 
)

function umfpack_report_control

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

function umfpack_free_numeric

inline void umfpack_free_numeric(
    void ** Numeric,
    double ,
    int 
)

function umfpack_free_numeric

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

function umfpack_free_numeric

inline void umfpack_free_numeric(
    void ** Numeric,
    double ,
    SuiteSparse_long 
)

function umfpack_free_numeric

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

function umfpack_free_symbolic

inline void umfpack_free_symbolic(
    void ** Symbolic,
    double ,
    int 
)

function umfpack_free_symbolic

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

function umfpack_free_symbolic

inline void umfpack_free_symbolic(
    void ** Symbolic,
    double ,
    SuiteSparse_long 
)

function umfpack_free_symbolic

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

function umfpack_symbolic

inline 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]
)

function umfpack_symbolic

inline 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]
)

function umfpack_symbolic

inline 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]
)

function umfpack_symbolic

inline 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]
)

function umfpack_numeric

inline 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]
)

function umfpack_numeric

inline 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]
)

function umfpack_numeric

inline 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]
)

function umfpack_numeric

inline 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]
)

function umfpack_solve

inline 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]
)

function umfpack_solve

inline 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]
)

function umfpack_solve

inline 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]
)

function umfpack_solve

inline 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]
)

function umfpack_get_lunz

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

function umfpack_get_lunz

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

function umfpack_get_lunz

inline 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 
)

function umfpack_get_lunz

inline 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 > 
)

function umfpack_get_numeric

inline 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
)

function umfpack_get_numeric

inline 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
)

function umfpack_get_numeric

inline 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
)

function umfpack_get_numeric

inline 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
)

function umfpack_get_determinant

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

function umfpack_get_determinant

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

function umfpack_get_determinant

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

function umfpack_get_determinant

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

Attributes Documentation

variable exponents

EIGEN_DEVICE_FUNC const Eigen::ArrayBase< Derived > & exponents {
    typedef typename internal::promote_scalar_arg<typename Derived::Scalar,Scalar,
                                                  EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type PromotedScalar;

variable Dynamic

const int Dynamic = -1;

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

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

variable DynamicIndex

const int DynamicIndex = 0xffffff;

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

variable UndefinedIncr

const int UndefinedIncr = 0xfffffe;

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

variable Infinity

const int Infinity = -1;

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

variable HugeCost

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

variable RowMajorBit

const unsigned int RowMajorBit = 0x1;

See: \blank TopicStorageOrders

for a matrix, this means that the storage order is row-major. If this bit is not set, the storage order is column-major. For an expression, this determines the storage order of the matrix created by evaluation of that expression.

variable EvalBeforeNestingBit

const unsigned int EvalBeforeNestingBit = 0x2;

means the expression should be evaluated by the calling expression

variable EvalBeforeAssigningBit

EIGEN_DEPRECATED const unsigned int EvalBeforeAssigningBit = 0x4;

Deprecated:

means the expression should be evaluated before any assignment

variable PacketAccessBit

const unsigned int PacketAccessBit = 0x8;

Note: This bit can be set regardless of whether vectorization is actually enabled. To check for actual vectorizability, see ActualPacketAccessBit.

Short version: means the expression might be vectorized

Long version: means that the coefficients can be handled by packets and start at a memory location whose alignment meets the requirements of the present CPU architecture for optimized packet access. In the fixed-size case, there is the additional condition that it be possible to access all the coefficients by packets (this implies the requirement that the size be a multiple of 16 bytes, and that any nontrivial strides don't break the alignment). In the dynamic-size case, there is no such condition on the total size and strides, so it might not be possible to access all coeffs by packets.

variable ActualPacketAccessBit

const unsigned int ActualPacketAccessBit = 0x0;

variable LinearAccessBit

const unsigned int LinearAccessBit = 0x10;

Short version: means the expression can be seen as 1D vector.

Long version: means that one can access the coefficients of this expression by coeff(int), and coeffRef(int) in the case of a lvalue expression. These index-based access methods are guaranteed to not have to do any runtime computation of a (row, col)-pair from the index, so that it is guaranteed that whenever it is available, index-based access is at least as fast as (row,col)-based access. Expressions for which that isn't possible don't have the LinearAccessBit.

If both PacketAccessBit and LinearAccessBit are set, then the packets of this expression can be accessed by packet(int), and writePacket(int) in the case of a lvalue expression.

Typically, all vector expressions have the LinearAccessBit, but there is one exception: Product expressions don't have it, because it would be troublesome for vectorization, even when the Product is a vector expression. Thus, vector Product expressions allow index-based coefficient access but not index-based packet access, so they don't have the LinearAccessBit.

variable LvalueBit

const unsigned int LvalueBit = 0x20;

Means the expression has a coeffRef() method, i.e. is writable as its individual coefficients are directly addressable. This rules out read-only expressions.

Note that DirectAccessBit and LvalueBit are mutually orthogonal, as there are examples of expression having one but note the other:

• writable expressions that don't have a very simple memory layout as a strided array, have LvalueBit but not DirectAccessBit
• Map-to-const expressions, for example Map, have DirectAccessBit but not LvalueBit

Expressions having LvalueBit also have their coeff() method returning a const reference instead of returning a new value.

variable DirectAccessBit

const unsigned int DirectAccessBit = 0x40;

Means that the underlying array of coefficients can be directly accessed as a plain strided array. The memory layout of the array of coefficients must be exactly the natural one suggested by rows(), cols(), outerStride(), innerStride(), and the RowMajorBit. This rules out expressions such as Diagonal, whose coefficients, though referencable, do not have such a regular memory layout.

See the comment on LvalueBit for an explanation of how LvalueBit and DirectAccessBit are mutually orthogonal.

variable AlignedBit

EIGEN_DEPRECATED const unsigned int AlignedBit = 0x80;

means the first coefficient packet is guaranteed to be aligned. An expression cannot have the AlignedBit without the PacketAccessBit flag. In other words, this means we are allow to perform an aligned packet access to the first element regardless of the expression kind:

expression.packet<Aligned>(0);

variable NestByRefBit

const unsigned int NestByRefBit = 0x100;

variable NoPreferredStorageOrderBit

const unsigned int NoPreferredStorageOrderBit = 0x200;

See: \blank RowMajorBit, TopicStorageOrders

for an expression, this means that the storage order can be either row-major or column-major. The precise choice will be decided at evaluation time or when combined with other expressions.

variable CompressedAccessBit

const unsigned int CompressedAccessBit = 0x400;

Means that the underlying coefficients can be accessed through pointers to the sparse (un)compressed storage format, that is, the expression provides:

inline const Scalar* valuePtr() const;
inline const Index* innerIndexPtr() const;
inline const Index* outerIndexPtr() const;
inline const Index* innerNonZeroPtr() const;

variable HereditaryBits

const unsigned int HereditaryBits = RowMajorBit
                                  | EvalBeforeNestingBit;

variable last

static const symbolic::SymbolExpr< internal::symbolic_last_tag > last;

See: end

Can be used as a parameter to Eigen::seq and Eigen::seqN functions to symbolically reference the last element/row/columns of the underlying vector or matrix once passed to DenseBase::operator()(const RowIndices&, const ColIndices&).

This symbolic placeholder supports standard arithmetic operations.

A typical usage example would be:

using namespace Eigen;
using Eigen::last;
VectorXd v(n);
v(seq(2,last-2)).setOnes();

variable all

static const Eigen::internal::all_t all;

Can be used as a parameter to DenseBase::operator()(const RowIndices&, const ColIndices&) to index all rows or columns

variable AutoOrder

const int AutoOrder = 2;

variable CoherentAccessPattern

const int CoherentAccessPattern = 0x1;

variable InnerRandomAccessPattern

const int InnerRandomAccessPattern = 0x2 | CoherentAccessPattern;

variable OuterRandomAccessPattern

const int OuterRandomAccessPattern = 0x4 | CoherentAccessPattern;

variable RandomAccessPattern

const int RandomAccessPattern = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern;

---

Updated on 2023-11-29 at 18:22:17 +0000