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

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

Namespaces

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

Classes

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

Typedefs

typedef Transform< double, 2, 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 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 Spline< double, 2 > Spline2d
 2D double B-spline with dynamic degree. More...
 
typedef Spline< float, 2 > Spline2f
 2D float B-spline with dynamic degree. More...
 
typedef Spline< double, 3 > Spline3d
 3D double B-spline with dynamic degree. More...
 
typedef Spline< float, 3 > Spline3f
 3D float B-spline with dynamic degree. More...
 
typedef ThreadPoolTempl< StlThreadEnvironmentThreadPool
 
typedef Translation< double, 2 > Translation2d
 
typedef Translation< float, 2 > Translation2f
 
typedef Translation< double, 3 > Translation3d
 
typedef Translation< float, 3 > Translation3f
 

Enumerations

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

Functions

template<typename DstXprType , typename SrcXprType >
void add_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename DerTypeA , typename DerTypeB >
const AutoDiffScalar< Matrix< typename internal::traits< typename internal::remove_all< DerTypeA >::type >::Scalar, Dynamic, 1 > > atan2 (const AutoDiffScalar< DerTypeA > &a, const AutoDiffScalar< DerTypeB > &b)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0_op< typename Derived::Scalar >, const Derived > bessel_i0 (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0e_op< typename Derived::Scalar >, const Derived > bessel_i0e (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1_op< typename Derived::Scalar >, const Derived > bessel_i1 (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1e_op< typename Derived::Scalar >, const Derived > bessel_i1e (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j0_op< typename Derived::Scalar >, const Derived > bessel_j0 (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j1_op< typename Derived::Scalar >, const Derived > bessel_j1 (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0_op< typename Derived::Scalar >, const Derived > bessel_k0 (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0e_op< typename Derived::Scalar >, const Derived > bessel_k0e (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1_op< typename Derived::Scalar >, const Derived > bessel_k1 (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1e_op< typename Derived::Scalar >, const Derived > bessel_k1e (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y0_op< typename Derived::Scalar >, const Derived > bessel_y0 (const Eigen::ArrayBase< Derived > &x)
 
template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y1_op< typename Derived::Scalar >, const Derived > bessel_y1 (const Eigen::ArrayBase< Derived > &x)
 
template<typename ADerived , typename BDerived , typename XDerived >
EIGEN_DEVICE_FUNC const EIGEN_STRONG_INLINE 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_STRONG_INLINE 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)
 
template<typename Scalar , int Dim>
AlignedBox< Scalar, Dim > bounding_box (const Matrix< Scalar, Dim, 1 > &v)
 
Box2d bounding_box (const Vector2d &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 const EIGEN_ALWAYS_INLINE T2choose (Cond< false >, const T1 &, const T2 &second)
 
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC const EIGEN_ALWAYS_INLINE T1choose (Cond< true >, const T1 &first, const T2 &)
 
template<typename PointArrayType , typename KnotVectorType >
void ChordLengths (const PointArrayType &pts, KnotVectorType &chord_lengths)
 Computes chord length parameters which are required for spline interpolation. More...
 
template<typename DerType >
const AutoDiffScalar< DerType > & conj (const AutoDiffScalar< DerType > &x)
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TconstCast (const T *data)
 
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType & copy_using_evaluator (const EigenBase< DstXprType > &dst, const SrcXprType &src)
 
template<typename DstXprType , template< typename > class StorageBase, typename SrcXprType >
const EIGEN_STRONG_INLINE DstXprType & copy_using_evaluator (const NoAlias< DstXprType, StorageBase > &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType & copy_using_evaluator (const PlainObjectBase< DstXprType > &dst, const SrcXprType &src)
 
template<typename MatrixType >
void createRandomPIMatrixOfRank (Index desired_rank, Index rows, Index cols, MatrixType &m)
 
template<typename SplineType , typename DerivativeType >
void derivativesImpl (const SplineType &spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType &der)
 
template<typename Dims1 , typename Dims2 >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool dimensions_match (Dims1 dims1, Dims2 dims2)
 
template<typename DstXprType , typename SrcXprType >
void divide_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T divup (const T x, const T y)
 
template<typename T , typename X , typename Y >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T divup (const X x, const Y 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 (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 (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 (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 (sinh, using std::sinh;using std::cosh;return Eigen::MakeAutoDiffScalar(sinh(x.value()), x.derivatives() *cosh(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cosh
 
 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 (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
 
template<int N>
internal::FixedInt< Nfix ()
 
template<int N, typename T >
internal::VariableAndFixedInt< Nfix (T val)
 
template<typename AlphaDerived , typename SampleDerived >
const EIGEN_STRONG_INLINE Eigen::CwiseBinaryOp< Eigen::internal::scalar_gamma_sample_der_alpha_op< typename AlphaDerived::Scalar >, const AlphaDerived, const SampleDerived > gamma_sample_der_alpha (const Eigen::ArrayBase< AlphaDerived > &alpha, const Eigen::ArrayBase< SampleDerived > &sample)
 
template<typename T >
NumTraits< typename T::Scalar >::Real get_test_precision (const T &, const typename T::Scalar *=0)
 
template<typename T >
NumTraits< T >::Real get_test_precision (const T &, typename internal::enable_if< internal::is_arithmetic< typename NumTraits< T >::Real >::value, T >::type *=0)
 
bool getMarketHeader (const std::string &filename, int &sym, bool &iscomplex, bool &isvector)
 
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType > householderSequence (const VectorsType &v, const CoeffsType &h)
 Convenience function for constructing a Householder sequence. More...
 
template<typename Derived , typename ExponentDerived >
const EIGEN_STRONG_INLINE 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_STRONG_INLINE Eigen::CwiseBinaryOp< Eigen::internal::scalar_igamma_der_a_op< typename Derived::Scalar >, const Derived, const ExponentDerived > igamma_der_a (const Eigen::ArrayBase< Derived > &a, const Eigen::ArrayBase< ExponentDerived > &x)
 
template<typename Derived , typename ExponentDerived >
const EIGEN_STRONG_INLINE Eigen::CwiseBinaryOp< Eigen::internal::scalar_igammac_op< typename Derived::Scalar >, const Derived, const ExponentDerived > igammac (const Eigen::ArrayBase< Derived > &a, const Eigen::ArrayBase< ExponentDerived > &x)
 
template<typename DerType >
DerType::Scalar imag (const AutoDiffScalar< DerType > &)
 
void initParallel ()
 
template<typename T1 , typename T2 >
internal::enable_if< internal::is_same< T1, T2 >::value, bool >::type is_same_type (const T1 &, const T2 &)
 
template<typename T >
bool isMinusInf (const T &x)
 
template<typename T >
bool isNotNaN (const T &x)
 
template<typename T >
bool isPlusInf (const T &x)
 
klu_numeric * klu_factor (int Ap[], int Ai[], double Ax[], klu_symbolic *Symbolic, klu_common *Common, double)
 
klu_numeric * klu_factor (int Ap[], int Ai[], std::complex< double > Ax[], klu_symbolic *Symbolic, klu_common *Common, std::complex< double >)
 
int klu_solve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B[], klu_common *Common, double)
 A sparse LU factorization and solver based on KLU. More...
 
int klu_solve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex< double >B[], klu_common *Common, std::complex< double >)
 
int klu_tsolve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B[], klu_common *Common, double)
 
int klu_tsolve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex< double >B[], klu_common *Common, std::complex< double >)
 
template<typename KnotVectorType >
void KnotAveraging (const KnotVectorType &parameters, DenseIndex degree, KnotVectorType &knots)
 Computes knot averages. 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 >
KroneckerProductSparse< A, BkroneckerProduct (const EigenBase< A > &a, const EigenBase< B > &b)
 
template<typename A , typename B >
KroneckerProduct< A, BkroneckerProduct (const MatrixBase< A > &a, const MatrixBase< B > &b)
 
std::ptrdiff_t l1CacheSize ()
 
std::ptrdiff_t l2CacheSize ()
 
std::ptrdiff_t l3CacheSize ()
 
static const symbolic::AddExpr< symbolic::SymbolExpr< internal::symbolic_last_tag >, symbolic::ValueExpr< Eigen::internal::FixedInt< 1 > > > lastp1 (last+fix< 1 >())
 
template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs, 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 DerType >
CleanedUpDerType< DerType >::type() max (const AutoDiffScalar< DerType > &x, const AutoDiffScalar< DerType > &y)
 
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type() max (const AutoDiffScalar< DerType > &x, const T &y)
 
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type() max (const T &x, const AutoDiffScalar< DerType > &y)
 
template<typename DerType >
CleanedUpDerType< DerType >::type() min (const AutoDiffScalar< DerType > &x, const AutoDiffScalar< DerType > &y)
 
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type() min (const AutoDiffScalar< DerType > &x, const T &y)
 
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type() min (const T &x, const AutoDiffScalar< DerType > &y)
 
template<typename 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 PermutationType >
const Product< Inverse< PermutationType >, SparseDerived, AliasFreeProductoperator* (const InverseImpl< PermutationType, PermutationStorage > &tperm, const SparseMatrixBase< SparseDerived > &matrix)
 
template<typename MatrixDerived , typename PermutationDerived >
const EIGEN_DEVICE_FUNC Product< MatrixDerived, PermutationDerived, AliasFreeProductoperator* (const MatrixBase< MatrixDerived > &matrix, const PermutationBase< PermutationDerived > &permutation)
 
template<typename MatrixDerived , typename TranspositionsDerived >
const EIGEN_DEVICE_FUNC Product< MatrixDerived, TranspositionsDerived, AliasFreeProductoperator* (const MatrixBase< MatrixDerived > &matrix, const TranspositionsBase< TranspositionsDerived > &transpositions)
 
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 SparseDerived , typename PermDerived >
const Product< PermDerived, SparseDerived, AliasFreeProductoperator* (const PermutationBase< PermDerived > &perm, const SparseMatrixBase< SparseDerived > &matrix)
 
template<typename PermutationDerived , typename MatrixDerived >
const EIGEN_DEVICE_FUNC Product< PermutationDerived, MatrixDerived, AliasFreeProductoperator* (const PermutationBase< PermutationDerived > &permutation, const MatrixBase< MatrixDerived > &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 PermDerived >
const Product< SparseDerived, PermDerived, AliasFreeProductoperator* (const SparseMatrixBase< SparseDerived > &matrix, const PermutationBase< PermDerived > &perm)
 
template<typename TranspositionsDerived , typename MatrixDerived >
const EIGEN_DEVICE_FUNC Product< TranspositionsDerived, MatrixDerived, AliasFreeProductoperator* (const TranspositionsBase< TranspositionsDerived > &transpositions, const MatrixBase< MatrixDerived > &matrix)
 
template<typename DenseDerived , typename SparseDerived >
const EIGEN_STRONG_INLINE 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 >
const EIGEN_STRONG_INLINE 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 >
const EIGEN_STRONG_INLINE 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 >
const EIGEN_STRONG_INLINE 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 IndexType , int NumDims>
std::ostream & operator<< (std::ostream &os, const DSizes< IndexType, NumDims > &dims)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const TensorBase< T, ReadOnlyAccessors > &expr)
 
template<class T , std::size_t N>
EIGEN_DEVICE_FUNC bool operator== (const array< T, N > &lhs, const array< T, N > &rhs)
 
template<typename U , typename V >
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator== (const Tuple< U, V > &x, const Tuple< U, V > &y)
 
template<typename Polynomials , typename T >
T poly_eval (const Polynomials &poly, const T &x)
 
template<typename Polynomials , typename T >
T poly_eval_horner (const Polynomials &poly, const T &x)
 
template<typename DerivedN , typename DerivedX >
const EIGEN_STRONG_INLINE Eigen::CwiseBinaryOp< Eigen::internal::scalar_polygamma_op< typename DerivedX::Scalar >, const DerivedN, const DerivedX > polygamma (const Eigen::ArrayBase< DerivedN > &n, const Eigen::ArrayBase< DerivedX > &x)
 
template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs > prod (const Lhs &lhs, const Rhs &rhs)
 
template<typename PermutationVectorType >
void randomPermutationVector (PermutationVectorType &v, Index size)
 
template<typename DerType >
const AutoDiffScalar< DerType > & real (const AutoDiffScalar< DerType > &x)
 
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType, 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)
 
template<typename Derived >
const DiagonalWrapper< const Derived > Scaling (const MatrixBase< Derived > &coeffs)
 
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 RealScalar >
UniformScaling< std::complex< RealScalar > > Scaling (const std::complex< RealScalar > &s)
 
UniformScaling< double > Scaling (double s)
 
UniformScaling< float > Scaling (float s)
 
template<typename FirstTypeDerived , typename LastTypeDerived >
ArithmeticSequence< FirstTypeDerived, symbolic::AddExpr< symbolic::AddExpr< LastTypeDerived, symbolic::NegateExpr< FirstTypeDerived > >, symbolic::ValueExpr< internal::FixedInt< 1 > > > > seq (const symbolic::BaseExpr< FirstTypeDerived > &f, const symbolic::BaseExpr< LastTypeDerived > &l)
 
template<typename FirstTypeDerived , typename LastTypeDerived , typename IncrType >
ArithmeticSequence< FirstTypeDerived, symbolic::QuotientExpr< symbolic::AddExpr< symbolic::AddExpr< LastTypeDerived, symbolic::NegateExpr< FirstTypeDerived > >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, typename internal::cleanup_seq_incr< IncrType >::typeseq (const symbolic::BaseExpr< FirstTypeDerived > &f, const symbolic::BaseExpr< LastTypeDerived > &l, IncrType incr)
 
template<typename FirstTypeDerived , typename LastType >
internal::enable_if<!symbolic::is_symbolic< LastType >::value, ArithmeticSequence< FirstTypeDerived, symbolic::AddExpr< symbolic::AddExpr< symbolic::NegateExpr< FirstTypeDerived >, symbolic::ValueExpr<> >, symbolic::ValueExpr< internal::FixedInt< 1 > > > > >::type seq (const symbolic::BaseExpr< FirstTypeDerived > &f, LastType l)
 
template<typename FirstTypeDerived , typename LastType , typename IncrType >
internal::enable_if<!symbolic::is_symbolic< LastType >::value, ArithmeticSequence< FirstTypeDerived, symbolic::QuotientExpr< symbolic::AddExpr< symbolic::AddExpr< symbolic::NegateExpr< FirstTypeDerived >, symbolic::ValueExpr<> >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, typename internal::cleanup_seq_incr< IncrType >::type > >::type seq (const symbolic::BaseExpr< FirstTypeDerived > &f, LastType l, IncrType incr)
 
template<typename FirstType , typename LastTypeDerived >
internal::enable_if<!symbolic::is_symbolic< FirstType >::value, ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, symbolic::AddExpr< symbolic::AddExpr< LastTypeDerived, symbolic::ValueExpr<> >, symbolic::ValueExpr< internal::FixedInt< 1 > > > > >::type seq (FirstType f, const symbolic::BaseExpr< LastTypeDerived > &l)
 
template<typename FirstType , typename LastTypeDerived , typename IncrType >
internal::enable_if<!symbolic::is_symbolic< FirstType >::value, ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, symbolic::QuotientExpr< symbolic::AddExpr< symbolic::AddExpr< LastTypeDerived, symbolic::ValueExpr<> >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, symbolic::ValueExpr< typename internal::cleanup_seq_incr< IncrType >::type > >, typename internal::cleanup_seq_incr< IncrType >::type > >::type seq (FirstType f, const symbolic::BaseExpr< LastTypeDerived > &l, IncrType incr)
 
template<typename FirstType , typename LastType >
internal::enable_if<!(symbolic::is_symbolic< FirstType >::value||symbolic::is_symbolic< LastType >::value), ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, Index > >::type seq (FirstType f, LastType l)
 
template<typename FirstType , typename LastType , typename IncrType >
internal::enable_if<!(symbolic::is_symbolic< FirstType >::value||symbolic::is_symbolic< LastType >::value), ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, Index, typename internal::cleanup_seq_incr< IncrType >::type > >::type seq (FirstType f, LastType l, IncrType incr)
 
template<typename FirstType , typename SizeType >
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::typeseqN (FirstType first, SizeType size)
 
template<typename FirstType , typename SizeType , typename IncrType >
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type, typename internal::cleanup_seq_incr< IncrType >::typeseqN (FirstType first, SizeType size, IncrType incr)
 
void setCpuCacheSizes (std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
 
void setNbThreads (int v)
 
static const char * SimdInstructionSetsInUse (void)
 
void ssaupd_ (int *ido, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *info)
 
void sseupd_ (int *rvec, char *All, int *select, float *d, float *z, int *ldz, float *sigma, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *ierr)
 
template<typename DstXprType , typename SrcXprType >
void subtract_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
void swap_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename T , typename U >
bool test_is_equal (const T &actual, const U &expected, bool expect_equal=true)
 
bool test_isApprox (const long double &a, const long double &b)
 
bool test_isApprox (const std::complex< double > &a, const std::complex< double > &b)
 
bool test_isApprox (const std::complex< float > &a, const std::complex< float > &b)
 
bool test_isApprox (const std::complex< long double > &a, const std::complex< long double > &b)
 
template<typename Type1 , typename Type2 >
bool test_isApprox (const Type1 &a, const Type2 &b, typename Type1::Scalar *=0)
 
bool test_isApproxOrLessThan (const long double &a, const long double &b)
 
template<typename Scalar , typename ScalarRef >
bool test_isApproxWithRef (const Scalar &a, const Scalar &b, const ScalarRef &ref)
 
bool test_isMuchSmallerThan (const long double &a, const long double &b)
 
template<typename Derived >
bool test_isMuchSmallerThan (const MatrixBase< Derived > &m, const typename NumTraits< typename internal::traits< Derived >::Scalar >::Real &s)
 
template<typename Derived1 , typename Derived2 >
bool test_isMuchSmallerThan (const MatrixBase< Derived1 > &m1, const MatrixBase< Derived2 > &m2)
 
bool test_isMuchSmallerThan (const std::complex< double > &a, const std::complex< double > &b)
 
bool test_isMuchSmallerThan (const std::complex< float > &a, const std::complex< float > &b)
 
bool test_isMuchSmallerThan (const std::complex< long double > &a, const std::complex< long double > &b)
 
template<typename Derived >
bool test_isUnitary (const MatrixBase< Derived > &m)
 
template<typename T >
NumTraits< T >::Real test_precision ()
 
template<>
AnnoyingScalar test_precision< AnnoyingScalar > ()
 
template<>
double test_precision< double > ()
 
template<>
float test_precision< float > ()
 
template<>
long double test_precision< long double > ()
 
template<>
Real test_precision< Real > ()
 
template<>
double test_precision< std::complex< double > > ()
 
template<>
float test_precision< std::complex< float > > ()
 
template<>
long double test_precision< std::complex< long double > > ()
 
template<typename S , int D>
S test_relative_error (const AlignedBox< S, D > &a, const AlignedBox< S, D > &b)
 
template<typename T , typename Derived >
T test_relative_error (const AlignedVector3< T > &a, const MatrixBase< Derived > &b)
 
template<typename T >
T test_relative_error (const AngleAxis< T > &a, const AngleAxis< T > &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 MatrixBase< T1 > &a, const SparseMatrixBase< T2 > &b)
 
template<typename S , int D, int O>
S test_relative_error (const ParametrizedLine< S, D, O > &a, const ParametrizedLine< S, D, O > &b)
 
template<typename T >
T test_relative_error (const Rotation2D< T > &a, const Rotation2D< T > &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 >
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 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 S , int D>
S test_relative_error (const Translation< S, D > &a, const Translation< S, D > &b)
 
template<typename Derived , typename OtherDerived >
internal::umeyama_transform_matrix_type< Derived, OtherDerived >::type umeyama (const MatrixBase< Derived > &src, const MatrixBase< OtherDerived > &dst, bool with_scaling=true)
 Returns the transformation between two point sets. More...
 
void umfpack_defaults (double control[UMFPACK_CONTROL], double, int)
 
void umfpack_defaults (double control[UMFPACK_CONTROL], double, SuiteSparse_long)
 
void umfpack_defaults (double control[UMFPACK_CONTROL], std::complex< double >, int)
 
void umfpack_defaults (double control[UMFPACK_CONTROL], std::complex< double >, SuiteSparse_long)
 
void umfpack_free_numeric (void **Numeric, double, int)
 
void umfpack_free_numeric (void **Numeric, double, SuiteSparse_long)
 
void umfpack_free_numeric (void **Numeric, std::complex< double >, int)
 
void umfpack_free_numeric (void **Numeric, std::complex< double >, SuiteSparse_long)
 
void umfpack_free_symbolic (void **Symbolic, double, int)
 
void umfpack_free_symbolic (void **Symbolic, double, SuiteSparse_long)
 
void umfpack_free_symbolic (void **Symbolic, std::complex< double >, int)
 
void umfpack_free_symbolic (void **Symbolic, std::complex< double >, SuiteSparse_long)
 
int umfpack_get_determinant (double *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO], int)
 
SuiteSparse_long umfpack_get_determinant (double *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO], SuiteSparse_long)
 
int umfpack_get_determinant (std::complex< double > *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO], int)
 
SuiteSparse_long umfpack_get_determinant (std::complex< double > *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO], SuiteSparse_long)
 
int umfpack_get_lunz (int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, double)
 
int umfpack_get_lunz (int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, std::complex< double >)
 
SuiteSparse_long umfpack_get_lunz (SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col, SuiteSparse_long *nz_udiag, void *Numeric, double)
 
SuiteSparse_long umfpack_get_lunz (SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col, SuiteSparse_long *nz_udiag, void *Numeric, std::complex< double >)
 
int umfpack_get_numeric (int Lp[], int Lj[], double Lx[], int Up[], int Ui[], double Ux[], int P[], int Q[], double Dx[], int *do_recip, double Rs[], void *Numeric)
 
int umfpack_get_numeric (int Lp[], int Lj[], std::complex< double > Lx[], int Up[], int Ui[], std::complex< double > Ux[], int P[], int Q[], std::complex< double > Dx[], int *do_recip, double Rs[], void *Numeric)
 
SuiteSparse_long umfpack_get_numeric (SuiteSparse_long Lp[], SuiteSparse_long Lj[], double Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], double Ux[], SuiteSparse_long P[], SuiteSparse_long Q[], double Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
 
SuiteSparse_long umfpack_get_numeric (SuiteSparse_long Lp[], SuiteSparse_long Lj[], std::complex< double > Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], std::complex< double > Ux[], SuiteSparse_long P[], SuiteSparse_long Q[], std::complex< double > Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
 
int umfpack_numeric (const int Ap[], const int Ai[], const double Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
int umfpack_numeric (const int Ap[], const int Ai[], const std::complex< double > Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
SuiteSparse_long umfpack_numeric (const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
SuiteSparse_long umfpack_numeric (const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex< double > Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
void umfpack_report_control (double control[UMFPACK_CONTROL], double, int)
 
void umfpack_report_control (double control[UMFPACK_CONTROL], double, SuiteSparse_long)
 
void umfpack_report_control (double control[UMFPACK_CONTROL], std::complex< double >, int)
 
void umfpack_report_control (double control[UMFPACK_CONTROL], std::complex< double >, SuiteSparse_long)
 
void umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, int)
 
void umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, SuiteSparse_long)
 
void umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex< double >, int)
 
void umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex< double >, SuiteSparse_long)
 
void umfpack_report_status (double control[UMFPACK_CONTROL], int status, double, int)
 
void umfpack_report_status (double control[UMFPACK_CONTROL], int status, double, SuiteSparse_long)
 
void umfpack_report_status (double control[UMFPACK_CONTROL], int status, std::complex< double >, int)
 
void umfpack_report_status (double control[UMFPACK_CONTROL], int status, std::complex< double >, SuiteSparse_long)
 
int umfpack_solve (int sys, const int Ap[], const int Ai[], const double Ax[], double X[], const double B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
int umfpack_solve (int sys, const int Ap[], const int Ai[], const std::complex< double > Ax[], std::complex< double > X[], const std::complex< double > B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
SuiteSparse_long umfpack_solve (int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], double X[], const double B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
SuiteSparse_long umfpack_solve (int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex< double > Ax[], std::complex< double > X[], const std::complex< double > B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
int umfpack_symbolic (int n_row, int n_col, const int Ap[], const int Ai[], const double Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
int umfpack_symbolic (int n_row, int n_col, const int Ap[], const int Ai[], const std::complex< double > Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
SuiteSparse_long umfpack_symbolic (SuiteSparse_long n_row, SuiteSparse_long n_col, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
SuiteSparse_long umfpack_symbolic (SuiteSparse_long n_row, SuiteSparse_long n_col, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex< double > Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
 
template<typename Type1 , typename Type2 >
bool verifyIsApprox (const Type1 &a, const Type2 &b)
 
template<typename _Scalar , int _Options, typename _Index >
const cholmod_sparse viewAsCholmod (const SparseMatrix< _Scalar, _Options, _Index > &mat)
 
template<typename _Scalar , int _Options, typename _Index , unsigned int UpLo>
cholmod_sparse viewAsCholmod (const SparseSelfAdjointView< const SparseMatrix< _Scalar, _Options, _Index >, UpLo > &mat)
 
template<typename _Scalar , int _Options, typename _Index >
const cholmod_sparse viewAsCholmod (const SparseVector< _Scalar, _Options, _Index > &mat)
 
template<typename Derived >
cholmod_dense viewAsCholmod (MatrixBase< Derived > &mat)
 
template<typename _Scalar , int _Options, typename _StorageIndex >
cholmod_sparse viewAsCholmod (Ref< SparseMatrix< _Scalar, _Options, _StorageIndex > > mat)
 
template<typename Scalar , int Flags, typename StorageIndex >
MappedSparseMatrix< Scalar, Flags, StorageIndex > viewAsEigen (cholmod_sparse &cm)
 
template<typename DerivedX , typename DerivedQ >
const EIGEN_STRONG_INLINE 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
 
const EIGEN_DEPRECATED unsigned int AlignedBit = 0x80
 
static const Eigen::internal::all_t all
 
const int AutoOrder = 2
 
const int CoherentAccessPattern = 0x1
 
const unsigned int CompressedAccessBit = 0x400
 
const unsigned int DirectAccessBit = 0x40
 
const int Dynamic = -1
 
const int DynamicIndex = 0xffffff
 
const EIGEN_DEPRECATED unsigned int EvalBeforeAssigningBit = 0x4
 
const unsigned int EvalBeforeNestingBit = 0x2
 
EIGEN_DEVICE_FUNC const Eigen::ArrayBase< Derived > & exponents
 
Scalar expx = exp(x.value())
 
static bool g_has_set_repeat = false
 
static bool g_has_set_seed = false
 
static int g_repeat = 1
 
static unsigned int g_seed = 0
 
static int g_test_level = 0
 
static std::vector< std::string > g_test_stack
 
const unsigned int HereditaryBits
 
const int HugeCost = 10000
 
const int Infinity = -1
 
const int InnerRandomAccessPattern = 0x2 | CoherentAccessPattern
 
static const symbolic::SymbolExpr< internal::symbolic_last_taglast
 
const unsigned int LinearAccessBit = 0x10
 
const unsigned int LvalueBit = 0x20
 
const unsigned int NestByRefBit = 0x100
 
static bool no_more_assert = false
 
const unsigned int NoPreferredStorageOrderBit = 0x200
 
const int OuterRandomAccessPattern = 0x4 | CoherentAccessPattern
 
const unsigned int PacketAccessBit = 0x8
 
const int RandomAccessPattern = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern
 
static bool report_on_cerr_on_assert_failure = true
 
const unsigned int RowMajorBit = 0x1
 
static const bool should_raise_an_assert = false
 
const unsigned int SkylineBit = 0x1200
 
const int UndefinedIncr = 0xfffffe
 

Detailed Description

Namespace containing all symbols from the Eigen library.

Typedef Documentation

◆ AlignedScaling2d

Deprecated:

Definition at line 166 of file Eigen/src/Geometry/Scaling.h.

◆ AlignedScaling2f

Deprecated:

Definition at line 164 of file Eigen/src/Geometry/Scaling.h.

◆ AlignedScaling3d

Deprecated:

Definition at line 170 of file Eigen/src/Geometry/Scaling.h.

◆ AlignedScaling3f

Deprecated:

Definition at line 168 of file Eigen/src/Geometry/Scaling.h.

◆ BlasIndex

Definition at line 131 of file MKL_support.h.

◆ dcomplex

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

Definition at line 125 of file MKL_support.h.

◆ DenseIndex

Definition at line 66 of file Meta.h.

◆ Index

The Index type as used for the API.

To change this, #define the preprocessor symbol EIGEN_DEFAULT_DENSE_INDEX_TYPE.

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

Definition at line 74 of file Meta.h.

◆ scomplex

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

Definition at line 126 of file MKL_support.h.

◆ Spline2d

typedef Spline<double,2> Eigen::Spline2d

2D double B-spline with dynamic degree.

Definition at line 87 of file SplineFwd.h.

◆ Spline2f

typedef Spline<float,2> Eigen::Spline2f

2D float B-spline with dynamic degree.

Definition at line 81 of file SplineFwd.h.

◆ Spline3d

typedef Spline<double,3> Eigen::Spline3d

3D double B-spline with dynamic degree.

Definition at line 90 of file SplineFwd.h.

◆ Spline3f

typedef Spline<float,3> Eigen::Spline3f

3D float B-spline with dynamic degree.

Definition at line 84 of file SplineFwd.h.

◆ ThreadPool

Definition at line 482 of file NonBlockingThreadPool.h.

◆ Translation2d

typedef Translation<double,2> Eigen::Translation2d

Definition at line 169 of file Translation.h.

◆ Translation2f

typedef Translation<float, 2> Eigen::Translation2f

Definition at line 168 of file Translation.h.

◆ Translation3d

typedef Translation<double,3> Eigen::Translation3d

Definition at line 171 of file Translation.h.

◆ Translation3f

typedef Translation<float, 3> Eigen::Translation3f

Definition at line 170 of file Translation.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
CPU_TIMER 
REAL_TIMER 

Definition at line 47 of file BenchTimer.h.

◆ anonymous enum

anonymous enum
Enumerator
NegationFlag 
ConjugationFlag 

Definition at line 15 of file Symmetry.h.

◆ anonymous enum

anonymous enum
Enumerator
GlobalRealFlag 
GlobalImagFlag 
GlobalZeroFlag 

Definition at line 20 of file Symmetry.h.

◆ anonymous enum

anonymous enum
Enumerator
IsSkyline 

Definition at line 24 of file SkylineUtil.h.

◆ anonymous enum

anonymous enum
Enumerator
SPD 
NonSymmetric 

Definition at line 16 of file MatrixMarketIterator.h.

◆ anonymous enum

anonymous enum
Enumerator
Large 
Small 

Definition at line 16 of file GeneralProduct.h.

◆ anonymous enum

anonymous enum
Enumerator
DontAlignCols 

Definition at line 16 of file IO.h.

◆ anonymous enum

anonymous enum
Enumerator
StreamPrecision 
FullPrecision 

Definition at line 17 of file IO.h.

◆ anonymous enum

anonymous enum
Enumerator
StandardCompressedFormat 

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

Definition at line 15 of file SparseRef.h.

◆ Action

Enumerator
GetAction 
SetAction 

Definition at line 504 of file Constants.h.

◆ AdditionalProductEvaluationMode

Enumerator
SkylineTimeDenseProduct 
SkylineTimeSkylineProduct 
DenseTimeSkylineProduct 

Definition at line 23 of file SkylineUtil.h.

◆ AmbiVectorMode

Enumerator
IsDense 
IsSparse 

Definition at line 366 of file Constants.h.

◆ AutoSize_t

Enumerator
AutoSize 

Definition at line 16 of file ReshapedHelper.h.

◆ CholmodMode

Enumerator
CholmodAuto 
CholmodSimplicialLLt 
CholmodSupernodalLLt 
CholmodLDLt 

Definition at line 203 of file CholmodSupport.h.

◆ convolution_type

Enumerator
CONV1D 
CONV2D 
CONV3D 

Definition at line 28 of file TensorConvolutionSycl.h.

◆ Default_t

Enumerator
Default 

Definition at line 362 of file Constants.h.

◆ EulerAxis

Representation of a fixed signed rotation axis for EulerSystem.

Values here represent:

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

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

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

Enumerator
EULER_X 

the X axis

EULER_Y 

the Y axis

EULER_Z 

the Z axis

Definition at line 61 of file EulerSystem.h.

◆ FFTDirection

Enumerator
FFT_FORWARD 
FFT_REVERSE 

Definition at line 138 of file TensorForwardDeclarations.h.

◆ FFTResultType

Enumerator
RealPart 
ImagPart 
BothParts 

Definition at line 132 of file TensorForwardDeclarations.h.

◆ NoChange_t

Enumerator
NoChange 

Definition at line 360 of file Constants.h.

◆ NumericalDiffMode

Enumerator
Forward 
Central 

Definition at line 18 of file NumericalDiff.h.

◆ PaddingType

Enumerator
PADDING_VALID 
PADDING_SAME 

Definition at line 257 of file TensorTraits.h.

◆ ProductImplType

Enumerator
DefaultProduct 
LazyProduct 
AliasFreeProduct 
CoeffBasedProductMode 
LazyCoeffBasedProductMode 
OuterProduct 
InnerProduct 
GemvProduct 
GemmProduct 

Definition at line 499 of file Constants.h.

◆ Sequential_t

Enumerator
Sequential 

Definition at line 361 of file Constants.h.

◆ SimplicialCholeskyMode

Enumerator
SimplicialCholeskyLLT 
SimplicialCholeskyLDLT 

Definition at line 15 of file SimplicialCholesky.h.

◆ SpecializedType

Enumerator
Specialized 
BuiltIn 

Definition at line 309 of file Constants.h.

◆ TraversalType

Enumerator
DefaultTraversal 
LinearTraversal 
InnerVectorizedTraversal 
LinearVectorizedTraversal 
SliceVectorizedTraversal 
InvalidTraversal 
AllAtOnceTraversal 

Definition at line 275 of file Constants.h.

◆ UnrollingType

Enumerator
NoUnrolling 
InnerUnrolling 
CompleteUnrolling 

Definition at line 297 of file Constants.h.

Function Documentation

◆ add_assign_using_evaluator()

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

Definition at line 53 of file evaluators.cpp.

◆ atan2()

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

Definition at line 654 of file AutoDiffScalar.h.

◆ bessel_i0()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i0 ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise i0(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i0(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_i0()

Definition at line 32 of file BesselFunctionsArrayAPI.h.

◆ bessel_i0e()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i0e ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise i0e(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i0e(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_i0e()

Definition at line 55 of file BesselFunctionsArrayAPI.h.

◆ bessel_i1()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i1 ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise i1(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i1(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_i1()

Definition at line 77 of file BesselFunctionsArrayAPI.h.

◆ bessel_i1e()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i1e ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise i1e(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i1e(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_i1e()

Definition at line 100 of file BesselFunctionsArrayAPI.h.

◆ bessel_j0()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_j0 ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise j0(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of j0(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_j0()

Definition at line 212 of file BesselFunctionsArrayAPI.h.

◆ bessel_j1()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_j1 ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise j1(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of j1(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_j1()

Definition at line 256 of file BesselFunctionsArrayAPI.h.

◆ bessel_k0()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k0 ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise k0(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k0(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_k0()

Definition at line 122 of file BesselFunctionsArrayAPI.h.

◆ bessel_k0e()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k0e ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise k0e(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k0e(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_k0e()

Definition at line 145 of file BesselFunctionsArrayAPI.h.

◆ bessel_k1()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k1 ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise k1(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k1(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_k1()

Definition at line 167 of file BesselFunctionsArrayAPI.h.

◆ bessel_k1e()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k1e ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise k1e(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k1e(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_k1e()

Definition at line 190 of file BesselFunctionsArrayAPI.h.

◆ bessel_y0()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_y0 ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise y0(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of y0(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_y0()

Definition at line 234 of file BesselFunctionsArrayAPI.h.

◆ bessel_y1()

template<typename Derived >
const EIGEN_STRONG_INLINE Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_y1 ( const Eigen::ArrayBase< Derived > &  x)
Returns
an expression of the coefficient-wise y1(x) to the given arrays.

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

Parameters
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of y1(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_y1()

Definition at line 278 of file BesselFunctionsArrayAPI.h.

◆ betainc() [1/2]

template<typename ADerived , typename BDerived , typename XDerived >
EIGEN_DEVICE_FUNC const EIGEN_STRONG_INLINE 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 
)

\cpp11

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

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

Definition at line 24 of file TensorGlobalFunctions.h.

◆ betainc() [2/2]

template<typename ArgADerived , typename ArgBDerived , typename ArgXDerived >
const EIGEN_STRONG_INLINE 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 
)

\cpp11

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

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

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

Definition at line 132 of file SpecialFunctionsArrayAPI.h.

◆ bounding_box() [1/2]

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.

◆ bounding_box() [2/2]

Box2d Eigen::bounding_box ( const Vector2d &  v)

Definition at line 9 of file BVH_Example.cpp.

◆ BVIntersect() [1/2]

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

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

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

Definition at line 79 of file BVAlgorithms.h.

◆ BVIntersect() [2/2]

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

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

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

Definition at line 93 of file BVAlgorithms.h.

◆ BVMinimize() [1/2]

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

Given a BVH, runs the query encapsulated by minimizer.

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

Definition at line 219 of file BVAlgorithms.h.

◆ BVMinimize() [2/2]

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

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

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

Definition at line 235 of file BVAlgorithms.h.

◆ cauchy_max_bound()

template<typename Polynomial >
NumTraits<typename Polynomial::Scalar>::Real Eigen::cauchy_max_bound ( const Polynomial &  poly)
inline
Returns
a maximum bound for the absolute value of any root of the polynomial.
Parameters
[in]poly: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. $ 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.

◆ cauchy_min_bound()

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

Definition at line 98 of file PolynomialUtils.h.

◆ choose() [1/2]

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

Definition at line 23 of file TensorMeta.h.

◆ choose() [2/2]

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

Definition at line 18 of file TensorMeta.h.

◆ conj()

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

Definition at line 574 of file AutoDiffScalar.h.

◆ constCast()

template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T* Eigen::constCast ( const T data)

◆ copy_using_evaluator() [1/3]

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

Definition at line 22 of file evaluators.cpp.

◆ copy_using_evaluator() [2/3]

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

Definition at line 30 of file evaluators.cpp.

◆ copy_using_evaluator() [3/3]

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

Definition at line 38 of file evaluators.cpp.

◆ createRandomPIMatrixOfRank()

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

Creates a random Partial Isometry matrix of given rank.

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

Definition at line 653 of file main.h.

◆ derivativesImpl()

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

Definition at line 311 of file Spline.h.

◆ dimensions_match()

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

Definition at line 484 of file TensorDimensions.h.

◆ divide_assign_using_evaluator()

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

Definition at line 74 of file evaluators.cpp.

◆ divup() [1/2]

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

Definition at line 36 of file TensorMeta.h.

◆ divup() [2/2]

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

Definition at line 30 of file TensorMeta.h.

◆ dsaupd_()

void Eigen::dsaupd_ ( int ido,
char *  bmat,
int n,
char *  which,
int nev,
double *  tol,
double *  resid,
int ncv,
double *  v,
int ldv,
int iparam,
int ipntr,
double *  workd,
double *  workl,
int lworkl,
int info 
)

◆ dseupd_()

void Eigen::dseupd_ ( int rvec,
char *  All,
int select,
double *  d,
double *  z,
int ldz,
double *  sigma,
char *  bmat,
int n,
char *  which,
int nev,
double *  tol,
double *  resid,
int ncv,
double *  v,
int ldv,
int iparam,
int ipntr,
double *  workd,
double *  workl,
int lworkl,
int ierr 
)

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [1/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [2/7]

Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY ( 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() [3/7]

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

Definition at line 637 of file AutoDiffScalar.h.

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [4/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [5/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [6/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [7/7]

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

◆ fix() [1/2]

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

Definition at line 192 of file IntegralConstant.h.

◆ fix() [2/2]

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

Definition at line 197 of file IntegralConstant.h.

◆ gamma_sample_der_alpha()

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

\cpp11

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

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

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

Definition at line 72 of file SpecialFunctionsArrayAPI.h.

◆ get_test_precision() [1/2]

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

Definition at line 572 of file main.h.

◆ get_test_precision() [2/2]

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

Definition at line 578 of file main.h.

◆ getMarketHeader()

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

Definition at line 109 of file MarketIO.h.

◆ igamma()

template<typename Derived , typename ExponentDerived >
const EIGEN_STRONG_INLINE 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 
)

\cpp11

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

This function computes the coefficient-wise incomplete gamma function.

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

Definition at line 28 of file SpecialFunctionsArrayAPI.h.

◆ igamma_der_a()

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

\cpp11

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

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

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

Definition at line 51 of file SpecialFunctionsArrayAPI.h.

◆ igammac()

template<typename Derived , typename ExponentDerived >
const EIGEN_STRONG_INLINE 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 
)

\cpp11

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

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

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

Definition at line 90 of file SpecialFunctionsArrayAPI.h.

◆ imag()

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

Definition at line 578 of file AutoDiffScalar.h.

◆ initParallel()

void Eigen::initParallel ( )
inline

Must be call first when calling Eigen from multiple threads

Definition at line 53 of file Parallelizer.h.

◆ is_same_type()

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

Definition at line 410 of file main.h.

◆ isMinusInf()

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

Definition at line 718 of file main.h.

◆ isNotNaN()

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

Definition at line 708 of file main.h.

◆ isPlusInf()

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

Definition at line 713 of file main.h.

◆ klu_factor() [1/2]

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

Definition at line 50 of file KLUSupport.h.

◆ klu_factor() [2/2]

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

Definition at line 54 of file KLUSupport.h.

◆ klu_solve() [1/2]

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

A sparse LU factorization and solver based on KLU.

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

Warning
The input matrix A should be in a compressed and column-major form. Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
Template Parameters
_MatrixTypethe type of the sparse matrix A, it must be a SparseMatrix<>

\implsparsesolverconcept

See also
Sparse solver concept, class UmfPackLU, class SparseLU

Definition at line 34 of file KLUSupport.h.

◆ klu_solve() [2/2]

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

Definition at line 38 of file KLUSupport.h.

◆ klu_tsolve() [1/2]

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

Definition at line 42 of file KLUSupport.h.

◆ klu_tsolve() [2/2]

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

Definition at line 46 of file KLUSupport.h.

◆ kroneckerProduct() [1/2]

template<typename A , typename B >
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.

◆ kroneckerProduct() [2/2]

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

Computes Kronecker tensor product of two dense matrices

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

Definition at line 271 of file KroneckerTensorProduct.h.

◆ l1CacheSize()

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

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

◆ l2CacheSize()

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

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

◆ l3CacheSize()

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

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

◆ lastp1()

◆ lazyprod()

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

Definition at line 15 of file evaluators.cpp.

◆ loadMarket()

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

Definition at line 134 of file MarketIO.h.

◆ loadMarketVector()

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

Definition at line 200 of file MarketIO.h.

◆ MakeAutoDiffScalar()

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

Definition at line 36 of file AutoDiffScalar.h.

◆ matrix_sqrt_quasi_triangular()

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

Compute matrix square root of quasi-triangular matrix.

Template Parameters
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.

◆ matrix_sqrt_triangular()

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

Compute matrix square root of triangular matrix.

Template Parameters
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.

◆ max() [1/3]

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

Definition at line 604 of file AutoDiffScalar.h.

◆ max() [2/3]

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

Definition at line 585 of file AutoDiffScalar.h.

◆ max() [3/3]

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

Definition at line 595 of file AutoDiffScalar.h.

◆ min() [1/3]

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

Definition at line 600 of file AutoDiffScalar.h.

◆ min() [2/3]

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

Definition at line 580 of file AutoDiffScalar.h.

◆ min() [3/3]

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

Definition at line 590 of file AutoDiffScalar.h.

◆ multiply_assign_using_evaluator()

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

Definition at line 67 of file evaluators.cpp.

◆ nbThreads()

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

Definition at line 63 of file Parallelizer.h.

◆ operator!=()

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

Definition at line 241 of file TensorMeta.h.

◆ operator*() [1/9]

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

Definition at line 171 of file SparsePermutation.h.

◆ operator*() [2/9]

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

Definition at line 515 of file PermutationMatrix.h.

◆ operator*() [3/9]

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

Definition at line 313 of file Transpositions.h.

◆ operator*() [4/9]

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

Computes the product of a matrix with a Householder sequence.

Parameters
[in]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 513 of file HouseholderSequence.h.

◆ operator*() [5/9]

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

Definition at line 154 of file SparsePermutation.h.

◆ operator*() [6/9]

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

Definition at line 527 of file PermutationMatrix.h.

◆ operator*() [7/9]

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

Definition at line 162 of file SparsePermutation.h.

◆ operator*() [8/9]

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

Definition at line 147 of file SparsePermutation.h.

◆ operator*() [9/9]

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

Definition at line 325 of file Transpositions.h.

◆ operator+() [1/2]

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

Definition at line 694 of file SparseCwiseBinaryOp.h.

◆ operator+() [2/2]

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

Definition at line 701 of file SparseCwiseBinaryOp.h.

◆ operator-() [1/2]

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

Definition at line 708 of file SparseCwiseBinaryOp.h.

◆ operator-() [2/2]

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

Definition at line 715 of file SparseCwiseBinaryOp.h.

◆ operator<<() [1/2]

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

Definition at line 387 of file TensorDimensions.h.

◆ operator<<() [2/2]

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

Definition at line 59 of file TensorIO.h.

◆ operator==() [1/2]

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

Definition at line 189 of file EmulateArray.h.

◆ operator==() [2/2]

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

Definition at line 235 of file TensorMeta.h.

◆ poly_eval()

template<typename Polynomials , typename T >
T Eigen::poly_eval ( const Polynomials &  poly,
const T x 
)
inline
Returns
the evaluation of the polynomial at x using stabilized Horner algorithm.
Parameters
[in]poly: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. $ 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.

◆ poly_eval_horner()

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

Definition at line 28 of file PolynomialUtils.h.

◆ polygamma()

template<typename DerivedN , typename DerivedX >
const EIGEN_STRONG_INLINE 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 
)

\cpp11

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

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

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

Definition at line 112 of file SpecialFunctionsArrayAPI.h.

◆ prod()

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

Definition at line 8 of file evaluators.cpp.

◆ randomPermutationVector()

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

Definition at line 693 of file main.h.

◆ real()

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

Definition at line 576 of file AutoDiffScalar.h.

◆ roots_to_monicPolynomial()

template<typename RootVector , typename Polynomial >
void Eigen::roots_to_monicPolynomial ( const RootVector &  rv,
Polynomial &  poly 
)

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

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

Definition at line 127 of file PolynomialUtils.h.

◆ saveMarket()

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

Definition at line 232 of file MarketIO.h.

◆ saveMarketVector()

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

Definition at line 258 of file MarketIO.h.

◆ Scaling() [1/6]

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

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

Definition at line 160 of file Eigen/src/Geometry/Scaling.h.

◆ Scaling() [2/6]

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

Constructs a 2D axis aligned scaling

Definition at line 149 of file Eigen/src/Geometry/Scaling.h.

◆ Scaling() [3/6]

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

Constructs a 3D axis aligned scaling

Definition at line 153 of file Eigen/src/Geometry/Scaling.h.

◆ Scaling() [4/6]

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

Constructs a uniform scaling from scale factor s

Definition at line 144 of file Eigen/src/Geometry/Scaling.h.

◆ Scaling() [5/6]

UniformScaling<double> Eigen::Scaling ( double  s)
inline

Constructs a uniform scaling from scale factor s

Definition at line 141 of file Eigen/src/Geometry/Scaling.h.

◆ Scaling() [6/6]

UniformScaling<float> Eigen::Scaling ( float  s)
inline

Constructs a uniform scaling from scale factor s

Definition at line 139 of file Eigen/src/Geometry/Scaling.h.

◆ seq() [1/8]

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

Definition at line 262 of file ArithmeticSequence.h.

◆ seq() [2/8]

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

Definition at line 313 of file ArithmeticSequence.h.

◆ seq() [3/8]

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

Definition at line 244 of file ArithmeticSequence.h.

◆ seq() [4/8]

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

Definition at line 286 of file ArithmeticSequence.h.

◆ seq() [5/8]

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

Definition at line 254 of file ArithmeticSequence.h.

◆ seq() [6/8]

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

Definition at line 299 of file ArithmeticSequence.h.

◆ seq() [7/8]

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

Definition at line 234 of file ArithmeticSequence.h.

◆ seq() [8/8]

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

Definition at line 271 of file ArithmeticSequence.h.

◆ seqN() [1/2]

template<typename FirstType , typename SizeType >
ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type > Eigen::seqN ( FirstType  first,
SizeType  size 
)
Returns
an ArithmeticSequence starting at first, of length size, and unit increment
See also
seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType)

Definition at line 171 of file ArithmeticSequence.h.

◆ seqN() [2/2]

template<typename FirstType , typename SizeType , typename IncrType >
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type, typename internal::cleanup_seq_incr< IncrType >::type > Eigen::seqN ( FirstType  first,
SizeType  size,
IncrType  incr 
)
Returns
an ArithmeticSequence starting at first, of length size, and increment incr
See also
seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType)

Definition at line 162 of file ArithmeticSequence.h.

◆ setCpuCacheSizes()

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

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

See also
computeProductBlockingSizes

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

◆ setNbThreads()

void Eigen::setNbThreads ( int  v)
inline

Sets the max number of threads reserved for Eigen

See also
nbThreads

Definition at line 72 of file Parallelizer.h.

◆ SimdInstructionSetsInUse()

static const char* Eigen::SimdInstructionSetsInUse ( void  )
inlinestatic

Definition at line 477 of file ConfigureVectorization.h.

◆ ssaupd_()

void Eigen::ssaupd_ ( int ido,
char *  bmat,
int n,
char *  which,
int nev,
float *  tol,
float *  resid,
int ncv,
float *  v,
int ldv,
int iparam,
int ipntr,
float *  workd,
float *  workl,
int lworkl,
int info 
)

◆ sseupd_()

void Eigen::sseupd_ ( int rvec,
char *  All,
int select,
float *  d,
float *  z,
int ldz,
float *  sigma,
char *  bmat,
int n,
char *  which,
int nev,
float *  tol,
float *  resid,
int ncv,
float *  v,
int ldv,
int iparam,
int ipntr,
float *  workd,
float *  workl,
int lworkl,
int ierr 
)

◆ subtract_assign_using_evaluator()

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

Definition at line 60 of file evaluators.cpp.

◆ swap_using_evaluator()

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

Definition at line 81 of file evaluators.cpp.

◆ test_is_equal()

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

Definition at line 633 of file main.h.

◆ test_isApprox() [1/5]

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

Definition at line 468 of file main.h.

◆ test_isApprox() [2/5]

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

Definition at line 454 of file main.h.

◆ test_isApprox() [3/5]

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

Definition at line 449 of file main.h.

◆ test_isApprox() [4/5]

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

Definition at line 460 of file main.h.

◆ test_isApprox() [5/5]

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

Definition at line 565 of file main.h.

◆ test_isApproxOrLessThan()

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

Definition at line 479 of file main.h.

◆ test_isApproxWithRef()

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

Definition at line 603 of file main.h.

◆ test_isMuchSmallerThan() [1/6]

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

Definition at line 477 of file main.h.

◆ test_isMuchSmallerThan() [2/6]

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

Definition at line 616 of file main.h.

◆ test_isMuchSmallerThan() [3/6]

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

Definition at line 609 of file main.h.

◆ test_isMuchSmallerThan() [4/6]

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

Definition at line 456 of file main.h.

◆ test_isMuchSmallerThan() [5/6]

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

Definition at line 451 of file main.h.

◆ test_isMuchSmallerThan() [6/6]

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

Definition at line 462 of file main.h.

◆ test_isUnitary()

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

Definition at line 623 of file main.h.

◆ test_precision()

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

Definition at line 415 of file main.h.

◆ test_precision< AnnoyingScalar >()

Definition at line 137 of file AnnoyingScalar.h.

◆ test_precision< double >()

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

Definition at line 417 of file main.h.

◆ test_precision< float >()

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

Definition at line 416 of file main.h.

◆ test_precision< long double >()

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

Definition at line 418 of file main.h.

◆ test_precision< Real >()

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

Definition at line 89 of file boostmultiprec.cpp.

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

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

Definition at line 420 of file main.h.

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

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

Definition at line 419 of file main.h.

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

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

Definition at line 421 of file main.h.

◆ test_relative_error() [1/13]

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

Definition at line 519 of file main.h.

◆ test_relative_error() [2/13]

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

Definition at line 16 of file alignedvector3.cpp.

◆ test_relative_error() [3/13]

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

Definition at line 559 of file main.h.

◆ test_relative_error() [4/13]

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

Definition at line 485 of file main.h.

◆ test_relative_error() [5/13]

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

Definition at line 526 of file main.h.

◆ test_relative_error() [6/13]

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

Definition at line 513 of file main.h.

◆ test_relative_error() [7/13]

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

Definition at line 553 of file main.h.

◆ test_relative_error() [8/13]

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

Definition at line 533 of file main.h.

◆ test_relative_error() [9/13]

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

Definition at line 540 of file main.h.

◆ test_relative_error() [10/13]

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

Definition at line 495 of file main.h.

◆ test_relative_error() [11/13]

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

Definition at line 501 of file main.h.

◆ test_relative_error() [12/13]

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

Definition at line 546 of file main.h.

◆ test_relative_error() [13/13]

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

Definition at line 507 of file main.h.

◆ umfpack_defaults() [1/4]

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

Definition at line 31 of file UmfPackSupport.h.

◆ umfpack_defaults() [2/4]

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

Definition at line 37 of file UmfPackSupport.h.

◆ umfpack_defaults() [3/4]

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

Definition at line 34 of file UmfPackSupport.h.

◆ umfpack_defaults() [4/4]

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

Definition at line 40 of file UmfPackSupport.h.

◆ umfpack_free_numeric() [1/4]

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

Definition at line 83 of file UmfPackSupport.h.

◆ umfpack_free_numeric() [2/4]

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

Definition at line 89 of file UmfPackSupport.h.

◆ umfpack_free_numeric() [3/4]

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

Definition at line 86 of file UmfPackSupport.h.

◆ umfpack_free_numeric() [4/4]

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

Definition at line 92 of file UmfPackSupport.h.

◆ umfpack_free_symbolic() [1/4]

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

Definition at line 96 of file UmfPackSupport.h.

◆ umfpack_free_symbolic() [2/4]

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

Definition at line 102 of file UmfPackSupport.h.

◆ umfpack_free_symbolic() [3/4]

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

Definition at line 99 of file UmfPackSupport.h.

◆ umfpack_free_symbolic() [4/4]

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

Definition at line 105 of file UmfPackSupport.h.

◆ umfpack_get_determinant() [1/4]

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

Definition at line 249 of file UmfPackSupport.h.

◆ umfpack_get_determinant() [2/4]

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

Definition at line 260 of file UmfPackSupport.h.

◆ umfpack_get_determinant() [3/4]

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

Definition at line 254 of file UmfPackSupport.h.

◆ umfpack_get_determinant() [4/4]

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

Definition at line 265 of file UmfPackSupport.h.

◆ umfpack_get_lunz() [1/4]

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

Definition at line 194 of file UmfPackSupport.h.

◆ umfpack_get_lunz() [2/4]

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

Definition at line 199 of file UmfPackSupport.h.

◆ umfpack_get_lunz() [3/4]

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

Definition at line 204 of file UmfPackSupport.h.

◆ umfpack_get_lunz() [4/4]

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

Definition at line 210 of file UmfPackSupport.h.

◆ umfpack_get_numeric() [1/4]

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

Definition at line 217 of file UmfPackSupport.h.

◆ umfpack_get_numeric() [2/4]

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

Definition at line 223 of file UmfPackSupport.h.

◆ umfpack_get_numeric() [3/4]

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

Definition at line 232 of file UmfPackSupport.h.

◆ umfpack_get_numeric() [4/4]

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

Definition at line 238 of file UmfPackSupport.h.

◆ umfpack_numeric() [1/4]

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

Definition at line 137 of file UmfPackSupport.h.

◆ umfpack_numeric() [2/4]

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

Definition at line 144 of file UmfPackSupport.h.

◆ umfpack_numeric() [3/4]

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

Definition at line 150 of file UmfPackSupport.h.

◆ umfpack_numeric() [4/4]

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

Definition at line 157 of file UmfPackSupport.h.

◆ umfpack_report_control() [1/4]

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

Definition at line 70 of file UmfPackSupport.h.

◆ umfpack_report_control() [2/4]

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

Definition at line 76 of file UmfPackSupport.h.

◆ umfpack_report_control() [3/4]

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

Definition at line 73 of file UmfPackSupport.h.

◆ umfpack_report_control() [4/4]

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

Definition at line 79 of file UmfPackSupport.h.

◆ umfpack_report_info() [1/4]

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

Definition at line 44 of file UmfPackSupport.h.

◆ umfpack_report_info() [2/4]

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

Definition at line 50 of file UmfPackSupport.h.

◆ umfpack_report_info() [3/4]

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

Definition at line 47 of file UmfPackSupport.h.

◆ umfpack_report_info() [4/4]

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

Definition at line 53 of file UmfPackSupport.h.

◆ umfpack_report_status() [1/4]

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

Definition at line 57 of file UmfPackSupport.h.

◆ umfpack_report_status() [2/4]

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

Definition at line 63 of file UmfPackSupport.h.

◆ umfpack_report_status() [3/4]

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

Definition at line 60 of file UmfPackSupport.h.

◆ umfpack_report_status() [4/4]

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

Definition at line 66 of file UmfPackSupport.h.

◆ umfpack_solve() [1/4]

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

Definition at line 165 of file UmfPackSupport.h.

◆ umfpack_solve() [2/4]

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

Definition at line 172 of file UmfPackSupport.h.

◆ umfpack_solve() [3/4]

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

Definition at line 179 of file UmfPackSupport.h.

◆ umfpack_solve() [4/4]

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

Definition at line 186 of file UmfPackSupport.h.

◆ umfpack_symbolic() [1/4]

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

Definition at line 109 of file UmfPackSupport.h.

◆ umfpack_symbolic() [2/4]

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

Definition at line 116 of file UmfPackSupport.h.

◆ umfpack_symbolic() [3/4]

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

Definition at line 122 of file UmfPackSupport.h.

◆ umfpack_symbolic() [4/4]

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

Definition at line 129 of file UmfPackSupport.h.

◆ verifyIsApprox()

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

Definition at line 585 of file main.h.

◆ viewAsCholmod() [1/5]

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

Definition at line 105 of file CholmodSupport.h.

◆ viewAsCholmod() [2/5]

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

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

Definition at line 121 of file CholmodSupport.h.

◆ viewAsCholmod() [3/5]

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

Definition at line 112 of file CholmodSupport.h.

◆ viewAsCholmod() [4/5]

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

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

Definition at line 137 of file CholmodSupport.h.

◆ viewAsCholmod() [5/5]

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

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

Definition at line 58 of file CholmodSupport.h.

◆ viewAsEigen()

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

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

Definition at line 158 of file CholmodSupport.h.

◆ zeta()

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

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

Parameters
xis the exponent, 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 156 of file SpecialFunctionsArrayAPI.h.

Variable Documentation

◆ ActualPacketAccessBit

const unsigned int Eigen::ActualPacketAccessBit = 0x0

Definition at line 107 of file Constants.h.

◆ AutoOrder

const int Eigen::AutoOrder = 2

Definition at line 17 of file ReshapedHelper.h.

◆ CoherentAccessPattern

const int Eigen::CoherentAccessPattern = 0x1

Definition at line 47 of file SparseUtil.h.

◆ Dynamic

const int Eigen::Dynamic = -1

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

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

Definition at line 22 of file Constants.h.

◆ DynamicIndex

const int Eigen::DynamicIndex = 0xffffff

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

Definition at line 27 of file Constants.h.

◆ exponents

EIGEN_DEVICE_FUNC const Eigen::ArrayBase<Derived>& Eigen::exponents
Initial value:
{
typedef typename internal::promote_scalar_arg<typename Derived::Scalar,Scalar,

Definition at line 175 of file GlobalFunctions.h.

◆ expx

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

Definition at line 634 of file AutoDiffScalar.h.

◆ g_has_set_repeat

bool Eigen::g_has_set_repeat = false
static

Definition at line 171 of file main.h.

◆ g_has_set_seed

bool Eigen::g_has_set_seed = false
static

Definition at line 171 of file main.h.

◆ g_repeat

int Eigen::g_repeat = 1
static

Definition at line 169 of file main.h.

◆ g_seed

unsigned int Eigen::g_seed = 0
static

Definition at line 170 of file main.h.

◆ g_test_level

int Eigen::g_test_level = 0
static

Definition at line 168 of file main.h.

◆ g_test_stack

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

Definition at line 165 of file main.h.

◆ HereditaryBits

const unsigned int Eigen::HereditaryBits
Initial value:

Definition at line 195 of file Constants.h.

◆ HugeCost

const int Eigen::HugeCost = 10000

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

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

Definition at line 44 of file Constants.h.

◆ Infinity

const int Eigen::Infinity = -1

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

Definition at line 36 of file Constants.h.

◆ InnerRandomAccessPattern

const int Eigen::InnerRandomAccessPattern = 0x2 | CoherentAccessPattern

Definition at line 48 of file SparseUtil.h.

◆ NestByRefBit

const unsigned int Eigen::NestByRefBit = 0x100

Definition at line 169 of file Constants.h.

◆ no_more_assert

bool Eigen::no_more_assert = false
static

Definition at line 225 of file main.h.

◆ OuterRandomAccessPattern

const int Eigen::OuterRandomAccessPattern = 0x4 | CoherentAccessPattern

Definition at line 49 of file SparseUtil.h.

◆ RandomAccessPattern

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

Definition at line 50 of file SparseUtil.h.

◆ report_on_cerr_on_assert_failure

bool Eigen::report_on_cerr_on_assert_failure = true
static

Definition at line 226 of file main.h.

◆ should_raise_an_assert

const bool Eigen::should_raise_an_assert = false
static

Definition at line 220 of file main.h.

◆ SkylineBit

const unsigned int Eigen::SkylineBit = 0x1200

Definition at line 21 of file SkylineUtil.h.

◆ UndefinedIncr

const int Eigen::UndefinedIncr = 0xfffffe

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

Definition at line 31 of file Constants.h.

Eigen::RowMajorBit
const unsigned int RowMajorBit
Definition: Constants.h:66
B
Definition: test_numpy_dtypes.cpp:299
type
Definition: pytypes.h:1525
A
Definition: test_numpy_dtypes.cpp:298
Eigen::ArrayBase::pow
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_pow_op< typename Derived::Scalar, typename ExponentDerived::Scalar >, const Derived, const ExponentDerived > pow(const Eigen::ArrayBase< Derived > &x, const Eigen::ArrayBase< ExponentDerived > &exponents)
Definition: GlobalFunctions.h:143
v2
Vector v2
Definition: testSerializationBase.cpp:39
Eigen::kroneckerProduct
KroneckerProduct< A, B > kroneckerProduct(const MatrixBase< A > &a, const MatrixBase< B > &b)
Definition: KroneckerTensorProduct.h:271
Eigen::EvalBeforeNestingBit
const unsigned int EvalBeforeNestingBit
Definition: Constants.h:70
v1
Vector v1
Definition: testSerializationBase.cpp:38
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:46
EIGEN_SCALAR_BINARY_SUPPORTED
#define EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME, TYPEA, TYPEB)
Definition: Macros.h:1344


gtsam
Author(s):
autogenerated on Sat Nov 16 2024 04:10:18