Eigen Namespace Reference

: TensorContractionSycl.h, provides various tensor contraction kernel for SYCL backend More...

Namespaces
	Architecture
	bfloat16_impl
	doxygen
	half_impl
	HybridNonLinearSolverSpace
	indexing
	internal
	LevenbergMarquardtSpace
	MatrixBase
	numext
	placeholders
	RunQueue
	Serializer
	SimplicialCholeskyBase
	SparseMatrix
	SparseMatrixBase
	StlThreadEnvironment
	symbolic
	TensorSycl
	ThreadLocal
	ThreadPoolTempl
	VectorwiseOp

Classes
class	AccelerateImpl
class	AdolcForwardJacobian
class	aligned_allocator
class	aligned_allocator_indirection
class	AlignedBox
class	AlignedVector3
	A vectorization friendly 3D vector. More...
class	AMDOrdering
class	AngleAxis
struct	AntiHermiticity
struct	AntiSymmetry
class	ArithmeticSequence
class	ArpackGeneralizedSelfAdjointEigenSolver
class	Array
class	ArrayBase
class	ArrayWrapper
struct	ArrayXpr
class	AutoDiffJacobian
class	AutoDiffScalar
	A scalar type replacement with automatic differentiation capability. More...
class	AutoDiffVector
struct	BandShape
class	Barrier
class	BDCSVD
struct	bfloat16
class	BiCGSTAB
class	BiCGSTABL
class	Block
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
class	CholmodDecomposition
class	CholmodSimplicialLDLT
class	CholmodSimplicialLLT
class	CholmodSupernodalLLT
struct	CleanedUpDerType
class	COLAMDOrdering
class	ColPivHouseholderQR
class	CommaInitializer
class	CompleteOrthogonalDecomposition
class	ComplexEigenSolver
class	ComplexSchur
struct	Cond
class	Conjugate
class	ConjugateGradient
struct	ConversionSubExprEval
struct	ConversionSubExprEval< true, Eval, EvalPointerType >
class	CwiseBinaryOp
class	CwiseBinaryOpImpl
class	CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >
class	CwiseNullaryOp
class	CwiseTernaryOp
class	CwiseTernaryOpImpl
class	CwiseUnaryOp
class	CwiseUnaryOpImpl
class	CwiseUnaryView
class	CwiseUnaryViewImpl
class	CwiseUnaryViewImpl< ViewOp, MatrixType, StrideType, Dense >
struct	default_fft_impl
struct	DefaultDevice
struct	Dense
class	DenseBase
class	DenseCoeffsBase
class	DenseCoeffsBase< Derived, DirectAccessors >
class	DenseCoeffsBase< Derived, DirectWriteAccessors >
class	DenseCoeffsBase< Derived, ReadOnlyAccessors >
class	DenseCoeffsBase< Derived, WriteAccessors >
struct	DenseFunctor
struct	DenseShape
struct	DenseSparseProductReturnType
class	DenseStorage
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
class	DiagonalBase
class	DiagonalMatrix
class	DiagonalPreconditioner
class	DiagonalProduct
struct	DiagonalShape
class	DiagonalWrapper
struct	DimensionList
struct	DSizes
class	DynamicSGroup
	Dynamic symmetry group. More...
class	DynamicSGroupFromTemplateArgs
class	DynamicSkylineMatrix
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
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	FABSum
class	FFT
struct	fft_fwd_proxy
struct	fft_inv_proxy
class	ForceAlignedAccess
class	FullPivHouseholderQR
class	FullPivLU
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
class	GeneralizedSelfAdjointEigenSolver
struct	GenericNumTraits
class	GMRES
	A GMRES solver for sparse square problems. More...
struct	half
struct	Hermiticity
class	HessenbergDecomposition
class	Homogeneous
struct	HomogeneousShape
class	HouseholderQR
class	HouseholderSequence
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
class	IdentityPreconditioner
class	IDRS
	The Induced Dimension Reduction method (IDR(s)) is a short-recurrences Krylov method for sparse square problems. More...
class	IDRSTABL
	The IDR(s)STAB(l) is a combination of IDR(s) and BiCGSTAB(l). It is a short-recurrences Krylov method for sparse square problems. It can outperform both IDR(s) and BiCGSTAB(l). IDR(s)STAB(l) generally closely follows the optimal GMRES convergence in terms of the number of Matrix-Vector products. However, without the increasing cost per iteration of GMRES. IDR(s)STAB(l) is suitable for both indefinite systems and systems with complex eigenvalues. More...
class	IncompleteCholesky
class	IncompleteLU
class	IncompleteLUT
class	IndexedView
class	IndexedViewImpl
struct	IndexList
struct	IndexPair
struct	IndexPairList
class	InnerStride
class	Inverse
class	InverseImpl
class	InverseImpl< PermutationType, PermutationStorage >
class	IOFormat
class	IterativeSolverBase
class	IterScaling
	iterative scaling algorithm to equilibrate rows and column norms in matrices More...
class	JacobiRotation
class	JacobiSVD
class	KahanSum
	Kahan algorithm based accumulator. 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
class	LeastSquareDiagonalPreconditioner
class	LeastSquaresConjugateGradient
class	LevenbergMarquardt
	Performs non linear optimization over a non-linear function, using a variant of the Levenberg Marquardt algorithm. More...
class	LLT
struct	MakeComplex
struct	MakeComplex< false >
struct	MakeComplex< true >
struct	MakePointer
class	Map
class	Map< const Quaternion< Scalar_ >, Options_ >
class	Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_ >, PacketAccess_ >
class	Map< Quaternion< Scalar_ >, Options_ >
class	Map< SparseMatrixType >
class	Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_ >, PacketAccess >
class	MapBase
class	MapBase< Derived, ReadOnlyAccessors >
class	MapBase< Derived, WriteAccessors >
class	MappedSkylineMatrix
class	Matrix
class	MatrixBase
class	MatrixComplexPowerReturnValue
	Proxy for the matrix power of some matrix (expression).
struct	MatrixExponentialReturnValue
	Proxy for the matrix exponential of some matrix (expression).
class	MatrixFunctionReturnValue
	Proxy for the matrix function of some matrix (expression).
class	MatrixLogarithmReturnValue
	Proxy for the matrix logarithm of some matrix (expression).
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).
class	MatrixSquareRootReturnValue
	Proxy for the matrix square root of some matrix (expression).
class	MatrixWrapper
struct	MatrixXpr
struct	max_n_1
struct	max_n_1< 0 >
class	MaxSizeVector
class	MetisOrdering
class	MINRES
	A minimal residual solver for sparse symmetric problems. More...
class	NaturalOrdering
class	NestByValue
class	NNLS
	Implementation of the Non-Negative Least Squares (NNLS) algorithm. More...
class	NoAlias
struct	NoOpOutputKernel
struct	Notification
class	NumericalDiff
class	NumTraits
struct	NumTraits< adtl::adouble >
struct	NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct	NumTraits< AutoDiffScalar< DerType > >
struct	NumTraits< bool >
struct	NumTraits< double >
struct	NumTraits< Eigen::bfloat16 >
struct	NumTraits< Eigen::half >
struct	NumTraits< float >
struct	NumTraits< long double >
struct	NumTraits< mpfr::mpreal >
struct	NumTraits< std::complex< Real_ > >
struct	NumTraits< std::string >
struct	NumTraits< type2index< n > >
struct	NumTraits< void >
class	OuterStride
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
struct	Pair
class	ParametrizedLine
class	PardisoImpl
class	PardisoLDLT
class	PardisoLLT
class	PardisoLU
struct	partial_redux_dummy_func
class	PartialPivLU
class	PartialReduxExpr
struct	PartOf
struct	PartOf< ImagPart >
struct	PartOf< RealPart >
class	PastixBase
class	PastixLDLT
class	PastixLLT
class	PastixLU
class	PermutationBase
class	PermutationMatrix
struct	PermutationShape
struct	PermutationStorage
class	PermutationWrapper
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
class	ProductImpl
class	ProductImpl< Lhs, Rhs, Option, Dense >
struct	ProductReturnType
class	Quaternion
class	QuaternionBase
class	RandomSetter
	The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access. More...
class	RealQZ
class	RealSchur
class	Ref
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< SparseMatrixType, Options >
class	Ref< SparseVectorType >
class	RefBase
class	Replicate
class	Reshaped
class	ReshapedImpl
class	ReshapedImpl< XprType, Rows, Cols, Order, Dense >
class	ReturnByValue
class	Reverse
class	Rotation2D
class	RotationBase
class	RunQueue
class	ScalarBinaryOpTraits
struct	ScalarBinaryOpTraits< AutoDiffScalar< DerType >, typename DerType::Scalar, BinOp >
struct	ScalarBinaryOpTraits< T, T, BinaryOp >
struct	ScalarBinaryOpTraits< T, typename NumTraits< std::enable_if_t< NumTraits< T >::IsComplex, T > >::Real, BinaryOp >
struct	ScalarBinaryOpTraits< T, void, BinaryOp >
struct	ScalarBinaryOpTraits< typename DerType::Scalar, AutoDiffScalar< DerType >, BinOp >
struct	ScalarBinaryOpTraits< typename NumTraits< std::enable_if_t< NumTraits< T >::IsComplex, T > >::Real, T, BinaryOp >
struct	ScalarBinaryOpTraits< void, T, BinaryOp >
struct	ScalarBinaryOpTraits< void, void, BinaryOp >
class	Select
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
struct	SelfAdjointShape
class	SelfAdjointView
class	Serializer
class	Serializer< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
class	Serializer< DenseBase< Derived >, void >
class	Serializer< Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
class	Serializer< SparseMatrix< Scalar, Options, StorageIndex >, void >
class	Serializer< SparseVector< Scalar, Options, StorageIndex >, void >
class	Serializer< T, typename std::enable_if_t< std::is_trivial< T >::value &&std::is_standard_layout< T >::value > >
class	SGroup
	Symmetry group, initialized from template arguments. More...
class	SimplicialCholesky
class	SimplicialCholeskyBase
class	SimplicialLDLT
class	SimplicialLLT
struct	Sizes
class	SkewSymmetricBase
class	SkewSymmetricMatrix3
struct	SkewSymmetricShape
class	SkewSymmetricWrapper
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
class	SolveImpl
class	SolveImpl< Decomposition, RhsType, Dense >
class	SolverBase
struct	SolverShape
struct	SolverStorage
class	SolveWithGuess
struct	Sparse
class	SparseCompressedBase
class	SparseDenseOuterProduct
struct	SparseDenseProductReturnType
class	SparseDiagonalProduct
struct	SparseFunctor
class	SparseInverse
	calculate sparse subset of inverse of sparse matrix More...
