Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Eigen Namespace Reference

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

Namespaces

 Architecture
 
 half_impl
 
 HybridNonLinearSolverSpace
 
 internal
 
 LevenbergMarquardtSpace
 
 numext
 
 TensorSycl
 

Classes

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

Typedefs

typedef Transform< double, 2, AffineAffine2d
 
typedef Transform< float, 2, AffineAffine2f
 
typedef Transform< double, 3, AffineAffine3d
 
typedef Transform< float, 3, AffineAffine3f
 
typedef Transform< double, 2, AffineCompactAffineCompact2d
 
typedef Transform< float, 2, AffineCompactAffineCompact2f
 
typedef Transform< double, 3, AffineCompactAffineCompact3d
 
typedef Transform< float, 3, AffineCompactAffineCompact3f
 
typedef DiagonalMatrix< double, 2 > AlignedScaling2d
 
typedef DiagonalMatrix< float, 2 > AlignedScaling2f
 
typedef DiagonalMatrix< double, 3 > AlignedScaling3d
 
typedef DiagonalMatrix< float, 3 > AlignedScaling3f
 
typedef AngleAxis< double > AngleAxisd
 
typedef AngleAxis< float > AngleAxisf
 
typedef int BlasIndex
 
typedef std::complex< double > dcomplex
 
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex
 
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
 The Index type as used for the API. More...
 
typedef Transform< double, 2, IsometryIsometry2d
 
typedef Transform< float, 2, IsometryIsometry2f
 
typedef Transform< double, 3, IsometryIsometry3d
 
typedef Transform< float, 3, IsometryIsometry3f
 
typedef NonBlockingThreadPoolTempl< StlThreadEnvironmentNonBlockingThreadPool
 
typedef Transform< double, 2, ProjectiveProjective2d
 
typedef Transform< float, 2, ProjectiveProjective2f
 
typedef Transform< double, 3, ProjectiveProjective3d
 
typedef Transform< float, 3, ProjectiveProjective3f
 
typedef Quaternion< double > Quaterniond
 
typedef Quaternion< float > Quaternionf
 
typedef Map< Quaternion< double >, AlignedQuaternionMapAlignedd
 
typedef Map< Quaternion< float >, AlignedQuaternionMapAlignedf
 
typedef Map< Quaternion< double >, 0 > QuaternionMapd
 
typedef Map< Quaternion< float >, 0 > QuaternionMapf
 
typedef Rotation2D< double > Rotation2Dd
 
typedef Rotation2D< float > Rotation2Df
 
typedef std::complex< float > scomplex
 
typedef SimpleThreadPoolTempl< StlThreadEnvironmentSimpleThreadPool
 
typedef Spline< double, 2 > Spline2d
 2D double B-spline with dynamic degree. More...
 
typedef Spline< float, 2 > Spline2f
 2D float B-spline with dynamic degree. More...
 
typedef Spline< double, 3 > Spline3d
 3D double B-spline with dynamic degree. More...
 
typedef Spline< float, 3 > Spline3f
 3D float B-spline with dynamic degree. More...
 
typedef Translation< double, 2 > Translation2d
 
typedef Translation< float, 2 > Translation2f
 
typedef Translation< double, 3 > Translation3d
 
typedef Translation< float, 3 > Translation3f
 

Enumerations

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

Functions

template<typename DstXprType , typename SrcXprType >
void add_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename DerTypeA , typename DerTypeB >
const AutoDiffScalar< Matrix< typename internal::traits< typename internal::remove_all< DerTypeA >::type >::Scalar, Dynamic, 1 > > atan2 (const AutoDiffScalar< DerTypeA > &a, const AutoDiffScalar< DerTypeB > &b)
 
template<typename ADerived , typename BDerived , typename XDerived >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorCwiseTernaryOp< internal::scalar_betainc_op< typename XDerived::Scalar >, const ADerived, const BDerived, const XDerived > betainc (const ADerived &a, const BDerived &b, const XDerived &x)
 
template<typename ArgADerived , typename ArgBDerived , typename ArgXDerived >
const Eigen::CwiseTernaryOp< Eigen::internal::scalar_betainc_op< typename ArgXDerived::Scalar >, const ArgADerived, const ArgBDerived, const ArgXDerived > betainc (const Eigen::ArrayBase< ArgADerived > &a, const Eigen::ArrayBase< ArgBDerived > &b, const Eigen::ArrayBase< ArgXDerived > &x)
 
Box2d bounding_box (const Vector2d &v)
 
template<typename Scalar , int Dim>
AlignedBox< Scalar, Dim > bounding_box (const Matrix< Scalar, Dim, 1 > &v)
 
template<typename BVH , typename Intersector >
void BVIntersect (const BVH &tree, Intersector &intersector)
 
template<typename BVH1 , typename BVH2 , typename Intersector >
void BVIntersect (const BVH1 &tree1, const BVH2 &tree2, Intersector &intersector)
 
template<typename BVH , typename Minimizer >
Minimizer::Scalar BVMinimize (const BVH &tree, Minimizer &minimizer)
 
template<typename BVH1 , typename BVH2 , typename Minimizer >
Minimizer::Scalar BVMinimize (const BVH1 &tree1, const BVH2 &tree2, Minimizer &minimizer)
 
template<typename Polynomial >
NumTraits< typename Polynomial::Scalar >::Real cauchy_max_bound (const Polynomial &poly)
 
template<typename Polynomial >
NumTraits< typename Polynomial::Scalar >::Real cauchy_min_bound (const Polynomial &poly)
 
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T1choose (Cond< true >, const T1 &first, const T2 &)
 
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T2choose (Cond< false >, const T1 &, const T2 &second)
 
template<typename PointArrayType , typename KnotVectorType >
void ChordLengths (const PointArrayType &pts, KnotVectorType &chord_lengths)
 Computes chord length parameters which are required for spline interpolation. More...
 
template<typename DerType >
const AutoDiffScalar< DerType > & conj (const AutoDiffScalar< DerType > &x)
 
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType & copy_using_evaluator (const EigenBase< DstXprType > &dst, const SrcXprType &src)
 
