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

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
 };

◆ anonymous enum

anonymous enum

Enumerator
GlobalRealFlag
GlobalImagFlag
GlobalZeroFlag

Definition at line 22 of file Symmetry.h.

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

◆ anonymous enum

anonymous enum

Enumerator
IsSkyline

Definition at line 26 of file SkylineUtil.h.

26 {IsSkyline = SkylineBit};

Eigen::IsSkyline

@ IsSkyline

Definition: SkylineUtil.h:26

Eigen::SkylineBit

const unsigned int SkylineBit

Definition: SkylineUtil.h:23

◆ anonymous enum

anonymous enum

Enumerator
SPD
NonSymmetric

Definition at line 18 of file MatrixMarketIterator.h.

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

◆ AdditionalProductEvaluationMode

enum Eigen::AdditionalProductEvaluationMode

Enumerator
SkylineTimeDenseProduct
SkylineTimeSkylineProduct
DenseTimeSkylineProduct

Definition at line 25 of file SkylineUtil.h.

25 {SkylineTimeDenseProduct, SkylineTimeSkylineProduct, DenseTimeSkylineProduct};

Eigen::SkylineTimeSkylineProduct

@ SkylineTimeSkylineProduct

Definition: SkylineUtil.h:25

Eigen::SkylineTimeDenseProduct

@ SkylineTimeDenseProduct

Definition: SkylineUtil.h:25

Eigen::DenseTimeSkylineProduct

@ DenseTimeSkylineProduct

Definition: SkylineUtil.h:25

◆ convolution_type

enum Eigen::convolution_type

strong

Enumerator
CONV1D
CONV2D
CONV3D

Definition at line 30 of file TensorConvolutionSycl.h.

30 { CONV1D, CONV2D, CONV3D };

Eigen::convolution_type::CONV2D

@ CONV2D

Eigen::convolution_type::CONV3D

@ CONV3D

Eigen::convolution_type::CONV1D

@ CONV1D

◆ FFTDirection

enum Eigen::FFTDirection

Enumerator
FFT_FORWARD
FFT_REVERSE

Definition at line 124 of file TensorForwardDeclarations.h.

                   {
     FFT_FORWARD = 0,
     FFT_REVERSE = 1
 };

◆ FFTResultType

enum Eigen::FFTResultType

Enumerator
RealPart
ImagPart
BothParts

Definition at line 118 of file TensorForwardDeclarations.h.

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

◆ NumericalDiffMode

enum Eigen::NumericalDiffMode

Enumerator
Forward
Central

Definition at line 20 of file NumericalDiff.h.

                        {
     Forward,
     Central
 };

◆ PaddingType

enum Eigen::PaddingType

Enumerator
PADDING_VALID
PADDING_SAME

Definition at line 259 of file TensorTraits.h.

                  {
   PADDING_VALID = 1,
   PADDING_SAME = 2
 };

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.

613 : 1) );)

◆ 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();
 }

◆ 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;
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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());
 }

◆ 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>());
 }

◆ 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()
   );
 }

◆ bounding_box()

Box2d Eigen::bounding_box ( const Vector2d & v )

Definition at line 9 of file BVH_Example.cpp.

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

Box2d

AlignedBox< double, 2 > Box2d

Definition: BVH_Example.cpp:6

◆ BVIntersect() [1/2]

template<typename BVH , typename Intersector >

void Eigen::BVIntersect	(	const BVH &	tree,
		Intersector &	intersector
	)

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

bool intersectVolume(const BVH::Volume &volume) //returns true if volume intersects the query

bool intersectObject(const BVH::Object &object) //returns true if the search should terminate immediately

Definition at line 81 of file BVAlgorithms.h.

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

◆ BVIntersect() [2/2]

template<typename BVH1 , typename BVH2 , typename Intersector >

void Eigen::BVIntersect	(	const BVH1 &	tree1,
		const BVH2 &	tree2,
		Intersector &	intersector
	)

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

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

Definition at line 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
       }
     }
   }
 }

◆ BVMinimize() [1/2]

template<typename BVH , typename Minimizer >