class	SparseLU
struct	SparseLUMatrixLReturnType
struct	SparseLUMatrixUReturnType
class	SparseLUTransposeView
class	SparseMapBase
class	SparseMapBase< Derived, ReadOnlyAccessors >
class	SparseMapBase< Derived, WriteAccessors >
class	SparseMatrix
class	SparseMatrixBase
class	SparseQR
struct	SparseQR_QProduct
struct	SparseQRMatrixQReturnType
struct	SparseQRMatrixQTransposeReturnType
class	SparseSelfAdjointView
struct	SparseShape
class	SparseSolverBase
class	SparseSparseProduct
struct	SparseSparseProductReturnType
class	SparseSymmetricPermutationProduct
class	SparseTimeDenseProduct
class	SparseVector
class	SparseView
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
struct	SPQR_QProduct
struct	SPQRMatrixQReturnType
struct	SPQRMatrixQTransposeReturnType
class	StaticSGroup
	Static symmetry group. More...
struct	StdMapTraits
struct	StdUnorderedMapTraits
struct	StlThreadEnvironment
struct	StorageMemory
class	Stride
class	SuperILU
class	SuperLU
class	SuperLUBase
class	SVDBase
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	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 TensorIndexPairOp< 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 TensorPairReducerOp< ReduceOp, Dims, 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 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	TensorIndexPairOp
class	TensorInflationOp
struct	TensorIOFormat
class	TensorLayoutSwapOp
class	TensorMap
	A tensor expression mapping an existing array of data. More...
class	TensorOpCost
class	TensorPaddingOp
class	TensorPairReducerOp
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	TensorVolumePatchOp
class	TensorWithFormat
class	TensorWithFormat< T, ColMajor, 0 >
class	TensorWithFormat< T, ColMajor, rank >
class	TensorWithFormat< T, RowMajor, rank >
class	ThreadLocal
class	ThreadPoolInterface
class	ThreadPoolTempl
class	Transform
class	Translation
class	Transpose
class	Transpose< TranspositionsBase< TranspositionsDerived > >
class	TransposeImpl
class	TransposeImpl< MatrixType, Dense >
class	TransposeImpl< MatrixType, Sparse >
class	Transpositions
class	TranspositionsBase
struct	TranspositionsShape
struct	TranspositionsStorage
class	TranspositionsWrapper
class	TriangularBase
struct	TriangularShape
class	TriangularView
class	TriangularViewImpl
class	TriangularViewImpl< MatrixType, Mode, Sparse >
class	TriangularViewImpl< MatrixType_, Mode_, Dense >
class	Tridiagonalization
class	Triplet
struct	type2index
struct	type2indexpair
class	UmfPackLU
class	UniformScaling
class	VectorBlock
class	VectorwiseOp
class	WithFormat