template<typename DstXprType , template< typename > class StorageBase, typename SrcXprType >
EIGEN_STRONG_INLINE const DstXprType & copy_using_evaluator (const NoAlias< DstXprType, StorageBase > &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType & copy_using_evaluator (const PlainObjectBase< DstXprType > &dst, const SrcXprType &src)
 
template<typename MatrixType >
void createRandomPIMatrixOfRank (Index desired_rank, Index rows, Index cols, MatrixType &m)
 
template<typename SplineType , typename DerivativeType >
void derivativesImpl (const SplineType &spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType &der)
 
template<typename Dims1 , typename Dims2 >
EIGEN_DEVICE_FUNC bool dimensions_match (Dims1 &dims1, Dims2 &dims2)
 
template<typename DstXprType , typename SrcXprType >
void divide_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename T , typename X , typename Y >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T divup (const X x, const Y y)
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T divup (const T x, const T y)
 
void dsaupd_ (int *ido, char *bmat, int *n, char *which, int *nev, double *tol, double *resid, int *ncv, double *v, int *ldv, int *iparam, int *ipntr, double *workd, double *workl, int *lworkl, int *info)
 
void dseupd_ (int *rvec, char *All, int *select, double *d, double *z, int *ldz, double *sigma, char *bmat, int *n, char *which, int *nev, double *tol, double *resid, int *ncv, double *v, int *ldv, int *iparam, int *ipntr, double *workd, double *workl, int *lworkl, int *ierr)
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (abs, using std::abs;return Eigen::MakeAutoDiffScalar(abs(x.value()), x.derivatives()*(x.value()< 0?-1:1));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sqrt, using std::sqrt;Scalar sqrtx=sqrt(x.value());return Eigen::MakeAutoDiffScalar(sqrtx, x.derivatives()*(Scalar(0.5)/sqrtx));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sin, using std::sin;using std::cos;return Eigen::MakeAutoDiffScalar(sin(x.value()), x.derivatives()*cos(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (log, using std::log;return Eigen::MakeAutoDiffScalar(log(x.value()), x.derivatives()*(Scalar(1)/x.value()));) template< typename DerType > inline const Eigen
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (tan, using std::tan;using std::cos;return Eigen::MakeAutoDiffScalar(tan(x.value()), x.derivatives()*(Scalar(1)/numext::abs2(cos(x.value()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(asin
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (acos, using std::sqrt;using std::acos;return Eigen::MakeAutoDiffScalar(acos(x.value()), x.derivatives()*(Scalar(-1)/sqrt(1-numext::abs2(x.value()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(tanh
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sinh, using std::sinh;using std::cosh;return Eigen::MakeAutoDiffScalar(sinh(x.value()), x.derivatives()*cosh(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cosh
 
template<typename Derived >
const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE (Derived, typename Derived::Scalar, pow) pow(const Eigen
 
template<typename Derived >
const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE (typename Derived::Scalar, Derived, pow) pow(const typename Derived
 
template<typename T >
NumTraits< typename T::Scalar >::Real get_test_precision (const T &, const typename T::Scalar *=0)
 
template<typename T >
NumTraits< T >::Real get_test_precision (const T &, typename internal::enable_if< internal::is_arithmetic< typename NumTraits< T >::Real >::value, T >::type *=0)
 
bool getMarketHeader (const std::string &filename, int &sym, bool &iscomplex, bool &isvector)
 
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType > householderSequence (const VectorsType &v, const CoeffsType &h)
 Convenience function for constructing a Householder sequence. More...
 
template<typename Derived , typename ExponentDerived >
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_igamma_op< typename Derived::Scalar >, const Derived, const ExponentDerived > igamma (const Eigen::ArrayBase< Derived > &a, const Eigen::ArrayBase< ExponentDerived > &x)
 
template<typename Derived , typename ExponentDerived >
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_igammac_op< typename Derived::Scalar >, const Derived, const ExponentDerived > igammac (const Eigen::ArrayBase< Derived > &a, const Eigen::ArrayBase< ExponentDerived > &x)
 
template<typename DerType >
DerType::Scalar imag (const AutoDiffScalar< DerType > &)
 
void initParallel ()
 
template<typename T >
bool isMinusInf (const T &x)
 
template<typename T >
bool isNotNaN (const T &x)
 
template<typename T >
bool isPlusInf (const T &x)
 
template<typename KnotVectorType >
void KnotAveraging (const KnotVectorType &parameters, DenseIndex degree, KnotVectorType &knots)
 Computes knot averages.The knots are computed as

\begin{align*} u_0 & = \hdots = u_p = 0 \\ u_{m-p} & = \hdots = u_{m} = 1 \\ u_{j+p} & = \frac{1}{p}\sum_{i=j}^{j+p-1}\bar{u}_i \quad\quad j=1,\hdots,n-p \end{align*}

where $p$ is the degree and $m+1$ the number knots of the desired interpolating spline. More...

 
template<typename KnotVectorType , typename ParameterVectorType , typename IndexArray >
void KnotAveragingWithDerivatives (const ParameterVectorType &parameters, const unsigned int degree, const IndexArray &derivativeIndices, KnotVectorType &knots)
 Computes knot averages when derivative constraints are present. Note that this is a technical interpretation of the referenced article since the algorithm contained therein is incorrect as written. More...
 
template<typename A , typename B >
KroneckerProduct< A, BkroneckerProduct (const MatrixBase< A > &a, const MatrixBase< B > &b)
 
template<typename A , typename B >
KroneckerProductSparse< A, BkroneckerProduct (const EigenBase< A > &a, const EigenBase< B > &b)
 
std::ptrdiff_t l1CacheSize ()
 
std::ptrdiff_t l2CacheSize ()
 
std::ptrdiff_t l3CacheSize ()
 
template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs, LazyProductlazyprod (const Lhs &lhs, const Rhs &rhs)
 
template<typename SparseMatrixType >
bool loadMarket (SparseMatrixType &mat, const std::string &filename)
 
template<typename VectorType >
bool loadMarketVector (VectorType &vec, const std::string &filename)
 
template<typename NewDerType >
AutoDiffScalar< NewDerType > MakeAutoDiffScalar (const typename NewDerType::Scalar &value, const NewDerType &der)
 
template<typename MatrixType , typename ResultType >
void matrix_sqrt_quasi_triangular (const MatrixType &arg, ResultType &result)
 Compute matrix square root of quasi-triangular matrix. More...
 
template<typename MatrixType , typename ResultType >
void matrix_sqrt_triangular (const MatrixType &arg, ResultType &result)
 Compute matrix square root of triangular matrix. More...
 
template<typename DstXprType , typename SrcXprType >
void multiply_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
int nbThreads ()
 
template<typename U , typename V >
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator!= (const Tuple< U, V > &x, const Tuple< U, V > &y)
 
template<typename SparseDerived , typename PermDerived >
const Product< SparseDerived, PermDerived, AliasFreeProductoperator* (const SparseMatrixBase< SparseDerived > &matrix, const PermutationBase< PermDerived > &perm)
 
template<typename SparseDerived , typename PermDerived >
const Product< PermDerived, SparseDerived, AliasFreeProductoperator* (const PermutationBase< PermDerived > &perm, const SparseMatrixBase< SparseDerived > &matrix)
 
template<typename SparseDerived , typename PermutationType >
const Product< SparseDerived, Inverse< PermutationType >, AliasFreeProductoperator* (const SparseMatrixBase< SparseDerived > &matrix, const InverseImpl< PermutationType, PermutationStorage > &tperm)
 
template<typename SparseDerived , typename PermutationType >
const Product< Inverse< PermutationType >, SparseDerived, AliasFreeProductoperator* (const InverseImpl< PermutationType, PermutationStorage > &tperm, const SparseMatrixBase< SparseDerived > &matrix)
 
template<typename MatrixDerived , typename TranspositionsDerived >
EIGEN_DEVICE_FUNC const Product< MatrixDerived, TranspositionsDerived, AliasFreeProductoperator* (const MatrixBase< MatrixDerived > &matrix, const TranspositionsBase< TranspositionsDerived > &transpositions)
 
template<typename TranspositionsDerived , typename MatrixDerived >
EIGEN_DEVICE_FUNC const Product< TranspositionsDerived, MatrixDerived, AliasFreeProductoperator* (const TranspositionsBase< TranspositionsDerived > &transpositions, const MatrixBase< MatrixDerived > &matrix)
 
template<typename OtherDerived , typename VectorsType , typename CoeffsType , int Side>
internal::matrix_type_times_scalar_type< typename VectorsType::Scalar, OtherDerived >::Type operator* (const MatrixBase< OtherDerived > &other, const HouseholderSequence< VectorsType, CoeffsType, Side > &h)
 Computes the product of a matrix with a Householder sequence. More...
 
template<typename MatrixDerived , typename PermutationDerived >
EIGEN_DEVICE_FUNC const Product< MatrixDerived, PermutationDerived, AliasFreeProductoperator* (const MatrixBase< MatrixDerived > &matrix, const PermutationBase< PermutationDerived > &permutation)
 
template<typename PermutationDerived , typename MatrixDerived >
EIGEN_DEVICE_FUNC const Product< PermutationDerived, MatrixDerived, AliasFreeProductoperator* (const PermutationBase< PermutationDerived > &permutation, const MatrixBase< MatrixDerived > &matrix)
 
template<typename DenseDerived , typename SparseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived > operator+ (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
 
template<typename SparseDerived , typename DenseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived > operator+ (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
 
template<typename DenseDerived , typename SparseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived > operator- (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
 
template<typename SparseDerived , typename DenseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived > operator- (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const TensorBase< T, ReadOnlyAccessors > &expr)
 
template<typename U , typename V >
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator== (const Tuple< U, V > &x, const Tuple< U, V > &y)
 
template<class T , std::size_t N>
EIGEN_DEVICE_FUNC bool operator== (const array< T, N > &lhs, const array< T, N > &rhs)
 
template<typename Polynomials , typename T >
T poly_eval (const Polynomials &poly, const T &x)
 
template<typename Polynomials , typename T >
T poly_eval_horner (const Polynomials &poly, const T &x)
 
template<typename DerivedN , typename DerivedX >
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_polygamma_op< typename DerivedX::Scalar >, const DerivedN, const DerivedX > polygamma (const Eigen::ArrayBase< DerivedN > &n, const Eigen::ArrayBase< DerivedX > &x)
 
template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs > prod (const Lhs &lhs, const Rhs &rhs)
 
template<typename PermutationVectorType >
void randomPermutationVector (PermutationVectorType &v, Index size)
 
template<typename DerType >
const AutoDiffScalar< DerType > & real (const AutoDiffScalar< DerType > &x)
 
 return (x<=y?ADS(x):ADS(y))
 
 return (x >=y?ADS(x):ADS(y))
 
 return (x< y?ADS(x):ADS(y))
 
 return (x > y?ADS(x):ADS(y))
 
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType, OnTheRightrightHouseholderSequence (const VectorsType &v, const CoeffsType &h)
 Convenience function for constructing a Householder sequence. More...
 
template<typename RootVector , typename Polynomial >
void roots_to_monicPolynomial (const RootVector &rv, Polynomial &poly)
 
template<typename SparseMatrixType >
bool saveMarket (const SparseMatrixType &mat, const std::string &filename, int sym=0)
 
template<typename VectorType >
bool saveMarketVector (const VectorType &vec, const std::string &filename)
 
UniformScaling< float > Scaling (float s)
 
UniformScaling< double > Scaling (double s)
 
template<typename RealScalar >
UniformScaling< std::complex< RealScalar > > Scaling (const std::complex< RealScalar > &s)
 
template<typename Scalar >
DiagonalMatrix< Scalar, 2 > Scaling (const Scalar &sx, const Scalar &sy)
 
template<typename Scalar >
DiagonalMatrix< Scalar, 3 > Scaling (const Scalar &sx, const Scalar &sy, const Scalar &sz)
 
template<typename Derived >
const DiagonalWrapper< const Derived > Scaling (const MatrixBase< Derived > &coeffs)
 
void setCpuCacheSizes (std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
 
void setNbThreads (int v)
 
void ssaupd_ (int *ido, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *info)
 
void sseupd_ (int *rvec, char *All, int *select, float *d, float *z, int *ldz, float *sigma, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *ierr)
 
template<typename DstXprType , typename SrcXprType >
void subtract_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
void swap_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename T , typename U >
bool test_is_equal (const T &actual, const U &expected, bool expect_equal=true)
 
bool test_isApprox (const short &a, const short &b)
 
bool test_isApprox (const unsigned short &a, const unsigned short &b)
 
bool test_isApprox (const unsigned int &a, const unsigned int &b)
 
bool test_isApprox (const long &a, const long &b)
 
bool test_isApprox (const unsigned long &a, const unsigned long &b)
 
bool test_isApprox (const int &a, const int &b)
 
bool test_isApprox (const float &a, const float &b)
 
bool test_isApprox (const double &a, const double &b)
 
bool test_isApprox (const std::complex< float > &a, const std::complex< float > &b)
 
bool test_isApprox (const std::complex< double > &a, const std::complex< double > &b)
 
bool test_isApprox (const std::complex< long double > &a, const std::complex< long double > &b)
 
bool test_isApprox (const long double &a, const long double &b)
 
bool test_isApprox (const half &a, const half &b)
 
template<typename Type1 , typename Type2 >
bool test_isApprox (const Type1 &a, const Type2 &b, typename Type1::Scalar *=0)
 
bool test_isApproxOrLessThan (const int &a, const int &b)
 
bool test_isApproxOrLessThan (const float &a, const float &b)
 
bool test_isApproxOrLessThan (const double &a, const double &b)
 
bool test_isApproxOrLessThan (const long double &a, const long double &b)
 
bool test_isApproxOrLessThan (const half &a, const half &b)
 
template<typename Scalar , typename ScalarRef >
bool test_isApproxWithRef (const Scalar &a, const Scalar &b, const ScalarRef &ref)
 
bool test_isMuchSmallerThan (const int &a, const int &b)
 
bool test_isMuchSmallerThan (const float &a, const float &b)
 
bool test_isMuchSmallerThan (const double &a, const double &b)
 
bool test_isMuchSmallerThan (const std::complex< float > &a, const std::complex< float > &b)
 
bool test_isMuchSmallerThan (const std::complex< double > &a, const std::complex< double > &b)
 
bool test_isMuchSmallerThan (const std::complex< long double > &a, const std::complex< long double > &b)
 
bool test_isMuchSmallerThan (const long double &a, const long double &b)
 
bool test_isMuchSmallerThan (const half &a, const half &b)
 
template<typename Derived1 , typename Derived2 >
bool test_isMuchSmallerThan (const MatrixBase< Derived1 > &m1, const MatrixBase< Derived2 > &m2)
 
template<typename Derived >
bool test_isMuchSmallerThan (const MatrixBase< Derived > &m, const typename NumTraits< typename internal::traits< Derived >::Scalar >::Real &s)
 
template<typename Derived >
bool test_isUnitary (const MatrixBase< Derived > &m)
 
template<typename T >
NumTraits< T >::Real test_precision ()
 
template<>
double test_precision< double > ()
 
template<>
float test_precision< float > ()
 
template<>
long double test_precision< long double > ()
 
template<>
Real test_precision< Real > ()
 
template<>
double test_precision< std::complex< double > > ()
 
template<>
float test_precision< std::complex< float > > ()
 
template<>
long double test_precision< std::complex< long double > > ()
 
template<typename T , typename Derived >
T test_relative_error (const AlignedVector3< T > &a, const MatrixBase< Derived > &b)
 
template<typename T1 , typename T2 >
NumTraits< typename T1::RealScalar >::NonInteger test_relative_error (const EigenBase< T1 > &a, const EigenBase< T2 > &b)
 
template<typename T1 , typename T2 >
T1::RealScalar test_relative_error (const T1 &a, const T2 &b, const typename T1::Coefficients *=0)
 
template<typename T1 , typename T2 >
T1::Scalar test_relative_error (const T1 &a, const T2 &b, const typename T1::MatrixType *=0)
 
template<typename S , int D>
test_relative_error (const Translation< S, D > &a, const Translation< S, D > &b)
 
template<typename S , int D, int O>
test_relative_error (const ParametrizedLine< S, D, O > &a, const ParametrizedLine< S, D, O > &b)
 
template<typename S , int D>
test_relative_error (const AlignedBox< S, D > &a, const AlignedBox< S, D > &b)
 
template<typename T1 , typename T2 >
T1::RealScalar test_relative_error (const MatrixBase< T1 > &a, const SparseMatrixBase< T2 > &b)
 
template<typename T1 , typename T2 >
T1::RealScalar test_relative_error (const SparseMatrixBase< T1 > &a, const MatrixBase< T2 > &b)
 
template<typename T1 , typename T2 >
T1::RealScalar test_relative_error (const SparseMatrixBase< T1 > &a, const SparseMatrixBase< T2 > &b)
 
template<typename T1 , typename T2 >
NumTraits< typename NumTraits< T1 >::Real >::NonInteger test_relative_error (const T1 &a, const T2 &b, typename internal::enable_if< internal::is_arithmetic< typename NumTraits< T1 >::Real >::value, T1 >::type *=0)
 
template<typename T >
T test_relative_error (const Rotation2D< T > &a, const Rotation2D< T > &b)
 
template<typename T >
T test_relative_error (const AngleAxis< T > &a, const AngleAxis< T > &b)
 
template<typename Derived , typename OtherDerived >
internal::umeyama_transform_matrix_type< Derived, OtherDerived >::type umeyama (const MatrixBase< Derived > &src, const MatrixBase< OtherDerived > &dst, bool with_scaling=true)
 Returns the transformation between two point sets. More...
 
void umfpack_defaults (double control[UMFPACK_CONTROL], double)
 
void umfpack_defaults (double control[UMFPACK_CONTROL], std::complex< double >)
 
void umfpack_free_numeric (void **Numeric, double)
 
void umfpack_free_numeric (void **Numeric, std::complex< double >)
 
void umfpack_free_symbolic (void **Symbolic, double)
 
void umfpack_free_symbolic (void **Symbolic, std::complex< double >)
 
int umfpack_get_determinant (double *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO])
 
int umfpack_get_determinant (std::complex< double > *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO])
 
int umfpack_get_lunz (int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, double)
 
int umfpack_get_lunz (int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, std::complex< double >)
 
int umfpack_get_numeric (int Lp[], int Lj[], double Lx[], int Up[], int Ui[], double Ux[], int P[], int Q[], double Dx[], int *do_recip, double Rs[], void *Numeric)
 
int umfpack_get_numeric (int Lp[], int Lj[], std::complex< double > Lx[], int Up[], int Ui[], std::complex< double > Ux[], int P[], int Q[], std::complex< double > Dx[], int *do_recip, double Rs[], void *Numeric)
 
int umfpack_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])
 
void umfpack_report_control (double control[UMFPACK_CONTROL], double)
 
void umfpack_report_control (double control[UMFPACK_CONTROL], std::complex< double >)
 
void umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double)
 
void umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex< double >)
 
void umfpack_report_status (double control[UMFPACK_CONTROL], int status, double)
 
void umfpack_report_status (double control[UMFPACK_CONTROL], int status, std::complex< double >)
 
int umfpack_solve (int sys, const int Ap[], const int Ai[], const double Ax[], double X[], const double B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
int umfpack_solve (int sys, const int Ap[], const int Ai[], const std::complex< double > Ax[], std::complex< double > X[], const std::complex< double > B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
int umfpack_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])
 
template<typename Type1 , typename Type2 >
bool verifyIsApprox (const Type1 &a, const Type2 &b)
 
template<typename _Scalar , int _Options, typename _StorageIndex >
cholmod_sparse viewAsCholmod (Ref< SparseMatrix< _Scalar, _Options, _StorageIndex > > mat)
 
template<typename _Scalar , int _Options, typename _Index >
const cholmod_sparse viewAsCholmod (const SparseMatrix< _Scalar, _Options, _Index > &mat)
 
template<typename _Scalar , int _Options, typename _Index >
const cholmod_sparse viewAsCholmod (const SparseVector< _Scalar, _Options, _Index > &mat)
 
template<typename _Scalar , int _Options, typename _Index , unsigned int UpLo>
cholmod_sparse viewAsCholmod (const SparseSelfAdjointView< const SparseMatrix< _Scalar, _Options, _Index >, UpLo > &mat)
 
template<typename Derived >
cholmod_dense viewAsCholmod (MatrixBase< Derived > &mat)
 
template<typename Scalar , int Flags, typename StorageIndex >
MappedSparseMatrix< Scalar, Flags, StorageIndex > viewAsEigen (cholmod_sparse &cm)
 
template<typename DerivedX , typename DerivedQ >
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_zeta_op< typename DerivedX::Scalar >, const DerivedX, const DerivedQ > zeta (const Eigen::ArrayBase< DerivedX > &x, const Eigen::ArrayBase< DerivedQ > &q)
 

Variables

const unsigned int ActualPacketAccessBit = 0x0
 
EIGEN_DEPRECATED const unsigned int AlignedBit = 0x80
 
const int CoherentAccessPattern = 0x1
 
const unsigned int CompressedAccessBit = 0x400
 
const unsigned int DirectAccessBit = 0x40
 
const int Dynamic = -1
 
const int DynamicIndex = 0xffffff
 
EIGEN_DEPRECATED const unsigned int EvalBeforeAssigningBit = 0x4
 
const unsigned int EvalBeforeNestingBit = 0x2
 
Scalar expx = exp(x.value())
 
static bool g_has_set_repeat
 
static bool g_has_set_seed
 
static int g_repeat
 
static unsigned int g_seed
 
static int g_test_level = 0
 
static std::vector< std::string > g_test_stack
 
const unsigned int HereditaryBits
 
const int HugeCost = 10000
 
const int Infinity = -1
 
const int InnerRandomAccessPattern = 0x2 | CoherentAccessPattern
 
const unsigned int LinearAccessBit = 0x10
 
const unsigned int LvalueBit = 0x20
 
const unsigned int NestByRefBit = 0x100
 
static bool no_more_assert = false
 
const unsigned int NoPreferredStorageOrderBit = 0x200
 
const int OuterRandomAccessPattern = 0x4 | CoherentAccessPattern
 
const unsigned int PacketAccessBit = 0x8
 
const int RandomAccessPattern = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern
 
static bool report_on_cerr_on_assert_failure = true
 
const unsigned int RowMajorBit = 0x1
 
static const bool should_raise_an_assert = false
 
const unsigned int SkylineBit = 0x1200
 
const Ty
 

Detailed Description

Namespace containing all symbols from the Eigen library.

Typedef Documentation

Definition at line 124 of file MKL_support.h.

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

Definition at line 118 of file MKL_support.h.

Definition at line 25 of file Meta.h.

The Index type as used for the API.

To change this, #define the preprocessor symbol EIGEN_DEFAULT_DENSE_INDEX_TYPE.

See also
Preprocessor directives, StorageIndex.
Examples:
/tmp/ws/src/gtsam/gtsam/3rdparty/Eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h.

Definition at line 33 of file Meta.h.

Definition at line 270 of file NonBlockingThreadPool.h.

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

Definition at line 119 of file MKL_support.h.

Definition at line 150 of file SimpleThreadPool.h.

typedef Spline<double,2> Eigen::Spline2d

2D double B-spline with dynamic degree.

Definition at line 87 of file SplineFwd.h.

typedef Spline<float,2> Eigen::Spline2f

2D float B-spline with dynamic degree.

Definition at line 81 of file SplineFwd.h.

typedef Spline<double,3> Eigen::Spline3d

3D double B-spline with dynamic degree.

Definition at line 90 of file SplineFwd.h.

typedef Spline<float,3> Eigen::Spline3f

3D float B-spline with dynamic degree.

Definition at line 84 of file SplineFwd.h.

Enumeration Type Documentation

anonymous enum
Enumerator
Large 
Small 

Definition at line 16 of file GeneralProduct.h.

anonymous enum
Enumerator
DontAlignCols 

Definition at line 16 of file IO.h.

anonymous enum
Enumerator
StreamPrecision 
FullPrecision 

Definition at line 17 of file IO.h.

anonymous enum
Enumerator
StandardCompressedFormat 

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

Definition at line 15 of file SparseRef.h.

anonymous enum
Enumerator
NegationFlag 
ConjugationFlag 

Definition at line 15 of file Symmetry.h.

anonymous enum
Enumerator
GlobalRealFlag 
GlobalImagFlag 
GlobalZeroFlag 

Definition at line 20 of file Symmetry.h.

anonymous enum
Enumerator
IsSkyline 

Definition at line 24 of file SkylineUtil.h.

anonymous enum
Enumerator
SPD 
NonSymmetric 

Definition at line 16 of file MatrixMarketIterator.h.

anonymous enum
Enumerator
CPU_TIMER 
REAL_TIMER 

Definition at line 43 of file BenchTimer.h.

Enumerator
GetAction 
SetAction 

Definition at line 488 of file Constants.h.

Enumerator
SkylineTimeDenseProduct 
SkylineTimeSkylineProduct 
DenseTimeSkylineProduct 

Definition at line 23 of file SkylineUtil.h.

Enumerator
IsDense 
IsSparse 

Definition at line 356 of file Constants.h.

Enumerator
CholmodAuto 
CholmodSimplicialLLt 
CholmodSupernodalLLt 
CholmodLDLt 

Definition at line 162 of file CholmodSupport.h.

Enumerator
Default 

Definition at line 352 of file Constants.h.

Representation of a fixed signed rotation axis for EulerSystem.

Values here represent:

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

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

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

Enumerator
EULER_X 

the X axis

EULER_Y 

the Y axis

EULER_Z 

the Z axis

Definition at line 55 of file EulerSystem.h.

Enumerator
FFT_FORWARD 
FFT_REVERSE 

Definition at line 82 of file TensorForwardDeclarations.h.

Enumerator
RealPart 
ImagPart 
BothParts 

Definition at line 76 of file TensorForwardDeclarations.h.

Enumerator
NoChange 

Definition at line 350 of file Constants.h.

Enumerator
Forward 
Central 

Definition at line 18 of file NumericalDiff.h.

Enumerator
PADDING_VALID 
PADDING_SAME 

Definition at line 265 of file TensorTraits.h.

Enumerator
DefaultProduct 
LazyProduct 
AliasFreeProduct 
CoeffBasedProductMode 
LazyCoeffBasedProductMode 
OuterProduct 
InnerProduct 
GemvProduct 
GemmProduct 

Definition at line 483 of file Constants.h.

Enumerator
Sequential 

Definition at line 351 of file Constants.h.

Enumerator
SimplicialCholeskyLLT 
SimplicialCholeskyLDLT 

Definition at line 15 of file SimplicialCholesky.h.

Enumerator
Specialized 
BuiltIn 

Definition at line 310 of file Constants.h.

Enumerator
DefaultTraversal 
LinearTraversal 
InnerVectorizedTraversal 
LinearVectorizedTraversal 
SliceVectorizedTraversal 
InvalidTraversal 
AllAtOnceTraversal 

Definition at line 276 of file Constants.h.

Enumerator
NoUnrolling 
InnerUnrolling 
CompleteUnrolling 

Definition at line 298 of file Constants.h.

Function Documentation

template<typename DstXprType , typename SrcXprType >
void Eigen::add_assign_using_evaluator ( const DstXprType &  dst,
const SrcXprType &  src 
)

Definition at line 53 of file evaluators.cpp.

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

Definition at line 623 of file AutoDiffScalar.h.

template<typename ADerived , typename BDerived , typename XDerived >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorCwiseTernaryOp<internal::scalar_betainc_op<typename XDerived::Scalar>, const ADerived, const BDerived, const XDerived> Eigen::betainc ( const ADerived &  a,
const BDerived &  b,
const XDerived &  x 
)
Returns
an expression of the coefficient-wise betainc(x, a, b) to the given tensors.

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

Definition at line 24 of file TensorGlobalFunctions.h.

template<typename ArgADerived , typename ArgBDerived , typename ArgXDerived >
const Eigen::CwiseTernaryOp<Eigen::internal::scalar_betainc_op<typename ArgXDerived::Scalar>, const ArgADerived, const ArgBDerived, const ArgXDerived> Eigen::betainc ( const Eigen::ArrayBase< ArgADerived > &  a,
const Eigen::ArrayBase< ArgBDerived > &  b,
const Eigen::ArrayBase< ArgXDerived > &  x 
)
inline
Returns
an expression of the coefficient-wise betainc(x, a, b) to the given arrays.

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

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

Definition at line 90 of file SpecialFunctionsArrayAPI.h.

Box2d Eigen::bounding_box ( const Vector2d &  v)

Definition at line 9 of file BVH_Example.cpp.

template<typename Scalar , int Dim>
AlignedBox<Scalar, Dim> Eigen::bounding_box ( const Matrix< Scalar, Dim, 1 > &  v)

Definition at line 17 of file BVH.cpp.

template<typename BVH , typename Intersector >
void Eigen::BVIntersect ( const BVH &  tree,
Intersector &  intersector 
)

Given a BVH, runs the query encapsulated by intersector. The Intersector type must provide the following members:

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

Definition at line 79 of file BVAlgorithms.h.

template<typename BVH1 , typename BVH2 , typename Intersector >
void Eigen::BVIntersect ( const BVH1 &  tree1,
const BVH2 &  tree2,
Intersector &  intersector 
)

Given two BVH's, runs the query on their Cartesian product encapsulated by intersector. The Intersector type must provide the following members:

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

Definition at line 93 of file BVAlgorithms.h.

template<typename BVH , typename Minimizer >
Minimizer::Scalar Eigen::BVMinimize ( const BVH &  tree,
Minimizer &  minimizer 
)

Given a BVH, runs the query encapsulated by minimizer.

Returns
the minimum value. The Minimizer type must provide the following members:
typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has one)
Scalar minimumOnVolume(const BVH::Volume &volume)
Scalar minimumOnObject(const BVH::Object &object)

Definition at line 219 of file BVAlgorithms.h.

template<typename BVH1 , typename BVH2 , typename Minimizer >
Minimizer::Scalar Eigen::BVMinimize ( const BVH1 &  tree1,
const BVH2 &  tree2,
Minimizer &  minimizer 
)

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

Returns
the minimum value. The Minimizer type must provide the following members:
typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has one)
Scalar minimumOnVolumeVolume(const BVH1::Volume &v1, const BVH2::Volume &v2)
Scalar minimumOnVolumeObject(const BVH1::Volume &v1, const BVH2::Object &o2)
Scalar minimumOnObjectVolume(const BVH1::Object &o1, const BVH2::Volume &v2)
Scalar minimumOnObjectObject(const BVH1::Object &o1, const BVH2::Object &o2)

Definition at line 235 of file BVAlgorithms.h.

template<typename Polynomial >
NumTraits<typename Polynomial::Scalar>::Real Eigen::cauchy_max_bound ( const Polynomial &  poly)
inline
Returns
a maximum bound for the absolute value of any root of the polynomial.
Parameters
[in]poly: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. $ 1 + 3x^2 $ is stored as a vector $ [ 1, 0, 3 ] $.
Precondition
the leading coefficient of the input polynomial poly must be non zero

Definition at line 75 of file PolynomialUtils.h.

template<typename Polynomial >
NumTraits<typename Polynomial::Scalar>::Real Eigen::cauchy_min_bound ( const Polynomial &  poly)
inline
Returns
a minimum bound for the absolute value of any non zero root of the polynomial.
Parameters
[in]poly: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. $ 1 + 3x^2 $ is stored as a vector $ [ 1, 0, 3 ] $.

Definition at line 98 of file PolynomialUtils.h.

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

Definition at line 18 of file TensorMeta.h.

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

Definition at line 23 of file TensorMeta.h.

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

Definition at line 543 of file AutoDiffScalar.h.

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

Definition at line 22 of file evaluators.cpp.

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

Definition at line 30 of file evaluators.cpp.

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

Definition at line 38 of file evaluators.cpp.

template<typename MatrixType >
void Eigen::createRandomPIMatrixOfRank ( Index  desired_rank,
Index  rows,
Index  cols,
MatrixType m 
)

Creates a random Partial Isometry matrix of given rank.

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

Definition at line 603 of file main.h.

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

Definition at line 311 of file Spline.h.

template<typename Dims1 , typename Dims2 >
EIGEN_DEVICE_FUNC bool Eigen::dimensions_match ( Dims1 &  dims1,
Dims2 &  dims2 
)

Definition at line 422 of file TensorDimensions.h.

template<typename DstXprType , typename SrcXprType >
void Eigen::divide_assign_using_evaluator ( const DstXprType &  dst,
const SrcXprType &  src 
)

Definition at line 74 of file evaluators.cpp.

template<typename T , typename X , typename Y >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::divup ( const X  x,
const Y  y 
)

Definition at line 30 of file TensorMeta.h.

template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T Eigen::divup ( const T  x,
const T  y 
)

Definition at line 36 of file TensorMeta.h.

void Eigen::dsaupd_ ( int ido,
char *  bmat,
int n,
char *  which,
int nev,
double *  tol,
double *  resid,
int ncv,
double *  v,
int ldv,
int iparam,
int ipntr,
double *  workd,
double *  workl,
int lworkl,
int info 
)
void Eigen::dseupd_ ( int rvec,
char *  All,
int select,
double *  d,
double *  z,
int ldz,
double *  sigma,
char *  bmat,
int n,
char *  which,
int nev,
double *  tol,
double *  resid,
int ncv,
double *  v,
int ldv,
int iparam,
int ipntr,
double *  workd,
double *  workl,
int lworkl,
int ierr 
)
Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY ( abs  ,
using std::abs;return Eigen::MakeAutoDiffScalar(abs(x.value()), x.derivatives()*(x.value()< 0?-1:1));   
)
Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY ( sqrt  ,
using std::sqrt;Scalar  sqrtx = sqrt(x.value()); return Eigen::MakeAutoDiffScalar(sqrtx,x.derivatives() * (Scalar(0.5) / sqrtx)); 
)
Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY ( sin  ,
using std::sin;using std::cos;return Eigen::MakeAutoDiffScalar(sin(x.value()), x.derivatives()*cos(x.value()));   
)
Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY ( log  ,
using std::log;return Eigen::MakeAutoDiffScalar(log(x.value()), x.derivatives()*(Scalar(1)/x.value()));   
) const

Definition at line 606 of file AutoDiffScalar.h.

Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY ( tan  ,
using std::tan;using std::cos;return Eigen::MakeAutoDiffScalar(tan(x.value()), x.derivatives()*(Scalar(1)/numext::abs2(cos(x.value()))));   
)
Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY ( acos  ,
using std::sqrt;using std::acos;return Eigen::MakeAutoDiffScalar(acos(x.value()), x.derivatives()*(Scalar(-1)/sqrt(1-numext::abs2(x.value()))));   
)
Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY ( sinh  ,
using std::sinh;using std::cosh;return Eigen::MakeAutoDiffScalar(sinh(x.value()), x.derivatives()*cosh(x.value()));   
)
template<typename Derived >
const Eigen::EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE ( Derived  ,
typename Derived::Scalar  ,
pow   
) const
inline

Definition at line 113 of file GlobalFunctions.h.

template<typename Derived >
const Eigen::EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE ( typename Derived::Scalar  ,
Derived  ,
pow   
) const
inline

Definition at line 168 of file GlobalFunctions.h.

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

Definition at line 522 of file main.h.

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

Definition at line 528 of file main.h.

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

Definition at line 109 of file MarketIO.h.

template<typename Derived , typename ExponentDerived >
const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_op<typename Derived::Scalar>, const Derived, const ExponentDerived> Eigen::igamma ( const Eigen::ArrayBase< Derived > &  a,
const Eigen::ArrayBase< ExponentDerived > &  x 
)
inline
Returns
an expression of the coefficient-wise igamma(a, x) to the given arrays.

This function computes the coefficient-wise incomplete gamma function.

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

Definition at line 28 of file SpecialFunctionsArrayAPI.h.

template<typename Derived , typename ExponentDerived >
const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igammac_op<typename Derived::Scalar>, const Derived, const ExponentDerived> Eigen::igammac ( const Eigen::ArrayBase< Derived > &  a,
const Eigen::ArrayBase< ExponentDerived > &  x 
)
inline
Returns
an expression of the coefficient-wise igammac(a, x) to the given arrays.

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

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

Definition at line 48 of file SpecialFunctionsArrayAPI.h.

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

Definition at line 547 of file AutoDiffScalar.h.

void Eigen::initParallel ( )
inline

Must be call first when calling Eigen from multiple threads

Definition at line 48 of file Parallelizer.h.

template<typename T >
bool Eigen::isMinusInf ( const T x)

Definition at line 668 of file main.h.

template<typename T >
bool Eigen::isNotNaN ( const T x)

Definition at line 658 of file main.h.

template<typename T >
bool Eigen::isPlusInf ( const T x)

Definition at line 663 of file main.h.

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

Computes Kronecker tensor product of two dense matrices

Warning
If you want to replace a matrix by its Kronecker product with some matrix, do NOT do this:
A = kroneckerProduct(A,B); // bug!!! caused by aliasing effect
instead, use eval() to work around this:
A = kroneckerProduct(A,B).eval();
Parameters
aDense matrix a
bDense matrix b
Returns
Kronecker tensor product of a and b

Definition at line 271 of file KroneckerTensorProduct.h.

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

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

Warning
If you want to replace a matrix by its Kronecker product with some matrix, do NOT do this:
A = kroneckerProduct(A,B); // bug!!! caused by aliasing effect
instead, use eval() to work around this:
A = kroneckerProduct(A,B).eval();
Parameters
aDense/sparse matrix a
bDense/sparse matrix b
Returns
Kronecker tensor product of a and b, stored in a sparse matrix

Definition at line 298 of file KroneckerTensorProduct.h.

std::ptrdiff_t Eigen::l1CacheSize ( )
inline
Returns
the currently set level 1 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.
See also
setCpuCacheSize

Definition at line 2118 of file GeneralBlockPanelKernel.h.

std::ptrdiff_t Eigen::l2CacheSize ( )
inline
Returns
the currently set level 2 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.
See also
setCpuCacheSize

Definition at line 2127 of file GeneralBlockPanelKernel.h.

std::ptrdiff_t Eigen::l3CacheSize ( )
inline
Returns
the currently set level 3 cpu cache size (in bytes) used to estimate the ideal blocking size paramete\ rs.
See also
setCpuCacheSize

Definition at line 2137 of file GeneralBlockPanelKernel.h.

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

Definition at line 15 of file evaluators.cpp.

template<typename SparseMatrixType >
bool Eigen::loadMarket ( SparseMatrixType &  mat,
const std::string &  filename 
)

Definition at line 134 of file MarketIO.h.

template<typename VectorType >
bool Eigen::loadMarketVector ( VectorType vec,
const std::string &  filename 
)

Definition at line 194 of file MarketIO.h.

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

Definition at line 36 of file AutoDiffScalar.h.

template<typename MatrixType , typename ResultType >
void Eigen::matrix_sqrt_quasi_triangular ( const MatrixType arg,
ResultType &  result 
)

Compute matrix square root of quasi-triangular matrix.

Template Parameters
MatrixTypetype of arg, the argument of matrix square root, expected to be an instantiation of the Matrix class template.
ResultTypetype of result, where result is to be stored.
Parameters
[in]argargument of matrix square root.
[out]resultmatrix square root of upper Hessenberg part of arg.

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

See also
MatrixSquareRoot, MatrixSquareRootQuasiTriangular

Definition at line 180 of file MatrixSquareRoot.h.

template<typename MatrixType , typename ResultType >
void Eigen::matrix_sqrt_triangular ( const MatrixType arg,
ResultType &  result 
)

Compute matrix square root of triangular matrix.

Template Parameters
MatrixTypetype of arg, the argument of matrix square root, expected to be an instantiation of the Matrix class template.
ResultTypetype of result, where result is to be stored.
Parameters
[in]argargument of matrix square root.
[out]resultmatrix square root of upper triangular part of arg.

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

See also
MatrixSquareRoot, MatrixSquareRootQuasiTriangular

Definition at line 204 of file MatrixSquareRoot.h.

template<typename DstXprType , typename SrcXprType >
void Eigen::multiply_assign_using_evaluator ( const DstXprType &  dst,
const SrcXprType &  src 
)

Definition at line 67 of file evaluators.cpp.

int Eigen::nbThreads ( )
inline
Returns
the max number of threads reserved for Eigen
See also
setNbThreads

Definition at line 58 of file Parallelizer.h.

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

Definition at line 148 of file TensorMeta.h.

template<typename SparseDerived , typename PermDerived >
const Product<SparseDerived, PermDerived, AliasFreeProduct> Eigen::operator* ( const SparseMatrixBase< SparseDerived > &  matrix,
const PermutationBase< PermDerived > &  perm 
)
inline
Returns
the matrix with the permutation applied to the columns

Definition at line 147 of file SparsePermutation.h.

template<typename SparseDerived , typename PermDerived >
const Product<PermDerived, SparseDerived, AliasFreeProduct> Eigen::operator* ( const PermutationBase< PermDerived > &  perm,
const SparseMatrixBase< SparseDerived > &  matrix 
)
inline
Returns
the matrix with the permutation applied to the rows

Definition at line 154 of file SparsePermutation.h.

template<typename SparseDerived , typename PermutationType >
const Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct> Eigen::operator* ( const SparseMatrixBase< SparseDerived > &  matrix,
const InverseImpl< PermutationType, PermutationStorage > &  tperm 
)
inline
Returns
the matrix with the inverse permutation applied to the columns.

Definition at line 162 of file SparsePermutation.h.

template<typename SparseDerived , typename PermutationType >
const Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct> Eigen::operator* ( const InverseImpl< PermutationType, PermutationStorage > &  tperm,
const SparseMatrixBase< SparseDerived > &  matrix 
)
inline
Returns
the matrix with the inverse permutation applied to the rows.

Definition at line 171 of file SparsePermutation.h.

template<typename MatrixDerived , typename TranspositionsDerived >
EIGEN_DEVICE_FUNC const Product<MatrixDerived, TranspositionsDerived, AliasFreeProduct> Eigen::operator* ( const MatrixBase< MatrixDerived > &  matrix,
const TranspositionsBase< TranspositionsDerived > &  transpositions 
)
Returns
the matrix with the transpositions applied to the columns.

Definition at line 338 of file Transpositions.h.

template<typename TranspositionsDerived , typename MatrixDerived >
EIGEN_DEVICE_FUNC const Product<TranspositionsDerived, MatrixDerived, AliasFreeProduct> Eigen::operator* ( const TranspositionsBase< TranspositionsDerived > &  transpositions,
const MatrixBase< MatrixDerived > &  matrix 
)
Returns
the matrix with the transpositions applied to the rows.

Definition at line 350 of file Transpositions.h.

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

Computes the product of a matrix with a Householder sequence.

Parameters
[in]otherMatrix being multiplied.
[in]hHouseholderSequence being multiplied.
Returns
Expression object representing the product.

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

Definition at line 438 of file HouseholderSequence.h.

template<typename MatrixDerived , typename PermutationDerived >
EIGEN_DEVICE_FUNC const Product<MatrixDerived, PermutationDerived, AliasFreeProduct> Eigen::operator* ( const MatrixBase< MatrixDerived > &  matrix,
const PermutationBase< PermutationDerived > &  permutation 
)
Returns
the matrix with the permutation applied to the columns.

Definition at line 543 of file PermutationMatrix.h.

template<typename PermutationDerived , typename MatrixDerived >
EIGEN_DEVICE_FUNC const Product<PermutationDerived, MatrixDerived, AliasFreeProduct> Eigen::operator* ( const PermutationBase< PermutationDerived > &  permutation,
const MatrixBase< MatrixDerived > &  matrix 
)
Returns
the matrix with the permutation applied to the rows.

Definition at line 555 of file PermutationMatrix.h.

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

Definition at line 698 of file SparseCwiseBinaryOp.h.

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

Definition at line 705 of file SparseCwiseBinaryOp.h.

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

Definition at line 712 of file SparseCwiseBinaryOp.h.

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

Definition at line 719 of file SparseCwiseBinaryOp.h.

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

Definition at line 59 of file TensorIO.h.

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

Definition at line 142 of file TensorMeta.h.

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

Definition at line 183 of file EmulateArray.h.

template<typename Polynomials , typename T >
T Eigen::poly_eval ( const Polynomials &  poly,
const T x 
)
inline
Returns
the evaluation of the polynomial at x using stabilized Horner algorithm.
Parameters
[in]poly: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. $ 1 + 3x^2 $ is stored as a vector $ [ 1, 0, 3 ] $.
[in]x: the value to evaluate the polynomial at.

Definition at line 46 of file PolynomialUtils.h.

template<typename Polynomials , typename T >
T Eigen::poly_eval_horner ( const Polynomials &  poly,
const T x 
)
inline
Returns
the evaluation of the polynomial at x using Horner algorithm.
Parameters
[in]poly: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. $ 1 + 3x^2 $ is stored as a vector $ [ 1, 0, 3 ] $.
[in]x: the value to evaluate the polynomial at.
Note
for stability: $ |x| \le 1 $

Definition at line 28 of file PolynomialUtils.h.

template<typename DerivedN , typename DerivedX >
const Eigen::CwiseBinaryOp<Eigen::internal::scalar_polygamma_op<typename DerivedX::Scalar>, const DerivedN, const DerivedX> Eigen::polygamma ( const Eigen::ArrayBase< DerivedN > &  n,
const Eigen::ArrayBase< DerivedX > &  x 
)
inline
Returns
an expression of the coefficient-wise polygamma(n, x) to the given arrays.

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

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

Definition at line 70 of file SpecialFunctionsArrayAPI.h.

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

Definition at line 8 of file evaluators.cpp.

template<typename PermutationVectorType >
void Eigen::randomPermutationVector ( PermutationVectorType &  v,
Index  size 
)

Definition at line 643 of file main.h.

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

Definition at line 545 of file AutoDiffScalar.h.

Eigen::return ( x<=y ADSx):ADS(y)
Eigen::return ( x >=y ADSx):ADS(y)
Eigen::return ( )
Eigen::return ( x  ,
y ADSx):ADS(y 
)
template<typename RootVector , typename Polynomial >
void Eigen::roots_to_monicPolynomial ( const RootVector &  rv,
Polynomial &  poly 
)

Given the roots of a polynomial compute the coefficients in the monomial basis of the monic polynomial with same roots and minimal degree. If RootVector is a vector of complexes, Polynomial should also be a vector of complexes.

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

Definition at line 127 of file PolynomialUtils.h.

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

Definition at line 226 of file MarketIO.h.

template<typename VectorType >
bool Eigen::saveMarketVector ( const VectorType vec,
const std::string &  filename 
)

Definition at line 252 of file MarketIO.h.

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

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

See also
computeProductBlockingSizes

Definition at line 2149 of file GeneralBlockPanelKernel.h.

void Eigen::setNbThreads ( int  v)
inline

Sets the max number of threads reserved for Eigen

See also
nbThreads

Definition at line 67 of file Parallelizer.h.

void Eigen::ssaupd_ ( int ido,
char *  bmat,
int n,
char *  which,
int nev,
float *  tol,
float *  resid,
int ncv,
float *  v,
int ldv,
int iparam,
int ipntr,
float *  workd,
float *  workl,
int lworkl,
int info 
)
void Eigen::sseupd_ ( int rvec,
char *  All,
int select,
float *  d,
float *  z,
int ldz,
float *  sigma,
char *  bmat,
int n,
char *  which,
int nev,
float *  tol,
float *  resid,
int ncv,
float *  v,
int ldv,
int iparam,
int ipntr,
float *  workd,
float *  workl,
int lworkl,
int ierr 
)
template<typename DstXprType , typename SrcXprType >
void Eigen::subtract_assign_using_evaluator ( const DstXprType &  dst,
const SrcXprType &  src 
)

Definition at line 60 of file evaluators.cpp.

template<typename DstXprType , typename SrcXprType >
void Eigen::swap_using_evaluator ( const DstXprType &  dst,
const SrcXprType &  src 
)

Definition at line 81 of file evaluators.cpp.

template<typename T , typename U >
bool Eigen::test_is_equal ( const T actual,
const U expected,
bool  expect_equal = true 
)

Definition at line 583 of file main.h.

bool Eigen::test_isApprox ( const short &  a,
const short &  b 
)
inline

Definition at line 359 of file main.h.

bool Eigen::test_isApprox ( const unsigned short &  a,
const unsigned short &  b 
)
inline

Definition at line 361 of file main.h.

bool Eigen::test_isApprox ( const unsigned int a,
const unsigned int b 
)
inline

Definition at line 363 of file main.h.

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

Definition at line 365 of file main.h.

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

Definition at line 367 of file main.h.

bool Eigen::test_isApprox ( const int a,
const int b 
)
inline

Definition at line 370 of file main.h.

bool Eigen::test_isApprox ( const float &  a,
const float &  b 
)
inline

Definition at line 377 of file main.h.

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

Definition at line 384 of file main.h.

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

Definition at line 392 of file main.h.

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

Definition at line 397 of file main.h.

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

Definition at line 403 of file main.h.

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

Definition at line 411 of file main.h.

bool Eigen::test_isApprox ( const half a,
const half b 
)
inline

Definition at line 426 of file main.h.

template<typename Type1 , typename Type2 >
bool Eigen::test_isApprox ( const Type1 &  a,
const Type2 &  b,
typename Type1::Scalar = 0 
)
inline

Definition at line 515 of file main.h.

bool Eigen::test_isApproxOrLessThan ( const int a,
const int b 
)
inline

Definition at line 374 of file main.h.

bool Eigen::test_isApproxOrLessThan ( const float &  a,
const float &  b 
)
inline

Definition at line 381 of file main.h.

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

Definition at line 388 of file main.h.

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

Definition at line 422 of file main.h.

bool Eigen::test_isApproxOrLessThan ( const half a,
const half b 
)
inline

Definition at line 430 of file main.h.

template<typename Scalar , typename ScalarRef >
bool Eigen::test_isApproxWithRef ( const Scalar a,
const Scalar b,
const ScalarRef &  ref 
)
inline

Definition at line 553 of file main.h.

bool Eigen::test_isMuchSmallerThan ( const int a,
const int b 
)
inline

Definition at line 372 of file main.h.

bool Eigen::test_isMuchSmallerThan ( const float &  a,
const float &  b 
)
inline

Definition at line 379 of file main.h.

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

Definition at line 386 of file main.h.

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

Definition at line 394 of file main.h.

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

Definition at line 399 of file main.h.

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

Definition at line 405 of file main.h.

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

Definition at line 420 of file main.h.

bool Eigen::test_isMuchSmallerThan ( const half a,
const half b 
)
inline

Definition at line 428 of file main.h.

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

Definition at line 559 of file main.h.

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

Definition at line 566 of file main.h.

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

Definition at line 573 of file main.h.

template<typename T >
NumTraits<T>::Real Eigen::test_precision ( )
inline

Definition at line 351 of file main.h.

template<>
double Eigen::test_precision< double > ( )
inline

Definition at line 353 of file main.h.

template<>
float Eigen::test_precision< float > ( )
inline

Definition at line 352 of file main.h.

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

Definition at line 354 of file main.h.

template<>
Real Eigen::test_precision< Real > ( )

Definition at line 83 of file boostmultiprec.cpp.

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

Definition at line 356 of file main.h.

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

Definition at line 355 of file main.h.

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

Definition at line 357 of file main.h.

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

Definition at line 16 of file alignedvector3.cpp.

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

Definition at line 435 of file main.h.

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

Definition at line 445 of file main.h.

template<typename T1 , typename T2 >
T1::Scalar Eigen::test_relative_error ( const T1 a,
const T2 b,
const typename T1::MatrixType = 0 
)

Definition at line 451 of file main.h.

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

Definition at line 457 of file main.h.

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

Definition at line 463 of file main.h.

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

Definition at line 469 of file main.h.

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

Definition at line 476 of file main.h.

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

Definition at line 483 of file main.h.

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

Definition at line 490 of file main.h.

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

Definition at line 496 of file main.h.

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

Definition at line 503 of file main.h.

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

Definition at line 509 of file main.h.

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

Definition at line 20 of file UmfPackSupport.h.

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

Definition at line 23 of file UmfPackSupport.h.

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

Definition at line 44 of file UmfPackSupport.h.

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

Definition at line 47 of file UmfPackSupport.h.

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

Definition at line 50 of file UmfPackSupport.h.

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

Definition at line 53 of file UmfPackSupport.h.

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

Definition at line 124 of file UmfPackSupport.h.

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

Definition at line 129 of file UmfPackSupport.h.

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

Definition at line 98 of file UmfPackSupport.h.

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

Definition at line 103 of file UmfPackSupport.h.

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

Definition at line 108 of file UmfPackSupport.h.

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

Definition at line 114 of file UmfPackSupport.h.

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

Definition at line 70 of file UmfPackSupport.h.

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

Definition at line 77 of file UmfPackSupport.h.

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

Definition at line 38 of file UmfPackSupport.h.

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

Definition at line 41 of file UmfPackSupport.h.

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

Definition at line 26 of file UmfPackSupport.h.

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

Definition at line 29 of file UmfPackSupport.h.

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

Definition at line 32 of file UmfPackSupport.h.

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

Definition at line 35 of file UmfPackSupport.h.

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

Definition at line 84 of file UmfPackSupport.h.

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

Definition at line 91 of file UmfPackSupport.h.

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

Definition at line 56 of file UmfPackSupport.h.

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

Definition at line 63 of file UmfPackSupport.h.

template<typename Type1 , typename Type2 >
bool Eigen::verifyIsApprox ( const Type1 &  a,
const Type2 &  b 
)
inline

Definition at line 535 of file main.h.

template<typename _Scalar , int _Options, typename _StorageIndex >
cholmod_sparse Eigen::viewAsCholmod ( Ref< SparseMatrix< _Scalar, _Options, _StorageIndex > >  mat)

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

Definition at line 58 of file CholmodSupport.h.

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

Definition at line 105 of file CholmodSupport.h.

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

Definition at line 112 of file CholmodSupport.h.

template<typename _Scalar , int _Options, typename _Index , unsigned int UpLo>
cholmod_sparse Eigen::viewAsCholmod ( const SparseSelfAdjointView< const SparseMatrix< _Scalar, _Options, _Index >, UpLo > &  mat)

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

Definition at line 121 of file CholmodSupport.h.

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

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

Definition at line 134 of file CholmodSupport.h.

template<typename Scalar , int Flags, typename StorageIndex >
MappedSparseMatrix<Scalar,Flags,StorageIndex> Eigen::viewAsEigen ( cholmod_sparse &  cm)

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

Definition at line 155 of file CholmodSupport.h.

template<typename DerivedX , typename DerivedQ >
const Eigen::CwiseBinaryOp<Eigen::internal::scalar_zeta_op<typename DerivedX::Scalar>, const DerivedX, const DerivedQ> Eigen::zeta ( const Eigen::ArrayBase< DerivedX > &  x,
const Eigen::ArrayBase< DerivedQ > &  q 
)
inline
Returns
an expression of the coefficient-wise zeta(x, q) to the given arrays.

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

Parameters
xis the exposent, it must be > 1
qis the shift, it must be > 0
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of zeta(T,T) for any scalar type T to be supported.
See also
ArrayBase::zeta()

Definition at line 114 of file SpecialFunctionsArrayAPI.h.

Variable Documentation

const unsigned int Eigen::ActualPacketAccessBit = 0x0

Definition at line 102 of file Constants.h.

const int Eigen::CoherentAccessPattern = 0x1

Definition at line 47 of file SparseUtil.h.

const int Eigen::Dynamic = -1

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

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

Definition at line 21 of file Constants.h.

const int Eigen::DynamicIndex = 0xffffff

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

Definition at line 26 of file Constants.h.

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

Definition at line 603 of file AutoDiffScalar.h.

bool Eigen::g_has_set_repeat
static

Definition at line 146 of file main.h.

bool Eigen::g_has_set_seed
static

Definition at line 146 of file main.h.

int Eigen::g_repeat
static

Definition at line 144 of file main.h.

unsigned int Eigen::g_seed
static

Definition at line 145 of file main.h.

int Eigen::g_test_level = 0
static

Definition at line 143 of file main.h.

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

Definition at line 140 of file main.h.

const unsigned int Eigen::HereditaryBits
Initial value:
const unsigned int RowMajorBit
Definition: Constants.h:61
const unsigned int EvalBeforeNestingBit
Definition: Constants.h:65

Definition at line 190 of file Constants.h.

const int Eigen::HugeCost = 10000

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

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

Definition at line 39 of file Constants.h.

const int Eigen::Infinity = -1

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

Definition at line 31 of file Constants.h.

const int Eigen::InnerRandomAccessPattern = 0x2 | CoherentAccessPattern

Definition at line 48 of file SparseUtil.h.

const unsigned int Eigen::NestByRefBit = 0x100

Definition at line 164 of file Constants.h.

bool Eigen::no_more_assert = false
static

Definition at line 170 of file main.h.

const int Eigen::OuterRandomAccessPattern = 0x4 | CoherentAccessPattern

Definition at line 49 of file SparseUtil.h.

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

Definition at line 50 of file SparseUtil.h.

bool Eigen::report_on_cerr_on_assert_failure = true
static

Definition at line 171 of file main.h.

const bool Eigen::should_raise_an_assert = false
static

Definition at line 165 of file main.h.

const unsigned int Eigen::SkylineBit = 0x1200

Definition at line 21 of file SkylineUtil.h.

const AutoDiffScalar< DerType > & Eigen::y
Initial value:
{
A scalar type replacement with automatic differentation capability.

Definition at line 549 of file AutoDiffScalar.h.



gtsam
Author(s):
autogenerated on Sat May 8 2021 02:51:59