Minimizer::Scalar Eigen::BVMinimize	(	const BVH &	tree,
		Minimizer &	minimizer
	)

Given a BVH, runs the query encapsulated by minimizer.

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

Scalar minimumOnVolume(const BVH::Volume &volume)

Scalar minimumOnObject(const BVH::Object &object)

Definition at line 221 of file BVAlgorithms.h.

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

◆ BVMinimize() [2/2]

template<typename BVH1 , typename BVH2 , typename Minimizer >

Minimizer::Scalar Eigen::BVMinimize	(	const BVH1 &	tree1,
		const BVH2 &	tree2,
		Minimizer &	minimizer
	)

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

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

Scalar minimumOnVolumeVolume(const BVH1::Volume &v1, const BVH2::Volume &v2)

Scalar minimumOnVolumeObject(const BVH1::Volume &v1, const BVH2::Object &o2)

Scalar minimumOnObjectVolume(const BVH1::Object &o1, const BVH2::Volume &v2)

Scalar minimumOnObjectObject(const BVH1::Object &o1, const BVH2::Object &o2)

Definition at line 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;
 }

◆ 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;
 }

◆ 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;
 }

◆ conj()

template<typename DerType >

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

inline

Definition at line 576 of file AutoDiffScalar.h.

576 { return x; }

◆ 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);
 }

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

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

Eigen::NumTraits

◆ 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();
     }
   }

◆ 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);
 }

◆ 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);
 }

◆ 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);
 }

◆ 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());
 }

◆ glLoadMatrix() [1/3]

template<typename Scalar >

void Eigen::glLoadMatrix ( const Transform< Scalar, 3, Affine > & t )

Definition at line 177 of file OpenGLSupport.

177 { glLoadMatrix(t.matrix()); }

Eigen::glLoadMatrix

void glLoadMatrix(const Transform< Scalar, 3, AffineCompact > &t)

Definition: OpenGLSupport:179

◆ glLoadMatrix() [2/3]

template<typename Scalar >

void Eigen::glLoadMatrix ( const Transform< Scalar, 3, AffineCompact > & t )

Definition at line 179 of file OpenGLSupport.

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

◆ glLoadMatrix() [3/3]

template<typename Scalar >

void Eigen::glLoadMatrix ( const Transform< Scalar, 3, Projective > & t )

Definition at line 178 of file OpenGLSupport.

178 { glLoadMatrix(t.matrix()); }

◆ glMultMatrix() [1/3]

template<typename Scalar >

void Eigen::glMultMatrix ( const Transform< Scalar, 3, Affine > & t )

Definition at line 169 of file OpenGLSupport.

169 { glMultMatrix(t.matrix()); }

Eigen::glMultMatrix

void glMultMatrix(const Transform< Scalar, 3, AffineCompact > &t)

Definition: OpenGLSupport:171

◆ glMultMatrix() [2/3]

template<typename Scalar >

void Eigen::glMultMatrix ( const Transform< Scalar, 3, AffineCompact > & t )

Definition at line 171 of file OpenGLSupport.

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

◆ glMultMatrix() [3/3]

template<typename Scalar >

void Eigen::glMultMatrix ( const Transform< Scalar, 3, Projective > & t )

Definition at line 170 of file OpenGLSupport.

170 { glMultMatrix(t.matrix()); }

◆ 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);
 }

◆ 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);
 }

◆ 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());
 }

◆ glScale()

template<typename Scalar >

void Eigen::glScale ( const UniformScaling< Scalar > & s )

Definition at line 149 of file OpenGLSupport.

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

Eigen::glScale

void glScale(const UniformScaling< Scalar > &s)

Definition: OpenGLSupport:149

◆ glScale2dv()

void Eigen::glScale2dv ( const double * v )

inline

Definition at line 139 of file OpenGLSupport.

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

◆ glScale2fv()

void Eigen::glScale2fv ( const float * v )

inline

Definition at line 138 of file OpenGLSupport.

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

◆ glScale3dv()

void Eigen::glScale3dv ( const double * v )

inline

Definition at line 141 of file OpenGLSupport.

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

◆ glScale3fv()

void Eigen::glScale3fv ( const float * v )

inline