Typedefs
typedef AccelerateImpl< MatrixType, 0, SparseFactorizationCholeskyAtA, false >	AccelerateCholeskyAtA
typedef AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationLDLT, true >	AccelerateLDLT
typedef AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationLDLTSBK, true >	AccelerateLDLTSBK
typedef AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationLDLTTPP, true >	AccelerateLDLTTPP
typedef AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationLDLTUnpivoted, true >	AccelerateLDLTUnpivoted
typedef AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationCholesky, true >	AccelerateLLT
typedef AccelerateImpl< MatrixType, 0, SparseFactorizationQR, false >	AccelerateQR
typedef Transform< double, 2, Affine >	Affine2d
typedef Transform< float, 2, Affine >	Affine2f
typedef Transform< double, 3, Affine >	Affine3d
typedef Transform< float, 3, Affine >	Affine3f
typedef Transform< double, 2, AffineCompact >	AffineCompact2d
typedef Transform< float, 2, AffineCompact >	AffineCompact2f
typedef Transform< double, 3, AffineCompact >	AffineCompact3d
typedef Transform< float, 3, AffineCompact >	AffineCompact3f
typedef AlignedBox< double, 1 >	AlignedBox1d
typedef AlignedBox< float, 1 >	AlignedBox1f
typedef AlignedBox< int, 1 >	AlignedBox1i
typedef AlignedBox< double, 2 >	AlignedBox2d
typedef AlignedBox< float, 2 >	AlignedBox2f
typedef AlignedBox< int, 2 >	AlignedBox2i
typedef AlignedBox< double, 3 >	AlignedBox3d
typedef AlignedBox< float, 3 >	AlignedBox3f
typedef AlignedBox< int, 3 >	AlignedBox3i
typedef AlignedBox< double, 4 >	AlignedBox4d
typedef AlignedBox< float, 4 >	AlignedBox4f
typedef AlignedBox< int, 4 >	AlignedBox4i
typedef AlignedBox< double, Dynamic >	AlignedBoxXd
typedef AlignedBox< float, Dynamic >	AlignedBoxXf
typedef AlignedBox< int, Dynamic >	AlignedBoxXi
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 std::array< T, N >	array
typedef Array< Type, 2, 1 >	Array2
typedef Array< Type, 2, 2 >	Array22
typedef Array< std::complex< double >, 2, 2 >	Array22cd
typedef Array< std::complex< float >, 2, 2 >	Array22cf
typedef Array< double, 2, 2 >	Array22d
typedef Array< float, 2, 2 >	Array22f
typedef Array< int, 2, 2 >	Array22i
typedef Array< std::complex< double >, 2, 1 >	Array2cd
typedef Array< std::complex< float >, 2, 1 >	Array2cf
typedef Array< double, 2, 1 >	Array2d
typedef Array< float, 2, 1 >	Array2f
typedef Array< int, 2, 1 >	Array2i
typedef Array< Type, 2, Dynamic >	Array2X
typedef Array< std::complex< double >, 2, Dynamic >	Array2Xcd
typedef Array< std::complex< float >, 2, Dynamic >	Array2Xcf
typedef Array< double, 2, Dynamic >	Array2Xd
typedef Array< float, 2, Dynamic >	Array2Xf
typedef Array< int, 2, Dynamic >	Array2Xi
typedef Array< Type, 3, 1 >	Array3
typedef Array< Type, 3, 3 >	Array33
typedef Array< std::complex< double >, 3, 3 >	Array33cd
typedef Array< std::complex< float >, 3, 3 >	Array33cf
typedef Array< double, 3, 3 >	Array33d
typedef Array< float, 3, 3 >	Array33f
typedef Array< int, 3, 3 >	Array33i
typedef Array< std::complex< double >, 3, 1 >	Array3cd
typedef Array< std::complex< float >, 3, 1 >	Array3cf
typedef Array< double, 3, 1 >	Array3d
typedef Array< float, 3, 1 >	Array3f
typedef Array< int, 3, 1 >	Array3i
typedef Array< Type, 3, Dynamic >	Array3X
typedef Array< std::complex< double >, 3, Dynamic >	Array3Xcd
typedef Array< std::complex< float >, 3, Dynamic >	Array3Xcf
typedef Array< double, 3, Dynamic >	Array3Xd
typedef Array< float, 3, Dynamic >	Array3Xf
typedef Array< int, 3, Dynamic >	Array3Xi
typedef Array< Type, 4, 1 >	Array4
typedef Array< Type, 4, 4 >	Array44
typedef Array< std::complex< double >, 4, 4 >	Array44cd
typedef Array< std::complex< float >, 4, 4 >	Array44cf
typedef Array< double, 4, 4 >	Array44d
typedef Array< float, 4, 4 >	Array44f
typedef Array< int, 4, 4 >	Array44i
typedef Array< std::complex< double >, 4, 1 >	Array4cd
typedef Array< std::complex< float >, 4, 1 >	Array4cf
typedef Array< double, 4, 1 >	Array4d
typedef Array< float, 4, 1 >	Array4f
typedef Array< int, 4, 1 >	Array4i
typedef Array< Type, 4, Dynamic >	Array4X
typedef Array< std::complex< double >, 4, Dynamic >	Array4Xcd
typedef Array< std::complex< float >, 4, Dynamic >	Array4Xcf
typedef Array< double, 4, Dynamic >	Array4Xd
typedef Array< float, 4, Dynamic >	Array4Xf
typedef Array< int, 4, Dynamic >	Array4Xi
typedef Array< Type, Dynamic, 1 >	ArrayX
typedef Array< Type, Dynamic, 2 >	ArrayX2
typedef Array< std::complex< double >, Dynamic, 2 >	ArrayX2cd
typedef Array< std::complex< float >, Dynamic, 2 >	ArrayX2cf
typedef Array< double, Dynamic, 2 >	ArrayX2d
typedef Array< float, Dynamic, 2 >	ArrayX2f
typedef Array< int, Dynamic, 2 >	ArrayX2i
typedef Array< Type, Dynamic, 3 >	ArrayX3
typedef Array< std::complex< double >, Dynamic, 3 >	ArrayX3cd
typedef Array< std::complex< float >, Dynamic, 3 >	ArrayX3cf
typedef Array< double, Dynamic, 3 >	ArrayX3d
typedef Array< float, Dynamic, 3 >	ArrayX3f
typedef Array< int, Dynamic, 3 >	ArrayX3i
typedef Array< Type, Dynamic, 4 >	ArrayX4
typedef Array< std::complex< double >, Dynamic, 4 >	ArrayX4cd
typedef Array< std::complex< float >, Dynamic, 4 >	ArrayX4cf
typedef Array< double, Dynamic, 4 >	ArrayX4d
typedef Array< float, Dynamic, 4 >	ArrayX4f
typedef Array< int, Dynamic, 4 >	ArrayX4i
typedef Array< std::complex< double >, Dynamic, 1 >	ArrayXcd
typedef Array< std::complex< float >, Dynamic, 1 >	ArrayXcf
typedef Array< double, Dynamic, 1 >	ArrayXd
typedef Array< float, Dynamic, 1 >	ArrayXf
typedef Array< int, Dynamic, 1 >	ArrayXi
typedef Array< Type, Dynamic, Dynamic >	ArrayXX
typedef Array< std::complex< double >, Dynamic, Dynamic >	ArrayXXcd
typedef Array< std::complex< float >, Dynamic, Dynamic >	ArrayXXcf
typedef Array< double, Dynamic, Dynamic >	ArrayXXd
typedef Array< float, Dynamic, Dynamic >	ArrayXXf
typedef Array< int, Dynamic, Dynamic >	ArrayXXi
typedef int	BlasIndex
typedef std::complex< double >	dcomplex
typedef int	DefaultPermutationIndex
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE	DenseIndex
typedef EulerAngles< double, EulerSystemXYX >	EulerAnglesXYXd
typedef EulerAngles< float, EulerSystemXYX >	EulerAnglesXYXf
typedef EulerAngles< double, EulerSystemXYZ >	EulerAnglesXYZd
typedef EulerAngles< float, EulerSystemXYZ >	EulerAnglesXYZf
typedef EulerAngles< double, EulerSystemXZX >	EulerAnglesXZXd
typedef EulerAngles< float, EulerSystemXZX >	EulerAnglesXZXf
typedef EulerAngles< double, EulerSystemXZY >	EulerAnglesXZYd
typedef EulerAngles< float, EulerSystemXZY >	EulerAnglesXZYf
typedef EulerAngles< double, EulerSystemYXY >	EulerAnglesYXYd
typedef EulerAngles< float, EulerSystemYXY >	EulerAnglesYXYf
typedef EulerAngles< double, EulerSystemYXZ >	EulerAnglesYXZd
typedef EulerAngles< float, EulerSystemYXZ >	EulerAnglesYXZf
typedef EulerAngles< double, EulerSystemYZX >	EulerAnglesYZXd
typedef EulerAngles< float, EulerSystemYZX >	EulerAnglesYZXf
typedef EulerAngles< double, EulerSystemYZY >	EulerAnglesYZYd
typedef EulerAngles< float, EulerSystemYZY >	EulerAnglesYZYf
typedef EulerAngles< double, EulerSystemZXY >	EulerAnglesZXYd
typedef EulerAngles< float, EulerSystemZXY >	EulerAnglesZXYf
typedef EulerAngles< double, EulerSystemZXZ >	EulerAnglesZXZd
typedef EulerAngles< float, EulerSystemZXZ >	EulerAnglesZXZf
typedef EulerAngles< double, EulerSystemZYX >	EulerAnglesZYXd
typedef EulerAngles< float, EulerSystemZYX >	EulerAnglesZYXf
typedef EulerAngles< double, EulerSystemZYZ >	EulerAnglesZYZd
typedef EulerAngles< float, EulerSystemZYZ >	EulerAnglesZYZf
typedef EulerSystem< EULER_X, EULER_Y, EULER_X >	EulerSystemXYX
typedef EulerSystem< EULER_X, EULER_Y, EULER_Z >	EulerSystemXYZ
typedef EulerSystem< EULER_X, EULER_Z, EULER_X >	EulerSystemXZX
typedef EulerSystem< EULER_X, EULER_Z, EULER_Y >	EulerSystemXZY
typedef EulerSystem< EULER_Y, EULER_X, EULER_Y >	EulerSystemYXY
typedef EulerSystem< EULER_Y, EULER_X, EULER_Z >	EulerSystemYXZ
typedef EulerSystem< EULER_Y, EULER_Z, EULER_X >	EulerSystemYZX
typedef EulerSystem< EULER_Y, EULER_Z, EULER_Y >	EulerSystemYZY
typedef EulerSystem< EULER_Z, EULER_X, EULER_Y >	EulerSystemZXY
typedef EulerSystem< EULER_Z, EULER_X, EULER_Z >	EulerSystemZXZ
typedef EulerSystem< EULER_Z, EULER_Y, EULER_X >	EulerSystemZYX
typedef EulerSystem< EULER_Z, EULER_Y, EULER_Z >	EulerSystemZYZ
typedef std::enable_if_t< !internal::is_arithmetic< typename NumTraits< Derived >::Real >::value &&internal::is_arithmetic< typename NumTraits< ScalarExponent >::Real >::value, CwiseUnaryOp< internal::scalar_unary_pow_op< typename Derived::Scalar, ScalarExponent >, const Derived > >	GlobalUnaryPowReturnType
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE	Index
typedef Transform< double, 2, Isometry >	Isometry2d
typedef Transform< float, 2, Isometry >	Isometry2f
typedef Transform< double, 3, Isometry >	Isometry3d
typedef Transform< float, 3, Isometry >	Isometry3f
typedef Matrix< Type, 2, 2 >	Matrix2
typedef Matrix< std::complex< double >, 2, 2 >	Matrix2cd
typedef Matrix< std::complex< float >, 2, 2 >	Matrix2cf
typedef Matrix< double, 2, 2 >	Matrix2d
typedef Matrix< float, 2, 2 >	Matrix2f
typedef Matrix< int, 2, 2 >	Matrix2i
typedef Matrix< Type, 2, Dynamic >	Matrix2X
typedef Matrix< std::complex< double >, 2, Dynamic >	Matrix2Xcd
typedef Matrix< std::complex< float >, 2, Dynamic >	Matrix2Xcf
typedef Matrix< double, 2, Dynamic >	Matrix2Xd
typedef Matrix< float, 2, Dynamic >	Matrix2Xf
typedef Matrix< int, 2, Dynamic >	Matrix2Xi
typedef Matrix< Type, 3, 3 >	Matrix3
typedef Matrix< std::complex< double >, 3, 3 >	Matrix3cd
typedef Matrix< std::complex< float >, 3, 3 >	Matrix3cf
typedef Matrix< double, 3, 3 >	Matrix3d
typedef Matrix< float, 3, 3 >	Matrix3f
typedef Matrix< int, 3, 3 >	Matrix3i
typedef Matrix< Type, 3, Dynamic >	Matrix3X
typedef Matrix< std::complex< double >, 3, Dynamic >	Matrix3Xcd
typedef Matrix< std::complex< float >, 3, Dynamic >	Matrix3Xcf
typedef Matrix< double, 3, Dynamic >	Matrix3Xd
typedef Matrix< float, 3, Dynamic >	Matrix3Xf
typedef Matrix< int, 3, Dynamic >	Matrix3Xi
typedef Matrix< Type, 4, 4 >	Matrix4
typedef Matrix< std::complex< double >, 4, 4 >	Matrix4cd
typedef Matrix< std::complex< float >, 4, 4 >	Matrix4cf
typedef Matrix< double, 4, 4 >	Matrix4d
typedef Matrix< float, 4, 4 >	Matrix4f
typedef Matrix< int, 4, 4 >	Matrix4i
typedef Matrix< Type, 4, Dynamic >	Matrix4X
typedef Matrix< std::complex< double >, 4, Dynamic >	Matrix4Xcd
typedef Matrix< std::complex< float >, 4, Dynamic >	Matrix4Xcf
typedef Matrix< double, 4, Dynamic >	Matrix4Xd
typedef Matrix< float, 4, Dynamic >	Matrix4Xf
typedef Matrix< int, 4, Dynamic >	Matrix4Xi
typedef Matrix< Type, Dynamic, Dynamic >	MatrixX
typedef Matrix< Type, Dynamic, 2 >	MatrixX2
typedef Matrix< std::complex< double >, Dynamic, 2 >	MatrixX2cd
typedef Matrix< std::complex< float >, Dynamic, 2 >	MatrixX2cf
typedef Matrix< double, Dynamic, 2 >	MatrixX2d
typedef Matrix< float, Dynamic, 2 >	MatrixX2f
typedef Matrix< int, Dynamic, 2 >	MatrixX2i
typedef Matrix< Type, Dynamic, 3 >	MatrixX3
typedef Matrix< std::complex< double >, Dynamic, 3 >	MatrixX3cd
typedef Matrix< std::complex< float >, Dynamic, 3 >	MatrixX3cf
typedef Matrix< double, Dynamic, 3 >	MatrixX3d
typedef Matrix< float, Dynamic, 3 >	MatrixX3f
typedef Matrix< int, Dynamic, 3 >	MatrixX3i
typedef Matrix< Type, Dynamic, 4 >	MatrixX4
typedef Matrix< std::complex< double >, Dynamic, 4 >	MatrixX4cd
typedef Matrix< std::complex< float >, Dynamic, 4 >	MatrixX4cf
typedef Matrix< double, Dynamic, 4 >	MatrixX4d
typedef Matrix< float, Dynamic, 4 >	MatrixX4f
typedef Matrix< int, Dynamic, 4 >	MatrixX4i
typedef Matrix< std::complex< double >, Dynamic, Dynamic >	MatrixXcd
typedef Matrix< std::complex< float >, Dynamic, Dynamic >	MatrixXcf
typedef Matrix< double, Dynamic, Dynamic >	MatrixXd
typedef Matrix< float, Dynamic, Dynamic >	MatrixXf
typedef Matrix< int, Dynamic, Dynamic >	MatrixXi
typedef Transform< double, 2, Projective >	Projective2d
typedef Transform< float, 2, Projective >	Projective2f
typedef Transform< double, 3, Projective >	Projective3d
typedef Transform< float, 3, Projective >	Projective3f
typedef Quaternion< double >	Quaterniond
typedef Quaternion< float >	Quaternionf
typedef Map< Quaternion< double >, Aligned >	QuaternionMapAlignedd
typedef Map< Quaternion< float >, Aligned >	QuaternionMapAlignedf
typedef Map< Quaternion< double >, 0 >	QuaternionMapd
typedef Map< Quaternion< float >, 0 >	QuaternionMapf
typedef Rotation2D< double >	Rotation2Dd
typedef Rotation2D< float >	Rotation2Df
typedef Matrix< Type, 1, Size >	RowVector
typedef Matrix< Type, 1, 2 >	RowVector2
typedef Matrix< std::complex< double >, 1, 2 >	RowVector2cd
typedef Matrix< std::complex< float >, 1, 2 >	RowVector2cf
typedef Matrix< double, 1, 2 >	RowVector2d
typedef Matrix< float, 1, 2 >	RowVector2f
typedef Matrix< int, 1, 2 >	RowVector2i
typedef Matrix< Type, 1, 3 >	RowVector3
typedef Matrix< std::complex< double >, 1, 3 >	RowVector3cd
typedef Matrix< std::complex< float >, 1, 3 >	RowVector3cf
typedef Matrix< double, 1, 3 >	RowVector3d
typedef Matrix< float, 1, 3 >	RowVector3f
typedef Matrix< int, 1, 3 >	RowVector3i
typedef Matrix< Type, 1, 4 >	RowVector4
typedef Matrix< std::complex< double >, 1, 4 >	RowVector4cd
typedef Matrix< std::complex< float >, 1, 4 >	RowVector4cf
typedef Matrix< double, 1, 4 >	RowVector4d
typedef Matrix< float, 1, 4 >	RowVector4f
typedef Matrix< int, 1, 4 >	RowVector4i
typedef Matrix< Type, 1, Dynamic >	RowVectorX
typedef Matrix< std::complex< double >, 1, Dynamic >	RowVectorXcd
typedef Matrix< std::complex< float >, 1, Dynamic >	RowVectorXcf
typedef Matrix< double, 1, Dynamic >	RowVectorXd
typedef Matrix< float, 1, Dynamic >	RowVectorXf
typedef Matrix< int, 1, Dynamic >	RowVectorXi
typedef std::complex< float >	scomplex
typedef Spline< double, 2 >	Spline2d
	2D double B-spline with dynamic degree. More...
typedef Spline< float, 2 >	Spline2f
	2D float B-spline with dynamic degree. More...
typedef Spline< double, 3 >	Spline3d
	3D double B-spline with dynamic degree. More...
typedef Spline< float, 3 >	Spline3f
	3D float B-spline with dynamic degree. More...
typedef ThreadPoolTempl< StlThreadEnvironment >	ThreadPool
typedef Translation< double, 2 >	Translation2d
typedef Translation< float, 2 >	Translation2f
typedef Translation< double, 3 >	Translation3d
typedef Translation< float, 3 >	Translation3f
typedef Matrix< Type, Size, 1 >	Vector
typedef Matrix< Type, 2, 1 >	Vector2
typedef Matrix< std::complex< double >, 2, 1 >	Vector2cd
typedef Matrix< std::complex< float >, 2, 1 >	Vector2cf
typedef Matrix< double, 2, 1 >	Vector2d
typedef Matrix< float, 2, 1 >	Vector2f
typedef Matrix< int, 2, 1 >	Vector2i
typedef Matrix< Type, 3, 1 >	Vector3
typedef Matrix< std::complex< double >, 3, 1 >	Vector3cd
typedef Matrix< std::complex< float >, 3, 1 >	Vector3cf
typedef Matrix< double, 3, 1 >	Vector3d
typedef Matrix< float, 3, 1 >	Vector3f
typedef Matrix< int, 3, 1 >	Vector3i
typedef Matrix< Type, 4, 1 >	Vector4
typedef Matrix< std::complex< double >, 4, 1 >	Vector4cd
typedef Matrix< std::complex< float >, 4, 1 >	Vector4cf
typedef Matrix< double, 4, 1 >	Vector4d
typedef Matrix< float, 4, 1 >	Vector4f
typedef Matrix< int, 4, 1 >	Vector4i
typedef Matrix< Type, Dynamic, 1 >	VectorX
typedef Matrix< std::complex< double >, Dynamic, 1 >	VectorXcd
typedef Matrix< std::complex< float >, Dynamic, 1 >	VectorXcf
typedef Matrix< double, Dynamic, 1 >	VectorXd
typedef Matrix< float, Dynamic, 1 >	VectorXf
typedef Matrix< int, Dynamic, 1 >	VectorXi

Enumerations
enum	{   NegationFlag ,   ConjugationFlag }
enum	{   GlobalRealFlag ,   GlobalImagFlag ,   GlobalZeroFlag }
enum	{ IsSkyline }
enum	{   SPD ,   NonSymmetric }
enum	AccessorLevels
enum	Action
enum	AdditionalProductEvaluationMode {   SkylineTimeDenseProduct ,   SkylineTimeSkylineProduct ,   DenseTimeSkylineProduct }
enum	AlignmentType
enum	AmbiVectorMode
enum	AutoSize_t
enum	CholmodMode
enum	ComputationInfo
enum class	convolution_type {   CONV1D ,   CONV2D ,   CONV3D }
enum	DecompositionOptions
enum	Default_t
enum	DirectionType
enum	EulerAxis {   EULER_X ,   EULER_Y ,   EULER_Z }
	Representation of a fixed signed rotation axis for EulerSystem. More...
enum	FFTDirection {   FFT_FORWARD ,   FFT_REVERSE }
enum	FFTResultType {   RealPart ,   ImagPart ,   BothParts }
enum	NaNPropagationOptions
enum	NoChange_t
enum	NumericalDiffMode {   Forward ,   Central }
enum	PaddingType {   PADDING_VALID ,   PADDING_SAME }
enum	ProductImplType
enum	QRPreconditioners
enum	Sequential_t
enum	SideType
enum	SimplicialCholeskyMode
enum	SpecializedType
enum	StorageOptions
enum	TransformTraits
enum	TraversalType
enum	UnrollingType
enum	UpLoType