Definition at line 140 of file OpenGLSupport.

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

◆ glTranslate() [1/2]

template<typename Scalar >

void Eigen::glTranslate ( const Translation< Scalar, 2 > & t )

Definition at line 162 of file OpenGLSupport.

162 { glTranslate(t.vector()); }

Eigen::glTranslate

void glTranslate(const Translation< Scalar, 3 > &t)

Definition: OpenGLSupport:163

◆ glTranslate() [2/2]

template<typename Scalar >

void Eigen::glTranslate ( const Translation< Scalar, 3 > & t )

Definition at line 163 of file OpenGLSupport.

163 { glTranslate(t.vector()); }

◆ glTranslate2dv()

void Eigen::glTranslate2dv ( const double * v )

inline

Definition at line 152 of file OpenGLSupport.

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

◆ glTranslate2fv()

void Eigen::glTranslate2fv ( const float * v )

inline

Definition at line 151 of file OpenGLSupport.

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

◆ glTranslate3dv()

void Eigen::glTranslate3dv ( const double * v )

inline

Definition at line 154 of file OpenGLSupport.

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

◆ glTranslate3fv()

void Eigen::glTranslate3fv ( const float * v )

inline

Definition at line 153 of file OpenGLSupport.

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

◆ 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()
   );
 }

◆ 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());
 }

◆ 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()
   );
 }

◆ imag()

template<typename DerType >

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

inline

Definition at line 580 of file AutoDiffScalar.h.

580 { return 0.; }

◆ 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...);
 }

◆ 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);
 }

◆ 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);
 }

◆ 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));
 }

◆ 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));
 }

◆ 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);
 }

◆ 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));
 }

◆ 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));
 }

◆ 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);
 }

◆ 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;
 }

◆ 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;
 }

◆ 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;
 }

◆ 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);
 }

◆ 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()
   );
 }

◆ 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)));
 }

◆ real()

template<typename DerType >

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

inline

Definition at line 578 of file AutoDiffScalar.h.

578 { return x; }

◆ 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()
   );
 }

Variable Documentation

◆ SkylineBit

const unsigned int Eigen::SkylineBit

Definition at line 23 of file SkylineUtil.h.

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ Spline2d

◆ Spline2f

◆ Spline3d

◆ Spline3f

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ AdditionalProductEvaluationMode

◆ convolution_type

◆ FFTDirection

◆ FFTResultType

◆ NumericalDiffMode

◆ PaddingType

Function Documentation

◆ abs()

◆ abs2()

◆ accurateDot()

◆ acos()

◆ asin()

◆ atan2()

◆ bessel_i0()

◆ bessel_i0e()

◆ bessel_i1()

◆ bessel_i1e()

◆ bessel_j0()

◆ bessel_j1()

◆ bessel_k0()

◆ bessel_k0e()

◆ bessel_k1()

◆ bessel_k1e()

◆ bessel_y0()

◆ bessel_y1()

◆ betainc() [1/2]

◆ betainc() [2/2]

◆ bounding_box()

◆ BVIntersect() [1/2]

◆ BVIntersect() [2/2]

◆ BVMinimize() [1/2]

◆ BVMinimize() [2/2]

◆ choose() [1/2]

◆ choose() [2/2]

◆ conj()

◆ constCast()

◆ cos()

◆ cosh()

◆ derivativesImpl()

◆ dimensions_match()

◆ divup() [1/2]

◆ divup() [2/2]

◆ dsaupd_()

◆ dseupd_()

◆ exp()

◆ gamma_sample_der_alpha()

◆ glLoadMatrix() [1/3]

◆ glLoadMatrix() [2/3]

◆ glLoadMatrix() [3/3]

◆ glMultMatrix() [1/3]

◆ glMultMatrix() [2/3]

◆ glMultMatrix() [3/3]

◆ glRotate() [1/3]

◆ glRotate() [2/3]

◆ glRotate() [3/3]

◆ glScale()

◆ glScale2dv()

◆ glScale2fv()

◆ glScale3dv()

◆ glScale3fv()

◆ glTranslate() [1/2]

◆ glTranslate() [2/2]

◆ glTranslate2dv()