Functions
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs_op< typename Derived::Scalar >, const Derived >	abs (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	abs (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs2_op< typename Derived::Scalar >, const Derived >	abs2 (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	abs2 (const Eigen::AutoDiffScalar< DerType > &x)
template<typename Derived , typename OtherDerived >
Derived::Scalar	accurateDot (const SparseMatrixBase< Derived > &A, const SparseMatrixBase< OtherDerived > &other)
	computes an accurate dot product on two sparse vectors More...
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_acos_op< typename Derived::Scalar >, const Derived >	acos (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	acos (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_acosh_op< typename Derived::Scalar >, const Derived >	acosh (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_arg_op< typename Derived::Scalar >, const Derived >	arg (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_asin_op< typename Derived::Scalar >, const Derived >	asin (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	asin (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_asinh_op< typename Derived::Scalar >, const Derived >	asinh (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_atan_op< typename Derived::Scalar >, const Derived >	atan (const Eigen::ArrayBase< Derived > &x)
template<typename DerTypeA , typename DerTypeB >
AutoDiffScalar< Matrix< typename internal::traits< internal::remove_all_t< DerTypeA > >::Scalar, Dynamic, 1 > >	atan2 (const AutoDiffScalar< DerTypeA > &a, const AutoDiffScalar< DerTypeB > &b)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_atanh_op< typename Derived::Scalar >, const Derived >	atanh (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
const 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::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0e_op< typename Derived::Scalar >, const Derived >	bessel_i0e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
const 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::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1e_op< typename Derived::Scalar >, const Derived >	bessel_i1e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
const 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::CwiseUnaryOp< Eigen::internal::scalar_bessel_j1_op< typename Derived::Scalar >, const Derived >	bessel_j1 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
const 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::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0e_op< typename Derived::Scalar >, const Derived >	bessel_k0e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
const 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::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1e_op< typename Derived::Scalar >, const Derived >	bessel_k1e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
const 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::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 >
const TensorCwiseTernaryOp< internal::scalar_betainc_op< typename XDerived::Scalar >, const ADerived, const BDerived, const XDerived >	betainc (const ADerived &a, const BDerived &b, const XDerived &x)
template<typename ArgADerived , typename ArgBDerived , typename ArgXDerived >
const Eigen::CwiseTernaryOp< Eigen::internal::scalar_betainc_op< typename ArgXDerived::Scalar >, const ArgADerived, const ArgBDerived, const ArgXDerived >	betainc (const Eigen::ArrayBase< ArgADerived > &a, const Eigen::ArrayBase< ArgBDerived > &b, const Eigen::ArrayBase< ArgXDerived > &x)
Box2d	bounding_box (const Vector2d &v)
template<typename 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)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_carg_op< typename Derived::Scalar >, const Derived >	carg (const Eigen::ArrayBase< Derived > &x)
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)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_ceil_op< typename Derived::Scalar >, const Derived >	ceil (const Eigen::ArrayBase< Derived > &x)
template<typename T1 , typename T2 >
EIGEN_ALWAYS_INLINE const T2 &	choose (Cond< false >, const T1 &, const T2 &second)
template<typename T1 , typename T2 >
EIGEN_ALWAYS_INLINE const T1 &	choose (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)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_conjugate_op< typename Derived::Scalar >, const Derived >	conj (const Eigen::ArrayBase< Derived > &x)
template<typename T >
T *	constCast (const T *data)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cos_op< typename Derived::Scalar >, const Derived >	cos (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	cos (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cosh_op< typename Derived::Scalar >, const Derived >	cosh (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	cosh (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cube_op< typename Derived::Scalar >, const Derived >	cube (const Eigen::ArrayBase< Derived > &x)
template<typename SplineType , typename DerivativeType >
void	derivativesImpl (const SplineType &spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType &der)
const uint8_t *	deserialize (const uint8_t *src, const uint8_t *end, Args &... args)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_digamma_op< typename Derived::Scalar >, const Derived >	digamma (const Eigen::ArrayBase< Derived > &x)
template<typename Dims1 , typename Dims2 >
EIGEN_ALWAYS_INLINE bool	dimensions_match (Dims1 dims1, Dims2 dims2)
template<typename T >
EIGEN_ALWAYS_INLINE T	divup (const T x, const T y)
template<typename T , typename X , typename Y >
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)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_erf_op< typename Derived::Scalar >, const Derived >	erf (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_erfc_op< typename Derived::Scalar >, const Derived >	erfc (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_exp_op< typename Derived::Scalar >, const Derived >	exp (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	exp (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_expm1_op< typename Derived::Scalar >, const Derived >	expm1 (const Eigen::ArrayBase< Derived > &x)
static const auto	fix ()
static const auto	fix (int val)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_floor_op< typename Derived::Scalar >, const Derived >	floor (const Eigen::ArrayBase< Derived > &x)
template<typename AlphaDerived , typename SampleDerived >
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_gamma_sample_der_alpha_op< typename AlphaDerived::Scalar >, const AlphaDerived, const SampleDerived >	gamma_sample_der_alpha (const Eigen::ArrayBase< AlphaDerived > &alpha, const Eigen::ArrayBase< SampleDerived > &sample)
bool	getMarketHeader (const std::string &filename, int &sym, bool &iscomplex, bool &isdense)
	Reads the header of a matrixmarket file and determines the properties of a matrix. More...
template<typename Scalar >
void	glLoadMatrix (const Transform< Scalar, 3, Affine > &t)
template<typename Scalar >
void	glLoadMatrix (const Transform< Scalar, 3, AffineCompact > &t)
template<typename Scalar >
void	glLoadMatrix (const Transform< Scalar, 3, Projective > &t)
template<typename Scalar >
void	glMultMatrix (const Transform< Scalar, 3, Affine > &t)
template<typename Scalar >
void	glMultMatrix (const Transform< Scalar, 3, AffineCompact > &t)
template<typename Scalar >
void	glMultMatrix (const Transform< Scalar, 3, Projective > &t)
void	glRotate (const Rotation2D< double > &rot)
void	glRotate (const Rotation2D< float > &rot)
template<typename Derived >
void	glRotate (const RotationBase< Derived, 3 > &rot)
template<typename Scalar >
void	glScale (const UniformScaling< Scalar > &s)
void	glScale2dv (const double *v)
void	glScale2fv (const float *v)
void	glScale3dv (const double *v)
void	glScale3fv (const float *v)
template<typename Scalar >
void	glTranslate (const Translation< Scalar, 2 > &t)
template<typename Scalar >
void	glTranslate (const Translation< Scalar, 3 > &t)
void	glTranslate2dv (const double *v)
void	glTranslate2fv (const float *v)
void	glTranslate3dv (const double *v)
void	glTranslate3fv (const float *v)
HouseholderSequence< VectorsType, CoeffsType >	householderSequence (const VectorsType &v, const CoeffsType &h)
template<typename Derived , typename ExponentDerived >
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_igamma_op< typename Derived::Scalar >, const Derived, const ExponentDerived >	igamma (const Eigen::ArrayBase< Derived > &a, const Eigen::ArrayBase< ExponentDerived > &x)
template<typename Derived , typename ExponentDerived >
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_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::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 > &)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_imag_op< typename Derived::Scalar >, const Derived >	imag (const Eigen::ArrayBase< Derived > &x)
void	initParallel ()
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_inverse_op< typename Derived::Scalar >, const Derived >	inverse (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isfinite_op< typename Derived::Scalar >, const Derived >	isfinite (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isinf_op< typename Derived::Scalar >, const Derived >	isinf (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isnan_op< typename Derived::Scalar >, const Derived >	isnan (const Eigen::ArrayBase< Derived > &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)
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, B >	kroneckerProduct (const EigenBase< A > &a, const EigenBase< B > &b)
template<typename A , typename B >
KroneckerProduct< A, B >	kroneckerProduct (const MatrixBase< A > &a, const MatrixBase< B > &b)
std::ptrdiff_t	l1CacheSize ()
std::ptrdiff_t	l2CacheSize ()
std::ptrdiff_t	l3CacheSize ()
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_lgamma_op< typename Derived::Scalar >, const Derived >	lgamma (const Eigen::ArrayBase< Derived > &x)
template<typename SparseMatrixType >
bool	loadMarket (SparseMatrixType &mat, const std::string &filename)
	Loads a sparse matrix from a matrixmarket format file. More...
template<typename DenseType >
bool	loadMarketDense (DenseType &mat, const std::string &filename)
	Loads a dense Matrix or Vector from a matrixmarket file. If a statically sized matrix has to be parsed and the file contains the wrong dimensions it is undefined behaviour. More...
template<typename VectorType >
bool	loadMarketVector (VectorType &vec, const std::string &filename)
	Same functionality as loadMarketDense, deprecated. More...
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log_op< typename Derived::Scalar >, const Derived >	log (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	log (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log10_op< typename Derived::Scalar >, const Derived >	log10 (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log1p_op< typename Derived::Scalar >, const Derived >	log1p (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log2_op< typename Derived::Scalar >, const Derived >	log2 (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_logistic_op< typename Derived::Scalar >, const Derived >	logistic (const Eigen::ArrayBase< Derived > &x)
template<typename FirstType , typename... OtherTypes>
constexpr IndexList< FirstType, OtherTypes... >	make_index_list (FirstType val1, OtherTypes... other_vals)
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)
int	nbThreads ()
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_ndtri_op< typename Derived::Scalar >, const Derived >	ndtri (const Eigen::ArrayBase< Derived > &x)
template<typename U , typename V >
EIGEN_CONSTEXPR bool	operator!= (const Pair< U, V > &x, const Pair< U, V > &y)
const Product< Inverse< PermutationType >, SparseDerived, AliasFreeProduct >	operator* (const InverseImpl< PermutationType, PermutationStorage > &tperm, const SparseMatrixBase< SparseDerived > &matrix)
const Product< MatrixDerived, PermutationDerived, AliasFreeProduct >	operator* (const MatrixBase< MatrixDerived > &matrix, const PermutationBase< PermutationDerived > &permutation)
const Product< MatrixDerived, TranspositionsDerived, AliasFreeProduct >	operator* (const MatrixBase< MatrixDerived > &matrix, const TranspositionsBase< TranspositionsDerived > &transpositions)
internal::matrix_type_times_scalar_type< typename VectorsType::Scalar, OtherDerived >::Type	operator* (const MatrixBase< OtherDerived > &other, const HouseholderSequence< VectorsType, CoeffsType, Side > &h)
const Product< PermDerived, SparseDerived, AliasFreeProduct >	operator* (const PermutationBase< PermDerived > &perm, const SparseMatrixBase< SparseDerived > &matrix)
const Product< PermutationDerived, MatrixDerived, AliasFreeProduct >	operator* (const PermutationBase< PermutationDerived > &permutation, const MatrixBase< MatrixDerived > &matrix)
const Product< SparseDerived, Inverse< PermutationType >, AliasFreeProduct >	operator* (const SparseMatrixBase< SparseDerived > &matrix, const InverseImpl< PermutationType, PermutationStorage > &tperm)
const Product< SparseDerived, PermDerived, AliasFreeProduct >	operator* (const SparseMatrixBase< SparseDerived > &matrix, const PermutationBase< PermDerived > &perm)
const Product< TranspositionsDerived, MatrixDerived, AliasFreeProduct >	operator* (const TranspositionsBase< TranspositionsDerived > &transpositions, const MatrixBase< MatrixDerived > &matrix)
const CwiseBinaryOp< internal::scalar_sum_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator+ (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
const CwiseBinaryOp< internal::scalar_sum_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator+ (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
const CwiseBinaryOp< internal::scalar_difference_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator- (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
const CwiseBinaryOp< internal::scalar_difference_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator- (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
template<typename IndexType , int NumDims>
std::ostream &	operator<< (std::ostream &os, const DSizes< IndexType, NumDims > &dims)
template<typename FirstType , typename... OtherTypes>
std::ostream &	operator<< (std::ostream &os, const IndexList< FirstType, OtherTypes... > &dims)
std::ostream &	operator<< (std::ostream &s, const DiagonalBase< Derived > &m)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const TensorBase< T, ReadOnlyAccessors > &t)
template<typename U , typename V >
EIGEN_CONSTEXPR bool	operator== (const Pair< U, V > &x, const Pair< 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::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 DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(internal::remove_all_t< DerType >, typename internal::traits< internal::remove_all_t< DerType >>::Scalar, product) >	pow (const Eigen::AutoDiffScalar< DerType > &x, const typename internal::traits< internal::remove_all_t< DerType >>::Scalar &y)
template<typename DerType >
const AutoDiffScalar< DerType > &	real (const AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_real_op< typename Derived::Scalar >, const Derived >	real (const Eigen::ArrayBase< Derived > &x)
HouseholderSequence< VectorsType, CoeffsType, OnTheRight >	rightHouseholderSequence (const VectorsType &v, const CoeffsType &h)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_rint_op< typename Derived::Scalar >, const Derived >	rint (const Eigen::ArrayBase< Derived > &x)
template<typename RootVector , typename Polynomial >
void	roots_to_monicPolynomial (const RootVector &rv, Polynomial &poly)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_round_op< typename Derived::Scalar >, const Derived >	round (const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_rsqrt_op< typename Derived::Scalar >, const Derived >	rsqrt (const Eigen::ArrayBase< Derived > &x)
template<typename SparseMatrixType >
bool	saveMarket (const SparseMatrixType &mat, const std::string &filename, int sym=0)
	writes a sparse Matrix to a marketmarket format file More...
template<typename DenseType >
bool	saveMarketDense (const DenseType &mat, const std::string &filename)
	writes a dense Matrix or vector to a marketmarket format file More...
template<typename VectorType >
bool	saveMarketVector (const VectorType &vec, const std::string &filename)
	Same functionality as saveMarketDense, deprecated. More...
const DiagonalWrapper< const Derived >	Scaling (const MatrixBase< Derived > &coeffs)
DiagonalMatrix< Scalar, 2 >	Scaling (const Scalar &sx, const Scalar &sy)
DiagonalMatrix< Scalar, 3 >	Scaling (const Scalar &sx, const Scalar &sy, const Scalar &sz)
UniformScaling< std::complex< RealScalar > >	Scaling (const std::complex< RealScalar > &s)
UniformScaling< double >	Scaling (double s)
UniformScaling< float >	Scaling (float s)
DiagonalWrapper< const Derived >::PlainObject	Scaling (MatrixBase< Derived > &&coeffs)
auto	seq (FirstType f, LastType l)
auto	seq (FirstType f, LastType l, IncrType incr)
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type >	seqN (FirstType first, SizeType size)
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type, typename internal::cleanup_seq_incr< IncrType >::type >	seqN (FirstType first, SizeType size, IncrType incr)
uint8_t *	serialize (uint8_t *dest, uint8_t *end, const Args &... args)
size_t	serialize_size (const Args &... args)
void	setCpuCacheSizes (std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
void	setNbThreads (int v)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sign_op< typename Derived::Scalar >, const Derived >	sign (const Eigen::ArrayBase< Derived > &x)
static const char *	SimdInstructionSetsInUse (void)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sin_op< typename Derived::Scalar >, const Derived >	sin (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	sin (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sinh_op< typename Derived::Scalar >, const Derived >	sinh (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	sinh (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sqrt_op< typename Derived::Scalar >, const Derived >	sqrt (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	sqrt (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_square_op< typename Derived::Scalar >, const Derived >	square (const Eigen::ArrayBase< Derived > &x)
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)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_tan_op< typename Derived::Scalar >, const Derived >	tan (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	tan (const Eigen::AutoDiffScalar< DerType > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_tanh_op< typename Derived::Scalar >, const Derived >	tanh (const Eigen::ArrayBase< Derived > &x)
template<typename DerType >
Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t< DerType >, typename Eigen::internal::traits< Eigen::internal::remove_all_t< DerType >>::Scalar, product) >	tanh (const Eigen::AutoDiffScalar< DerType > &x)
internal::umeyama_transform_matrix_type< Derived, OtherDerived >::type	umeyama (const MatrixBase< Derived > &src, const MatrixBase< OtherDerived > &dst, bool with_scaling=true)
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])
const cholmod_sparse	viewAsCholmod (const SparseMatrix< Scalar_, Options_, Index_ > &mat)
cholmod_sparse	viewAsCholmod (const SparseSelfAdjointView< const SparseMatrix< Scalar_, Options_, Index_ >, UpLo > &mat)
const cholmod_sparse	viewAsCholmod (const SparseVector< Scalar_, Options_, Index_ > &mat)
cholmod_dense	viewAsCholmod (MatrixBase< Derived > &mat)
cholmod_sparse	viewAsCholmod (Ref< SparseMatrix< Scalar_, Options_, StorageIndex_ > > mat)
Map< SparseMatrix< Scalar, Flags, StorageIndex > >	viewAsEigen (cholmod_sparse &cm)
template<typename DerivedX , typename DerivedQ >
const Eigen::CwiseBinaryOp< Eigen::internal::scalar_zeta_op< typename DerivedX::Scalar >, const DerivedX, const DerivedQ >	zeta (const Eigen::ArrayBase< DerivedX > &x, const Eigen::ArrayBase< DerivedQ > &q)

Variables
	ABx_lx
const unsigned int	ActualPacketAccessBit
	Affine
	AffineCompact
	AliasFreeProduct
	Aligned
	Aligned128
	Aligned16
	Aligned32
	Aligned64
	Aligned8
EIGEN_DEPRECATED const unsigned int	AlignedBit
	AlignedMask
	AlignedMax
	AllAtOnceTraversal
	AutoAlign
const int	AutoOrder
	AutoSize
	Ax_lBx
	BAx_lx
	BothDirections
	BuiltIn
	CholmodAuto
	CholmodLDLt
	CholmodSimplicialLLt
	CholmodSupernodalLLt
	CoeffBasedProductMode
const int	CoherentAccessPattern
	ColMajor
	ColPivHouseholderQRPreconditioner
	CompleteUnrolling
const unsigned int	CompressedAccessBit
	ComputeEigenvectors
	ComputeFullU
	ComputeFullV
	ComputeThinU
	ComputeThinV
	Default
	DefaultProduct
	DefaultTraversal
const unsigned int	DirectAccessBit
	DirectAccessors
	DirectWriteAccessors
	DisableQRDecomposition
	DontAlign
	DontAlignCols
const int	Dynamic
const int	DynamicIndex
	EigenvaluesOnly
	EigVecMask
EIGEN_DEPRECATED const unsigned int	EvalBeforeAssigningBit
const unsigned int	EvalBeforeNestingBit
	FullPivHouseholderQRPreconditioner
	FullPrecision
	GemmProduct
	GemvProduct
	GenEigMask
	GetAction
const unsigned int	HereditaryBits
	Horizontal
	HouseholderQRPreconditioner
const int	HugeCost
const int	Infinity
	InnerProduct
const int	InnerRandomAccessPattern
	InnerUnrolling
	InnerVectorizedTraversal
	InvalidInput
	InvalidTraversal
	IsDense
	Isometry
	IsSparse
	Large
	LazyCoeffBasedProductMode
	LazyProduct
const unsigned int	LinearAccessBit
	LinearTraversal
	LinearVectorizedTraversal
	Lower
const unsigned int	LvalueBit
const unsigned int	NestByRefBit
	NoChange
	NoConvergence
	NoPivoting
const unsigned int	NoPreferredStorageOrderBit
	NoQRPreconditioner
	NoUnrolling
	NumericalIssue
	OnTheLeft
	OnTheRight
	OuterProduct
const int	OuterRandomAccessPattern
const unsigned int	PacketAccessBit
	Pivoting
	Projective
	PropagateFast
	PropagateNaN
	PropagateNumbers
const int	RandomAccessPattern
	ReadOnlyAccessors
	RowMajor
const unsigned int	RowMajorBit
	SelfAdjoint
	Sequential
	SetAction
	SimplicialCholeskyLDLT
	SimplicialCholeskyLLT
const unsigned int	SkylineBit
	SliceVectorizedTraversal
	Small
	Specialized
	StandardCompressedFormat
	StreamPrecision
	StrictlyLower
	StrictlyUpper
	Success
	Symmetric
	Unaligned
const int	UndefinedIncr
	UnitDiag
	UnitLower
	UnitUpper
	Upper
	Vertical
	WriteAccessors
	ZeroDiag

Detailed Description

: TensorContractionSycl.h, provides various tensor contraction kernel for SYCL backend

Namespace containing all symbols from the Eigen library.

: Tensor Scan Sycl implement the extend version of "Efficient parallel scan algorithms for GPUs." .for Tensor operations. The algorithm requires up to 3 stage (consequently 3 kernels) depending on the size of the tensor. In the first kernel (ScanKernelFunctor), each threads within the work-group individually reduces the allocated elements per thread in order to reduces the total number of blocks. In the next step all thread within the work-group will reduce the associated blocks into the temporary buffers. In the next kernel(ScanBlockKernelFunctor), the temporary buffer is given as an input and all the threads within a work-group scan and reduces the boundaries between the blocks (generated from the previous kernel). and write the data on the temporary buffer. If the second kernel is required, the third and final kernel (ScanAdjustmentKernelFunctor) will adjust the final result into the output buffer. The original algorithm for the parallel prefix sum can be found here:

: This is the specialization of the reduction operation. Two phase reduction approach is used since the GPU does not have Global Synchronization for global memory among different work-group/thread block. To solve the problem, we need to create two kernels to reduce the data, where the first kernel reduce the data locally and each local workgroup/thread-block save the input data into global memory. In the second phase (global reduction) one work-group uses one work-group/thread-block to reduces the intermediate data into one single element. Here is an NVIDIA presentation explaining the optimized two phase reduction algorithm on GPU: https://developer.download.nvidia.com/assets/cuda/files/reduction.pdf

TensorContractionSycl.h

TensorReductionSycl.h

TensorScanSycl.h

Sengupta, Shubhabrata, Mark Harris, and Michael Garland. "Efficient parallel scan algorithms for GPUs." NVIDIA, Santa Clara, CA, Tech. Rep. NVR-2008-003 1, no. 1 (2008): 1-17.

Typedef Documentation

Spline2d

typedef Spline<double,2> Eigen::Spline2d

2D double B-spline with dynamic degree.

Definition at line 88 of file SplineFwd.h.

Spline2f

typedef Spline<float,2> Eigen::Spline2f

2D float B-spline with dynamic degree.

Definition at line 82 of file SplineFwd.h.

Spline3d

typedef Spline<double,3> Eigen::Spline3d

3D double B-spline with dynamic degree.

Definition at line 91 of file SplineFwd.h.

Spline3f

typedef Spline<float,3> Eigen::Spline3f

3D float B-spline with dynamic degree.

Definition at line 85 of file SplineFwd.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
NegationFlag
ConjugationFlag

Definition at line 17 of file Symmetry.h.

     {
  NegationFlag           = 0x01,
  ConjugationFlag        = 0x02
};

Code

anonymous enum

anonymous enum

Enumerator
GlobalRealFlag
GlobalImagFlag
GlobalZeroFlag

Definition at line 22 of file Symmetry.h.

     {
  GlobalRealFlag         = 0x01,
  GlobalImagFlag         = 0x02,
  GlobalZeroFlag         = 0x03
};

Code

anonymous enum

anonymous enum

Enumerator
IsSkyline

Definition at line 26 of file SkylineUtil.h.

{IsSkyline = SkylineBit};

Code

anonymous enum

anonymous enum

Enumerator
SPD
NonSymmetric

Definition at line 18 of file MatrixMarketIterator.h.

     {
  SPD = 0x100,
  NonSymmetric = 0x0
}; 

Code

AdditionalProductEvaluationMode

enum Eigen::AdditionalProductEvaluationMode

Enumerator
SkylineTimeDenseProduct
SkylineTimeSkylineProduct
DenseTimeSkylineProduct

Definition at line 25 of file SkylineUtil.h.

{SkylineTimeDenseProduct, SkylineTimeSkylineProduct, DenseTimeSkylineProduct};

Code

convolution_type

enum Eigen::convolution_type

strong

Enumerator
CONV1D
CONV2D
CONV3D

Definition at line 30 of file TensorConvolutionSycl.h.

{ CONV1D, CONV2D, CONV3D };

Code

FFTDirection

enum Eigen::FFTDirection

Enumerator
FFT_FORWARD
FFT_REVERSE

Definition at line 124 of file TensorForwardDeclarations.h.

                  {
    FFT_FORWARD = 0,
    FFT_REVERSE = 1
};

Code

FFTResultType

enum Eigen::FFTResultType

Enumerator
RealPart
ImagPart
BothParts

Definition at line 118 of file TensorForwardDeclarations.h.

                   {
  RealPart = 0,
  ImagPart = 1,
  BothParts = 2
};

Code

NumericalDiffMode

enum Eigen::NumericalDiffMode

Enumerator
Forward
Central

Definition at line 20 of file NumericalDiff.h.

                       {
    Forward,
    Central
};

Code

PaddingType

enum Eigen::PaddingType

Enumerator
PADDING_VALID
PADDING_SAME

Definition at line 259 of file TensorTraits.h.

                 {
  PADDING_VALID = 1,
  PADDING_SAME = 2
};

Code

Function Documentation

abs()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::abs ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 613 of file AutoDiffScalar.h.

: 1) );)

Code

abs2()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::abs2 ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 617 of file AutoDiffScalar.h.

accurateDot()

template<typename Derived , typename OtherDerived >

Derived::Scalar Eigen::accurateDot	(	const SparseMatrixBase< Derived > &	A,
		const SparseMatrixBase< OtherDerived > &	other
	)

computes an accurate dot product on two sparse vectors

Uses an accurate summation algorithm for the accumulator in order to compute an accurate dot product for two sparse vectors.

Definition at line 80 of file SparseInverse.h.

                                                                                                                    {
  typedef typename Derived::Scalar Scalar;
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived, OtherDerived)
  static_assert(internal::is_same<Scalar, typename OtherDerived::Scalar>::value, "mismatched types");
 
  internal::evaluator<Derived> thisEval(A.derived());
  typename Derived::ReverseInnerIterator i(thisEval, 0);
 
  internal::evaluator<OtherDerived> otherEval(other.derived());
  typename OtherDerived::ReverseInnerIterator j(otherEval, 0);
 
  FABSum<Scalar> res;
  while (i && j) {
    if (i.index() == j.index()) {
      res += numext::conj(i.value()) * j.value();
      --i;
      --j;
    } else if (i.index() > j.index())
      --i;
    else
      --j;
  }
  return res.value();
}

Code

acos()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::acos ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 685 of file AutoDiffScalar.h.

asin()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::asin ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 680 of file AutoDiffScalar.h.

atan2()

template<typename DerTypeA , typename DerTypeB >

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

inline

Definition at line 656 of file AutoDiffScalar.h.

{
  using std::atan2;
  typedef typename internal::traits<internal::remove_all_t<DerTypeA>>::Scalar Scalar;
  typedef AutoDiffScalar<Matrix<Scalar,Dynamic,1> > PlainADS;
  PlainADS ret;
  ret.value() = atan2(a.value(), b.value());
  
  Scalar squared_hypot = a.value() * a.value() + b.value() * b.value();
  
  // if (squared_hypot==0) the derivation is undefined and the following results in a NaN:
  ret.derivatives() = (a.derivatives() * b.value() - a.value() * b.derivatives()) / squared_hypot;
 
  return ret;
}

Code

bessel_i0()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i0 ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_i0()

Definition at line 34 of file BesselFunctionsArrayAPI.h.

                                            {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_i0e()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i0e ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_i0e()

Definition at line 57 of file BesselFunctionsArrayAPI.h.

                                             {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_i1()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i1 ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_i1()

Definition at line 79 of file BesselFunctionsArrayAPI.h.

                                            {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_i1e()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i1e ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_i1e()

Definition at line 102 of file BesselFunctionsArrayAPI.h.

                                             {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_j0()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_j0 ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_j0()

Definition at line 214 of file BesselFunctionsArrayAPI.h.

                                            {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_j1()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_j1 ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_j1()

Definition at line 258 of file BesselFunctionsArrayAPI.h.

                                            {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_k0()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k0 ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_k0()

Definition at line 124 of file BesselFunctionsArrayAPI.h.

                                            {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_k0e()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k0e ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_k0e()

Definition at line 147 of file BesselFunctionsArrayAPI.h.

                                             {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_k1()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k1 ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_k1()

Definition at line 169 of file BesselFunctionsArrayAPI.h.

                                            {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_k1e()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k1e ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_k1e()

Definition at line 192 of file BesselFunctionsArrayAPI.h.

                                             {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_y0()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_y0 ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_y0()

Definition at line 236 of file BesselFunctionsArrayAPI.h.

                                            {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

bessel_y1()

template<typename Derived >

const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_y1 ( const Eigen::ArrayBase< Derived > &  x )

inline

Returns

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

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

Parameters

x	is the argument

Note

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

See also

ArrayBase::bessel_y1()

Definition at line 280 of file BesselFunctionsArrayAPI.h.

                                            {
  return Eigen::CwiseUnaryOp<
      Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>,
      const Derived>(x.derived());
}

Code

betainc() [1/2]

template<typename ADerived , typename BDerived , typename XDerived >

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

inline

[c++11]

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 26 of file TensorGlobalFunctions.h.

                                                                     {
  return TensorCwiseTernaryOp<
      internal::scalar_betainc_op<typename XDerived::Scalar>, const ADerived,
      const BDerived, const XDerived>(
      a, b, x, internal::scalar_betainc_op<typename XDerived::Scalar>());
}

Code

betainc() [2/2]

template<typename ArgADerived , typename ArgBDerived , typename ArgXDerived >

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

inline

[c++11]

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 134 of file SpecialFunctionsArrayAPI.h.

{
  return Eigen::CwiseTernaryOp<Eigen::internal::scalar_betainc_op<typename ArgXDerived::Scalar>, const ArgADerived, const ArgBDerived, const ArgXDerived>(
    a.derived(),
    b.derived(),
    x.derived()
  );
}

Code

bounding_box()

Box2d Eigen::bounding_box

(

const Vector2d &

v

)

Definition at line 9 of file BVH_Example.cpp.

{ return Box2d(v, v); } //compute the bounding box of a single point

Code

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

Code

Definition at line 81 of file BVAlgorithms.h.

{
  internal::intersect_helper(tree, intersector, tree.getRootIndex());
}

Code

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

Code

Definition at line 95 of file BVAlgorithms.h.

{
  typedef typename BVH1::Index Index1;
  typedef typename BVH2::Index Index2;
  typedef internal::intersector_helper1<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object, Intersector> Helper1;
  typedef internal::intersector_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object, Intersector> Helper2;
  typedef typename BVH1::VolumeIterator VolIter1;
  typedef typename BVH1::ObjectIterator ObjIter1;
  typedef typename BVH2::VolumeIterator VolIter2;
  typedef typename BVH2::ObjectIterator ObjIter2;
 
  VolIter1 vBegin1 = VolIter1(), vEnd1 = VolIter1();
  ObjIter1 oBegin1 = ObjIter1(), oEnd1 = ObjIter1();
  VolIter2 vBegin2 = VolIter2(), vEnd2 = VolIter2(), vCur2 = VolIter2();
  ObjIter2 oBegin2 = ObjIter2(), oEnd2 = ObjIter2(), oCur2 = ObjIter2();
 
  std::vector<std::pair<Index1, Index2> > todo(1, std::make_pair(tree1.getRootIndex(), tree2.getRootIndex()));
 
  while(!todo.empty()) {
    tree1.getChildren(todo.back().first, vBegin1, vEnd1, oBegin1, oEnd1);
    tree2.getChildren(todo.back().second, vBegin2, vEnd2, oBegin2, oEnd2);
    todo.pop_back();
 
    for(; vBegin1 != vEnd1; ++vBegin1) { //go through child volumes of first tree
      const typename BVH1::Volume &vol1 = tree1.getVolume(*vBegin1);
      for(vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) { //go through child volumes of second tree
        if(intersector.intersectVolumeVolume(vol1, tree2.getVolume(*vCur2)))
          todo.push_back(std::make_pair(*vBegin1, *vCur2));
      }
 
      for(oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {//go through child objects of second tree
        Helper1 helper(*oCur2, intersector);
        if(internal::intersect_helper(tree1, helper, *vBegin1))
          return; //intersector said to stop query
      }
    }
 
    for(; oBegin1 != oEnd1; ++oBegin1) { //go through child objects of first tree
      for(vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) { //go through child volumes of second tree
        Helper2 helper(*oBegin1, intersector);
        if(internal::intersect_helper(tree2, helper, *vCur2))
          return; //intersector said to stop query
      }
 
      for(oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {//go through child objects of second tree
        if(intersector.intersectObjectObject(*oBegin1, *oCur2))
          return; //intersector said to stop query
      }
    }
  }
}

Code

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)

Code

Definition at line 221 of file BVAlgorithms.h.

{
  return internal::minimize_helper(tree, minimizer, tree.getRootIndex(), (std::numeric_limits<typename Minimizer::Scalar>::max)());
}

Code

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)

Code

Definition at line 237 of file BVAlgorithms.h.

{
  typedef typename Minimizer::Scalar Scalar;
  typedef typename BVH1::Index Index1;
  typedef typename BVH2::Index Index2;
  typedef internal::minimizer_helper1<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object, Minimizer> Helper1;
  typedef internal::minimizer_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object, Minimizer> Helper2;
  typedef std::pair<Scalar, std::pair<Index1, Index2> > QueueElement; //first element is priority
  typedef typename BVH1::VolumeIterator VolIter1;
  typedef typename BVH1::ObjectIterator ObjIter1;
  typedef typename BVH2::VolumeIterator VolIter2;
  typedef typename BVH2::ObjectIterator ObjIter2;
 
  VolIter1 vBegin1 = VolIter1(), vEnd1 = VolIter1();
  ObjIter1 oBegin1 = ObjIter1(), oEnd1 = ObjIter1();
  VolIter2 vBegin2 = VolIter2(), vEnd2 = VolIter2(), vCur2 = VolIter2();
  ObjIter2 oBegin2 = ObjIter2(), oEnd2 = ObjIter2(), oCur2 = ObjIter2();
  std::priority_queue<QueueElement, std::vector<QueueElement>, std::greater<QueueElement> > todo; //smallest is at the top
 
  Scalar minimum = (std::numeric_limits<Scalar>::max)();
  todo.push(std::make_pair(Scalar(), std::make_pair(tree1.getRootIndex(), tree2.getRootIndex())));
 
  while(!todo.empty()) {
    tree1.getChildren(todo.top().second.first, vBegin1, vEnd1, oBegin1, oEnd1);
    tree2.getChildren(todo.top().second.second, vBegin2, vEnd2, oBegin2, oEnd2);
    todo.pop();
 
    for(; oBegin1 != oEnd1; ++oBegin1) { //go through child objects of first tree
      for(oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {//go through child objects of second tree
        minimum = (std::min)(minimum, minimizer.minimumOnObjectObject(*oBegin1, *oCur2));
      }
 
      for(vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) { //go through child volumes of second tree
        Helper2 helper(*oBegin1, minimizer);
        minimum = (std::min)(minimum, internal::minimize_helper(tree2, helper, *vCur2, minimum));
      }
    }
 
    for(; vBegin1 != vEnd1; ++vBegin1) { //go through child volumes of first tree
      const typename BVH1::Volume &vol1 = tree1.getVolume(*vBegin1);
 
      for(oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {//go through child objects of second tree
        Helper1 helper(*oCur2, minimizer);
        minimum = (std::min)(minimum, internal::minimize_helper(tree1, helper, *vBegin1, minimum));
      }
 
      for(vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) { //go through child volumes of second tree
        Scalar val = minimizer.minimumOnVolumeVolume(vol1, tree2.getVolume(*vCur2));
        if(val < minimum)
          todo.push(std::make_pair(val, std::make_pair(*vBegin1, *vCur2)));
      }
    }
  }
  return minimum;
}

Code

choose() [1/2]

template<typename T1 , typename T2 >

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

Definition at line 25 of file TensorMeta.h.

                                                           {
  return second;
}

Code

choose() [2/2]

template<typename T1 , typename T2 >

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

Definition at line 20 of file TensorMeta.h.

                                                         {
  return first;
}

Code

conj()

template<typename DerType >

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

inline

Definition at line 576 of file AutoDiffScalar.h.

{ return x; }

Code

constCast()

template<typename T >

T* Eigen::constCast ( const T *  data )

inline

Examples

/home/runner/work/eigen/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h.

Definition at line 29 of file TensorForwardDeclarations.h.

                                                                  {
  return const_cast<T*>(data);
}

Code

cos()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::cos ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 627 of file AutoDiffScalar.h.

cosh()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::cosh ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 700 of file AutoDiffScalar.h.

: NumTraits< typename NumTraits<typename internal::remove_all_t<DerType>::Scalar>::Real >

Code

derivativesImpl()

template<typename SplineType , typename DerivativeType >

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

Definition at line 313 of file Spline.h.

  {    
    enum { Dimension = SplineTraits<SplineType>::Dimension };
    enum { Order = SplineTraits<SplineType>::OrderAtCompileTime };
    enum { DerivativeOrder = DerivativeType::ColsAtCompileTime };
 
    typedef typename SplineTraits<SplineType>::ControlPointVectorType ControlPointVectorType;
    typedef typename SplineTraits<SplineType,DerivativeOrder>::BasisDerivativeType BasisDerivativeType;
    typedef typename BasisDerivativeType::ConstRowXpr BasisDerivativeRowXpr;    
 
    const DenseIndex p = spline.degree();
    const DenseIndex span = spline.span(u);
 
    const DenseIndex n = (std::min)(p, order);
 
    der.resize(Dimension,n+1);
 
    // Retrieve the basis function derivatives up to the desired order...    
    const BasisDerivativeType basis_func_ders = spline.template basisFunctionDerivatives<DerivativeOrder>(u, n+1);
 
    // ... and perform the linear combinations of the control points.
    for (DenseIndex der_order=0; der_order<n+1; ++der_order)
    {
      const Replicate<BasisDerivativeRowXpr,Dimension,1> ctrl_weights( basis_func_ders.row(der_order) );
      const Block<const ControlPointVectorType,Dimension,Order> ctrl_pts(spline.ctrls(),0,span-p,Dimension,p+1);
      der.col(der_order) = (ctrl_weights * ctrl_pts).rowwise().sum();
    }
  }

Code

dimensions_match()

template<typename Dims1 , typename Dims2 >

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

Definition at line 441 of file TensorDimensions.h.

                                                                                      {
  return internal::sizes_match_below_dim<Dims1, Dims2, internal::array_size<Dims1>::value, internal::array_size<Dims2>::value>::run(dims1, dims2);
}

Code

divup() [1/2]

template<typename T >

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

Definition at line 39 of file TensorMeta.h.

                              {
  // Note: This form is used because it cannot overflow.
  return static_cast<T>(x == 0 ? 0 : (x - 1) / y + 1);
}

Code

divup() [2/2]

template<typename T , typename X , typename Y >

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

Definition at line 32 of file TensorMeta.h.

                              {
  // Note: This form is used because it cannot overflow.
  return static_cast<T>(x == 0 ? 0 : (x - 1) / y + 1);
}

Code

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
	)

exp()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::exp ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 637 of file AutoDiffScalar.h.

gamma_sample_der_alpha()

template<typename AlphaDerived , typename SampleDerived >

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

inline

[c++11]

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 74 of file SpecialFunctionsArrayAPI.h.

                                                                                                               {
  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_gamma_sample_der_alpha_op<typename AlphaDerived::Scalar>, const AlphaDerived, const SampleDerived>(
      alpha.derived(),
      sample.derived());
}

Code

glLoadMatrix() [1/3]

template<typename Scalar >

void Eigen::glLoadMatrix

(

const Transform< Scalar, 3, Affine > &

t

)

Definition at line 177 of file OpenGLSupport.

{ glLoadMatrix(t.matrix()); }

Code

glLoadMatrix() [2/3]

template<typename Scalar >

void Eigen::glLoadMatrix

(

const Transform< Scalar, 3, AffineCompact > &

t

)

Definition at line 179 of file OpenGLSupport.

{ glLoadMatrix(Transform<Scalar,3,Affine>(t).matrix()); }

Code

glLoadMatrix() [3/3]

template<typename Scalar >

void Eigen::glLoadMatrix

(

const Transform< Scalar, 3, Projective > &

t

)

Definition at line 178 of file OpenGLSupport.

{ glLoadMatrix(t.matrix()); }

Code

glMultMatrix() [1/3]

template<typename Scalar >

void Eigen::glMultMatrix

(

const Transform< Scalar, 3, Affine > &

t

)

Definition at line 169 of file OpenGLSupport.

{ glMultMatrix(t.matrix()); }

Code

glMultMatrix() [2/3]

template<typename Scalar >

void Eigen::glMultMatrix

(

const Transform< Scalar, 3, AffineCompact > &

t

)

Definition at line 171 of file OpenGLSupport.

{ glMultMatrix(Transform<Scalar,3,Affine>(t).matrix()); }

Code

glMultMatrix() [3/3]

template<typename Scalar >

void Eigen::glMultMatrix

(

const Transform< Scalar, 3, Projective > &

t

)

Definition at line 170 of file OpenGLSupport.

{ glMultMatrix(t.matrix()); }

Code

glRotate() [1/3]

void Eigen::glRotate ( const Rotation2D< double > &  rot )

inline

Definition at line 185 of file OpenGLSupport.

{
  glRotated(rot.angle()*180.0/double(EIGEN_PI), 0.0, 0.0, 1.0);
}

Code

glRotate() [2/3]

void Eigen::glRotate ( const Rotation2D< float > &  rot )

inline

Definition at line 181 of file OpenGLSupport.

{
  glRotatef(rot.angle()*180.f/float(EIGEN_PI), 0.f, 0.f, 1.f);
}

Code

glRotate() [3/3]

template<typename Derived >

void Eigen::glRotate

(

const RotationBase< Derived, 3 > &

rot

)

Definition at line 190 of file OpenGLSupport.

{  
  Transform<typename Derived::Scalar,3,Projective> tr(rot);
  glMultMatrix(tr.matrix());
}

Code

glScale()

template<typename Scalar >

void Eigen::glScale

(

const UniformScaling< Scalar > &

s

)

Definition at line 149 of file OpenGLSupport.

{ glScale(Matrix<Scalar,3,1>::Constant(s.factor())); }

Code

glScale2dv()

void Eigen::glScale2dv ( const double *  v )

inline

Definition at line 139 of file OpenGLSupport.

{ glScaled(v[0], v[1], 1.0);  }

Code

glScale2fv()

void Eigen::glScale2fv ( const float *  v )

inline

Definition at line 138 of file OpenGLSupport.

{ glScalef(v[0], v[1], 1.f);  }

Code

glScale3dv()

void Eigen::glScale3dv ( const double *  v )

inline

Definition at line 141 of file OpenGLSupport.

{ glScaled(v[0], v[1], v[2]); }

Code

glScale3fv()

void Eigen::glScale3fv ( const float *  v )

inline

Definition at line 140 of file OpenGLSupport.

{ glScalef(v[0], v[1], v[2]); }

Code

glTranslate() [1/2]

template<typename Scalar >

void Eigen::glTranslate

(

const Translation< Scalar, 2 > &

t

)

Definition at line 162 of file OpenGLSupport.

{ glTranslate(t.vector()); }

Code

glTranslate() [2/2]

template<typename Scalar >

void Eigen::glTranslate

(

const Translation< Scalar, 3 > &

t

)

Definition at line 163 of file OpenGLSupport.

{ glTranslate(t.vector()); }

Code

glTranslate2dv()

void Eigen::glTranslate2dv ( const double *  v )

inline

Definition at line 152 of file OpenGLSupport.

{ glTranslated(v[0], v[1], 0.0);  }

Code

glTranslate2fv()

void Eigen::glTranslate2fv ( const float *  v )

inline

Definition at line 151 of file OpenGLSupport.

{ glTranslatef(v[0], v[1], 0.f);  }

Code

glTranslate3dv()

void Eigen::glTranslate3dv ( const double *  v )

inline

Definition at line 154 of file OpenGLSupport.

{ glTranslated(v[0], v[1], v[2]); }

Code

glTranslate3fv()

void Eigen::glTranslate3fv ( const float *  v )

inline

Definition at line 153 of file OpenGLSupport.

{ glTranslatef(v[0], v[1], v[2]); }

Code

igamma()

template<typename Derived , typename ExponentDerived >

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

inline

[c++11]

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 30 of file SpecialFunctionsArrayAPI.h.

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

Code

igamma_der_a()

template<typename Derived , typename ExponentDerived >

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

inline

[c++11]

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 53 of file SpecialFunctionsArrayAPI.h.

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

Code

igammac()

template<typename Derived , typename ExponentDerived >

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

inline

[c++11]

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 92 of file SpecialFunctionsArrayAPI.h.

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

Code

imag()

template<typename DerType >

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

inline

Definition at line 580 of file AutoDiffScalar.h.

{ return 0.; }

Code

log()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::log ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 641 of file AutoDiffScalar.h.

make_index_list()

template<typename FirstType , typename... OtherTypes>

constexpr IndexList<FirstType, OtherTypes...> Eigen::make_index_list ( FirstType  val1, OtherTypes...  other_vals  )

constexpr

Definition at line 342 of file TensorIndexList.h.

                                                                                                        {
  return IndexList<FirstType, OtherTypes...>(val1, other_vals...);
}

Code

MakeAutoDiffScalar()

template<typename NewDerType >

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

inline

Definition at line 38 of file AutoDiffScalar.h.

                                                                                                                    {
  return AutoDiffScalar<NewDerType>(value,der);
}

Code

max() [1/3]

template<typename DerType >

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

inline

Definition at line 606 of file AutoDiffScalar.h.

                                                                                                                        {
  return (x.value() >= y.value() ? x : y);
}

Code

max() [2/3]

template<typename DerType , typename T >

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

inline

Definition at line 587 of file AutoDiffScalar.h.

                                                                                                  {
  typedef typename CleanedUpDerType<DerType>::type ADS;
  return (x >= y ? ADS(x) : ADS(y));
}

Code

max() [3/3]

template<typename DerType , typename T >

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

inline

Definition at line 597 of file AutoDiffScalar.h.

                                                                                                  {
  typedef typename CleanedUpDerType<DerType>::type ADS;
  return (x > y ? ADS(x) : ADS(y));
}

Code

min() [1/3]

template<typename DerType >

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

inline

Definition at line 602 of file AutoDiffScalar.h.

                                                                                                                        {
  return (x.value() < y.value() ? x : y);
}

Code

min() [2/3]

template<typename DerType , typename T >

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

inline

Definition at line 582 of file AutoDiffScalar.h.

                                                                                                  {
  typedef typename CleanedUpDerType<DerType>::type ADS;
  return (x <= y ? ADS(x) : ADS(y));
}

Code

min() [3/3]

template<typename DerType , typename T >

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

inline

Definition at line 592 of file AutoDiffScalar.h.

                                                                                                  {
  typedef typename CleanedUpDerType<DerType>::type ADS;
  return (x < y ? ADS(x) : ADS(y));
}

Code

operator!=()

template<typename U , typename V >

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

inline

Definition at line 246 of file TensorMeta.h.

                                                          {
  return !(x == y);
}

Code

operator<<() [1/3]

template<typename IndexType , int NumDims>

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

Definition at line 344 of file TensorDimensions.h.

                                                                 {
  os << "[";
  for (int i = 0; i < NumDims; ++i) {
    if (i > 0) os << ", ";
    os << dims[i];
  }
  os << "]";
  return os;
}

Code

operator<<() [2/3]

template<typename FirstType , typename... OtherTypes>

std::ostream& Eigen::operator<<	(	std::ostream &	os,
		const IndexList< FirstType, OtherTypes... > &	dims
	)

Definition at line 330 of file TensorIndexList.h.

                                                                          {
  os << "[";
  for (size_t i = 0; i < 1 + sizeof...(OtherTypes); ++i) {
    if (i > 0) os << ", ";
    os << dims[i];
  }
  os << "]";
  return os;
}

Code

operator<<() [3/3]

template<typename T >

std::ostream& Eigen::operator<<	(	std::ostream &	s,
		const TensorBase< T, ReadOnlyAccessors > &	t
	)

Definition at line 368 of file TensorIO.h.

                                                                                 {
  s << t.format(TensorIOFormat::Plain());
  return s;
}

Code

operator==()

template<typename U , typename V >

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

inline

Definition at line 240 of file TensorMeta.h.

                                                          {
  return (x.first == y.first && x.second == y.second);
}

Code

polygamma()

template<typename DerivedN , typename DerivedX >

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

inline

[c++11]

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 114 of file SpecialFunctionsArrayAPI.h.

{
  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_polygamma_op<typename DerivedX::Scalar>, const DerivedN, const DerivedX>(
    n.derived(),
    x.derived()
  );
}

Code

pow()

template<typename DerType >

Eigen::AutoDiffScalar<EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(internal::remove_all_t<DerType>, typename internal::traits<internal::remove_all_t<DerType>>::Scalar,product) > Eigen::pow ( const Eigen::AutoDiffScalar< DerType > &  x, const typename internal::traits< internal::remove_all_t< DerType >>::Scalar &  y  )

inline

Definition at line 646 of file AutoDiffScalar.h.

{
  using namespace Eigen;
  using std::pow;
  return Eigen::MakeAutoDiffScalar(pow(x.value(),y), x.derivatives() * (y * pow(x.value(),y-1)));
}

Code

real()

template<typename DerType >

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

inline

Definition at line 578 of file AutoDiffScalar.h.

{ return x; }

Code

sin()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::sin ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 632 of file AutoDiffScalar.h.

sinh()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::sinh ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 695 of file AutoDiffScalar.h.

sqrt()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::sqrt ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 622 of file AutoDiffScalar.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
	)

tan()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::tan ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 675 of file AutoDiffScalar.h.

tanh()

template<typename DerType >

Eigen::AutoDiffScalar< EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Eigen::internal::remove_all_t<DerType>, typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar, product) > Eigen::tanh ( const Eigen::AutoDiffScalar< DerType > &  x )

inline

Definition at line 690 of file AutoDiffScalar.h.

zeta()

template<typename DerivedX , typename DerivedQ >

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

inline

Returns

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

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

Parameters

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

Note

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

See also

ArrayBase::zeta()

Definition at line 158 of file SpecialFunctionsArrayAPI.h.

{
  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_zeta_op<typename DerivedX::Scalar>, const DerivedX, const DerivedQ>(
    x.derived(),
    q.derived()
  );
}

Code

Variable Documentation

SkylineBit

const unsigned int Eigen::SkylineBit

Definition at line 23 of file SkylineUtil.h.