Eigen Namespace Reference

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

Namespaces
	Architecture
	bfloat16_impl
	half_impl
	HybridNonLinearSolverSpace
	indexing
	internal
	Namespace containing low-level routines from the Eigen library.
	LevenbergMarquardtSpace
	numext
	placeholders
	symbolic
	TensorSycl
	test

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

Typedefs
template<typename MatrixType , int UpLo = Lower>
using	AccelerateLLT = AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationCholesky, true >
template<typename MatrixType , int UpLo = Lower>
using	AccelerateLDLT = AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationLDLT, true >
template<typename MatrixType , int UpLo = Lower>
using	AccelerateLDLTUnpivoted = AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationLDLTUnpivoted, true >
template<typename MatrixType , int UpLo = Lower>
using	AccelerateLDLTSBK = AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationLDLTSBK, true >
template<typename MatrixType , int UpLo = Lower>
using	AccelerateLDLTTPP = AccelerateImpl< MatrixType, UpLo|Symmetric, SparseFactorizationLDLTTPP, true >
template<typename MatrixType >
using	AccelerateQR = AccelerateImpl< MatrixType, 0, SparseFactorizationQR, false >
template<typename MatrixType >
using	AccelerateCholeskyAtA = AccelerateImpl< MatrixType, 0, SparseFactorizationCholeskyAtA, false >
template<typename Derived , typename ScalarExponent >
using	GlobalUnaryPowReturnType = 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 > >
template<typename Type , int Size>
using	Vector = Matrix< Type, Size, 1 >
	\cpp11 Size×1 vector of type Type. More...
template<typename Type , int Size>
using	RowVector = Matrix< Type, 1, Size >
	\cpp11 1×Size vector of type Type. More...
template<typename T , std::size_t N>
using	array = std::array< T, N >
typedef int	DefaultPermutationIndex
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE	DenseIndex
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE	Index
	The Index type as used for the API. More...
typedef std::complex< double >	dcomplex
typedef std::complex< float >	scomplex
typedef int	BlasIndex
typedef AngleAxis< float >	AngleAxisf
typedef AngleAxis< double >	AngleAxisd
typedef Quaternion< float >	Quaternionf
typedef Quaternion< double >	Quaterniond
typedef Map< Quaternion< float >, 0 >	QuaternionMapf
typedef Map< Quaternion< double >, 0 >	QuaternionMapd
typedef Map< Quaternion< float >, Aligned >	QuaternionMapAlignedf
typedef Map< Quaternion< double >, Aligned >	QuaternionMapAlignedd
typedef Rotation2D< float >	Rotation2Df
typedef Rotation2D< double >	Rotation2Dd
typedef DiagonalMatrix< float, 2 >	AlignedScaling2f
typedef DiagonalMatrix< double, 2 >	AlignedScaling2d
typedef DiagonalMatrix< float, 3 >	AlignedScaling3f
typedef DiagonalMatrix< double, 3 >	AlignedScaling3d
typedef Transform< float, 2, Isometry >	Isometry2f
typedef Transform< float, 3, Isometry >	Isometry3f
typedef Transform< double, 2, Isometry >	Isometry2d
typedef Transform< double, 3, Isometry >	Isometry3d
typedef Transform< float, 2, Affine >	Affine2f
typedef Transform< float, 3, Affine >	Affine3f
typedef Transform< double, 2, Affine >	Affine2d
typedef Transform< double, 3, Affine >	Affine3d
typedef Transform< float, 2, AffineCompact >	AffineCompact2f
typedef Transform< float, 3, AffineCompact >	AffineCompact3f
typedef Transform< double, 2, AffineCompact >	AffineCompact2d
typedef Transform< double, 3, AffineCompact >	AffineCompact3d
typedef Transform< float, 2, Projective >	Projective2f
typedef Transform< float, 3, Projective >	Projective3f
typedef Transform< double, 2, Projective >	Projective2d
typedef Transform< double, 3, Projective >	Projective3d
typedef Translation< float, 2 >	Translation2f
typedef Translation< double, 2 >	Translation2d
typedef Translation< float, 3 >	Translation3f
typedef Translation< double, 3 >	Translation3d
typedef ThreadPoolTempl< StlThreadEnvironment >	ThreadPool
typedef Spline< float, 2 >	Spline2f
	2D float B-spline with dynamic degree. More...
typedef Spline< float, 3 >	Spline3f
	3D float B-spline with dynamic degree. More...
typedef Spline< double, 2 >	Spline2d
	2D double B-spline with dynamic degree. More...
typedef Spline< double, 3 >	Spline3d
	3D double B-spline with dynamic degree. More...

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

Functions
template<typename Scalar_ , int Options_, typename StorageIndex_ >
cholmod_sparse	viewAsCholmod (Ref< SparseMatrix< Scalar_, Options_, StorageIndex_ > > mat)
template<typename Scalar_ , int Options_, typename Index_ >
const cholmod_sparse	viewAsCholmod (const SparseMatrix< Scalar_, Options_, Index_ > &mat)
template<typename Scalar_ , int Options_, typename Index_ >
const cholmod_sparse	viewAsCholmod (const SparseVector< Scalar_, Options_, Index_ > &mat)
template<typename Scalar_ , int Options_, typename Index_ , unsigned int UpLo>
cholmod_sparse	viewAsCholmod (const SparseSelfAdjointView< const SparseMatrix< Scalar_, Options_, Index_ >, UpLo > &mat)
template<typename Derived >
cholmod_dense	viewAsCholmod (MatrixBase< Derived > &mat)
template<typename Scalar , typename StorageIndex >
Map< const SparseMatrix< Scalar, ColMajor, StorageIndex > >	viewAsEigen (cholmod_sparse &cm)
template<typename Scalar , typename StorageIndex >
Map< const SparseMatrix< Scalar, ColMajor, StorageIndex > >	viewAsEigen (cholmod_factor &cm)
template<typename FirstType , typename SizeType , typename IncrType >
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type, typename internal::cleanup_seq_incr< IncrType >::type >	seqN (FirstType first, SizeType size, IncrType incr)
template<typename FirstType , typename SizeType >
ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type >	seqN (FirstType first, SizeType size)
template<typename FirstType , typename LastType >
auto	seq (FirstType f, LastType l) -> decltype(seqN(typename internal::cleanup_index_type< FirstType >::type(f),(typename internal::cleanup_index_type< LastType >::type(l) - typename internal::cleanup_index_type< FirstType >::type(f)+fix< 1 >())))
template<typename FirstType , typename LastType , typename IncrType >
auto	seq (FirstType f, LastType l, IncrType incr) -> decltype(seqN(typename internal::cleanup_index_type< FirstType >::type(f),(typename internal::cleanup_index_type< LastType >::type(l) - typename internal::cleanup_index_type< FirstType >::type(f)+typename internal::cleanup_seq_incr< IncrType >::type(incr))/typename internal::cleanup_seq_incr< IncrType >::type(incr), typename internal::cleanup_seq_incr< IncrType >::type(incr)))
template<typename DerivedA , typename DerivedB >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t< std::is_base_of< DenseBase< std::decay_t< DerivedA > >, std::decay_t< DerivedA > >::value &&std::is_base_of< DenseBase< std::decay_t< DerivedB > >, std::decay_t< DerivedB > >::value, void >	swap (DerivedA &&a, DerivedB &&b)
	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY (lgamma, scalar_lgamma_op, natural logarithm of the gamma function,\sa ArrayBase::lgamma) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs2
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY (carg, scalar_carg_op, complex argument, \sa ArrayBase::carg DOXCOMMA MatrixBase::cwiseCArg) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(square
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2	square (power 2)
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY (rint, scalar_rint_op, nearest integer,\sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(round
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY (floor, scalar_floor_op, nearest integer not greater than the given value,\sa Eigen::ceil DOXCOMMA ArrayBase::floor) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(ceil
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY (trunc, scalar_trunc_op, nearest integer not greater in magnitude than the given value,\sa Eigen::trunc DOXCOMMA ArrayBase::trunc) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isnan
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil not a number sa Eigen::isinf DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isnan	EIGEN_ARRAY_DECLARE_GLOBAL_UNARY (isinf, scalar_isinf_op, infinite value test,\sa Eigen::isnan DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isinf) EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isfinite
template<typename Derived >
std::ostream &	operator<< (std::ostream &s, const DiagonalBase< Derived > &m)
template<typename MatrixDerived , typename PermutationDerived >
EIGEN_DEVICE_FUNC const Product< MatrixDerived, PermutationDerived, AliasFreeProduct >	operator* (const MatrixBase< MatrixDerived > &matrix, const PermutationBase< PermutationDerived > &permutation)
template<typename PermutationDerived , typename MatrixDerived >
EIGEN_DEVICE_FUNC const Product< PermutationDerived, MatrixDerived, AliasFreeProduct >	operator* (const PermutationBase< PermutationDerived > &permutation, const MatrixBase< MatrixDerived > &matrix)
std::ptrdiff_t	l1CacheSize ()
std::ptrdiff_t	l2CacheSize ()
std::ptrdiff_t	l3CacheSize ()
void	setCpuCacheSizes (std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
EIGEN_DEPRECATED void	initParallel ()
int	nbThreads ()
void	setNbThreads (int v)
template<typename MatrixDerived , typename TranspositionsDerived >
EIGEN_DEVICE_FUNC const Product< MatrixDerived, TranspositionsDerived, AliasFreeProduct >	operator* (const MatrixBase< MatrixDerived > &matrix, const TranspositionsBase< TranspositionsDerived > &transpositions)
template<typename TranspositionsDerived , typename MatrixDerived >
EIGEN_DEVICE_FUNC const Product< TranspositionsDerived, MatrixDerived, AliasFreeProduct >	operator* (const TranspositionsBase< TranspositionsDerived > &transpositions, const MatrixBase< MatrixDerived > &matrix)
static const char *	SimdInstructionSetsInUse (void)
template<typename... Args>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t	serialize_size (const Args &... args)
template<typename... Args>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint8_t *	serialize (uint8_t *dest, uint8_t *end, const Args &... args)
template<typename... Args>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const uint8_t *	deserialize (const uint8_t *src, const uint8_t *end, Args &... args)
UniformScaling< float >	Scaling (float s)
UniformScaling< double >	Scaling (double s)
template<typename RealScalar >
UniformScaling< std::complex< RealScalar > >	Scaling (const std::complex< RealScalar > &s)
template<typename Scalar >
DiagonalMatrix< Scalar, 2 >	Scaling (const Scalar &sx, const Scalar &sy)
template<typename Scalar >
DiagonalMatrix< Scalar, 3 >	Scaling (const Scalar &sx, const Scalar &sy, const Scalar &sz)
template<typename Derived >
const DiagonalWrapper< const Derived >	Scaling (const MatrixBase< Derived > &coeffs)
template<typename Derived >
DiagonalWrapper< const Derived >::PlainObject	Scaling (MatrixBase< Derived > &&coeffs)
template<typename Derived , typename OtherDerived >
internal::umeyama_transform_matrix_type< Derived, OtherDerived >::type	umeyama (const MatrixBase< Derived > &src, const MatrixBase< OtherDerived > &dst, bool with_scaling=true)
	Returns the transformation between two point sets. More...
template<typename OtherDerived , typename VectorsType , typename CoeffsType , int Side>
internal::matrix_type_times_scalar_type< typename VectorsType::Scalar, OtherDerived >::Type	operator* (const MatrixBase< OtherDerived > &other, const HouseholderSequence< VectorsType, CoeffsType, Side > &h)
	Computes the product of a matrix with a Householder sequence. More...
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType >	householderSequence (const VectorsType &v, const CoeffsType &h)
	Convenience function for constructing a Householder sequence. More...
template<typename VectorsType , typename CoeffsType >
HouseholderSequence< VectorsType, CoeffsType, OnTheRight >	rightHouseholderSequence (const VectorsType &v, const CoeffsType &h)
	Convenience function for constructing a Householder sequence. More...
int	klu_solve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B[], klu_common *Common, double)
	A sparse LU factorization and solver based on KLU. More...
int	klu_solve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex< double > B[], klu_common *Common, std::complex< double >)
int	klu_tsolve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B[], klu_common *Common, double)
int	klu_tsolve (klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex< double > B[], klu_common *Common, std::complex< double >)
klu_numeric *	klu_factor (int Ap[], int Ai[], double Ax[], klu_symbolic *Symbolic, klu_common *Common, double)
klu_numeric *	klu_factor (int Ap[], int Ai[], std::complex< double > Ax[], klu_symbolic *Symbolic, klu_common *Common, std::complex< double >)
template<typename DenseDerived , typename SparseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator+ (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
template<typename SparseDerived , typename DenseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_sum_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator+ (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
template<typename DenseDerived , typename SparseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename DenseDerived::Scalar, typename SparseDerived::Scalar >, const DenseDerived, const SparseDerived >	operator- (const MatrixBase< DenseDerived > &a, const SparseMatrixBase< SparseDerived > &b)
template<typename SparseDerived , typename DenseDerived >
EIGEN_STRONG_INLINE const CwiseBinaryOp< internal::scalar_difference_op< typename SparseDerived::Scalar, typename DenseDerived::Scalar >, const SparseDerived, const DenseDerived >	operator- (const SparseMatrixBase< SparseDerived > &a, const MatrixBase< DenseDerived > &b)
template<typename SparseDerived , typename PermDerived >
const Product< SparseDerived, PermDerived, AliasFreeProduct >	operator* (const SparseMatrixBase< SparseDerived > &matrix, const PermutationBase< PermDerived > &perm)
template<typename SparseDerived , typename PermDerived >
const Product< PermDerived, SparseDerived, AliasFreeProduct >	operator* (const PermutationBase< PermDerived > &perm, const SparseMatrixBase< SparseDerived > &matrix)
template<typename SparseDerived , typename PermutationType >
const Product< SparseDerived, Inverse< PermutationType >, AliasFreeProduct >	operator* (const SparseMatrixBase< SparseDerived > &matrix, const InverseImpl< PermutationType, PermutationStorage > &tperm)
template<typename SparseDerived , typename PermutationType >
const Product< Inverse< PermutationType >, SparseDerived, AliasFreeProduct >	operator* (const InverseImpl< PermutationType, PermutationStorage > &tperm, const SparseMatrixBase< SparseDerived > &matrix)
void	umfpack_defaults (double control[UMFPACK_CONTROL], double, int)
void	umfpack_defaults (double control[UMFPACK_CONTROL], std::complex< double >, int)
void	umfpack_defaults (double control[UMFPACK_CONTROL], double, SuiteSparse_long)
void	umfpack_defaults (double control[UMFPACK_CONTROL], std::complex< double >, SuiteSparse_long)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, int)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex< double >, int)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, SuiteSparse_long)
void	umfpack_report_info (double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex< double >, SuiteSparse_long)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, double, int)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, std::complex< double >, int)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, double, SuiteSparse_long)
void	umfpack_report_status (double control[UMFPACK_CONTROL], int status, std::complex< double >, SuiteSparse_long)
void	umfpack_report_control (double control[UMFPACK_CONTROL], double, int)
void	umfpack_report_control (double control[UMFPACK_CONTROL], std::complex< double >, int)
void	umfpack_report_control (double control[UMFPACK_CONTROL], double, SuiteSparse_long)
void	umfpack_report_control (double control[UMFPACK_CONTROL], std::complex< double >, SuiteSparse_long)
void	umfpack_free_numeric (void **Numeric, double, int)
void	umfpack_free_numeric (void **Numeric, std::complex< double >, int)
void	umfpack_free_numeric (void **Numeric, double, SuiteSparse_long)
void	umfpack_free_numeric (void **Numeric, std::complex< double >, SuiteSparse_long)
void	umfpack_free_symbolic (void **Symbolic, double, int)
void	umfpack_free_symbolic (void **Symbolic, std::complex< double >, int)
void	umfpack_free_symbolic (void **Symbolic, double, SuiteSparse_long)
void	umfpack_free_symbolic (void **Symbolic, std::complex< double >, SuiteSparse_long)
int	umfpack_symbolic (int n_row, int n_col, const int Ap[], const int Ai[], const double Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_symbolic (int n_row, int n_col, const int Ap[], const int Ai[], const std::complex< double > Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
SuiteSparse_long	umfpack_symbolic (SuiteSparse_long n_row, SuiteSparse_long n_col, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
SuiteSparse_long	umfpack_symbolic (SuiteSparse_long n_row, SuiteSparse_long n_col, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex< double > Ax[], void **Symbolic, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_numeric (const int Ap[], const int Ai[], const double Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_numeric (const int Ap[], const int Ai[], const std::complex< double > Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
SuiteSparse_long	umfpack_numeric (const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
SuiteSparse_long	umfpack_numeric (const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex< double > Ax[], void *Symbolic, void **Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_solve (int sys, const int Ap[], const int Ai[], const double Ax[], double X[], const double B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_solve (int sys, const int Ap[], const int Ai[], const std::complex< double > Ax[], std::complex< double > X[], const std::complex< double > B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
SuiteSparse_long	umfpack_solve (int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], double X[], const double B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
SuiteSparse_long	umfpack_solve (int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex< double > Ax[], std::complex< double > X[], const std::complex< double > B[], void *Numeric, const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
int	umfpack_get_lunz (int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, double)
int	umfpack_get_lunz (int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, std::complex< double >)
SuiteSparse_long	umfpack_get_lunz (SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col, SuiteSparse_long *nz_udiag, void *Numeric, double)
SuiteSparse_long	umfpack_get_lunz (SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col, SuiteSparse_long *nz_udiag, void *Numeric, std::complex< double >)
int	umfpack_get_numeric (int Lp[], int Lj[], double Lx[], int Up[], int Ui[], double Ux[], int P[], int Q[], double Dx[], int *do_recip, double Rs[], void *Numeric)
int	umfpack_get_numeric (int Lp[], int Lj[], std::complex< double > Lx[], int Up[], int Ui[], std::complex< double > Ux[], int P[], int Q[], std::complex< double > Dx[], int *do_recip, double Rs[], void *Numeric)
SuiteSparse_long	umfpack_get_numeric (SuiteSparse_long Lp[], SuiteSparse_long Lj[], double Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], double Ux[], SuiteSparse_long P[], SuiteSparse_long Q[], double Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
SuiteSparse_long	umfpack_get_numeric (SuiteSparse_long Lp[], SuiteSparse_long Lj[], std::complex< double > Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], std::complex< double > Ux[], SuiteSparse_long P[], SuiteSparse_long Q[], std::complex< double > Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
int	umfpack_get_determinant (double *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO], int)
int	umfpack_get_determinant (std::complex< double > *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO], int)
SuiteSparse_long	umfpack_get_determinant (double *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO], SuiteSparse_long)
SuiteSparse_long	umfpack_get_determinant (std::complex< double > *Mx, double *Ex, void *NumericHandle, double User_Info[UMFPACK_INFO], SuiteSparse_long)
template<>
AnnoyingScalar	test_precision< AnnoyingScalar > ()
template<>
Real	test_precision< Real > ()
template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs >	prod (const Lhs &lhs, const Rhs &rhs)
template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs, LazyProduct >	lazyprod (const Lhs &lhs, const Rhs &rhs)
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType &	copy_using_evaluator (const EigenBase< DstXprType > &dst, const SrcXprType &src)
template<typename DstXprType , template< typename > class StorageBase, typename SrcXprType >
EIGEN_STRONG_INLINE const DstXprType &	copy_using_evaluator (const NoAlias< DstXprType, StorageBase > &dst, const SrcXprType &src)
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType &	copy_using_evaluator (const PlainObjectBase< DstXprType > &dst, const SrcXprType &src)
template<typename DstXprType , typename SrcXprType >
void	add_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
template<typename DstXprType , typename SrcXprType >
void	subtract_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
template<typename DstXprType , typename SrcXprType >
void	multiply_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
template<typename DstXprType , typename SrcXprType >
void	divide_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
template<typename DstXprType , typename SrcXprType >
void	swap_using_evaluator (const DstXprType &dst, const SrcXprType &src)
template<typename Kernel , typename... Args>
auto	run_on_cpu (Kernel kernel, Args &&... args) -> decltype(kernel(args...))
template<typename Kernel , typename... Args>
auto	run (Kernel kernel, Args &&... args) -> decltype(kernel(args...))
template<typename Kernel , typename... Args>
auto	run_with_hint (size_t buffer_capacity_hint, Kernel kernel, Args &&... args) -> decltype(kernel(args...))
template<typename T1 , typename T2 >
std::enable_if_t< internal::is_same< T1, T2 >::value, bool >	is_same_type (const T1 &, const T2 &)
template<typename T >
NumTraits< T >::Real	test_precision ()
template<>
float	test_precision< float > ()
template<>
double	test_precision< double > ()
template<>
long double	test_precision< long double > ()
template<>
float	test_precision< std::complex< float > > ()
template<>
double	test_precision< std::complex< double > > ()
template<>
long double	test_precision< std::complex< long double > > ()
bool	test_isApprox (const std::complex< float > &a, const std::complex< float > &b)
bool	test_isMuchSmallerThan (const std::complex< float > &a, const std::complex< float > &b)
bool	test_isApprox (const std::complex< double > &a, const std::complex< double > &b)
bool	test_isMuchSmallerThan (const std::complex< double > &a, const std::complex< double > &b)
bool	test_isApprox (const std::complex< long double > &a, const std::complex< long double > &b)
bool	test_isMuchSmallerThan (const std::complex< long double > &a, const std::complex< long double > &b)
bool	test_isApprox (const long double &a, const long double &b)
bool	test_isMuchSmallerThan (const long double &a, const long double &b)
bool	test_isApproxOrLessThan (const long double &a, const long double &b)
template<typename T1 , typename T2 >
NumTraits< typename T1::RealScalar >::NonInteger	test_relative_error (const EigenBase< T1 > &a, const EigenBase< T2 > &b)
template<typename T1 , typename T2 >
T1::RealScalar	test_relative_error (const T1 &a, const T2 &b, const typename T1::Coefficients *=0)
template<typename T1 , typename T2 >
T1::Scalar	test_relative_error (const T1 &a, const T2 &b, const typename T1::MatrixType *=0)
template<typename S , int D>
S	test_relative_error (const Translation< S, D > &a, const Translation< S, D > &b)
template<typename S , int D, int O>
S	test_relative_error (const ParametrizedLine< S, D, O > &a, const ParametrizedLine< S, D, O > &b)
template<typename S , int D>
S	test_relative_error (const AlignedBox< S, D > &a, const AlignedBox< S, D > &b)
template<typename T1 , typename T2 >
T1::RealScalar	test_relative_error (const MatrixBase< T1 > &a, const SparseMatrixBase< T2 > &b)
template<typename T1 , typename T2 >
T1::RealScalar	test_relative_error (const SparseMatrixBase< T1 > &a, const MatrixBase< T2 > &b)
template<typename T1 , typename T2 >
T1::RealScalar	test_relative_error (const SparseMatrixBase< T1 > &a, const SparseMatrixBase< T2 > &b)
template<typename T1 , typename T2 >
NumTraits< typename NumTraits< T1 >::Real >::NonInteger	test_relative_error (const T1 &a, const T2 &b, std::enable_if_t< internal::is_arithmetic< typename NumTraits< T1 >::Real >::value, T1 > *=0)
template<typename T >
T	test_relative_error (const Rotation2D< T > &a, const Rotation2D< T > &b)
template<typename T >
T	test_relative_error (const AngleAxis< T > &a, const AngleAxis< T > &b)
template<typename Type1 , typename Type2 >
bool	test_isApprox (const Type1 &a, const Type2 &b, typename Type1::Scalar *=0)
template<typename T >
NumTraits< typename T::Scalar >::Real	get_test_precision (const T &, const typename T::Scalar *=0)
template<typename T >
NumTraits< T >::Real	get_test_precision (const T &, std::enable_if_t< internal::is_arithmetic< typename NumTraits< T >::Real >::value, T > *=0)
template<typename Type1 , typename Type2 >
bool	verifyIsApprox (const Type1 &a, const Type2 &b)
template<typename Type1 , typename Type2 >
bool	verifyIsCwiseApprox (const Type1 &a, const Type2 &b, bool exact)
template<typename Scalar , typename ScalarRef >
bool	test_isApproxWithRef (const Scalar &a, const Scalar &b, const ScalarRef &ref)
template<typename Derived1 , typename Derived2 >
bool	test_isMuchSmallerThan (const MatrixBase< Derived1 > &m1, const MatrixBase< Derived2 > &m2)
template<typename Derived >
bool	test_isMuchSmallerThan (const MatrixBase< Derived > &m, const typename NumTraits< typename internal::traits< Derived >::Scalar >::Real &s)
template<typename Derived >
bool	test_isUnitary (const MatrixBase< Derived > &m)
template<typename Derived1 , typename Derived2 >
bool	test_isCwiseApprox (const DenseBase< Derived1 > &m1, const DenseBase< Derived2 > &m2, bool exact)
template<typename Derived1 , typename Derived2 >
bool	test_isCwiseApprox (const SparseMatrixBase< Derived1 > &m1, const SparseMatrixBase< Derived2 > &m2, bool exact)
template<typename T , typename U >
bool	test_is_equal (const T &actual, const U &expected, bool expect_equal)
template<typename T >
bool	isNotNaN (const T &x)
template<typename T >
bool	isPlusInf (const T &x)
template<typename T >
bool	isMinusInf (const T &x)
template<typename MatrixType >
void	createRandomPIMatrixOfRank (Index desired_rank, Index rows, Index cols, MatrixType &m)
template<typename PermutationVectorType >
void	randomPermutationVector (PermutationVectorType &v, Index size)
template<typename MatrixType >
MatrixType	generateRandomUnitaryMatrix (const Index dim)
template<typename MatrixType , typename RealScalarVectorType >
void	generateRandomMatrixSvs (const RealScalarVectorType &svs, const Index rows, const Index cols, MatrixType &M)
template<typename VectorType , typename RealScalar >
VectorType	setupRandomSvs (const Index dim, const RealScalar max)
template<typename VectorType , typename RealScalar >
VectorType	setupRangeSvs (const Index dim, const RealScalar min, const RealScalar max)
Box2d	bounding_box (const Vector2d &v)
template<typename IndexType , int NumDims>
std::ostream &	operator<< (std::ostream &os, const DSizes< IndexType, NumDims > &dims)
template<typename Dims1 , typename Dims2 >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool	dimensions_match (Dims1 dims1, Dims2 dims2)
template<typename T >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T *	constCast (const T *data)
template<typename ADerived , typename BDerived , typename XDerived >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorCwiseTernaryOp< internal::scalar_betainc_op< typename XDerived::Scalar >, const ADerived, const BDerived, const XDerived >	betainc (const Eigen::TensorBase< ADerived, ReadOnlyAccessors > &a, const Eigen::TensorBase< BDerived, ReadOnlyAccessors > &b, const Eigen::TensorBase< XDerived, ReadOnlyAccessors > &x)
template<typename FirstType , typename... OtherTypes>
std::ostream &	operator<< (std::ostream &os, const IndexList< FirstType, OtherTypes... > &dims)
template<typename FirstType , typename... OtherTypes>
constexpr IndexList< FirstType, OtherTypes... >	make_index_list (FirstType val1, OtherTypes... other_vals)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const TensorBase< T, ReadOnlyAccessors > &t)
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T1 &	choose (Cond< true >, const T1 &first, const T2 &)
template<typename T1 , typename T2 >
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T2 &	choose (Cond< false >, const T1 &, const T2 &second)
template<typename T >
EIGEN_DEPRECATED EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE T	divup (const T x, const T y)
template<typename U , typename V >
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool	operator== (const Pair< U, V > &x, const Pair< U, V > &y)
template<typename U , typename V >
EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool	operator!= (const Pair< U, V > &x, const Pair< U, V > &y)
template<typename NewDerType >
AutoDiffScalar< NewDerType >	MakeAutoDiffScalar (const typename NewDerType::Scalar &value, const NewDerType &der)
template<typename DerType >
const AutoDiffScalar< DerType > &	conj (const AutoDiffScalar< DerType > &x)
template<typename DerType >
const AutoDiffScalar< DerType > &	real (const AutoDiffScalar< DerType > &x)
template<typename DerType >
DerType::Scalar	imag (const AutoDiffScalar< DerType > &)
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type()	min (const AutoDiffScalar< DerType > &x, const T &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()	min (const T &x, const AutoDiffScalar< DerType > &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 >
CleanedUpDerType< DerType >::type()	max (const AutoDiffScalar< DerType > &x, const AutoDiffScalar< DerType > &y)
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (abs, using std::abs;return Eigen::MakeAutoDiffScalar(abs(x.value()), x.derivatives() *(x.value()< 0 ? -1 :1));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sqrt, using std::sqrt;Scalar sqrtx=sqrt(x.value());return Eigen::MakeAutoDiffScalar(sqrtx, x.derivatives() *(Scalar(0.5)/sqrtx));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sin, using std::sin;using std::cos;return Eigen::MakeAutoDiffScalar(sin(x.value()), x.derivatives() *cos(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (log, using std::log;return Eigen::MakeAutoDiffScalar(log(x.value()), x.derivatives() *(Scalar(1)/x.value()));) template< typename DerType > inline auto pow(const Eigen
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)
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (tan, using std::tan;using std::cos;return Eigen::MakeAutoDiffScalar(tan(x.value()), x.derivatives() *(Scalar(1)/numext::abs2(cos(x.value()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(asin
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (acos, using std::sqrt;using std::acos;return Eigen::MakeAutoDiffScalar(acos(x.value()), x.derivatives() *(Scalar(-1)/sqrt(1 - numext::abs2(x.value()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(tanh
	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sinh, using std::sinh;using std::cosh;return Eigen::MakeAutoDiffScalar(sinh(x.value()), x.derivatives() *cosh(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cosh
template<typename 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)
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)
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)
template<typename A , typename B >
KroneckerProduct< A, B >	kroneckerProduct (const MatrixBase< A > &a, const MatrixBase< B > &b)
template<typename A , typename B >
KroneckerProductSparse< A, B >	kroneckerProduct (const EigenBase< A > &a, const EigenBase< B > &b)
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 Polynomials , typename T >
T	poly_eval_horner (const Polynomials &poly, const T &x)
template<typename Polynomials , typename T >
T	poly_eval (const Polynomials &poly, const T &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)
template<typename RootVector , typename Polynomial >
void	roots_to_monicPolynomial (const RootVector &rv, Polynomial &poly)
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 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...
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...
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...
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0_op< typename Derived::Scalar >, const Derived >	bessel_i0 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0e_op< typename Derived::Scalar >, const Derived >	bessel_i0e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1_op< typename Derived::Scalar >, const Derived >	bessel_i1 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1e_op< typename Derived::Scalar >, const Derived >	bessel_i1e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0_op< typename Derived::Scalar >, const Derived >	bessel_k0 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0e_op< typename Derived::Scalar >, const Derived >	bessel_k0e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1_op< typename Derived::Scalar >, const Derived >	bessel_k1 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1e_op< typename Derived::Scalar >, const Derived >	bessel_k1e (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j0_op< typename Derived::Scalar >, const Derived >	bessel_j0 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y0_op< typename Derived::Scalar >, const Derived >	bessel_y0 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j1_op< typename Derived::Scalar >, const Derived >	bessel_j1 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived >
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y1_op< typename Derived::Scalar >, const Derived >	bessel_y1 (const Eigen::ArrayBase< Derived > &x)
template<typename Derived , typename ExponentDerived >
EIGEN_STRONG_INLINE 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 >
EIGEN_STRONG_INLINE 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 AlphaDerived , typename SampleDerived >
EIGEN_STRONG_INLINE 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)
template<typename Derived , typename ExponentDerived >
EIGEN_STRONG_INLINE 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 DerivedN , typename DerivedX >
EIGEN_STRONG_INLINE 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 ArgADerived , typename ArgBDerived , typename ArgXDerived >
EIGEN_STRONG_INLINE 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)
template<typename DerivedX , typename DerivedQ >
EIGEN_STRONG_INLINE 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)
template<typename SplineType , typename DerivativeType >
void	derivativesImpl (const SplineType &spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType &der)
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 PointArrayType , typename KnotVectorType >
void	ChordLengths (const PointArrayType &pts, KnotVectorType &chord_lengths)
	Computes chord length parameters which are required for spline interpolation. More...
template<typename T , typename Derived >
T	test_relative_error (const AlignedVector3< T > &a, const MatrixBase< Derived > &b)
template<typename Scalar , int Dim>
AlignedBox< Scalar, Dim >	bounding_box (const Matrix< Scalar, Dim, 1 > &v)

Variables
	scalar_abs2_op
squared absolute	value
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2	scalar_square_op
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square	scalar_round_op
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest	integer
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round	scalar_ceil_op
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil	scalar_isnan_op
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil not a number	test
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil not a number sa Eigen::isinf DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isnan	scalar_isfinite_op
EIGEN_DEVICE_FUNC const const Eigen::ArrayBase< Derived > &	exponents
const int	Dynamic = -1
const int	DynamicIndex = 0xffffff
const int	Undefined = 0xfffffe
const int	Infinity = -1
const int	HugeCost = 10000
const unsigned int	RowMajorBit = 0x1
const unsigned int	EvalBeforeNestingBit = 0x2
EIGEN_DEPRECATED const unsigned int	EvalBeforeAssigningBit = 0x4
const unsigned int	PacketAccessBit = 0x8
const unsigned int	ActualPacketAccessBit = 0x0
const unsigned int	LinearAccessBit = 0x10
const unsigned int	LvalueBit = 0x20
const unsigned int	DirectAccessBit = 0x40
EIGEN_DEPRECATED const unsigned int	AlignedBit = 0x80
const unsigned int	NestByRefBit = 0x100
const unsigned int	NoPreferredStorageOrderBit = 0x200
const unsigned int	CompressedAccessBit = 0x400
const unsigned int	HereditaryBits = RowMajorBit | EvalBeforeNestingBit
template<int N>
constexpr internal::FixedInt< N >	fix {}
const int	AutoOrder = 2
const int	CoherentAccessPattern = 0x1
const int	InnerRandomAccessPattern = 0x2 | CoherentAccessPattern
const int	OuterRandomAccessPattern = 0x4 | CoherentAccessPattern
const int	RandomAccessPattern = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern
static std::vector< std::string >	g_test_stack
static int	g_test_level = 0
static int	g_repeat = 1
static unsigned int	g_seed = 0
static bool	g_has_set_repeat = false
static bool	g_has_set_seed = false
static const bool	should_raise_an_assert = false
static bool	no_more_assert = false
static bool	report_on_cerr_on_assert_failure = true
Scalar	expx = exp(x.value())

Detailed Description

Namespace containing all symbols from the Eigen library.

Typedef Documentation

AccelerateCholeskyAtA

template<typename MatrixType >

using Eigen::AccelerateCholeskyAtA = typedef AccelerateImpl<MatrixType, 0, SparseFactorizationCholeskyAtA, false>

AccelerateLDLT

template<typename MatrixType , int UpLo = Lower>

using Eigen::AccelerateLDLT = typedef AccelerateImpl<MatrixType, UpLo | Symmetric, SparseFactorizationLDLT, true>

AccelerateLDLTSBK

template<typename MatrixType , int UpLo = Lower>

using Eigen::AccelerateLDLTSBK = typedef AccelerateImpl<MatrixType, UpLo | Symmetric, SparseFactorizationLDLTSBK, true>

AccelerateLDLTTPP

template<typename MatrixType , int UpLo = Lower>

using Eigen::AccelerateLDLTTPP = typedef AccelerateImpl<MatrixType, UpLo | Symmetric, SparseFactorizationLDLTTPP, true>

AccelerateLDLTUnpivoted

template<typename MatrixType , int UpLo = Lower>

using Eigen::AccelerateLDLTUnpivoted = typedef AccelerateImpl<MatrixType, UpLo | Symmetric, SparseFactorizationLDLTUnpivoted, true>

AccelerateLLT

template<typename MatrixType , int UpLo = Lower>

using Eigen::AccelerateLLT = typedef AccelerateImpl<MatrixType, UpLo | Symmetric, SparseFactorizationCholesky, true>

AccelerateQR

template<typename MatrixType >

using Eigen::AccelerateQR = typedef AccelerateImpl<MatrixType, 0, SparseFactorizationQR, false>

AlignedScaling2d

typedef DiagonalMatrix<double, 2> Eigen::AlignedScaling2d

Deprecated:

AlignedScaling2f

typedef DiagonalMatrix<float, 2> Eigen::AlignedScaling2f

Deprecated:

AlignedScaling3d

typedef DiagonalMatrix<double, 3> Eigen::AlignedScaling3d

Deprecated:

AlignedScaling3f

typedef DiagonalMatrix<float, 3> Eigen::AlignedScaling3f

Deprecated:

array

template<typename T , std::size_t N>

using Eigen::array = typedef std::array<T, N>

BlasIndex

typedef int Eigen::BlasIndex

dcomplex

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

DefaultPermutationIndex

typedef int Eigen::DefaultPermutationIndex

DenseIndex

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Eigen::DenseIndex

GlobalUnaryPowReturnType

template<typename Derived , typename ScalarExponent >

using Eigen::GlobalUnaryPowReturnType = 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> >

Index

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Eigen::Index

The Index type as used for the API.

To change this, #define the preprocessor symbol EIGEN_DEFAULT_DENSE_INDEX_TYPE.

See also

\blank Preprocessor directives, StorageIndex.

Examples

/home/plath/mercurydpm2/mercurydpm/Eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h.

scomplex

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

Spline2d

typedef Spline<double, 2> Eigen::Spline2d

2D double B-spline with dynamic degree.

Spline2f

typedef Spline<float, 2> Eigen::Spline2f

2D float B-spline with dynamic degree.

Spline3d

typedef Spline<double, 3> Eigen::Spline3d

3D double B-spline with dynamic degree.

Spline3f

typedef Spline<float, 3> Eigen::Spline3f

3D float B-spline with dynamic degree.

ThreadPool

typedef ThreadPoolTempl<StlThreadEnvironment> Eigen::ThreadPool

Translation2d

typedef Translation<double, 2> Eigen::Translation2d

Translation2f

typedef Translation<float, 2> Eigen::Translation2f

Translation3d

typedef Translation<double, 3> Eigen::Translation3d

Translation3f

typedef Translation<float, 3> Eigen::Translation3f

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
NegationFlag
ConjugationFlag

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

anonymous enum

anonymous enum

Enumerator
GlobalRealFlag
GlobalImagFlag
GlobalZeroFlag

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

anonymous enum

anonymous enum

Enumerator
SPD
NonSymmetric

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

anonymous enum

anonymous enum

Enumerator
CPU_TIMER
REAL_TIMER

{ CPU_TIMER = 0, REAL_TIMER = 1 };

anonymous enum

anonymous enum

Enumerator
Large
Small

{ Large = 2, Small = 3 };

anonymous enum

anonymous enum

Enumerator
DontAlignCols

{ DontAlignCols = 1 };

anonymous enum

anonymous enum

Enumerator
StreamPrecision
FullPrecision

{ StreamPrecision = -1, FullPrecision = -2 };

anonymous enum

anonymous enum

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

     {
  StandardCompressedFormat =
      2 
};

AutoSize_t

enum Eigen::AutoSize_t

Enumerator
AutoSize

{ AutoSize };

CholmodMode

enum Eigen::CholmodMode

Enumerator
CholmodAuto
CholmodSimplicialLLt
CholmodSupernodalLLt
CholmodLDLt

{ CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt };

convolution_type

enum Eigen::convolution_type

strong

Enumerator
CONV1D
CONV2D
CONV3D

{ CONV1D, CONV2D, CONV3D };

Default_t

enum Eigen::Default_t

Enumerator
Default

{ Default };

EulerAxis

enum Eigen::EulerAxis

Representation of a fixed signed rotation axis for EulerSystem.

Values here represent:

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

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

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

Enumerator
EULER_X	the X axis
EULER_Y	the Y axis
EULER_Z	the Z axis

               {
  EULER_X = 1, 
  EULER_Y = 2, 
  EULER_Z = 3  
};

FFTDirection

enum Eigen::FFTDirection

Enumerator
FFT_FORWARD
FFT_REVERSE

{ FFT_FORWARD = 0, FFT_REVERSE = 1 };

FFTResultType

enum Eigen::FFTResultType

Enumerator
RealPart
ImagPart
BothParts

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

NoChange_t

enum Eigen::NoChange_t

Enumerator
NoChange

{ NoChange };

NumericalDiffMode

enum Eigen::NumericalDiffMode

Enumerator
Forward
Central

{ Forward, Central };

PaddingType

enum Eigen::PaddingType

Enumerator
PADDING_VALID
PADDING_SAME

{ PADDING_VALID = 1, PADDING_SAME = 2 };

Sequential_t

enum Eigen::Sequential_t

Enumerator
Sequential

{ Sequential };

SimplicialCholeskyMode

enum Eigen::SimplicialCholeskyMode

Enumerator
SimplicialCholeskyLLT
SimplicialCholeskyLDLT

{ SimplicialCholeskyLLT, SimplicialCholeskyLDLT };

Function Documentation

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.

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

References conj(), Eigen::SparseMatrixBase< Derived >::derived(), EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE, EIGEN_STATIC_ASSERT_VECTOR_ONLY, i, j, and res.

Referenced by Eigen::SparseInverse< Scalar >::computeInverse().

add_assign_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::add_assign_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

                                                                              {
  typedef typename DstXprType::Scalar Scalar;
  call_assignment(const_cast<DstXprType&>(dst), src.derived(),
                  internal::add_assign_op<Scalar, typename SrcXprType::Scalar>());
}

References Eigen::internal::call_assignment().

Referenced by EIGEN_DECLARE_TEST().

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

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

References a, atan2(), b, and ret.

Referenced by Eigen::QuaternionBase< Derived >::angularDistance(), Eigen::numext::atan2(), binary_ops_test(), Eigen::EulerSystem< _AlphaAxis, _BetaAxis, _GammaAxis >::CalcEulerAngles_imp(), Eigen::internal::complex_log(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 3, false >::computeRoots(), Eigen::Rotation2D< Scalar_ >::fromRotationMatrix(), and Eigen::AngleAxis< Scalar_ >::operator=().

bessel_i0()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i0

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_i0_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_i0().

bessel_i0e()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i0e

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_i0e_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_i0e().

bessel_i1()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i1

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_i1_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_i1().

bessel_i1e()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_i1e

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_i1e_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_i1e().

bessel_j0()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_j0

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_j0_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_j0().

bessel_j1()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_j1

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_j1_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_j1().

bessel_k0()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k0

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_k0_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_k0().

bessel_k0e()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k0e

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_k0e_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_k0e().

bessel_k1()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k1

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_k1_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_k1().

bessel_k1e()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>, const Derived> Eigen::bessel_k1e

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_k1e_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_k1e().

bessel_y0()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>, const Derived> Eigen::bessel_y0

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_y0_op< Scalar >::operator()(), and Eigen::internal::pbessel_y0().

bessel_y1()

template<typename Derived >

EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>, const Derived> Eigen::bessel_y1

(

const Eigen::ArrayBase< Derived > &

x

)

Returns

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

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

Parameters

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

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

References plotDoE::x.

Referenced by array_bessel_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_bessel_y1_op< Scalar >::operator()(), packetmath_real(), and Eigen::internal::pbessel_y1().

betainc() [1/2]

template<typename ArgADerived , typename ArgBDerived , typename ArgXDerived >

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

\cpp11

Returns

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

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

Note

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

See also

Eigen::betainc(), Eigen::lgamma()

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

References a, b, and plotDoE::x.

betainc() [2/2]

template<typename ADerived , typename BDerived , typename XDerived >

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

\cpp11

Returns

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

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

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

References a, b, and plotDoE::x.

Referenced by array_special_functions(), Eigen::internal::scalar_betainc_op< Scalar >::operator()(), and Eigen::internal::pbetainc().

bounding_box() [1/2]

template<typename Scalar , int Dim>

AlignedBox<Scalar, Dim> Eigen::bounding_box

(

const Matrix< Scalar, Dim, 1 > &

v

)

                                                                      {
  return AlignedBox<Scalar, Dim>(v);
}

References v.

bounding_box() [2/2]

Box2d Eigen::bounding_box

(

const Vector2d &

v

)

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

References v.

Referenced by Eigen::internal::get_boxes_helper< ObjectList, VolumeList, int >::operator()().

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

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

References Eigen::internal::intersect_helper().

Referenced by TreeTest< Dim >::testIntersect1(), and TreeTest< Dim >::testIntersect2().

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 

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

References Eigen::internal::intersect_helper(), and Global_Physical_Variables::Volume.

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) 

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

References max, and Eigen::internal::minimize_helper().

Referenced by main(), TreeTest< Dim >::testMinimize1(), and TreeTest< Dim >::testMinimize2().

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)

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

References max, min, Eigen::internal::minimize_helper(), calibrate::val, and Global_Physical_Variables::Volume.

cauchy_max_bound()

template<typename Polynomial >

NumTraits<typename Polynomial::Scalar>::Real Eigen::cauchy_max_bound ( const Polynomial &  poly )

inline

Returns

a maximum bound for the absolute value of any root of the polynomial.

Parameters

[in]

poly

: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. \( 1 + 3x^2 \) is stored as a vector \( [ 1, 0, 3 ] \).

Precondition

the leading coefficient of the input polynomial poly must be non zero

                                                                                                  {
  using std::abs;
  typedef typename Polynomial::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real Real;
 
  eigen_assert(Scalar(0) != poly[poly.size() - 1]);
  const Scalar inv_leading_coeff = Scalar(1) / poly[poly.size() - 1];
  Real cb(0);
 
  for (DenseIndex i = 0; i < poly.size() - 1; ++i) {
    cb += abs(poly[i] * inv_leading_coeff);
  }
  return cb + Real(1);
}

References abs(), eigen_assert, and i.

Referenced by CauchyBounds().

cauchy_min_bound()

template<typename Polynomial >

NumTraits<typename Polynomial::Scalar>::Real Eigen::cauchy_min_bound ( const Polynomial &  poly )

inline

Returns

a minimum bound for the absolute value of any non zero root of the polynomial.

Parameters

[in]

poly

: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. \( 1 + 3x^2 \) is stored as a vector \( [ 1, 0, 3 ] \).

                                                                                                  {
  using std::abs;
  typedef typename Polynomial::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real Real;
 
  DenseIndex i = 0;
  while (i < poly.size() - 1 && Scalar(0) == poly(i)) {
    ++i;
  }
  if (poly.size() - 1 == i) {
    return Real(1);
  }
 
  const Scalar inv_min_coeff = Scalar(1) / poly[i];
  Real cb(1);
  for (DenseIndex j = i + 1; j < poly.size(); ++j) {
    cb += abs(poly[j] * inv_min_coeff);
  }
  return Real(1) / cb;
}

References abs(), i, and j.

Referenced by CauchyBounds().

choose() [1/2]

template<typename T1 , typename T2 >

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

                                                                                                 {
  return second;
}

choose() [2/2]

template<typename T1 , typename T2 >

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

                                                                                               {
  return first;
}

Referenced by Eigen::TensorBase< Derived, ReadOnlyAccessors >::cast(), and Eigen::TensorBase< Derived, ReadOnlyAccessors >::conjugate().

conj()

template<typename DerType >

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

inline

                                                                             {
  return x;
}

References plotDoE::x.

Referenced by Eigen::JacobiRotation< Scalar >::adjoint(), Eigen::GeneralizedEigenSolver< MatrixType_ >::compute(), Eigen::internal::FullPivHouseholderQRMatrixQReturnType< MatrixType, PermutationIndex >::evalTo(), Eigen::internal::blas_traits< CwiseUnaryOp< scalar_conjugate_op< Scalar >, NestedXpr > >::extractScalarFactor(), Eigen::internal::kissfft_impl< Scalar_ >::fwd(), Eigen::internal::kissfft_impl< Scalar_ >::inv(), Eigen::internal::trsmKernelL< Scalar, Index, Mode, Conjugate, TriStorageOrder, OtherInnerStride, Specialized >::kernel(), Eigen::internal::trsmKernelR< Scalar, Index, Mode, Conjugate, TriStorageOrder, OtherInnerStride, Specialized >::kernel(), Eigen::JacobiRotation< Scalar >::makeGivens(), Eigen::MatrixBase< Derived >::makeHouseholder(), Eigen::JacobiRotation< Scalar >::operator*(), Eigen::internal::conj_default_impl< Scalar, true >::run(), Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, Options, true >::run(), Eigen::SparseLUMatrixUReturnType< MatrixLType, MatrixUType >::solveTransposedInPlace(), Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::solveTransposedInPlace(), Eigen::JacobiRotation< Scalar >::transpose(), and Eigen::internal::tridiagonalization_inplace().

constCast()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T* Eigen::constCast

(

const T *

data

)

Examples

/home/plath/mercurydpm2/mercurydpm/Eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h.

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

References data.

Referenced by Eigen::TensorEvaluator< const TensorChippingOp< DimId, ArgType >, Device >::data(), Eigen::TensorEvaluator< const TensorLayoutSwapOp< ArgType >, Device >::data(), Eigen::TensorEvaluator< const TensorReshapingOp< NewDimensions, ArgType >, Device >::data(), and Eigen::TensorEvaluator< const TensorSlicingOp< StartIndices, Sizes, ArgType >, Device >::data().

copy_using_evaluator() [1/3]

template<typename DstXprType , typename SrcXprType >

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

                                                                                                              {
  call_assignment(dst.const_cast_derived(), src.derived(),
                  internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>());
  return dst.const_cast_derived();
}

References Eigen::internal::call_assignment(), and Eigen::EigenBase< Derived >::const_cast_derived().

copy_using_evaluator() [2/3]

template<typename DstXprType , template< typename > class StorageBase, typename SrcXprType >

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

                                                                                  {
  call_assignment(dst, src.derived(), internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>());
  return dst.expression();
}

References Eigen::internal::call_assignment(), and Eigen::NoAlias< ExpressionType, StorageBase >::expression().

copy_using_evaluator() [3/3]

template<typename DstXprType , typename SrcXprType >

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

                                                                                                                    {
#ifdef EIGEN_NO_AUTOMATIC_RESIZING
  eigen_assert((dst.size() == 0 || (IsVectorAtCompileTime ? (dst.size() == src.size())
                                                          : (dst.rows() == src.rows() && dst.cols() == src.cols()))) &&
               "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
#else
  dst.const_cast_derived().resizeLike(src.derived());
#endif
 
  call_assignment(dst.const_cast_derived(), src.derived(),
                  internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>());
  return dst.const_cast_derived();
}

References Eigen::internal::call_assignment(), Eigen::PlainObjectBase< Derived >::cols(), eigen_assert, Eigen::PlainObjectBase< Derived >::resizeLike(), and Eigen::PlainObjectBase< Derived >::rows().

Referenced by EIGEN_DECLARE_TEST().

createRandomPIMatrixOfRank()

template<typename MatrixType >

void Eigen::createRandomPIMatrixOfRank	(	Index	desired_rank,
		Index	rows,
		Index	cols,
		MatrixType &	m
	)

Creates a random partial isometry matrix of given rank.

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

Template Parameters

MatrixType

type of random partial isometry matrix

Parameters

desired_rank	rank requested for the random partial isometry matrix
rows	row dimension of requested random partial isometry matrix
cols	column dimension of requested random partial isometry matrix
m	random partial isometry matrix

                                                                                           {
  typedef typename internal::traits<MatrixType>::Scalar Scalar;
  enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
 
  typedef Matrix<Scalar, Dynamic, 1> VectorType;
  typedef Matrix<Scalar, Rows, Rows> MatrixAType;
  typedef Matrix<Scalar, Cols, Cols> MatrixBType;
 
  if (desired_rank == 0) {
    m.setZero(rows, cols);
    return;
  }
 
  if (desired_rank == 1) {
    // here we normalize the vectors to get a partial isometry
    m = VectorType::Random(rows).normalized() * VectorType::Random(cols).normalized().transpose();
    return;
  }
 
  MatrixAType a = MatrixAType::Random(rows, rows);
  MatrixType d = MatrixType::Identity(rows, cols);
  MatrixBType b = MatrixBType::Random(cols, cols);
 
  // set the diagonal such that only desired_rank non-zero entries remain
  const Index diag_size = (std::min)(d.rows(), d.cols());
  if (diag_size != desired_rank)
    d.diagonal().segment(desired_rank, diag_size - desired_rank) = VectorType::Zero(diag_size - desired_rank);
 
  HouseholderQR<MatrixAType> qra(a);
  HouseholderQR<MatrixBType> qrb(b);
  m = qra.householderQ() * d * qrb.householderQ();
}

References a, b, cols, Eigen::HouseholderQR< MatrixType_ >::householderQ(), m, min, rows, and oomph::PseudoSolidHelper::Zero.

Referenced by cod(), cod_fixedsize(), inverse(), lu_non_invertible(), qr(), qr_fixedsize(), and svd_fill_random().

derivativesImpl()

template<typename SplineType , typename DerivativeType >

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

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

References min, n, and p.

Referenced by Eigen::Spline< Scalar_, Dim_, Degree_ >::derivatives().

deserialize()

template<typename... Args>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const uint8_t* Eigen::deserialize	(	const uint8_t *	src,
		const uint8_t *	end,
		Args &...	args
	)

Deserialize a set of values from the byte buffer.

Parameters

src	input byte buffer; if this is nullptr, does nothing.
end	the end of input byte buffer.
args	... arguments to deserialize in sequence.

Returns

the next address after all parsed values; nullptr if parsing errors are detected.

                                                                                {
  return internal::serialize_impl<sizeof...(args), Args...>::deserialize(src, end, args...);
}

References compute_granudrum_aor::args, and Eigen::placeholders::end.

Referenced by Eigen::internal::serialize_impl< N, T1, Ts... >::deserialize(), Eigen::internal::run_serialized(), and test_dense_types().

dimensions_match()

template<typename Dims1 , typename Dims2 >

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

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

References run().

Referenced by Eigen::TensorEvaluator< const TensorAssignOp< LeftArgType, RightArgType >, Device >::evalSubExprsIfNeeded(), Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::Run(), Eigen::TensorEvaluator< const TensorCwiseBinaryOp< BinaryOp, LeftArgType, RightArgType >, Device >::TensorEvaluator(), Eigen::TensorEvaluator< const TensorCwiseTernaryOp< TernaryOp, Arg1Type, Arg2Type, Arg3Type >, Device >::TensorEvaluator(), Eigen::TensorEvaluator< const TensorSelectOp< IfArgType, ThenArgType, ElseArgType >, Device >::TensorEvaluator(), test_async_multithread_contraction_agrees_with_singlethread(), test_dim_check(), test_full_contraction(), test_match(), test_multithread_contraction_agrees_with_singlethread(), and VerifyBlockEvaluator().

divide_assign_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::divide_assign_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

                                                                                 {
  typedef typename DstXprType::Scalar Scalar;
  call_assignment(dst.const_cast_derived(), src.derived(),
                  internal::div_assign_op<Scalar, typename SrcXprType::Scalar>());
}

References Eigen::internal::call_assignment().

Referenced by EIGEN_DECLARE_TEST().

divup()

template<typename T >

EIGEN_DEPRECATED EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE T Eigen::divup ( const T  x, const T  y  )

constexpr

                                                                                               {
  return Eigen::numext::div_ceil(x, y);
}

References Eigen::numext::div_ceil(), plotDoE::x, and y.

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
	)

Referenced by Eigen::internal::arpack_wrapper< double, double >::saupd().

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
	)

Referenced by Eigen::internal::arpack_wrapper< double, double >::seupd().

EIGEN_ARRAY_DECLARE_GLOBAL_UNARY() [1/6]

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 Eigen::EIGEN_ARRAY_DECLARE_GLOBAL_UNARY	(	carg	,
		scalar_carg_op	,
		complex	argument,
		\sa ArrayBase::carg DOXCOMMA MatrixBase::cwiseCArg
	)

EIGEN_ARRAY_DECLARE_GLOBAL_UNARY() [2/6]

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round Eigen::EIGEN_ARRAY_DECLARE_GLOBAL_UNARY	(	floor	,
		scalar_floor_op	,
		nearest integer not greater than the given	value,
		\sa Eigen::ceil DOXCOMMA ArrayBase::floor
	)

EIGEN_ARRAY_DECLARE_GLOBAL_UNARY() [3/6]

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil not a number sa Eigen::isinf DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isnan Eigen::EIGEN_ARRAY_DECLARE_GLOBAL_UNARY	(	isinf	,
		scalar_isinf_op	,
		infinite value	test,
		\sa Eigen::isnan DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isinf
	)

EIGEN_ARRAY_DECLARE_GLOBAL_UNARY() [4/6]

Eigen::EIGEN_ARRAY_DECLARE_GLOBAL_UNARY	(	lgamma	,
		scalar_lgamma_op	,
		natural logarithm of the gamma	function,
		\sa ArrayBase::lgamma
	)

EIGEN_ARRAY_DECLARE_GLOBAL_UNARY() [5/6]

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square Eigen::EIGEN_ARRAY_DECLARE_GLOBAL_UNARY	(	rint	,
		scalar_rint_op	,
		nearest	integer,
		\sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round
	)

EIGEN_ARRAY_DECLARE_GLOBAL_UNARY() [6/6]

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil Eigen::EIGEN_ARRAY_DECLARE_GLOBAL_UNARY	(	trunc	,
		scalar_trunc_op	,
		nearest integer not greater in magnitude than the given	value,
		\sa Eigen::trunc DOXCOMMA ArrayBase::trunc
	)

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [1/7]

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

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [2/7]

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

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [3/7]

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

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

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [4/7]

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

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [5/7]

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

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [6/7]

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

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [7/7]

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

gamma_sample_der_alpha()

template<typename AlphaDerived , typename SampleDerived >

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

\cpp11

Returns

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

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

Note

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

See also

Eigen::igamma(), Eigen::lgamma()

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

References alpha.

Referenced by array_special_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_gamma_sample_der_alpha_op< Scalar >::operator()(), and Eigen::internal::pgamma_sample_der_alpha().

generateRandomMatrixSvs()

template<typename MatrixType , typename RealScalarVectorType >

void Eigen::generateRandomMatrixSvs	(	const RealScalarVectorType &	svs,
		const Index	rows,
		const Index	cols,
		MatrixType &	M
	)

Generation of random matrix with prescribed singular values.

We generate random matrices with given singular values by setting up a singular value decomposition. By choosing the number of zeros as singular values we can specify the rank of the matrix. Moreover, we also control its spectral norm, which is the largest singular value, as well as its condition number with respect to the l2-norm, which is the quotient of the largest and smallest singular value.

Reference: For details on the method see e.g. Section 8.1 (pp. 62 f) in

C. C. Paige, M. A. Saunders, LSQR: An algorithm for sparse linear equations and sparse least squares. ACM Transactions on Mathematical Software 8(1), pp. 43-71, 1982. https://web.stanford.edu/group/SOL/software/lsqr/lsqr-toms82a.pdf

and also the LSQR webpage https://web.stanford.edu/group/SOL/software/lsqr/.

Template Parameters

MatrixType	matrix type to generate
RealScalarVectorType	vector type with real entries used for singular values

Parameters

svs	vector of desired singular values
rows	row dimension of requested random matrix
cols	column dimension of requested random matrix
M	generated matrix with prescribed singular values

                                                                                                                 {
  enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
  typedef typename internal::traits<MatrixType>::Scalar Scalar;
  typedef Matrix<Scalar, Rows, Rows> MatrixAType;
  typedef Matrix<Scalar, Cols, Cols> MatrixBType;
 
  const Index min_dim = (std::min)(rows, cols);
 
  const MatrixAType U = generateRandomUnitaryMatrix<MatrixAType>(rows);
  const MatrixBType V = generateRandomUnitaryMatrix<MatrixBType>(cols);
 
  M = U.block(0, 0, rows, min_dim) * svs.asDiagonal() * V.block(0, 0, cols, min_dim).transpose();
}

References cols, min, rows, RachelsAdvectionDiffusion::U, and V.

Referenced by check_generateRandomMatrixSvs(), and test_nnls_random_problem().

generateRandomUnitaryMatrix()

template<typename MatrixType >

MatrixType Eigen::generateRandomUnitaryMatrix

(

const Index

dim

)

Generate a random unitary matrix of prescribed dimension.

The algorithm is using a random Householder sequence to produce a random unitary matrix.

Template Parameters

MatrixType

type of matrix to generate

Parameters

dim	row and column dimension of the requested square matrix

Returns

random unitary matrix

                                                        {
  typedef typename internal::traits<MatrixType>::Scalar Scalar;
  typedef Matrix<Scalar, Dynamic, 1> VectorType;
 
  MatrixType v = MatrixType::Identity(dim, dim);
  VectorType h = VectorType::Zero(dim);
  for (Index i = 0; i < dim; ++i) {
    v.col(i).tail(dim - i - 1) = VectorType::Random(dim - i - 1);
    h(i) = 2 / v.col(i).tail(dim - i).squaredNorm();
  }
 
  const Eigen::HouseholderSequence<MatrixType, VectorType> HSeq(v, h);
  return MatrixType(HSeq);
}

References i, v, and oomph::PseudoSolidHelper::Zero.

get_test_precision() [1/2]

template<typename T >

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

                                                                                                   {
  return test_precision<typename NumTraits<typename T::Scalar>::Real>();
}

Referenced by verifyIsApprox(), and verifyIsCwiseApprox().

get_test_precision() [2/2]

template<typename T >

NumTraits<T>::Real Eigen::get_test_precision	(	const T &	,
		std::enable_if_t< internal::is_arithmetic< typename NumTraits< T >::Real >::value, T > *	= 0
	)

                                                                                             {
  return test_precision<typename NumTraits<T>::Real>();
}

getMarketHeader()

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

inline

Reads the header of a matrixmarket file and determines the properties of a matrix.

Parameters

filename	of the file
sym	if the matrix is hermitian,symmetric or none of the latter (sym=0)
iscomplex	if the matrix has complex or real coefficients
isdense	if the matrix is dense or sparse

Returns

true if the file was found

                                                                                                 {
  sym = 0;
  iscomplex = false;
  isdense = false;
  std::ifstream in(filename.c_str(), std::ios::in);
  if (!in) return false;
 
  std::string line;
  // The matrix header is always the first line in the file
  std::getline(in, line);
  eigen_assert(in.good());
 
  std::stringstream fmtline(line);
  std::string substr[5];
  fmtline >> substr[0] >> substr[1] >> substr[2] >> substr[3] >> substr[4];
  if (substr[2].compare("array") == 0) isdense = true;
  if (substr[3].compare("complex") == 0) iscomplex = true;
  if (substr[4].compare("symmetric") == 0)
    sym = Symmetric;
  else if (substr[4].compare("Hermitian") == 0)
    sym = SelfAdjoint;
 
  return true;
}

References compare(), eigen_assert, MergeRestartFiles::filename, calibrate::line, SelfAdjoint, oomph::Global_string_for_annotation::string(), and Symmetric.

Referenced by Eigen::MatrixMarketIterator< Scalar >::Getnextvalidmatrix(), and main().

igamma()

template<typename Derived , typename ExponentDerived >

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

\cpp11

Returns

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

This function computes the coefficient-wise incomplete gamma function.

Note

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

See also

Eigen::igammac(), Eigen::lgamma()

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

References a, and plotDoE::x.

Referenced by array_special_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_igamma_op< Scalar >::operator()(), and Eigen::internal::pigamma().

igamma_der_a()

template<typename Derived , typename ExponentDerived >

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

\cpp11

Returns

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

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

Note

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

See also

Eigen::igamma(), Eigen::lgamma()

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

References a, and plotDoE::x.

Referenced by array_special_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_igamma_der_a_op< Scalar >::operator()(), and Eigen::internal::pigamma_der_a().

igammac()

template<typename Derived , typename ExponentDerived >

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

\cpp11

Returns

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

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

Note

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

See also

Eigen::igamma(), Eigen::lgamma()

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

References a, and plotDoE::x.

Referenced by array_special_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_igammac_op< Scalar >::operator()(), and Eigen::internal::pigammac().

imag()

template<typename DerType >

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

inline

                                                                   {
  return 0.;
}

Referenced by array_real(), Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly3(), Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly4(), Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly5(), Eigen::internal::kissfft_impl< Scalar_ >::fwd(), Eigen::internal::getAdjointVal(), Eigen::internal::matrix_log_compute_2x2(), Eigen::internal::pmul< Packet1cd >(), Eigen::EigenSolver< MatrixType_ >::pseudoEigenvalueMatrix(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::realRoots(), Eigen::internal::imag_default_impl< Scalar, true >::run(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToAbsRealPart(), and Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToRealPart().

initParallel()

EIGEN_DEPRECATED void Eigen::initParallel ( )

inline

Must be call first when calling Eigen from multiple threads

{}

Referenced by main().

is_same_type()

template<typename T1 , typename T2 >

std::enable_if_t<internal::is_same<T1, T2>::value, bool> Eigen::is_same_type	(	const T1 &	,
		const T2 &
	)

                                                                                      {
  return true;
}

Referenced by adjoint(), check_symbolic_index(), and triangular_square().

isMinusInf()

template<typename T >

bool Eigen::isMinusInf

(

const T &

x

)

Check if number is minus infinity.

Template Parameters

T	input type

Parameters

x	input value

Returns

true, if input value is minus infinity

                            {
  return x < NumTraits<T>::lowest();
}

isNotNaN()

template<typename T >

bool Eigen::isNotNaN

(

const T &

x

)

Check if number is "not a number" (NaN).

Template Parameters

T	input type

Parameters

x	input value

Returns

true, if input value is "not a number" (NaN)

                          {
  return x == x;
}

References plotDoE::x.

isPlusInf()

template<typename T >

bool Eigen::isPlusInf

(

const T &

x

)

Check if number is plus infinity.

Template Parameters

T	input type

Parameters

x	input value

Returns

true, if input value is plus infinity

                           {
  return x > NumTraits<T>::highest();
}

References plotDoE::x.

Referenced by stable_norm().

klu_factor() [1/2]

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

inline

                                                                                                                    {
  return klu_factor(Ap, Ai, Ax, Symbolic, Common);
}

Referenced by Eigen::KLU< MatrixType_ >::factorize_impl().

klu_factor() [2/2]

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

inline

                                                                       {
  return klu_z_factor(Ap, Ai, &numext::real_ref(Ax[0]), Symbolic, Common);
}

References Eigen::numext::real_ref().

klu_solve() [1/2]

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

inline

A sparse LU factorization and solver based on KLU.

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

Warning

The input matrix A should be in a compressed and column-major form. Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.

Template Parameters

MatrixType_

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

\implsparsesolverconcept

See also

Sparse solver concept, class UmfPackLU, class SparseLU

                                                 {
  return klu_solve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), B,
                   Common);
}

Referenced by Eigen::KLU< MatrixType_ >::_solve_impl().

klu_solve() [2/2]

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

inline

                                                             {
  return klu_z_solve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs),
                     &numext::real_ref(B[0]), Common);
}

References Eigen::numext::real_ref().

klu_tsolve() [1/2]

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

inline

                                                  {
  return klu_tsolve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), B,
                    Common);
}

klu_tsolve() [2/2]

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

inline

                                                              {
  return klu_z_tsolve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs),
                      &numext::real_ref(B[0]), 0, Common);
}

References Eigen::numext::real_ref().

kroneckerProduct() [1/2]

template<typename A , typename B >

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

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

Warning

If you want to replace a matrix by its Kronecker product with some matrix, do NOT do this:

A = kroneckerProduct(A,B); // bug!!! caused by aliasing effect

instead, use eval() to work around this:

A = kroneckerProduct(A,B).eval();

Parameters

a	Dense/sparse matrix a
b	Dense/sparse matrix b

Returns

Kronecker tensor product of a and b, stored in a sparse matrix

                                                                                            {
  return KroneckerProductSparse<A, B>(a.derived(), b.derived());
}

References a, and b.

kroneckerProduct() [2/2]

template<typename A , typename B >

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

Computes Kronecker tensor product of two dense matrices

Warning

If you want to replace a matrix by its Kronecker product with some matrix, do NOT do this:

A = kroneckerProduct(A,B); // bug!!! caused by aliasing effect

instead, use eval() to work around this:

A = kroneckerProduct(A,B).eval();

Parameters

a	Dense matrix a
b	Dense matrix b

Returns

Kronecker tensor product of a and b

                                                                                        {
  return KroneckerProduct<A, B>(a.derived(), b.derived());
}

References a, and b.

l1CacheSize()

std::ptrdiff_t Eigen::l1CacheSize ( )

inline

Returns

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

See also

setCpuCacheSize

                                  {
  std::ptrdiff_t l1, l2, l3;
  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
  return l1;
}

References GetAction, and Eigen::internal::manage_caching_sizes().

Referenced by Eigen::internal::CacheSizes::CacheSizes(), Eigen::DefaultDevice::firstLevelCacheSize(), main(), and product_large_regressions().

l2CacheSize()

std::ptrdiff_t Eigen::l2CacheSize ( )

inline

Returns

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

See also

setCpuCacheSize

                                  {
  std::ptrdiff_t l1, l2, l3;
  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
  return l2;
}

References GetAction, and Eigen::internal::manage_caching_sizes().

Referenced by Eigen::internal::CacheSizes::CacheSizes(), main(), and product_large_regressions().

l3CacheSize()

std::ptrdiff_t Eigen::l3CacheSize ( )

inline

Returns

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

See also

setCpuCacheSize

                                  {
  std::ptrdiff_t l1, l2, l3;
  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
  return l3;
}

References GetAction, and Eigen::internal::manage_caching_sizes().

Referenced by Eigen::internal::CacheSizes::CacheSizes(), and Eigen::DefaultDevice::lastLevelCacheSize().

lazyprod()

template<typename Lhs , typename Rhs >

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

                                                                              {
  return Product<Lhs, Rhs, LazyProduct>(lhs, rhs);
}

Referenced by EIGEN_DECLARE_TEST().

loadMarket()

template<typename SparseMatrixType >

bool Eigen::loadMarket	(	SparseMatrixType &	mat,
		const std::string &	filename
	)

Loads a sparse matrix from a matrixmarket format file.

Template Parameters

SparseMatrixType

to read into, symmetries are not supported

Parameters

mat	SparseMatrix to read into, current values are overwritten
filename	to parse matrix from

Returns

returns true if file exists. Returns false if the parsing did not succeed.

                                                                  {
  typedef typename SparseMatrixType::Scalar Scalar;
  typedef typename SparseMatrixType::StorageIndex StorageIndex;
  std::ifstream input(filename.c_str(), std::ios::in);
  if (!input) return false;
 
  char rdbuffer[4096];
  input.rdbuf()->pubsetbuf(rdbuffer, 4096);
 
  const int maxBuffersize = 2048;
  char buffer[maxBuffersize];
 
  bool readsizes = false;
 
  typedef Triplet<Scalar, StorageIndex> T;
  std::vector<T> elements;
 
  Index M(-1), N(-1), NNZ(-1);
  Index count = 0;
  while (input.getline(buffer, maxBuffersize)) {
    // skip comments
    // NOTE An appropriate test should be done on the header to get the  symmetry
    if (buffer[0] == '%') continue;
 
    if (!readsizes) {
      std::stringstream line(buffer);
      line >> M >> N >> NNZ;
      if (M > 0 && N > 0) {
        readsizes = true;
        mat.resize(M, N);
        mat.reserve(NNZ);
        elements.reserve(NNZ);
      }
    } else {
      StorageIndex i(-1), j(-1);
      Scalar value;
      internal::GetMarketLine(buffer, i, j, value);
 
      i--;
      j--;
      if (i >= 0 && j >= 0 && i < M && j < N) {
        ++count;
        elements.push_back(T(i, j, value));
      } else {
        std::cerr << "Invalid read: " << i << "," << j << "\n";
        return false;
      }
    }
  }
 
  mat.setFromTriplets(elements.begin(), elements.end());
  if (count != NNZ) {
    std::cerr << count << "!=" << NNZ << "\n";
    return false;
  }
  input.close();
  return true;
}

References MergeRestartFiles::filename, Eigen::internal::GetMarketLine(), i, j, calibrate::line, N, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserve(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resize(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::setFromTriplets(), and value.

Referenced by check_marketio(), main(), and Eigen::MatrixMarketIterator< Scalar >::matrix().

loadMarketDense()

template<typename DenseType >

bool Eigen::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.

Template Parameters

DenseMatrixType

to read into

Parameters

mat	DenseMatrix to read into, current values are overwritten, symmetries are not supported
filename	to parse matrix from

Returns

true if parsing was successful. Returns false if the parsing did not succeed.

                                                                {
  typedef typename DenseType::Scalar Scalar;
  std::ifstream in(filename.c_str(), std::ios::in);
  if (!in) return false;
 
  std::string line;
  Index rows(0), cols(0);
  do {  // Skip comments
    std::getline(in, line);
    eigen_assert(in.good());
  } while (line[0] == '%');
  std::istringstream newline(line);
  newline >> rows >> cols;
 
  bool sizes_not_positive = (rows < 1 || cols < 1);
  bool wrong_input_rows = (DenseType::MaxRowsAtCompileTime != Dynamic && rows > DenseType::MaxRowsAtCompileTime) ||
                          (DenseType::RowsAtCompileTime != Dynamic && rows != DenseType::RowsAtCompileTime);
  bool wrong_input_cols = (DenseType::MaxColsAtCompileTime != Dynamic && cols > DenseType::MaxColsAtCompileTime) ||
                          (DenseType::ColsAtCompileTime != Dynamic && cols != DenseType::ColsAtCompileTime);
 
  if (sizes_not_positive || wrong_input_rows || wrong_input_cols) {
    if (sizes_not_positive) {
      std::cerr << "non-positive row or column size in file" << filename << "\n";
    } else {
      std::cerr << "Input matrix can not be resized to" << rows << " x " << cols << "as given in " << filename << "\n";
    }
    in.close();
    return false;
  }
 
  mat.resize(rows, cols);
  Index row = 0;
  Index col = 0;
  Index n = 0;
  Scalar value;
  while (std::getline(in, line) && (row < rows) && (col < cols)) {
    internal::GetDenseElt(line, value);
    // matrixmarket format is column major
    mat(row, col) = value;
    row++;
    if (row == rows) {
      row = 0;
      col++;
    }
    n++;
  }
  in.close();
  if (n != mat.size()) {
    std::cerr << "Unable to read all elements from file " << filename << "\n";
    return false;
  }
  return true;
}

References col(), cols, Dynamic, eigen_assert, MergeRestartFiles::filename, Eigen::internal::GetDenseElt(), calibrate::line, n, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resize(), row(), rows, Eigen::SparseMatrixBase< Derived >::size(), oomph::Global_string_for_annotation::string(), and value.

Referenced by check_marketio_dense(), and loadMarketVector().

loadMarketVector()

template<typename VectorType >

bool Eigen::loadMarketVector	(	VectorType &	vec,
		const std::string &	filename
	)

Same functionality as loadMarketDense, deprecated.

                                                                  {
  return loadMarketDense(vec, filename);
}

References MergeRestartFiles::filename, and loadMarketDense().

Referenced by check_marketio_vector(), main(), Eigen::MatrixMarketIterator< Scalar >::refX(), and Eigen::MatrixMarketIterator< Scalar >::rhs().

make_index_list()

template<typename FirstType , typename... OtherTypes>

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

constexpr

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

Referenced by test_dynamic_index_list(), test_mixed_index_list(), and test_static_index_list().

MakeAutoDiffScalar()

template<typename NewDerType >

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

inline

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

References value.

Referenced by Eigen::AutoDiffScalar< DerivativeType >::operator*(), Eigen::AutoDiffScalar< DerivativeType >::operator+(), Eigen::AutoDiffScalar< DerivativeType >::operator-(), and Eigen::AutoDiffScalar< DerivativeType >::operator/().

matrix_sqrt_quasi_triangular()

template<typename MatrixType , typename ResultType >

void Eigen::matrix_sqrt_quasi_triangular	(	const MatrixType &	arg,
		ResultType &	result
	)

Compute matrix square root of quasi-triangular matrix.

Template Parameters

MatrixType	type of arg, the argument of matrix square root, expected to be an instantiation of the Matrix class template.
ResultType	type of result, where result is to be stored.

Parameters

[in]	arg	argument of matrix square root.
[out]	result	matrix square root of upper Hessenberg part of arg.

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

See also

MatrixSquareRoot, MatrixSquareRootQuasiTriangular

                                                                             {
  eigen_assert(arg.rows() == arg.cols());
  result.resize(arg.rows(), arg.cols());
  internal::matrix_sqrt_quasi_triangular_diagonal(arg, result);
  internal::matrix_sqrt_quasi_triangular_off_diagonal(arg, result);
}

References eigen_assert, Eigen::internal::matrix_sqrt_quasi_triangular_diagonal(), and Eigen::internal::matrix_sqrt_quasi_triangular_off_diagonal().

Referenced by Eigen::internal::matrix_sqrt_compute< MatrixType, 0 >::run().

matrix_sqrt_triangular()

template<typename MatrixType , typename ResultType >

void Eigen::matrix_sqrt_triangular	(	const MatrixType &	arg,
		ResultType &	result
	)

Compute matrix square root of triangular matrix.

Template Parameters

MatrixType	type of arg, the argument of matrix square root, expected to be an instantiation of the Matrix class template.
ResultType	type of result, where result is to be stored.

Parameters

[in]	arg	argument of matrix square root.
[out]	result	matrix square root of upper triangular part of arg.

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

See also

MatrixSquareRoot, MatrixSquareRootQuasiTriangular

                                                                       {
  using std::sqrt;
  typedef typename MatrixType::Scalar Scalar;
 
  eigen_assert(arg.rows() == arg.cols());
 
  // Compute square root of arg and store it in upper triangular part of result
  // This uses that the square root of triangular matrices can be computed directly.
  result.resize(arg.rows(), arg.cols());
  for (Index i = 0; i < arg.rows(); i++) {
    result.coeffRef(i, i) = sqrt(arg.coeff(i, i));
  }
  for (Index j = 1; j < arg.cols(); j++) {
    for (Index i = j - 1; i >= 0; i--) {
      // if i = j-1, then segment has length 0 so tmp = 0
      Scalar tmp = (result.row(i).segment(i + 1, j - i - 1) * result.col(j).segment(i + 1, j - i - 1)).value();
      // denominator may be zero if original matrix is singular
      result.coeffRef(i, j) = (arg.coeff(i, j) - tmp) / (result.coeff(i, i) + result.coeff(j, j));
    }
  }
}

References eigen_assert, i, j, sqrt(), tmp, and value.

Referenced by Eigen::MatrixPowerAtomic< MatrixType >::computeBig(), Eigen::internal::matrix_log_compute_big(), and Eigen::internal::matrix_sqrt_compute< MatrixType, 1 >::run().

max() [1/3]

template<typename DerType >

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

inline

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

References plotDoE::x, and y.

max() [2/3]

template<typename DerType , typename T >

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

inline

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

References plotDoE::x, and y.

Referenced by Eigen::TensorEvaluator< const TensorStridingSlicingOp< StartIndices, StopIndices, Strides, ArgType >, Device >::clamp(), Eigen::TensorBase< Derived, ReadOnlyAccessors >::clip(), Eigen::internal::predux_max< Packet4c >(), Eigen::internal::predux_max< Packet4s >(), Eigen::internal::predux_max< Packet4uc >(), Eigen::internal::predux_max< Packet4us >(), Eigen::internal::predux_max< Packet8c >(), Eigen::internal::predux_max< Packet8uc >(), run_benchmarks(), setupRandomSvs(), and setupRangeSvs().

max() [3/3]

template<typename DerType , typename T >

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

inline

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

References plotDoE::x, and y.

min() [1/3]

template<typename DerType >

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

inline

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

References plotDoE::x, and y.

min() [2/3]

template<typename DerType , typename T >

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

inline

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

References plotDoE::x, and y.

Referenced by Eigen::TensorEvaluator< const TensorStridingSlicingOp< StartIndices, StopIndices, Strides, ArgType >, Device >::clamp(), Eigen::TensorBase< Derived, ReadOnlyAccessors >::clip(), Eigen::internal::predux_min< Packet4c >(), Eigen::internal::predux_min< Packet4s >(), Eigen::internal::predux_min< Packet4uc >(), Eigen::internal::predux_min< Packet4us >(), Eigen::internal::predux_min< Packet8c >(), Eigen::internal::predux_min< Packet8uc >(), and setupRangeSvs().

min() [3/3]

template<typename DerType , typename T >

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

inline

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

References plotDoE::x, and y.

multiply_assign_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::multiply_assign_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

                                                                                   {
  typedef typename DstXprType::Scalar Scalar;
  call_assignment(dst.const_cast_derived(), src.derived(),
                  internal::mul_assign_op<Scalar, typename SrcXprType::Scalar>());
}

References Eigen::internal::call_assignment().

Referenced by EIGEN_DECLARE_TEST().

nbThreads()

int Eigen::nbThreads ( )

inline

Returns

the max number of threads reserved for Eigen

See also

setNbThreads

                       {
  int ret;
  internal::manage_multi_threading(GetAction, &ret);
  return ret;
}

References GetAction, Eigen::internal::manage_multi_threading(), and ret.

Referenced by Eigen::internal::sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar, RowMajor, true >::run(), and Eigen::internal::sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar, RowMajor, false >::run().

operator!=()

template<typename U , typename V >

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

                                                                                                                {
  return !(x == y);
}

References plotDoE::x, and y.

Referenced by Eigen::TensorBase< Derived, ReadOnlyAccessors >::operator!=().

operator*() [1/9]

template<typename SparseDerived , typename PermutationType >

const Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct> Eigen::operator* ( const InverseImpl< PermutationType, PermutationStorage > &  tperm, const SparseMatrixBase< SparseDerived > &  matrix  )

inline

Returns

the matrix with the inverse permutation applied to the rows.

                                                                                                                  {
  return Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>(tperm.derived(), matrix.derived());
}

References AliasFreeProduct, Eigen::EigenBase< Derived >::derived(), and matrix().

operator*() [2/9]

template<typename MatrixDerived , typename PermutationDerived >

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

Returns

the matrix with the permutation applied to the columns.

                                                                                                     {
  return Product<MatrixDerived, PermutationDerived, AliasFreeProduct>(matrix.derived(), permutation.derived());
}

References Eigen::PermutationBase< Derived >::derived(), and matrix().

operator*() [3/9]

template<typename MatrixDerived , typename TranspositionsDerived >

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

Returns

the matrix with the transpositions applied to the columns.

                                                                                                              {
  return Product<MatrixDerived, TranspositionsDerived, AliasFreeProduct>(matrix.derived(), transpositions.derived());
}

References Eigen::TranspositionsBase< Derived >::derived(), and matrix().

operator*() [4/9]

template<typename OtherDerived , typename VectorsType , typename CoeffsType , int Side>

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

Computes the product of a matrix with a Householder sequence.

Parameters

[in]	other	Matrix being multiplied.
[in]	h	HouseholderSequence being multiplied.

Returns

Expression object representing the product.

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

                                                                                                        {
  typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar, OtherDerived>::Type res(
      other.template cast<typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,
                                                                           OtherDerived>::ResultScalar>());
  h.applyThisOnTheRight(res);
  return res;
}

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheRight(), Eigen::internal::cast(), and res.

operator*() [5/9]

template<typename SparseDerived , typename PermDerived >

const Product<PermDerived, SparseDerived, AliasFreeProduct> Eigen::operator* ( const PermutationBase< PermDerived > &  perm, const SparseMatrixBase< SparseDerived > &  matrix  )

inline

Returns

the matrix with the permutation applied to the rows

                                                                                             {
  return Product<PermDerived, SparseDerived, AliasFreeProduct>(perm.derived(), matrix.derived());
}

References Eigen::PermutationBase< Derived >::derived(), and matrix().

operator*() [6/9]

template<typename PermutationDerived , typename MatrixDerived >

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

Returns

the matrix with the permutation applied to the rows.

                                                                                                     {
  return Product<PermutationDerived, MatrixDerived, AliasFreeProduct>(permutation.derived(), matrix.derived());
}

References Eigen::PermutationBase< Derived >::derived(), and matrix().

operator*() [7/9]

template<typename SparseDerived , typename PermutationType >

const Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct> Eigen::operator* ( const SparseMatrixBase< SparseDerived > &  matrix, const InverseImpl< PermutationType, PermutationStorage > &  tperm  )

inline

Returns

the matrix with the inverse permutation applied to the columns.

                                                                                                                  {
  return Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>(matrix.derived(), tperm.derived());
}

References AliasFreeProduct, Eigen::EigenBase< Derived >::derived(), and matrix().

operator*() [8/9]

template<typename SparseDerived , typename PermDerived >

const Product<SparseDerived, PermDerived, AliasFreeProduct> Eigen::operator* ( const SparseMatrixBase< SparseDerived > &  matrix, const PermutationBase< PermDerived > &  perm  )

inline

Returns

the matrix with the permutation applied to the columns

                                                                                             {
  return Product<SparseDerived, PermDerived, AliasFreeProduct>(matrix.derived(), perm.derived());
}

References Eigen::PermutationBase< Derived >::derived(), and matrix().

operator*() [9/9]

template<typename TranspositionsDerived , typename MatrixDerived >

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

Returns

the matrix with the transpositions applied to the rows.

                                                                                                              {
  return Product<TranspositionsDerived, MatrixDerived, AliasFreeProduct>(transpositions.derived(), matrix.derived());
}

References Eigen::TranspositionsBase< Derived >::derived(), and matrix().

operator+() [1/2]

template<typename DenseDerived , typename SparseDerived >

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

                                                                                           {
  return CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar, typename SparseDerived::Scalar>,
                       const DenseDerived, const SparseDerived>(a.derived(), b.derived());
}

References a, and b.

operator+() [2/2]

template<typename SparseDerived , typename DenseDerived >

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

                                                                                           {
  return CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar, typename DenseDerived::Scalar>,
                       const SparseDerived, const DenseDerived>(a.derived(), b.derived());
}

References a, and b.

operator-() [1/2]

template<typename DenseDerived , typename SparseDerived >

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

                                                                                           {
  return CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar, typename SparseDerived::Scalar>,
                       const DenseDerived, const SparseDerived>(a.derived(), b.derived());
}

References a, and b.

operator-() [2/2]

template<typename SparseDerived , typename DenseDerived >

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

                                                                                           {
  return CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar, typename DenseDerived::Scalar>,
                       const SparseDerived, const DenseDerived>(a.derived(), b.derived());
}

References a, and b.

operator<<() [1/4]

template<typename IndexType , int NumDims>

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

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

References i.

operator<<() [2/4]

template<typename FirstType , typename... OtherTypes>

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

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

References i.

operator<<() [3/4]

template<typename Derived >

std::ostream& Eigen::operator<<	(	std::ostream &	s,
		const DiagonalBase< Derived > &	m
	)

                                                                      {
  return internal::print_matrix(s, m.derived(), EIGEN_DEFAULT_IO_FORMAT);
}

References EIGEN_DEFAULT_IO_FORMAT, m, Eigen::internal::print_matrix(), and s.

operator<<() [4/4]

template<typename T >

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

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

References Eigen::TensorIOFormat::Plain(), s, and plotPSD::t.

operator==()

template<typename U , typename V >

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

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

References plotDoE::x, and y.

Referenced by Eigen::TensorBase< Derived, ReadOnlyAccessors >::operator==().

poly_eval()

template<typename Polynomials , typename T >

T Eigen::poly_eval ( const Polynomials &  poly, const T &  x  )

inline

Returns

the evaluation of the polynomial at x using stabilized Horner algorithm.

Parameters

[in]	poly	: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. \( 1 + 3x^2 \) is stored as a vector \( [ 1, 0, 3 ] \).
[in]	x	: the value to evaluate the polynomial at.

                                                        {
  typedef typename NumTraits<T>::Real Real;
 
  if (numext::abs2(x) <= Real(1)) {
    return poly_eval_horner(poly, x);
  } else {
    T val = poly[0];
    T inv_x = T(1) / x;
    for (DenseIndex i = 1; i < poly.size(); ++i) {
      val = val * inv_x + poly[i];
    }
 
    return numext::pow(x, (T)(poly.size() - 1)) * val;
  }
}

References Eigen::numext::abs2(), i, poly_eval_horner(), Eigen::numext::pow(), calibrate::val, and plotDoE::x.

Referenced by aux_evalSolver(), Eigen::PolynomialSolver< Scalar_, Deg_ >::compute(), main(), and realRoots_to_monicPolynomial_test().

poly_eval_horner()

template<typename Polynomials , typename T >

T Eigen::poly_eval_horner ( const Polynomials &  poly, const T &  x  )

inline

Returns

the evaluation of the polynomial at x using Horner algorithm.

Parameters

[in]	poly	: the vector of coefficients of the polynomial ordered by degrees i.e. poly[i] is the coefficient of degree i of the polynomial e.g. \( 1 + 3x^2 \) is stored as a vector \( [ 1, 0, 3 ] \).
[in]	x	: the value to evaluate the polynomial at.

Note

for stability: \( |x| \le 1 \)

                                                               {
  T val = poly[poly.size() - 1];
  for (DenseIndex i = poly.size() - 2; i >= 0; --i) {
    val = val * x + poly[i];
  }
  return val;
}

References i, calibrate::val, and plotDoE::x.

Referenced by poly_eval().

polygamma()

template<typename DerivedN , typename DerivedX >

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

\cpp11

Returns

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

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

Note

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

See also

Eigen::digamma()

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

References n, and plotDoE::x.

Referenced by array_special_functions(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::scalar_polygamma_op< Scalar >::operator()(), and Eigen::internal::ppolygamma().

prod()

template<typename Lhs , typename Rhs >

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

                                                             {
  return Product<Lhs, Rhs>(lhs, rhs);
}

Referenced by Eigen::internal::array_prod(), Eigen::IncompleteLUT< Scalar_, StorageIndex_ >::factorize(), Eigen::BDCSVD< MatrixType_, Options_ >::perturbCol0(), Eigen::internal::predux_mul< Packet2cf >(), Eigen::internal::predux_mul< Packet4c >(), Eigen::internal::predux_mul< Packet4f >(), Eigen::internal::predux_mul< Packet4s >(), Eigen::internal::predux_mul< Packet4uc >(), Eigen::internal::predux_mul< Packet4us >(), Eigen::internal::predux_mul< Packet8c >(), Eigen::internal::predux_mul< Packet8uc >(), Eigen::internal::predux_mul< PacketXf >(), Eigen::internal::predux_mul< PacketXi >(), Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, true >::run(), and Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, false >::run().

randomPermutationVector()

template<typename PermutationVectorType >

void Eigen::randomPermutationVector	(	PermutationVectorType &	v,
		Index	size
	)

Generate random permutation vector.

Template Parameters

PermutationVectorType

type of vector used to store permutation

Parameters

v	permutation vector
size	length of permutation vector

                                                                   {
  typedef typename PermutationVectorType::Scalar Scalar;
  v.resize(size);
  for (Index i = 0; i < size; ++i) v(i) = Scalar(i);
  if (size == 1) return;
  for (Index n = 0; n < 3 * size; ++n) {
    Index i = internal::random<Index>(0, size - 1);
    Index j;
    do j = internal::random<Index>(0, size - 1);
    while (j == i);
    std::swap(v(i), v(j));
  }
}

References i, j, n, size, swap(), and v.

Referenced by permutationmatrices(), rvalue_transpositions(), and sparse_permutations().

real()

template<typename DerType >

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

inline

                                                                             {
  return x;
}

References plotDoE::x.

Referenced by array_real(), Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly3(), Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly4(), Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly5(), Eigen::GeneralizedEigenSolver< MatrixType_ >::compute(), Eigen::internal::kissfft_impl< Scalar_ >::fwd(), Eigen::internal::getAdjointVal(), Eigen::internal::kissfft_impl< Scalar_ >::inv(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::logDeterminant(), Eigen::internal::matrix_sqrt_quasi_triangular_2x2_diagonal_block(), Eigen::EigenSolver< MatrixType_ >::pseudoEigenvalueMatrix(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::realRoots(), Eigen::internal::real_default_impl< Scalar, true >::run(), Eigen::internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex >::run(), and Eigen::Tridiagonalization< MatrixType_ >::subDiagonal().

roots_to_monicPolynomial()

template<typename RootVector , typename Polynomial >

void Eigen::roots_to_monicPolynomial	(	const RootVector &	rv,
		Polynomial &	poly
	)

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

Parameters

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

                                                                      {
  typedef typename Polynomial::Scalar Scalar;
 
  poly.setZero(rv.size() + 1);
  poly[0] = -rv[0];
  poly[1] = Scalar(1);
  for (DenseIndex i = 1; i < rv.size(); ++i) {
    for (DenseIndex j = i + 1; j > 0; --j) {
      poly[j] = poly[j - 1] - rv[i] * poly[j];
    }
    poly[0] = -rv[i] * poly[0];
  }
}

References i, and j.

Referenced by CauchyBounds(), main(), polynomialsolver(), and realRoots_to_monicPolynomial_test().

run()

template<typename Kernel , typename... Args>

auto Eigen::run	(	Kernel	kernel,
		Args &&...	args
	)		-> decltype(kernel(args...))

Runs a kernel on the GPU (if EIGEN_GPUCC), or CPU otherwise.

This is to better support creating generic tests.

The kernel must be able to be passed directly as an input to a global function (i.e. empty or POD). Its inputs must be "Serializable" so we can transfer them to the device, and the output must be a Serializable value type so it can be transferred back from the device.

Parameters

kernel	kernel to run.
args	... input arguments, must be "Serializable".

Returns

kernel(args...).

                                                                     {
#ifdef EIGEN_GPUCC
  return run_on_gpu(kernel, std::forward<Args>(args)...);
#else
  return run_on_cpu(kernel, std::forward<Args>(args)...);
#endif
}

References compute_granudrum_aor::args, run_on_cpu(), and run_on_gpu().

Referenced by Eigen::internal::generic_product_impl< Lhs, Rhs, SparseShape, SparseShape, ProductType >::addTo(), Eigen::internal::call_triangular_assignment_loop(), Eigen::ComplexSchur< MatrixType_ >::compute(), Eigen::SelfAdjointEigenSolver< MatrixType_ >::computeDirect(), Eigen::QuaternionBase< Derived >::conjugate(), Eigen::MatrixBase< Derived >::cross3(), Eigen::MatrixBase< Derived >::determinant(), Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::determinant(), Eigen::FullPivHouseholderQR< MatrixType_, PermutationIndex_ >::determinant(), Eigen::HouseholderQR< MatrixType_ >::determinant(), dimensions_match(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), Eigen::internal::EIGEN_MATHFUNC_RETVAL(), Eigen::MatrixBase< Derived >::eigenvalues(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemv(), Eigen::TensorEvaluator< const TensorConversionOp< TargetType, ArgType >, Device >::evalSubExprsIfNeeded(), Eigen::TensorEvaluator< const TensorForcedEvalOp< ArgType_ >, Device >::evalSubExprsIfNeeded(), Eigen::internal::generic_product_impl< Lhs, Rhs, SparseShape, SparseShape, ProductType >::evalTo(), Eigen::internal::h_array_apply_and_reduce(), Eigen::internal::h_array_zip_and_reduce(), Eigen::internal::initialize_tensor(), Eigen::Transform< Scalar_, Dim_, Mode_, Options_ >::makeAffine(), Eigen::QuaternionBase< Derived >::operator*(), Eigen::Transform< Scalar_, Dim_, Mode_, Options_ >::operator*(), Eigen::SparseMatrixBase< Derived >::operator=(), Eigen::SelfAdjointView< MatrixType_, UpLo >::rankUpdate(), Eigen::test::runner< Scalar, PacketType, true, true >::run(), Eigen::internal::random_impl< bool >::run(), Eigen::internal::gemv_dense_selector< OnTheRight, ColMajor, true >::run(), Eigen::internal::gemv_dense_selector< OnTheRight, RowMajor, true >::run(), Eigen::internal::trmv_selector< Mode, ColMajor >::run(), Eigen::internal::trmv_selector< Mode, RowMajor >::run(), Eigen::internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, 1 >::run(), Eigen::internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, Dynamic >::run(), Eigen::internal::triangular_solver_selector< Lhs, Rhs, OnTheRight, Mode, CompleteUnrolling, 1 >::run(), Eigen::internal::random_int_impl< Scalar, false, true >::run(), Eigen::internal::random_default_impl< Scalar, false, false >::run(), Eigen::internal::selfadjoint_product_impl< Lhs, LhsMode, false, Rhs, 0, true >::run(), Eigen::internal::selfadjoint_product_impl< Lhs, 0, true, Rhs, RhsMode, false >::run(), Eigen::internal::selfadjoint_product_impl< Lhs, LhsMode, false, Rhs, RhsMode, false >::run(), Eigen::internal::triangular_product_impl< Mode, LhsIsTriangular, Lhs, false, Rhs, false >::run(), Eigen::internal::triangular_product_impl< Mode, true, Lhs, false, Rhs, true >::run(), Eigen::internal::triangular_product_impl< Mode, false, Lhs, true, Rhs, false >::run(), Eigen::internal::triangular_matrix_vector_product< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, RowMajor, Version >::run(), Eigen::internal::triangular_matrix_vector_product< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, ColMajor, Version >::run(), Eigen::internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, LhsSelfAdjoint, ConjugateLhs, RhsStorageOrder, RhsSelfAdjoint, ConjugateRhs, RowMajor, ResInnerStride >::run(), Eigen::internal::general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor, ResInnerStride >::run(), Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, RowMajor, ResInnerStride, Version >::run(), Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheRight, Mode, Conjugate, StorageOrder >::run(), Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, RowMajor >::run(), Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, ColMajor >::run(), Eigen::internal::packed_triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheRight, Mode, Conjugate, StorageOrder >::run(), Eigen::internal::triangular_solve_matrix< Scalar, Index, Side, Mode, Conjugate, TriStorageOrder, RowMajor, OtherInnerStride >::run(), Eigen::internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor, ResInnerStride, UpLo, Version >::run(), Eigen::internal::dense_assignment_loop< Kernel, InnerVectorizedTraversal, InnerUnrolling >::run(), Eigen::selfadjoint_product_selector< MatrixType, OtherType, UpLo, true >::run(), Eigen::selfadjoint_product_selector< MatrixType, OtherType, UpLo, false >::run(), Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, true >::run(), Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, false >::run(), Eigen::internal::Assignment< DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse >::run(), Eigen::internal::tuple_impl::tuple_cat_impl< NTuples, TupleImpl< N1, Args1... >, TupleImpl< N2, Args2... >, Tuples... >::run(), Eigen::internal::eigen_zero_impl< Xpr, false >::run(), Eigen::internal::eigen_fill_impl< Xpr, false >::run(), Eigen::internal::eigen_fill_impl< Xpr, true >::run(), Eigen::internal::eigen_zero_impl< Xpr, true >::run(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, GemvProduct >::scaleAndAddTo(), Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::signDeterminant(), Eigen::FullPivHouseholderQR< MatrixType_, PermutationIndex_ >::signDeterminant(), Eigen::HouseholderQR< MatrixType_ >::signDeterminant(), Eigen::internal::smart_copy(), Eigen::internal::smart_memmove(), Eigen::PlainObjectBase< Derived >::swap(), Eigen::Transform< Scalar_, Dim_, Mode_, Options_ >::Transform(), Eigen::internal::tuple_impl::tuple_cat(), and Eigen::internal::unary_evaluator< SparseView< Product< Lhs, Rhs, Options > >, IteratorBased >::unary_evaluator().

run_on_cpu()

template<typename Kernel , typename... Args>

auto Eigen::run_on_cpu	(	Kernel	kernel,
		Args &&...	args
	)		-> decltype(kernel(args...))

Runs a kernel on the CPU, returning the results.

Parameters

kernel	kernel to run.
args	... input arguments.

Returns

kernel(args...).

                                                                            {
  return kernel(std::forward<Args>(args)...);
}

References compute_granudrum_aor::args.

run_with_hint()

template<typename Kernel , typename... Args>

auto Eigen::run_with_hint	(	size_t	buffer_capacity_hint,
		Kernel	kernel,
		Args &&...	args
	)		-> decltype(kernel(args...))

Runs a kernel on the GPU (if EIGEN_GPUCC), or CPU otherwise.

This version allows specifying a minimum buffer capacity size required for serializing the puts to transfer results from device to host. Use this when run(...) fails to determine an appropriate capacity by default.

Parameters

buffer_capacity_hint	minimum required buffer size for serializing outputs.
kernel	kernel to run.
args	... input arguments, must be "Serializable".

Returns

kernel(args...).

See also

run

                                                                                                            {
#ifdef EIGEN_GPUCC
  return run_on_gpu_with_hint(buffer_capacity_hint, kernel, std::forward<Args>(args)...);
#else
  EIGEN_UNUSED_VARIABLE(buffer_capacity_hint)
  return run_on_cpu(kernel, std::forward<Args>(args)...);
#endif
}

References compute_granudrum_aor::args, EIGEN_UNUSED_VARIABLE, and run_on_cpu().

saveMarket()

template<typename SparseMatrixType >

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

writes a sparse Matrix to a marketmarket format file

Template Parameters

SparseMatrixType

to write to file

Parameters

mat	matrix to write to file
filename	filename to write to
sym	at the moment no symmetry operations are supported

Returns

true if writing succeeded

                                                                                     {
  typedef typename SparseMatrixType::Scalar Scalar;
  typedef typename SparseMatrixType::RealScalar RealScalar;
  std::ofstream out(filename.c_str(), std::ios::out);
  if (!out) return false;
 
  out.flags(std::ios_base::scientific);
  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
  std::string header;
  internal::putMarketHeader<Scalar>(header, sym);
  out << header << std::endl;
  out << mat.rows() << " " << mat.cols() << " " << mat.nonZeros() << "\n";
  int count = 0;
  EIGEN_UNUSED_VARIABLE(count);
  for (int j = 0; j < mat.outerSize(); ++j)
    for (typename SparseMatrixType::InnerIterator it(mat, j); it; ++it) {
      ++count;
      internal::PutMatrixElt(it.value(), it.row() + 1, it.col() + 1, out);
    }
  out.close();
  return true;
}

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), EIGEN_UNUSED_VARIABLE, MergeRestartFiles::filename, j, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::nonZeros(), out(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::outerSize(), Eigen::internal::PutMatrixElt(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), and oomph::Global_string_for_annotation::string().

Referenced by check_marketio().

saveMarketDense()

template<typename DenseType >

bool Eigen::saveMarketDense	(	const DenseType &	mat,
		const std::string &	filename
	)

writes a dense Matrix or vector to a marketmarket format file

Template Parameters

DenseMatrixType

to write to file

Parameters

mat	matrix to write to file
filename	filename to write to

Returns

true if writing succeeded

                                                                      {
  typedef typename DenseType::Scalar Scalar;
  typedef typename DenseType::RealScalar RealScalar;
  std::ofstream out(filename.c_str(), std::ios::out);
  if (!out) return false;
 
  out.flags(std::ios_base::scientific);
  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
  if (internal::is_same<Scalar, std::complex<float> >::value || internal::is_same<Scalar, std::complex<double> >::value)
    out << "%%MatrixMarket matrix array complex general\n";
  else
    out << "%%MatrixMarket matrix array real general\n";
  out << mat.rows() << " " << mat.cols() << "\n";
  for (Index i = 0; i < mat.cols(); i++) {
    for (Index j = 0; j < mat.rows(); j++) {
      internal::putDenseElt(mat(j, i), out);
    }
  }
  out.close();
  return true;
}

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), MergeRestartFiles::filename, i, j, out(), Eigen::internal::putDenseElt(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), and value.

Referenced by check_marketio_dense(), and saveMarketVector().

saveMarketVector()

template<typename VectorType >

bool Eigen::saveMarketVector	(	const VectorType &	vec,
		const std::string &	filename
	)

Same functionality as saveMarketDense, deprecated.

                                                                        {
  return saveMarketDense(vec, filename);
}

References MergeRestartFiles::filename, and saveMarketDense().

Referenced by check_marketio_vector().

Scaling() [1/7]

template<typename Derived >

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

inline

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

                                                                                       {
  return coeffs.asDiagonal();
}

References Eigen::MatrixBase< Derived >::asDiagonal().

Scaling() [2/7]

template<typename Scalar >

DiagonalMatrix<Scalar, 2> Eigen::Scaling ( const Scalar &  sx, const Scalar &  sy  )

inline

Constructs a 2D axis aligned scaling

                                                                             {
  return DiagonalMatrix<Scalar, 2>(sx, sy);
}

Scaling() [3/7]

template<typename Scalar >

DiagonalMatrix<Scalar, 3> Eigen::Scaling ( const Scalar &  sx, const Scalar &  sy, const Scalar &  sz  )

inline

Constructs a 3D axis aligned scaling

                                                                                               {
  return DiagonalMatrix<Scalar, 3>(sx, sy, sz);
}

Scaling() [4/7]

template<typename RealScalar >

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

inline

Constructs a uniform scaling from scale factor s

                                                                                        {
  return UniformScaling<std::complex<RealScalar> >(s);
}

References s.

Scaling() [5/7]

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

inline

Constructs a uniform scaling from scale factor s

{ return UniformScaling<double>(s); }

References s.

Scaling() [6/7]

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

inline

Constructs a uniform scaling from scale factor s

{ return UniformScaling<float>(s); }

References s.

Referenced by FancySpheres::draw(), FancySpheres::FancySpheres(), openglsupport_test_loop(), transform_associativity(), and transformations().

Scaling() [7/7]

template<typename Derived >

DiagonalWrapper<const Derived>::PlainObject Eigen::Scaling ( MatrixBase< Derived > &&  coeffs )

inline

Constructs an axis aligned scaling expression from vector coeffs when passed as an rvalue reference

                                                                                                {
  return typename DiagonalWrapper<const Derived>::PlainObject(std::move(coeffs.derived()));
}

seq() [1/2]

template<typename FirstType , typename LastType >

auto Eigen::seq	(	FirstType	f,
		LastType	l
	)		-> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f), (typename internal::cleanup_index_type<LastType>::type(l) - typename internal::cleanup_index_type<FirstType>::type(f) + fix<1>())))

                                                                                          {
  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
              (typename internal::cleanup_index_type<LastType>::type(l) -
               typename internal::cleanup_index_type<FirstType>::type(f) + fix<1>()));
}

References f(), and seqN().

Referenced by check_indexed_view(), check_tutorial_examples(), reshape4x4(), and test_stl_iterators().

seq() [2/2]

template<typename FirstType , typename LastType , typename IncrType >

auto Eigen::seq	(	FirstType	f,
		LastType	l,
		IncrType	incr
	)		-> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f), (typename internal::cleanup_index_type<LastType>::type(l) - typename internal::cleanup_index_type<FirstType>::type(f) + typename internal::cleanup_seq_incr<IncrType>::type(incr)) / typename internal::cleanup_seq_incr<IncrType>::type(incr), typename internal::cleanup_seq_incr<IncrType>::type(incr)))

                                                                             {
  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
              (typename internal::cleanup_index_type<LastType>::type(l) -
               typename internal::cleanup_index_type<FirstType>::type(f) + CleanedIncrType(incr)) /
                  CleanedIncrType(incr),
              CleanedIncrType(incr));
}

References f(), and seqN().

seqN() [1/2]

template<typename FirstType , typename SizeType >

ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type, typename internal::cleanup_index_type<SizeType>::type> Eigen::seqN	(	FirstType	first,
		SizeType	size
	)

Returns

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

See also

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

                                     {
  return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
                            typename internal::cleanup_index_type<SizeType>::type>(first, size);
}

References size.

seqN() [2/2]

template<typename FirstType , typename SizeType , typename IncrType >

ArithmeticSequence< typename internal::cleanup_index_type< FirstType >::type, typename internal::cleanup_index_type< SizeType >::type, typename internal::cleanup_seq_incr< IncrType >::type > Eigen::seqN	(	FirstType	first,
		SizeType	size,
		IncrType	incr
	)

Returns

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

See also

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

                                                    {
  return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
                            typename internal::cleanup_index_type<SizeType>::type,
                            typename internal::cleanup_seq_incr<IncrType>::type>(first, size, incr);
}

References size.

Referenced by check_indexed_view(), check_tutorial_examples(), Eigen::placeholders::lastN(), Eigen::ArithmeticSequence< FirstType, SizeType, IncrType >::reverse(), and seq().

serialize()

template<typename... Args>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint8_t* Eigen::serialize	(	uint8_t *	dest,
		uint8_t *	end,
		const Args &...	args
	)

Serialize a set of values to the byte buffer.

Parameters

dest	output byte buffer; if this is nullptr, does nothing.
end	the end of the output byte buffer.
args	... arguments to serialize in sequence.

Returns

the next address after all serialized values.

                                                                                                           {
  return internal::serialize_impl<sizeof...(args), Args...>::serialize(dest, end, args...);
}

References compute_granudrum_aor::args, and Eigen::placeholders::end.

Referenced by Eigen::internal::run_serialized(), and test_dense_types().

serialize_size()

template<typename... Args>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t Eigen::serialize_size

(

const Args &...

args

)

Determine the buffer size required to serialize a set of values.

Parameters

args	... arguments to serialize in sequence.

Returns

the total size of the required buffer.

                                                                                 {
  return internal::serialize_impl<sizeof...(args), Args...>::serialize_size(args...);
}

References compute_granudrum_aor::args.

Referenced by Eigen::internal::run_serialized(), Eigen::internal::serialize_impl< N, T1, Ts... >::serialize_size(), and test_dense_types().

setCpuCacheSizes()

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

inline

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

See also

computeProductBlockingSizes

                                                                                {
  internal::manage_caching_sizes(SetAction, &l1, &l2, &l3);
}

References Eigen::internal::manage_caching_sizes(), and SetAction.

Referenced by main(), product_large_regressions(), and test_small_blocking_factors().

setNbThreads()

void Eigen::setNbThreads ( int  v )

inline

Sets the max number of threads reserved for Eigen

See also

nbThreads

{ internal::manage_multi_threading(SetAction, &v); }

References Eigen::internal::manage_multi_threading(), SetAction, and v.

Referenced by main().

setupRandomSvs()

template<typename VectorType , typename RealScalar >

VectorType Eigen::setupRandomSvs	(	const Index	dim,
		const RealScalar	max
	)

Setup a vector of random singular values with prescribed upper limit. For use with generateRandomMatrixSvs().

Singular values are non-negative real values. By convention (to be consistent with singular value decomposition) we sort them in decreasing order.

This strategy produces random singular values in the range [0, max], in particular the singular values can be zero or arbitrarily close to zero.

Template Parameters

VectorType	vector type with real entries used for singular values
RealScalar	data type used for real entry

Parameters

dim	number of singular values to generate
max	upper bound for singular values

Returns

vector of singular values

                                                                 {
  VectorType svs = max / RealScalar(2) * (VectorType::Random(dim) + VectorType::Ones(dim));
  std::sort(svs.begin(), svs.end(), std::greater<RealScalar>());
  return svs;
}

References max().

setupRangeSvs()

template<typename VectorType , typename RealScalar >

VectorType Eigen::setupRangeSvs	(	const Index	dim,
		const RealScalar	min,
		const RealScalar	max
	)

Setup a vector of random singular values with prescribed range. For use with generateRandomMatrixSvs().

Singular values are non-negative real values. By convention (to be consistent with singular value decomposition) we sort them in decreasing order.

For dim > 1 this strategy generates a vector with largest entry max, smallest entry min, and remaining entries in the range [min, max]. For dim == 1 the only entry is min.

Template Parameters

VectorType	vector type with real entries used for singular values
RealScalar	data type used for real entry

Parameters

dim	number of singular values to generate
min	smallest singular value to use
max	largest singular value to use

Returns

vector of singular values

                                                                                      {
  VectorType svs = VectorType::Random(dim);
  if (dim == 0) return svs;
  if (dim == 1) {
    svs(0) = min;
    return svs;
  }
  std::sort(svs.begin(), svs.end(), std::greater<RealScalar>());
 
  // scale to range [min, max]
  const RealScalar c_min = svs(dim - 1), c_max = svs(0);
  svs = (svs - VectorType::Constant(dim, c_min)) / (c_max - c_min);
  return min * (VectorType::Ones(dim) - svs) + max * svs;
}

References max(), and min().

Referenced by test_nnls_random_problem().

SimdInstructionSetsInUse()

static const char* Eigen::SimdInstructionSetsInUse ( void  )

inlinestatic

                                                         {
#if defined(EIGEN_VECTORIZE_AVX512)
  return "AVX512, FMA, AVX2, AVX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
#elif defined(EIGEN_VECTORIZE_AVX)
  return "AVX SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
#elif defined(EIGEN_VECTORIZE_SSE4_2)
  return "SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
#elif defined(EIGEN_VECTORIZE_SSE4_1)
  return "SSE, SSE2, SSE3, SSSE3, SSE4.1";
#elif defined(EIGEN_VECTORIZE_SSSE3)
  return "SSE, SSE2, SSE3, SSSE3";
#elif defined(EIGEN_VECTORIZE_SSE3)
  return "SSE, SSE2, SSE3";
#elif defined(EIGEN_VECTORIZE_SSE2)
  return "SSE, SSE2";
#elif defined(EIGEN_VECTORIZE_ALTIVEC)
  return "AltiVec";
#elif defined(EIGEN_VECTORIZE_VSX)
  return "VSX";
#elif defined(EIGEN_VECTORIZE_NEON)
  return "ARM NEON";
#elif defined(EIGEN_VECTORIZE_SVE)
  return "ARM SVE";
#elif defined(EIGEN_VECTORIZE_ZVECTOR)
  return "S390X ZVECTOR";
#elif defined(EIGEN_VECTORIZE_MSA)
  return "MIPS MSA";
#elif defined(EIGEN_VECTORIZE_LSX)
  return "LOONGARCH64 LSX";
#else
  return "None";
#endif
}

square()

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 Eigen::square

(

power

2

)

Referenced by adjoint(), MeltableNormalSpecies::analyseTimeScales(), array_complex(), array_real(), basicStuff(), PSD::convertProbabilityDensityNumberDistributionToProbabilityDensity(), PSD::convertProbabilityDensityToProbabilityDensityNumberDistribution(), PSDContinuous::convertSubtractiveNumberToVolume(), PSDContinuous::convertSubtractiveVolumeToNumber(), dontalign(), HorizontalScrew::getDistanceAndNormal(), Screw::getDistanceAndNormalLabCoordinates(), inplace(), integer_type_tests(), LaserOnLayer::LaserOnLayer(), miscMatrices(), product(), product_extra(), adjoint_specific< true >::run(), adjoint_specific< false >::run(), test_async_execute_unary_expr(), and test_execute_unary_expr().

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
	)

Referenced by Eigen::internal::arpack_wrapper< float, float >::saupd().

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
	)

Referenced by Eigen::internal::arpack_wrapper< float, float >::seupd().

subtract_assign_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::subtract_assign_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

                                                                                   {
  typedef typename DstXprType::Scalar Scalar;
  call_assignment(const_cast<DstXprType&>(dst), src.derived(),
                  internal::sub_assign_op<Scalar, typename SrcXprType::Scalar>());
}

References Eigen::internal::call_assignment().

Referenced by EIGEN_DECLARE_TEST().

swap()

template<typename DerivedA , typename DerivedB >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<std::is_base_of<DenseBase<std::decay_t<DerivedA> >, std::decay_t<DerivedA> >::value && std::is_base_of<DenseBase<std::decay_t<DerivedB> >, std::decay_t<DerivedB> >::value, void> Eigen::swap	(	DerivedA &&	a,
		DerivedB &&	b
	)

Free-function swap.

                                     {
  a.swap(b);
}

References a, and b.

Referenced by Eigen::BDCSVD< MatrixType_, Options_ >::computeSingVals(), Eigen::BDCSVD< MatrixType_, Options_ >::computeSVDofM(), Eigen::BDCSVD< MatrixType_, Options_ >::deflation(), Eigen::IncompleteLUT< Scalar_, StorageIndex_ >::factorize(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator=(), and Eigen::TensorStorage< T, DSizes< IndexType, NumIndices_ >, Options_ >::operator=().

swap_using_evaluator()

template<typename DstXprType , typename SrcXprType >

void Eigen::swap_using_evaluator	(	const DstXprType &	dst,
		const SrcXprType &	src
	)

                                                                        {
  typedef typename DstXprType::Scalar Scalar;
  call_assignment(dst.const_cast_derived(), src.const_cast_derived(), internal::swap_assign_op<Scalar>());
}

References Eigen::internal::call_assignment().

Referenced by EIGEN_DECLARE_TEST().

test_is_equal()

template<typename T , typename U >

bool Eigen::test_is_equal	(	const T &	actual,
		const U &	expected,
		bool	expect_equal
	)

                                                                          {
  if (numext::equal_strict(actual, expected) == expect_equal) return true;
  // false:
  std::cerr << "\n    actual   = " << actual << "\n    expected " << (expect_equal ? "= " : "!=") << expected << "\n\n";
  return false;
}

References Eigen::numext::equal_strict().

Referenced by test_contiguous_ref_no_copy(), and test_cref_move_ctor().

test_isApprox() [1/5]

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

inline

                                                                      {
  bool ret = internal::isApprox(a, b, test_precision<long double>());
  if (!ret)
    std::cerr << std::endl << "    actual   = " << a << std::endl << "    expected = " << b << std::endl << std::endl;
  return ret;
}

References a, b, Eigen::internal::isApprox(), ret, and test_precision< long double >().

test_isApprox() [2/5]

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

inline

                                                                                    {
  return internal::isApprox(a, b, test_precision<std::complex<double> >());
}

References a, b, Eigen::internal::isApprox(), and test_precision().

test_isApprox() [3/5]

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

inline

                                                                                  {
  return internal::isApprox(a, b, test_precision<std::complex<float> >());
}

References a, b, Eigen::internal::isApprox(), and test_precision().

Referenced by test_isApproxWithRef(), test_isCwiseApprox(), and verifyIsApprox().

test_isApprox() [4/5]

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

inline

                                                                                              {
  return internal::isApprox(a, b, test_precision<std::complex<long double> >());
}

References a, b, Eigen::internal::isApprox(), and test_precision().

test_isApprox() [5/5]

template<typename Type1 , typename Type2 >

bool Eigen::test_isApprox ( const Type1 &  a, const Type2 &  b, typename Type1::Scalar *  = 0  )

inline

{
  return a.isApprox(b, test_precision<typename Type1::Scalar>());
}

References a, and b.

test_isApproxOrLessThan()

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

inline

                                                                                {
  return internal::isApproxOrLessThan(a, b, test_precision<long double>());
}

References a, b, Eigen::internal::isApproxOrLessThan(), and test_precision< long double >().

test_isApproxWithRef()

template<typename Scalar , typename ScalarRef >

bool Eigen::test_isApproxWithRef ( const Scalar &  a, const Scalar &  b, const ScalarRef &  ref  )

inline

                                                                                         {
  return test_isApprox(a + ref, b + ref);
}

References a, b, and test_isApprox().

Referenced by adjoint_specific< true >::run(), and adjoint_specific< false >::run().

test_isCwiseApprox() [1/2]

template<typename Derived1 , typename Derived2 >

bool Eigen::test_isCwiseApprox	(	const DenseBase< Derived1 > &	m1,
		const DenseBase< Derived2 > &	m2,
		bool	exact
	)

                                                                                                  {
  if (m1.rows() != m2.rows()) {
    return false;
  }
  if (m1.cols() != m2.cols()) {
    return false;
  }
  for (Index r = 0; r < m1.rows(); ++r) {
    for (Index c = 0; c < m1.cols(); ++c) {
      if (m1(r, c) != m2(r, c) && !((numext::isnan)(m1(r, c)) && (numext::isnan)(m2(r, c))) &&
          (exact || !test_isApprox(m1(r, c), m2(r, c)))) {
        return false;
      }
    }
  }
  return true;
}

References calibrate::c, Eigen::numext::isnan(), m1, m2(), UniformPSDSelfTest::r, and test_isApprox().

Referenced by test_isCwiseApprox(), and verifyIsCwiseApprox().

test_isCwiseApprox() [2/2]

template<typename Derived1 , typename Derived2 >

bool Eigen::test_isCwiseApprox	(	const SparseMatrixBase< Derived1 > &	m1,
		const SparseMatrixBase< Derived2 > &	m2,
		bool	exact
	)

                                                                                                                {
  return test_isCwiseApprox(m1.toDense(), m2.toDense(), exact);
}

References m1, m2(), and test_isCwiseApprox().

test_isMuchSmallerThan() [1/6]

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

inline

                                                                               {
  return internal::isMuchSmallerThan(a, b, test_precision<long double>());
}

References a, b, Eigen::internal::isMuchSmallerThan(), and test_precision< long double >().

test_isMuchSmallerThan() [2/6]

template<typename Derived >

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

inline

                                                                                                            {
  return m.isMuchSmallerThan(s, test_precision<typename internal::traits<Derived>::Scalar>());
}

References m, s, and test_precision().

test_isMuchSmallerThan() [3/6]

template<typename Derived1 , typename Derived2 >

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

inline

                                                                                                   {
  return m1.isMuchSmallerThan(m2, test_precision<typename internal::traits<Derived1>::Scalar>());
}

References m1, m2(), and test_precision().

test_isMuchSmallerThan() [4/6]

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

inline

                                                                                             {
  return internal::isMuchSmallerThan(a, b, test_precision<std::complex<double> >());
}

References a, b, Eigen::internal::isMuchSmallerThan(), and test_precision().

test_isMuchSmallerThan() [5/6]

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

inline

                                                                                           {
  return internal::isMuchSmallerThan(a, b, test_precision<std::complex<float> >());
}

References a, b, Eigen::internal::isMuchSmallerThan(), and test_precision().

test_isMuchSmallerThan() [6/6]

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

inline

                                                                                                       {
  return internal::isMuchSmallerThan(a, b, test_precision<std::complex<long double> >());
}

References a, b, Eigen::internal::isMuchSmallerThan(), and test_precision().

test_isUnitary()

template<typename Derived >

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

inline

                                                         {
  return m.isUnitary(test_precision<typename internal::traits<Derived>::Scalar>());
}

References m, and test_precision().

test_precision()

template<typename T >

NumTraits<T>::Real Eigen::test_precision ( )

inline

                                                  {
  return NumTraits<T>::dummy_precision();
}

Referenced by test_isApprox(), test_isMuchSmallerThan(), and test_isUnitary().

test_precision< AnnoyingScalar >()

template<>

AnnoyingScalar Eigen::test_precision< AnnoyingScalar > ( )

inline

                                                       {
  return test_precision<float>();
}

References test_precision< float >().

Referenced by get_test_precision().

test_precision< double >()

template<>

double Eigen::test_precision< double > ( )

inline

                                       {
  return 1e-6;
}

References e().

Referenced by test_precision< std::complex< double > >(), and test_precision< std::complex< double > >().

test_precision< float >()

template<>

float Eigen::test_precision< float > ( )

inline

                                     {
  return 1e-3f;
}

Referenced by test_precision< AnnoyingScalar >(), test_precision< std::complex< float > >(), and test_precision< std::complex< float > >().

test_precision< long double >()

template<>

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

inline

                                                 {
  return 1e-6l;
}

Referenced by test_isApprox(), test_isApproxOrLessThan(), test_isMuchSmallerThan(), and test_precision< std::complex< long double > >().

test_precision< Real >()

template<>

Real Eigen::test_precision< Real >

(

)

                            {
  return 1e-50;
}

References e().

Referenced by boost::multiprecision::get_test_precision(), boost::multiprecision::test_isApprox(), boost::multiprecision::test_isApproxOrLessThan(), and boost::multiprecision::test_isMuchSmallerThan().

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

template<>

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

inline

                                                    {
  return test_precision<double>();
}

References test_precision< double >().

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

template<>

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

inline

                                                  {
  return test_precision<float>();
}

References test_precision< float >().

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

template<>

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

inline

                                                              {
  return test_precision<long double>();
}

References test_precision< long double >().

test_relative_error() [1/13]

template<typename S , int D>

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

                                                                            {
  return (std::max)(test_relative_error((a.min)(), (b.min)()), test_relative_error((a.max)(), (b.max)()));
}

References a, b, max, and test_relative_error().

test_relative_error() [2/13]

template<typename T , typename Derived >

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

                                                                                {
  return test_relative_error(a.coeffs().template head<3>(), b);
}

References a, b, and test_relative_error().

test_relative_error() [3/13]

template<typename T >

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

                                                                    {
  return (std::max)(test_relative_error(a.angle(), b.angle()), test_relative_error(a.axis(), b.axis()));
}

References a, b, max, and test_relative_error().

test_relative_error() [4/13]

template<typename T1 , typename T2 >

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

                                                                                                    {
  using std::sqrt;
  typedef typename NumTraits<typename T1::RealScalar>::NonInteger RealScalar;
  typename internal::nested_eval<T1, 2>::type ea(a.derived());
  typename internal::nested_eval<T2, 2>::type eb(b.derived());
  return sqrt(RealScalar((ea.matrix() - eb.matrix()).cwiseAbs2().sum()) /
              RealScalar((std::min)(eb.cwiseAbs2().sum(), ea.cwiseAbs2().sum())));
}

References a, b, min, and sqrt().

Referenced by test_relative_error(), verifyIsApprox(), and verifyIsCwiseApprox().

test_relative_error() [5/13]

template<typename T1 , typename T2 >

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

                                                                                                  {
  return test_relative_error(a, b.toDense());
}

References a, b, and test_relative_error().

test_relative_error() [6/13]

template<typename S , int D, int O>

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

                                                                                              {
  return (std::max)(test_relative_error(a.origin(), b.origin()), test_relative_error(a.origin(), b.origin()));
}

References a, b, max, and test_relative_error().

test_relative_error() [7/13]

template<typename T >

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

                                                                      {
  return test_relative_error(a.angle(), b.angle());
}

References a, b, and test_relative_error().

test_relative_error() [8/13]

template<typename T1 , typename T2 >

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

                                                                                                  {
  return test_relative_error(a.toDense(), b);
}

References a, b, and test_relative_error().

test_relative_error() [9/13]

template<typename T1 , typename T2 >

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

                                                                                                        {
  return test_relative_error(a.toDense(), b.toDense());
}

References a, b, and test_relative_error().

test_relative_error() [10/13]

template<typename T1 , typename T2 >

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

                                                                                                        {
  return test_relative_error(a.coeffs(), b.coeffs());
}

References a, b, and test_relative_error().

test_relative_error() [11/13]

template<typename T1 , typename T2 >

T1::Scalar Eigen::test_relative_error	(	const T1 &	a,
		const T2 &	b,
		const typename T1::MatrixType *	= 0
	)

                                                                                                  {
  return test_relative_error(a.matrix(), b.matrix());
}

References a, b, and test_relative_error().

test_relative_error() [12/13]

template<typename T1 , typename T2 >

NumTraits<typename NumTraits<T1>::Real>::NonInteger Eigen::test_relative_error	(	const T1 &	a,
		const T2 &	b,
		std::enable_if_t< internal::is_arithmetic< typename NumTraits< T1 >::Real >::value, T1 > *	= 0
	)

                                                                                                               {
  typedef typename NumTraits<typename NumTraits<T1>::Real>::NonInteger RealScalar;
  return numext::sqrt(RealScalar(numext::abs2(a - b)) /
                      (numext::mini)(RealScalar(numext::abs2(a)), RealScalar(numext::abs2(b))));
}

References a, Eigen::numext::abs2(), b, Eigen::numext::mini(), and Eigen::numext::sqrt().

test_relative_error() [13/13]

template<typename S , int D>

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

                                                                              {
  return test_relative_error(a.vector(), b.vector());
}

References a, b, and test_relative_error().

umfpack_defaults() [1/4]

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

inline

{ umfpack_di_defaults(control); }

Referenced by Eigen::UmfPackLU< MatrixType_ >::init().

umfpack_defaults() [2/4]

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

inline

                                                                                        {
  umfpack_dl_defaults(control);
}

umfpack_defaults() [3/4]

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

inline

                                                                                       {
  umfpack_zi_defaults(control);
}

umfpack_defaults() [4/4]

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

inline

                                                                                                    {
  umfpack_zl_defaults(control);
}

umfpack_free_numeric() [1/4]

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

inline

                                                              {
  umfpack_di_free_numeric(Numeric);
  *Numeric = 0;
}

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern(), Eigen::UmfPackLU< MatrixType_ >::compute(), Eigen::UmfPackLU< MatrixType_ >::factorize(), and Eigen::UmfPackLU< MatrixType_ >::~UmfPackLU().

umfpack_free_numeric() [2/4]

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

inline

                                                                           {
  umfpack_dl_free_numeric(Numeric);
  *Numeric = 0;
}

umfpack_free_numeric() [3/4]

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

inline

                                                                          {
  umfpack_zi_free_numeric(Numeric);
  *Numeric = 0;
}

umfpack_free_numeric() [4/4]

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

inline

                                                                                       {
  umfpack_zl_free_numeric(Numeric);
  *Numeric = 0;
}

umfpack_free_symbolic() [1/4]

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

inline

                                                                {
  umfpack_di_free_symbolic(Symbolic);
  *Symbolic = 0;
}

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern(), Eigen::UmfPackLU< MatrixType_ >::compute(), and Eigen::UmfPackLU< MatrixType_ >::~UmfPackLU().

umfpack_free_symbolic() [2/4]

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

inline

                                                                             {
  umfpack_dl_free_symbolic(Symbolic);
  *Symbolic = 0;
}

umfpack_free_symbolic() [3/4]

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

inline

                                                                            {
  umfpack_zi_free_symbolic(Symbolic);
  *Symbolic = 0;
}

umfpack_free_symbolic() [4/4]

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

inline

                                                                                         {
  umfpack_zl_free_symbolic(Symbolic);
  *Symbolic = 0;
}

umfpack_get_determinant() [1/4]

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

inline

                                                                                                                     {
  return umfpack_di_get_determinant(Mx, Ex, NumericHandle, User_Info);
}

Referenced by Eigen::UmfPackLU< MatrixType_ >::determinant().

umfpack_get_determinant() [2/4]

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

inline

                                                                                                  {
  return umfpack_dl_get_determinant(Mx, Ex, NumericHandle, User_Info);
}

umfpack_get_determinant() [3/4]

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

inline

                                                                        {
  double &mx_real = numext::real_ref(*Mx);
  return umfpack_zi_get_determinant(&mx_real, 0, Ex, NumericHandle, User_Info);
}

References Eigen::numext::real_ref().

umfpack_get_determinant() [4/4]

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

inline

                                                                                                  {
  double &mx_real = numext::real_ref(*Mx);
  return umfpack_zl_get_determinant(&mx_real, 0, Ex, NumericHandle, User_Info);
}

References Eigen::numext::real_ref().

umfpack_get_lunz() [1/4]

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

inline

                                                                                                              {
  return umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

Referenced by Eigen::UmfPackLU< MatrixType_ >::extractData().

umfpack_get_lunz() [2/4]

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

inline

                                                {
  return umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

umfpack_get_lunz() [3/4]

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

inline

                                                                                                                     {
  return umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

umfpack_get_lunz() [4/4]

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

inline

                                                             {
  return umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric);
}

umfpack_get_numeric() [1/4]

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

inline

                                                                                       {
  return umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric);
}

References oomph::StefanBoltzmannHelper::Dx(), Global_Parameters::Lx, Global_Physical_Variables::P, and Q.

Referenced by Eigen::UmfPackLU< MatrixType_ >::extractData().

umfpack_get_numeric() [2/4]

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

inline

                                                           {
  double &lx0_real = numext::real_ref(Lx[0]);
  double &ux0_real = numext::real_ref(Ux[0]);
  double &dx0_real = numext::real_ref(Dx[0]);
  return umfpack_zi_get_numeric(Lp, Lj, Lx ? &lx0_real : 0, 0, Up, Ui, Ux ? &ux0_real : 0, 0, P, Q, Dx ? &dx0_real : 0,
                                0, do_recip, Rs, Numeric);
}

References oomph::StefanBoltzmannHelper::Dx(), Global_Parameters::Lx, Global_Physical_Variables::P, Q, and Eigen::numext::real_ref().

umfpack_get_numeric() [3/4]

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

inline

                                                                                                    {
  return umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric);
}

References oomph::StefanBoltzmannHelper::Dx(), Global_Parameters::Lx, Global_Physical_Variables::P, and Q.

umfpack_get_numeric() [4/4]

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

inline

                                                                                                    {
  double &lx0_real = numext::real_ref(Lx[0]);
  double &ux0_real = numext::real_ref(Ux[0]);
  double &dx0_real = numext::real_ref(Dx[0]);
  return umfpack_zl_get_numeric(Lp, Lj, Lx ? &lx0_real : 0, 0, Up, Ui, Ux ? &ux0_real : 0, 0, P, Q, Dx ? &dx0_real : 0,
                                0, do_recip, Rs, Numeric);
}

References oomph::StefanBoltzmannHelper::Dx(), Global_Parameters::Lx, Global_Physical_Variables::P, Q, and Eigen::numext::real_ref().

umfpack_numeric() [1/4]

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

inline

                                                                                             {
  return umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info);
}

Referenced by Eigen::UmfPackLU< MatrixType_ >::factorize_impl().

umfpack_numeric() [2/4]

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

inline

                                                                                                             {
  return umfpack_zi_numeric(Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Numeric, Control, Info);
}

References Eigen::numext::real_ref().

umfpack_numeric() [3/4]

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

inline

                                                                   {
  return umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info);
}

umfpack_numeric() [4/4]

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

inline

                                                                                                          {
  return umfpack_zl_numeric(Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Numeric, Control, Info);
}

References Eigen::numext::real_ref().

umfpack_report_control() [1/4]

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

inline

{ umfpack_di_report_control(control); }

Referenced by Eigen::UmfPackLU< MatrixType_ >::printUmfpackControl().

umfpack_report_control() [2/4]

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

inline

                                                                                              {
  umfpack_dl_report_control(control);
}

umfpack_report_control() [3/4]

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

inline

                                                                                             {
  umfpack_zi_report_control(control);
}

umfpack_report_control() [4/4]

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

inline

                                                                                                          {
  umfpack_zl_report_control(control);
}

umfpack_report_info() [1/4]

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

inline

                                                                                                         {
  umfpack_di_report_info(control, info);
}

References info.

Referenced by Eigen::UmfPackLU< MatrixType_ >::printUmfpackInfo().

umfpack_report_info() [2/4]

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

inline

                                                                                                                      {
  umfpack_dl_report_info(control, info);
}

References info.

umfpack_report_info() [3/4]

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

inline

                                                                                                                     {
  umfpack_zi_report_info(control, info);
}

References info.

umfpack_report_info() [4/4]

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

inline

                                                  {
  umfpack_zl_report_info(control, info);
}

References info.

umfpack_report_status() [1/4]

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

inline

                                                                                            {
  umfpack_di_report_status(control, status);
}

Referenced by Eigen::UmfPackLU< MatrixType_ >::printUmfpackStatus().

umfpack_report_status() [2/4]

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

inline

                                                                                                         {
  umfpack_dl_report_status(control, status);
}

umfpack_report_status() [3/4]

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

inline

                                                                                                        {
  umfpack_zi_report_status(control, status);
}

umfpack_report_status() [4/4]

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

inline

                                                                                                                     {
  umfpack_zl_report_status(control, status);
}

umfpack_solve() [1/4]

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

inline

                                                                                                          {
  return umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info);
}

References X.

Referenced by Eigen::UmfPackLU< MatrixType_ >::_solve_impl().

umfpack_solve() [2/4]

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

inline

                                                                                           {
  return umfpack_zi_solve(sys, Ap, Ai, &numext::real_ref(Ax[0]), 0, &numext::real_ref(X[0]), 0, &numext::real_ref(B[0]),
                          0, Numeric, Control, Info);
}

References Eigen::numext::real_ref(), and X.

umfpack_solve() [3/4]

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

inline

                                                                                                        {
  return umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info);
}

References X.

umfpack_solve() [4/4]

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

inline

                                                                                                        {
  return umfpack_zl_solve(sys, Ap, Ai, &numext::real_ref(Ax[0]), 0, &numext::real_ref(X[0]), 0, &numext::real_ref(B[0]),
                          0, Numeric, Control, Info);
}

References Eigen::numext::real_ref(), and X.

umfpack_symbolic() [1/4]

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

inline

                                                                                              {
  return umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info);
}

Referenced by Eigen::UmfPackLU< MatrixType_ >::analyzePattern_impl().

umfpack_symbolic() [2/4]

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

inline

                                                                                                               {
  return umfpack_zi_symbolic(n_row, n_col, Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Control, Info);
}

References Eigen::numext::real_ref().

umfpack_symbolic() [3/4]

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

inline

                                                                                                           {
  return umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info);
}

umfpack_symbolic() [4/4]

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

inline

                                                                                                           {
  return umfpack_zl_symbolic(n_row, n_col, Ap, Ai, &numext::real_ref(Ax[0]), 0, Symbolic, Control, Info);
}

References Eigen::numext::real_ref().

verifyIsApprox()

template<typename Type1 , typename Type2 >

bool Eigen::verifyIsApprox ( const Type1 &  a, const Type2 &  b  )

inline

                                                           {
  bool ret = test_isApprox(a, b);
  if (!ret) {
    std::cerr << "Difference too large wrt tolerance " << get_test_precision(a)
              << ", relative error is: " << test_relative_error(a, b) << std::endl;
  }
  return ret;
}

References a, b, get_test_precision(), ret, test_isApprox(), and test_relative_error().

Referenced by exp_complex_test_impl< Scalar, Packet, HasExp >::is_exactly_equal(), packetmath_test_IEEE_corner_cases(), cast_test_impl< SrcType, DstType, RowsAtCompileTime, ColsAtCompileTime >::run(), and verifyIsApprox().

verifyIsCwiseApprox()

template<typename Type1 , typename Type2 >

bool Eigen::verifyIsCwiseApprox ( const Type1 &  a, const Type2 &  b, bool  exact  )

inline

                                                                            {
  bool ret = test_isCwiseApprox(a, b, exact);
  if (!ret) {
    if (exact) {
      std::cerr << "Values are not an exact match";
    } else {
      std::cerr << "Difference too large wrt tolerance " << get_test_precision(a);
    }
    std::cerr << ", relative error is: " << test_relative_error(a, b) << std::endl;
  }
  return ret;
}

References a, b, get_test_precision(), ret, test_isCwiseApprox(), and test_relative_error().

viewAsCholmod() [1/5]

template<typename Scalar_ , int Options_, typename Index_ >

const cholmod_sparse Eigen::viewAsCholmod

(

const SparseMatrix< Scalar_, Options_, Index_ > &

mat

)

                                                                                       {
  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<Scalar_, Options_, Index_> >(mat.const_cast_derived()));
  return res;
}

References Eigen::SparseMatrixBase< Derived >::const_cast_derived(), res, and viewAsCholmod().

viewAsCholmod() [2/5]

template<typename Scalar_ , int Options_, typename Index_ , unsigned int UpLo>

cholmod_sparse Eigen::viewAsCholmod

(

const SparseSelfAdjointView< const SparseMatrix< Scalar_, Options_, Index_ >, UpLo > &

mat

)

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

                                                                                                                    {
  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<Scalar_, Options_, Index_> >(mat.matrix().const_cast_derived()));
 
  if (UpLo == Upper) res.stype = 1;
  if (UpLo == Lower) res.stype = -1;
  // swap stype for rowmajor matrices (only works for real matrices)
  EIGEN_STATIC_ASSERT((Options_ & RowMajorBit) == 0 || NumTraits<Scalar_>::IsComplex == 0,
                      THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
  if (Options_ & RowMajorBit) res.stype *= -1;
 
  return res;
}

References Eigen::SparseMatrixBase< Derived >::const_cast_derived(), EIGEN_STATIC_ASSERT, Lower, res, RowMajorBit, Upper, and viewAsCholmod().

viewAsCholmod() [3/5]

template<typename Scalar_ , int Options_, typename Index_ >

const cholmod_sparse Eigen::viewAsCholmod

(

const SparseVector< Scalar_, Options_, Index_ > &

mat

)

                                                                                       {
  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<Scalar_, Options_, Index_> >(mat.const_cast_derived()));
  return res;
}

References Eigen::SparseMatrixBase< Derived >::const_cast_derived(), res, and viewAsCholmod().

viewAsCholmod() [4/5]

template<typename Derived >

cholmod_dense Eigen::viewAsCholmod

(

MatrixBase< Derived > &

mat

)

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

                                                      {
  EIGEN_STATIC_ASSERT((internal::traits<Derived>::Flags & RowMajorBit) == 0,
                      THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
  typedef typename Derived::Scalar Scalar;
 
  cholmod_dense res;
  res.nrow = mat.rows();
  res.ncol = mat.cols();
  res.nzmax = res.nrow * res.ncol;
  res.d = Derived::IsVectorAtCompileTime ? mat.derived().size() : mat.derived().outerStride();
  res.x = (void*)(mat.derived().data());
  res.z = 0;
 
  internal::cholmod_configure_matrix<Scalar>::run(res);
 
  return res;
}

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), Eigen::SparseMatrixBase< Derived >::derived(), EIGEN_STATIC_ASSERT, res, RowMajorBit, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), and run().

viewAsCholmod() [5/5]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

cholmod_sparse Eigen::viewAsCholmod

(

Ref< SparseMatrix< Scalar_, Options_, StorageIndex_ > >

mat

)

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

                                                                                       {
  cholmod_sparse res;
  res.nzmax = mat.nonZeros();
  res.nrow = mat.rows();
  res.ncol = mat.cols();
  res.p = mat.outerIndexPtr();
  res.i = mat.innerIndexPtr();
  res.x = mat.valuePtr();
  res.z = 0;
  res.sorted = 1;
  if (mat.isCompressed()) {
    res.packed = 1;
    res.nz = 0;
  } else {
    res.packed = 0;
    res.nz = mat.innerNonZeroPtr();
  }
 
  res.dtype = 0;
  res.stype = -1;
 
  if (internal::is_same<StorageIndex_, int>::value) {
    res.itype = CHOLMOD_INT;
  } else if (internal::is_same<StorageIndex_, SuiteSparse_long>::value) {
    res.itype = CHOLMOD_LONG;
  } else {
    eigen_assert(false && "Index type not supported yet");
  }
 
  // setup res.xtype
  internal::cholmod_configure_matrix<Scalar_>::run(res);
 
  res.stype = 0;
 
  return res;
}

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), eigen_assert, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerIndexPtr(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerNonZeroPtr(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::isCompressed(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::nonZeros(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::outerIndexPtr(), res, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), run(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::valuePtr().

Referenced by Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::_solve_impl(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::analyzePattern(), Eigen::SPQR< MatrixType_ >::compute(), Eigen::SPQR_QProduct< SPQRType, Derived >::evalTo(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::factorize(), and viewAsCholmod().

viewAsEigen() [1/2]

template<typename Scalar , typename StorageIndex >

Map<const SparseMatrix<Scalar, ColMajor, StorageIndex> > Eigen::viewAsEigen

(

cholmod_factor &

cm

)

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

                                                                                         {
  return Map<const SparseMatrix<Scalar, ColMajor, StorageIndex> >(
      cm.n, cm.n, static_cast<StorageIndex*>(cm.p)[cm.n], static_cast<StorageIndex*>(cm.p),
      static_cast<StorageIndex*>(cm.i), static_cast<Scalar*>(cm.x));
}

viewAsEigen() [2/2]

template<typename Scalar , typename StorageIndex >

Map<const SparseMatrix<Scalar, ColMajor, StorageIndex> > Eigen::viewAsEigen

(

cholmod_sparse &

cm

)

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

                                                                                         {
  return Map<const SparseMatrix<Scalar, ColMajor, StorageIndex> >(
      cm.nrow, cm.ncol, static_cast<StorageIndex*>(cm.p)[cm.ncol], static_cast<StorageIndex*>(cm.p),
      static_cast<StorageIndex*>(cm.i), static_cast<Scalar*>(cm.x));
}

zeta()

template<typename DerivedX , typename DerivedQ >

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

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

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

References Eigen::numext::q, and plotDoE::x.

Referenced by oomph::PseudoBucklingRing::accel(), QuarterCircleDrivenCavityProblem2< ELEMENT >::actions_before_newton_solve(), QuarterCircleDrivenCavityProblem< ELEMENT >::actions_before_newton_solve(), PrescribedBoundaryDisplacementProblem< ELEMENT >::actions_before_newton_solve(), RefineableBinArray::add_sample_point(), AirwayReopeningProblem< ELEMENT >::AirwayReopeningProblem(), oomph::MyAlgebraicCollapsibleChannelMesh< ELEMENT >::algebraic_node_update(), oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::AlgebraicChannelWithLeafletMesh(), array_special_functions(), oomph::QMacroElement< 2 >::assemble_macro_to_eulerian_jacobian(), oomph::QMacroElement< 2 >::assemble_macro_to_eulerian_jacobian2(), AxisymmetricVibratingShellProblem< ELEMENT >::AxisymmetricVibratingShellProblem(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::DiskTetMeshFacetedSurface::boundary_zeta01(), oomph::TetMeshFacetedSurface::boundary_zeta01(), oomph::TetMeshFacetedSurface::boundary_zeta12(), oomph::TetMeshFacetedSurface::boundary_zeta20(), oomph::BrethertonSpineMesh< ELEMENT, SpineLineFluidInterfaceElement< ELEMENT > >::BrethertonSpineMesh(), BubbleInChannelProblem< ELEMENT >::BubbleInChannelProblem(), oomph::SarahBL::buckled_ring_residual(), SarahBL::buckled_ring_residual(), oomph::RefineableQElement< 3 >::build(), oomph::RefineableQElement< 2 >::build(), oomph::ChannelSpineMesh< ELEMENT >::build_channel_spine_mesh(), oomph::FishMesh< ELEMENT >::build_mesh(), oomph::BrickFromTetMesh< ELEMENT >::build_mesh(), oomph::RefineableSolidCubicMesh< ELEMENT >::calculate_boundary_coordinate_of_node(), oomph::ChannelWithLeafletDomain::ChannelWithLeafletDomain(), oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), check_locate_zeta(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), AirwayReopeningProblem< ELEMENT >::connect_walls(), BinArray::coords_to_bin_index(), BinArray::coords_to_vectorial_bin_index(), SinusoidalWall::d2position(), oomph::Ellipse::d2position(), oomph::EllipticalTube::d2position(), UndeformedWall::d2position(), UndeformedLeaflet::d2position(), SpikedLine::d2position(), FlatPlate::d2position(), oomph::StraightLine::d2position(), DarcyProblem< ELEMENT >::DarcyProblem(), oomph::DiskTetMeshFacetedSurface::DiskTetMeshFacetedSurface(), oomph::SarahBL::Diss_sarah(), SarahBL::Diss_sarah(), UnstructuredFluidProblem< ELEMENT >::doc_boundary_coordinates(), oomph::Mesh::doc_boundary_coordinates(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solid_boundary_coordinates(), UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::doc_solid_boundary_coordinates(), GeomObjectAsGeneralisedElementProblem::doc_solution(), CollapsibleChannelProblem< ELEMENT >::doc_solution(), OscRingNStProblem< ELEMENT >::doc_solution_historic(), SinusoidalWall::dposition(), SpikedLine::dposition(), oomph::Ellipse::dposition(), oomph::GeomObject::dposition_dt(), oomph::PseudoBucklingRing::dposition_dt(), oomph::ImmersedRigidBodyElement::dposition_dt(), DropInChannelProblem< ELEMENT >::DropInChannelProblem(), Eigen::numext::EIGEN_MATHFUNC_RETVAL(), oomph::ElasticRefineableRectangularQuadMesh< ELEMENT >::ElasticRefineableRectangularQuadMesh(), ElasticRefineableTwoLayerMesh< ELEMENT >::ElasticRefineableTwoLayerMesh(), TanhSolnForLinearWave::exact_d2udt2(), TanhSolnForLinearWave::exact_dudt(), oomph::SarahBL::exact_soln(), SarahBL::exact_soln(), TanhSolnForLinearWave::exact_u(), RefineableBinArray::fill_bin_array(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_generic_contribution_to_residuals_displ_lagr_multiplier(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::fill_in_generic_contribution_to_residuals_fsi_displ_lagr_multiplier(), oomph::Multi_domain_functions::first_closer_than_second(), oomph::FSIDrivenCavityMesh< ELEMENT >::FSIDrivenCavityMesh(), oomph::SarahBL::full_exact_soln(), SarahBL::full_exact_soln(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), NonRefineableBinArray::get_bin(), TanhSolnForLinearWave::get_exact_gradient(), ExactSolnForUnsteadyHeat::get_exact_u(), oomph::BrethertonSpineMesh< ELEMENT, SpineLineFluidInterfaceElement< ELEMENT > >::initial_element_reorder(), oomph::FiniteElement::interpolated_zeta(), oomph::GeomObject::interpolated_zeta(), oomph::RefineableQElement< 2 >::interpolated_zeta_on_edge(), oomph::RefineableQElement< 3 >::interpolated_zeta_on_face(), oomph::FSIHermiteBeamElement::locate_zeta(), oomph::FiniteElement::locate_zeta(), RefineableBin::locate_zeta(), RefineableBinArray::locate_zeta(), NonRefineableBinArray::locate_zeta(), oomph::GeomObject::locate_zeta(), oomph::MeshAsGeomObject::locate_zeta(), oomph::ChannelWithLeafletDomain::macro_bound_I_E(), oomph::ChannelWithLeafletDomain::macro_bound_I_N(), oomph::ChannelWithLeafletDomain::macro_bound_I_S(), oomph::ChannelWithLeafletDomain::macro_bound_I_W(), oomph::ChannelWithLeafletDomain::macro_bound_II_E(), oomph::ChannelWithLeafletDomain::macro_bound_II_N(), oomph::ChannelWithLeafletDomain::macro_bound_II_S(), oomph::ChannelWithLeafletDomain::macro_bound_II_W(), oomph::ChannelWithLeafletDomain::macro_bound_III_E(), oomph::ChannelWithLeafletDomain::macro_bound_III_N(), oomph::ChannelWithLeafletDomain::macro_bound_III_S(), oomph::ChannelWithLeafletDomain::macro_bound_III_W(), oomph::ChannelWithLeafletDomain::macro_bound_IV_E(), oomph::ChannelWithLeafletDomain::macro_bound_IV_N(), oomph::ChannelWithLeafletDomain::macro_bound_IV_S(), oomph::ChannelWithLeafletDomain::macro_bound_IV_W(), oomph::FullCircleDomain::macro_element_boundary(), oomph::TubeDomain::macro_element_boundary(), oomph::FishDomain::macro_element_boundary(), oomph::ChannelWithLeafletDomain::macro_element_boundary(), oomph::CollapsibleChannelDomain::macro_element_boundary(), oomph::CylinderWithFlagDomain::macro_element_boundary(), oomph::QMacroElement< 2 >::macro_map(), oomph::QExtrudedMacroElement< 3 >::macro_map(), oomph::QMacroElement< 3 >::macro_map(), main(), NonRefineableBinArray::min_distance(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_I(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_II(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_III(), oomph::AlgebraicFishMesh< ELEMENT >::node_update_in_body(), oomph::AlgebraicFishMesh< ELEMENT >::node_update_in_fin(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_IV(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_IX(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_V(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_VI(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_VII(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::node_update_VIII(), Eigen::internal::scalar_zeta_op< Scalar >::operator()(), oomph::FSIAxisymmetricLinearElasticityTractionElement< ELASTICITY_BULK_ELEMENT, NAVIER_STOKES_BULK_ELEMENT >::output(), oomph::LinearisedFSIAxisymmetricNStNoSlipBCElementElement< FLUID_BULK_ELEMENT, SOLID_BULK_ELEMENT >::output(), oomph::FourierDecomposedTimeHarmonicLinElastLoadedByHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >::output(), oomph::FourierDecomposedHelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >::output(), oomph::TimeHarmonicLinElastLoadedByHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >::output(), oomph::HelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >::output(), oomph::TimeHarmonicLinElastLoadedByPMLHelmholtzPressureBCElement< ELASTICITY_BULK_ELEMENT, HELMHOLTZ_BULK_ELEMENT >::output(), oomph::PMLHelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >::output(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::output(), oomph::FSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::output(), oomph::TriangleMeshCurviLine::output(), NonRefineableBinArray::output_bins(), oomph::DiskLikeGeomObjectWithBoundaries::output_boundaries_and_triads(), oomph::TriangleMesh< ELEMENT >::output_boundary_coordinates(), oomph::TriangleMesh< FLUID_ELEMENT >::output_boundary_coordinates(), oomph::FaceElement::output_zeta(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::p_refine(), oomph::SarahBL::P_sarah(), SarahBL::P_sarah(), OscillatingWall::position(), oomph::FiniteElement::position(), oomph::GeomObject::position(), WarpedLine::position(), MyStraightLine::position(), oomph::SimpleCircle::position(), oomph::GeneralCircle::position(), UndeformedWall::position(), UndeformedLeaflet::position(), WarpedPlane::position(), WavyWall::position(), SinusoidalWall::position(), SpikedLine::position(), FlatPlate::position(), oomph::FSIAxisymFoepplvonKarmanElement< NNODE_1D, FLUID_ELEMENT >::position(), oomph::WarpedCircularDisk::position(), oomph::StraightLine::position(), oomph::Ellipse::position(), oomph::Circle::position(), oomph::EllipticalTube::position(), oomph::MeshAsGeomObject::position(), oomph::PseudoBucklingRing::position(), oomph::CircularPenetrator::position_from_zeta(), HeatedCircularPenetratorElement::position_from_zeta(), oomph::DiskLikeGeomObjectWithBoundaries::position_on_boundary(), ExactSolnForUnsteadyHeat::prescribed_flux_on_fixed_y_boundary(), BinArray::profile_get_neighbouring_bins_helper(), Eigen::internal::pzeta(), oomph::QuarterCircleSectorMesh< ELEMENT >::QuarterCircleSectorMesh(), oomph::QuarterPipeMesh< ELEMENT >::QuarterPipeMesh(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), oomph::WarpedCubeDomain::r_B(), oomph::QuarterTubeDomain::r_bot_right_B(), oomph::QuarterTubeDomain::r_bot_right_D(), oomph::QuarterTubeDomain::r_bot_right_F(), oomph::QuarterTubeDomain::r_bot_right_L(), oomph::QuarterTubeDomain::r_bot_right_R(), oomph::QuarterTubeDomain::r_bot_right_U(), oomph::QuarterTubeDomain::r_centr_B(), oomph::EighthSphereDomain::r_centr_B(), oomph::QuarterTubeDomain::r_centr_D(), oomph::EighthSphereDomain::r_centr_D(), oomph::QuarterTubeDomain::r_centr_F(), oomph::EighthSphereDomain::r_centr_F(), oomph::QuarterTubeDomain::r_centr_L(), oomph::EighthSphereDomain::r_centr_L(), oomph::QuarterTubeDomain::r_centr_R(), oomph::EighthSphereDomain::r_centr_R(), oomph::QuarterTubeDomain::r_centr_U(), oomph::EighthSphereDomain::r_centr_U(), oomph::WarpedCubeDomain::r_D(), oomph::CollapsibleChannelDomain::r_E_collapsible(), oomph::CollapsibleChannelDomain::r_E_straight(), oomph::WarpedCubeDomain::r_F(), oomph::EighthSphereDomain::r_front_B(), oomph::EighthSphereDomain::r_front_D(), oomph::EighthSphereDomain::r_front_F(), oomph::EighthSphereDomain::r_front_L(), oomph::EighthSphereDomain::r_front_R(), oomph::EighthSphereDomain::r_front_U(), oomph::WarpedCubeDomain::r_L(), oomph::FishDomain::r_lower_body_E(), oomph::FishDomain::r_lower_body_N(), oomph::FishDomain::r_lower_body_S(), oomph::FishDomain::r_lower_body_W(), oomph::FishDomain::r_lower_fin_E(), oomph::FishDomain::r_lower_fin_N(), oomph::FishDomain::r_lower_fin_S(), oomph::FishDomain::r_lower_fin_W(), oomph::CollapsibleChannelDomain::r_N_collapsible(), oomph::CollapsibleChannelDomain::r_N_straight(), oomph::WarpedCubeDomain::r_R(), oomph::EighthSphereDomain::r_right_B(), oomph::EighthSphereDomain::r_right_D(), oomph::EighthSphereDomain::r_right_F(), oomph::EighthSphereDomain::r_right_L(), oomph::EighthSphereDomain::r_right_R(), oomph::EighthSphereDomain::r_right_U(), oomph::CollapsibleChannelDomain::r_S_collapsible(), oomph::CollapsibleChannelDomain::r_S_straight(), oomph::QuarterTubeDomain::r_top_left_B(), oomph::QuarterTubeDomain::r_top_left_D(), oomph::QuarterTubeDomain::r_top_left_F(), oomph::QuarterTubeDomain::r_top_left_L(), oomph::QuarterTubeDomain::r_top_left_R(), oomph::QuarterTubeDomain::r_top_left_U(), oomph::WarpedCubeDomain::r_U(), oomph::EighthSphereDomain::r_up_B(), oomph::EighthSphereDomain::r_up_D(), oomph::EighthSphereDomain::r_up_F(), oomph::EighthSphereDomain::r_up_L(), oomph::EighthSphereDomain::r_up_R(), oomph::EighthSphereDomain::r_up_U(), oomph::FishDomain::r_upper_body_E(), oomph::FishDomain::r_upper_body_N(), oomph::FishDomain::r_upper_body_S(), oomph::FishDomain::r_upper_body_W(), oomph::FishDomain::r_upper_fin_E(), oomph::FishDomain::r_upper_fin_N(), oomph::FishDomain::r_upper_fin_S(), oomph::FishDomain::r_upper_fin_W(), oomph::CollapsibleChannelDomain::r_W_collapsible(), oomph::CollapsibleChannelDomain::r_W_straight(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 3 >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 2 >::rebuild_from_sons(), oomph::RefineableImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::refineable_fill_in_generic_contribution_to_residuals_displ_lagr_multiplier(), oomph::RefineableFSIImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::refineable_fill_in_generic_contribution_to_residuals_fsi_displ_lagr_multiplier(), RefineableElasticCubicMesh< ELEMENT >::RefineableElasticCubicMesh(), oomph::RefineableSolidCubicMesh< ELEMENT >::RefineableSolidCubicMesh(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::reposition_spines(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::set_boundary_shape_geom_object_pt(), oomph::TetMeshVertex::set_zeta_in_geom_object(), oomph::MyAlgebraicCollapsibleChannelMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicCollapsibleChannelMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicFSIDrivenCavityMesh< ELEMENT >::setup_algebraic_node_update(), oomph::TetMeshBase::setup_boundary_coordinates(), oomph::XdaTetMesh< ELEMENT >::setup_boundary_coordinates(), oomph::UnstructuredTwoDMeshGeometryBase::setup_boundary_coordinates(), oomph::Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh(), RefineableDrivenCavityProblem< ELEMENT >::setup_line_plot_points(), RectangularDrivenCavityProblem< ELEMENT >::setup_line_plot_points(), oomph::ChannelWithLeafletDomain::slanted_bound_up(), oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::slanted_bound_up(), oomph::TetMeshBase::snap_nodes_onto_geometric_objects(), oomph::TetMeshBase::snap_to_quadratic_surface(), oomph::ImposeDisplacementByLagrangeMultiplierElement< ELEMENT >::square_of_l2_norm_of_error(), oomph::CircularPenetrator::surface_coordinate(), HeatedCircularPenetratorElement::surface_coordinate(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), oomph::TubeMesh< ELEMENT >::TubeMesh(), oomph::SarahBL::U_sarah(), SarahBL::U_sarah(), UnstructuredFluidProblem< ELEMENT >::UnstructuredFluidProblem(), UnstructuredFvKProblem< ELEMENT >::UnstructuredFvKProblem(), UnstructuredPoissonProblem< ELEMENT >::UnstructuredPoissonProblem(), oomph::RefineableAlgebraicCollapsibleChannelMesh< ELEMENT >::update_node_update(), oomph::AlgebraicFishMesh< ELEMENT >::update_node_update(), oomph::RefineableAlgebraicFSIDrivenCavityMesh< ELEMENT >::update_node_update(), oomph::SarahBL::V_sarah(), SarahBL::V_sarah(), oomph::PseudoBucklingRing::veloc(), VibratingShellProblem< ELEMENT >::VibratingShellProblem(), WallMesh< ELEMENT >::WallMesh(), oomph::SarahBL::X_sarah(), SarahBL::X_sarah(), oomph::SarahBL::Y_sarah(), SarahBL::Y_sarah(), oomph::HeatedLinearSurfaceContactElement< ELEMENT >::zeta_nodal(), oomph::HeatedPenetratorFluxElement< ELEMENT >::zeta_nodal(), oomph::FaceElement::zeta_nodal(), oomph::FreeStandingFaceElement< ELEMENT >::zeta_nodal(), oomph::GenericLagrangeInterpolatedProjectableElement< ELEMENT >::zeta_nodal(), and oomph::DiskLikeGeomObjectWithBoundaries::zeta_on_boundary().

Variable Documentation

ActualPacketAccessBit

const unsigned int Eigen::ActualPacketAccessBit = 0x0

AutoOrder

const int Eigen::AutoOrder = 2

Referenced by Eigen::internal::get_compiletime_reshape_order().

CoherentAccessPattern

const int Eigen::CoherentAccessPattern = 0x1

Dynamic

const int Eigen::Dynamic = -1

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

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

Referenced by __attribute__(), Eigen::SVDBase< Derived >::_solve_impl(), Eigen::SVDBase< Derived >::_solve_impl_transposed(), Eigen::AlignedBox< Scalar_, AmbientDim_ >::AlignedBox(), Eigen::SVDBase< Derived >::allocate(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheLeft(), array_generic(), Eigen::internal::companion< Scalar_, Deg_ >::balance(), basicStuff(), benchBasic_loop(), Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel >::Block(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::blockInnerIndex(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::blockInnerSize(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::blockOuterIndex(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::blockOuterSize(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::blockPtr(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::BlockSparseMatrix(), Eigen::internal::call_triangular_assignment_loop(), check_auto_reshape4x4(), check_indexed_view(), check_marketio_dense(), Eigen::internal::check_svd_options_assertions(), check_tutorial_examples(), Eigen::MapBase< Derived, ReadOnlyAccessors >::checkSanity(), cholesky(), Eigen::internal::evaluator< SparseCompressedBase< Derived > >::coeff(), Eigen::internal::evaluator< SparseCompressedBase< Derived > >::coeffRef(), Eigen::CwiseTernaryOp< TernaryOp, Arg1Type, Arg2Type, Arg3Type >::cols(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::BlockInnerIterator::cols(), Eigen::CwiseBinaryOp< BinaryOp, LhsType, RhsType >::cols(), Eigen::RefBase< Derived >::construct(), ctms_decompositions(), Eigen::CwiseNullaryOp< NullaryOp, PlainObjectType >::CwiseNullaryOp(), Eigen::BDCSVD< MatrixType_, Options_ >::deflation(), Eigen::Spline< Scalar_, Dim_, Degree_ >::degree(), diagonal(), Eigen::AlignedBox< Scalar_, AmbientDim_ >::dim(), Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::dim(), EIGEN_DECLARE_TEST(), Eigen::internal::enum_eq_not_dynamic(), Eigen::internal::enum_ge_not_dynamic(), Eigen::internal::enum_gt_not_dynamic(), Eigen::internal::enum_le_not_dynamic(), Eigen::internal::enum_lt_not_dynamic(), Eigen::internal::homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs >::evalTo(), Eigen::internal::homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs >::evalTo(), Eigen::internal::evaluator< PartialReduxExpr< ArgType, MemberOp, Direction > >::evaluator(), Eigen::internal::evaluator< SparseCompressedBase< Derived > >::find(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::innerSize(), Eigen::internal::IndexedViewImpl< XprType, RowIndices, ColIndices, StorageKind, true >::innerStride(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::innerToBlock(), inplace(), Eigen::MatrixBase< Derived >::lazyProduct(), loadMarketDense(), lu_invertible(), lu_non_invertible(), map_class_matrix(), Eigen::MapBase< Derived, ReadOnlyAccessors >::MapBase(), Eigen::internal::max_size_prefer_dynamic(), Eigen::internal::min_size_prefer_dynamic(), Eigen::internal::min_size_prefer_fixed(), Eigen::BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >::nonZeros(), Eigen::AutoDiffJacobian< Functor >::operator()(), Eigen::TensorMap< PlainObjectType, Options_, MakePointer_ >::operator()(), Eigen::MatrixBase< Derived >::operator*(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::operator=(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::outerSize(), Eigen::Map< PlainObjectType, MapOptions, StrideType >::outerStride(), Eigen::internal::IndexedViewImpl< XprType, RowIndices, ColIndices, StorageKind, true >::outerStride(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::outerToBlock(), Eigen::internal::product_evaluator< Product< Lhs, Rhs, LazyProduct >, ProductTag, DenseShape, DenseShape >::packet(), Eigen::PlainObjectBase< Derived >::PlainObjectBase(), plaintype_tests(), Eigen::DenseBase< Derived >::prod(), qr(), Eigen::Replicate< MatrixType, RowFactor, ColFactor >::Replicate(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::reserve(), reshape4x4(), Eigen::Reshaped< XprType, Rows, Cols, Order >::Reshaped(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::DenseBase< Derived >::reverseInPlace(), Eigen::CwiseTernaryOp< TernaryOp, Arg1Type, Arg2Type, Arg3Type >::rows(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::BlockInnerIterator::rows(), Eigen::CwiseBinaryOp< BinaryOp, LhsType, RhsType >::rows(), cast_test_impl< SrcType, DstType, RowsAtCompileTime, ColsAtCompileTime >::run(), Eigen::internal::determinant_impl< Derived, DeterminantType >::run(), Eigen::internal::LU_kernel_bmod< SegSizeAtCompileTime >::run(), Eigen::internal::vectorwise_reverse_inplace_impl< Vertical >::run(), Eigen::internal::vectorwise_reverse_inplace_impl< Horizontal >::run(), Eigen::internal::apply_rotation_in_the_plane_selector< Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, true >::run(), run_nesting_ops_2(), rvalue_copyassign(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, DenseShape, GemmProduct >::scaleAndAddTo(), Eigen::internal::generic_product_impl< Lhs, Rhs, SparseShape, DenseShape, ProductType >::scaleAndAddTo(), Eigen::internal::generic_product_impl< Lhs, Rhs, DenseShape, SparseShape, ProductType >::scaleAndAddTo(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::setBlockStructure(), Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::setFromTriplets(), Eigen::internal::size_at_compile_time(), Eigen::Spline< Scalar_, Dim_, Degree_ >::Spline(), Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::Stride(), Eigen::DenseBase< Derived >::sum(), svd_check_max_size_matrix(), svd_min_norm(), svd_test_solvers(), swap(), Eigen::PlainObjectBase< Derived >::swap(), Eigen::TensorMap< PlainObjectType, Options_, MakePointer_ >::TensorMap(), test_contractions(), test_cref_move_ctor(), test_linear_but_not_vectorizable(), test_nnls_random_problem(), testVectorType(), Eigen::DenseBase< Derived >::transposeInPlace(), trsolve(), vectorwiseop_array(), verifySizeOf(), zeroSizedMatrix(), and zeroSizedVector().

DynamicIndex

const int Eigen::DynamicIndex = 0xffffff

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

Referenced by Eigen::internal::IndexedViewImpl< XprType, RowIndices, ColIndices, StorageKind, true >::colIncrement(), and Eigen::internal::IndexedViewImpl< XprType, RowIndices, ColIndices, StorageKind, true >::rowIncrement().

exponents

EIGEN_DEVICE_FUNC const const Eigen::ArrayBase<Derived>& Eigen::exponents

Initial value:

{
  typedef
      typename internal::promote_scalar_arg<typename Derived::Scalar, Scalar,
                                            EIGEN_SCALAR_BINARY_SUPPORTED(pow, Scalar, typename Derived::Scalar)>::type
          PromotedScalar

Referenced by array_generic(), and Eigen::ArrayBase< Derived >::pow().

expx

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

Referenced by Eigen::internal::pexp_complex().

fix

template<int N>

constexpr internal::FixedInt<N> Eigen::fix {}

constexpr

Referenced by check_symbolic_index(), check_tutorial_examples(), and DPMBase::readNextDataFile().

g_has_set_repeat

bool Eigen::g_has_set_repeat = false

static

Referenced by main(), and set_repeat_from_string().

g_has_set_seed

bool Eigen::g_has_set_seed = false

static

Referenced by main(), and set_seed_from_string().

g_repeat

int Eigen::g_repeat = 1

static

Referenced by check_sparse_leastsquare_solving(), check_sparse_nonhermitian_determinant(), check_sparse_nonhermitian_solving(), check_sparse_spd_determinant(), check_sparse_spd_solving(), check_sparse_square_abs_determinant(), check_sparse_square_determinant(), check_sparse_square_solving(), EIGEN_DECLARE_TEST(), hessenberg(), main(), randomTest(), schur(), set_repeat_from_string(), testGeneral(), testLogThenExp(), testMatrixType(), and testSingular().

g_seed

unsigned int Eigen::g_seed = 0

static

Referenced by main(), set_seed_from_string(), test_assign_to_tensor_reshape(), test_block_io_copy_using_reordered_dimensions(), and test_eval_tensor_reshape().

g_test_level

int Eigen::g_test_level = 0

static

Referenced by check_inf_nan(), check_sparse_solving(), cholesky(), svd_compare_to_full(), svd_least_square(), test_sparseqr_scalar(), and verify_impl().

g_test_stack

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

static

Referenced by main(), and verify_impl().

HereditaryBits

const unsigned int Eigen::HereditaryBits = RowMajorBit | EvalBeforeNestingBit

HugeCost

const int Eigen::HugeCost = 10000

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

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

Referenced by Eigen::internal::call_triangular_assignment_loop(), and Eigen::internal::evaluator< PartialReduxExpr< ArgType, MemberOp, Direction > >::evaluator().

Infinity

const int Eigen::Infinity = -1

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

Referenced by main().

InnerRandomAccessPattern

const int Eigen::InnerRandomAccessPattern = 0x2 | CoherentAccessPattern

integer

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest Eigen::integer

NestByRefBit

const unsigned int Eigen::NestByRefBit = 0x100

Referenced by Eigen::internal::compute_matrix_flags().

no_more_assert

bool Eigen::no_more_assert = false

static

Referenced by Eigen::eigen_assert_exception::~eigen_assert_exception(), and Eigen::eigen_static_assert_exception::~eigen_static_assert_exception().

OuterRandomAccessPattern

const int Eigen::OuterRandomAccessPattern = 0x4 | CoherentAccessPattern

Referenced by Eigen::internal::assign_sparse_to_sparse().

RandomAccessPattern

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

report_on_cerr_on_assert_failure

bool Eigen::report_on_cerr_on_assert_failure = true

static

scalar_abs2_op

Eigen::scalar_abs2_op

scalar_ceil_op

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round Eigen::scalar_ceil_op

scalar_isfinite_op

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil not a number sa Eigen::isinf DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isnan Eigen::scalar_isfinite_op

scalar_isnan_op

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil Eigen::scalar_isnan_op

scalar_round_op

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square Eigen::scalar_round_op

scalar_square_op

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 Eigen::scalar_square_op

should_raise_an_assert

const bool Eigen::should_raise_an_assert = false

static

test

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil not a number sa Eigen::isinf DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isnan finite value Eigen::test

Referenced by ModalPoissonEquations< DIM >::add_generic_residual_contribution(), oomph::PoissonEquations< 1 >::compute_error(), oomph::QSUPGAdvectionDiffusionElement< DIM, NNODE_1D >::compute_stabilisation_parameter(), oomph::QSUPGAdvectionDiffusionElement< DIM, NNODE_1D >::dshape_and_dtest_eulerian_at_knot_adv_diff(), oomph::AxisymFoepplvonKarmanEquations::fill_in_contribution_to_residuals(), oomph::DisplacementBasedFoepplvonKarmanEquations::fill_in_contribution_to_residuals(), oomph::FoepplvonKarmanEquations::fill_in_contribution_to_residuals(), oomph::RefineablePolarStreamfunctionEquations::fill_in_generic_residual_contribution(), oomph::PolarStreamfunctionEquations::fill_in_generic_residual_contribution(), oomph::AdvectionDiffusionEquations< DIM >::fill_in_generic_residual_contribution_adv_diff(), oomph::RefineableAdvectionDiffusionEquations< DIM >::fill_in_generic_residual_contribution_adv_diff(), oomph::SteadyAxisymAdvectionDiffusionEquations::fill_in_generic_residual_contribution_adv_diff(), oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >::fill_in_generic_residual_contribution_adv_diff_react(), oomph::RefineableAdvectionDiffusionReactionEquations< NREAGENT, DIM >::fill_in_generic_residual_contribution_adv_diff_react(), oomph::AxisymAdvectionDiffusionEquations::fill_in_generic_residual_contribution_axi_adv_diff(), oomph::RefineableAxisymAdvectionDiffusionEquations::fill_in_generic_residual_contribution_axi_adv_diff(), oomph::GeneralisedAdvectionDiffusionEquations< DIM >::fill_in_generic_residual_contribution_cons_adv_diff(), oomph::RefineableGeneralisedAdvectionDiffusionEquations< DIM >::fill_in_generic_residual_contribution_cons_adv_diff(), oomph::RefineableGeneralisedAxisymAdvectionDiffusionEquations::fill_in_generic_residual_contribution_cons_axisym_adv_diff(), oomph::FluxTransportEquations< DIM >::fill_in_generic_residual_contribution_flux_transport(), oomph::FourierDecomposedHelmholtzEquations::fill_in_generic_residual_contribution_fourier_decomposed_helmholtz(), oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >::fill_in_generic_residual_contribution_fourier_decomposed_helmholtz_DtN_bc(), oomph::HelmholtzEquations< DIM >::fill_in_generic_residual_contribution_helmholtz(), oomph::RefineableHelmholtzEquations< DIM >::fill_in_generic_residual_contribution_helmholtz(), oomph::PMLHelmholtzEquations< DIM >::fill_in_generic_residual_contribution_helmholtz(), oomph::RefineablePMLHelmholtzEquations< DIM >::fill_in_generic_residual_contribution_helmholtz(), oomph::HelmholtzAbsorbingBCElement< ELEMENT >::fill_in_generic_residual_contribution_helmholtz_abc(), oomph::HelmholtzDtNBoundaryElement< ELEMENT >::fill_in_generic_residual_contribution_helmholtz_DtN_bc(), oomph::LinearWaveEquations< DIM >::fill_in_generic_residual_contribution_lin_wave(), oomph::RefineableLinearWaveEquations< DIM >::fill_in_generic_residual_contribution_lin_wave(), oomph::MultiPoissonEquations< DIM, NFIELDS >::fill_in_generic_residual_contribution_multi_poisson(), oomph::PeriodicOrbitEquations::fill_in_generic_residual_contribution_orbit(), oomph::PMLFourierDecomposedHelmholtzEquations::fill_in_generic_residual_contribution_pml_fourier_decomposed_helmholtz(), oomph::PoissonEquations< DIM >::fill_in_generic_residual_contribution_poisson(), oomph::RefineablePoissonEquations< DIM >::fill_in_generic_residual_contribution_poisson(), oomph::RefineableSphericalAdvectionDiffusionEquations::fill_in_generic_residual_contribution_spherical_adv_diff(), oomph::SphericalAdvectionDiffusionEquations::fill_in_generic_residual_contribution_spherical_adv_diff(), oomph::RefineableSpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::SpaceTimeUnsteadyHeatMixedOrderEquations< SPATIAL_DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::RefineableSpaceTimeUnsteadyHeatMixedOrderEquations< SPATIAL_DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::RefineableUnsteadyHeatEquations< DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::UnsteadyHeatEquations< DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::WomersleyEquations< DIM >::fill_in_generic_residual_contribution_womersley(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson(), RefineableQAxisymAdvectionDiffusionBoussinesqElement::fill_in_off_diagonal_block_analytic(), QAxisymAdvectionDiffusionElementWithExternalElement::fill_in_off_diagonal_block_analytic(), RefineableQAdvectionDiffusionElementWithExternalElement< DIM >::fill_in_off_diagonal_block_analytic(), QAdvectionDiffusionElementWithExternalElement< DIM >::fill_in_off_diagonal_block_analytic(), oomph::RefineableAdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >::fill_in_off_diagonal_block_analytic(), oomph::AdvectionDiffusionBoussinesqElement< AD_ELEMENT, NST_ELEMENT >::fill_in_off_diagonal_block_analytic(), RefineableModalPoissonEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::PoissonEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineablePoissonEquations< DIM >::get_dresidual_dnodal_coordinates(), ModalPoissonEquations< DIM >::get_flux(), oomph::AxisymmetricNavierStokesEquations::get_pressure_and_velocity_mass_matrix_diagonal(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::get_pressure_and_velocity_mass_matrix_diagonal(), oomph::SphericalNavierStokesEquations::get_pressure_and_velocity_mass_matrix_diagonal(), oomph::Problem::globally_convergent_line_search(), oomph::GeneralisedAdvectionDiffusionEquations< 2 >::integrate_u(), oomph::ProjectableAdvectionDiffusionReactionElement< ADR_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectableDisplacementBasedFoepplvonKarmanElement< FVK_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectableFoepplvonKarmanElement< FVK_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectableFourierDecomposedHelmholtzElement< FOURIER_DECOMPOSED_HELMHOLTZ_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectableHelmholtzElement< HELMHOLTZ_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectablePMLFourierDecomposedHelmholtzElement< FOURIER_DECOMPOSED_HELMHOLTZ_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectablePMLHelmholtzElement< HELMHOLTZ_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectablePoissonElement< POISSON_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectableUnsteadyHeatSpaceTimeElement< UNSTEADY_HEAT_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectableUnsteadyHeatMixedOrderSpaceTimeElement< UNSTEADY_HEAT_ELEMENT >::jacobian_and_shape_of_field(), oomph::ProjectableUnsteadyHeatElement< UNSTEADY_HEAT_ELEMENT >::jacobian_and_shape_of_field(), oomph::BlackBoxFDNewtonSolver::line_search(), loadingTest(), main(), normalAndTangentialLoadingTest(), objectivenessTest(), ModalPoissonEquations< DIM >::output(), oomph::GeneralisedAdvectionDiffusionEquations< 2 >::output_fct(), and oomph::UnsteadyHeatEquations< 2 >::output_fct().

Undefined

const int Eigen::Undefined = 0xfffffe

This value means that the requested value is not defined.

Referenced by Eigen::internal::IndexedViewImpl< XprType, RowIndices, ColIndices, StorageKind, true >::colIncrement(), Eigen::symbolic::EvalSymbolValueHelper< Tag >::eval_at_compile_time_impl(), Eigen::symbolic::ValueExpr< IndexType >::eval_at_compile_time_impl(), Eigen::symbolic::NegateExpr< Arg0 >::eval_at_compile_time_impl(), Eigen::symbolic::AddExpr< Arg0, Arg1 >::eval_at_compile_time_impl(), Eigen::symbolic::ProductExpr< Arg0, Arg1 >::eval_at_compile_time_impl(), Eigen::symbolic::QuotientExpr< Arg0, Arg1 >::eval_at_compile_time_impl(), Eigen::symbolic::EvalSymbolValueHelper< Tag >::eval_impl(), Eigen::internal::IndexedViewHelper< Indices, EnableIf >::incr(), Eigen::internal::IndexedViewImpl< XprType, RowIndices, ColIndices, StorageKind, true >::rowIncrement(), and Eigen::symbolic::SymbolValue< Tag, Index >::value_at_compile_time().

value

squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given Eigen::value

Examples

/home/plath/mercurydpm2/mercurydpm/Eigen/unsupported/Eigen/CXX11/src/Tensor/TensorLayoutSwap.h.

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelerateImpl(), InclinedPlaneProblem< ELEMENT, INTERFACE_ELEMENT >::actions_before_implicit_timestep(), RefineableConvectionProblem< NST_ELEMENT, AD_ELEMENT >::actions_before_newton_solve(), add_const(), rapidjson::GenericValue< Encoding, Allocator >::AddMember(), VTKPointDescriptor< T >::addProperty(), VTKData::addToPointData(), Eigen::IndexList< FirstType, OtherTypes >::all_values_known_statically(), TetmeshPoissonProblem< ELEMENT >::apply_boundary_conditions(), Eigen::internal::array_get(), Eigen::internal::array_prod(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::assignDiagonal(), basic_tuple_test(), Eigen::numext::bit_cast(), oomph::HelmholtzMGPreconditioner< DIM >::block_preconditioner_self_test(), oomph::CRMatrix< T >::build(), oomph::CCMatrix< T >::build(), MortaringValidationProblem< ELEMENT, NON_MORTAR_ELEMENT >::build_mortaring_elements(), oomph::CRMatrix< T >::build_without_copy(), oomph::CCMatrix< T >::build_without_copy(), check_extremity_accuracy(), check_is_convertible(), check_limits_specialization(), check_sparse_spd_solving(), check_sparse_square_solving(), cholesky(), Eigen::TensorEvaluator< const TensorStridingSlicingOp< StartIndices, StopIndices, Strides, ArgType >, Device >::clamp(), Eigen::internal::inner_product_evaluator< Func, Lhs, Rhs >::coeff(), Eigen::TensorEvaluator< const TensorBroadcastingOp< Broadcast, ArgType >, Device >::coeff(), RectangularDrivenCavityProblem< ELEMENT >::compare_assembly_strategies(), DPM::computeLocalCGHGrid(), Eigen::TensorBase< Derived, ReadOnlyAccessors >::constant(), Eigen::DenseBase< Derived >::Constant(), Eigen::internal::copyBToRowMajor(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_matrix(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_matrix_for_aztecoo(), dense_storage_alignment(), Eigen::Serializer< DenseBase< Derived >, void >::deserialize(), Eigen::Serializer< SparseMatrix< Scalar, Options, StorageIndex >, void >::deserialize(), Eigen::Serializer< SparseVector< Scalar, Options, StorageIndex >, void >::deserialize(), Eigen::Serializer< T, typename std::enable_if_t< std::is_trivial< T >::value &&std::is_standard_layout< T >::value > >::deserialize(), Eigen::internal::serialize_impl< N, T1, Ts... >::deserialize(), Eigen::internal::tensor_symmetry_value_setter< Tensor_, Symmetry_, Flags >::doAssign(), checkIdx::doCheck_(), Eigen::ComplexEigenSolver< MatrixType_ >::doComputeEigenvectors(), EIGEN_DECLARE_TEST(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::EIGEN_STATIC_ASSERT(), Eigen::symbolic::SymbolValue< Tag, Index >::eval_impl(), Eigen::symbolic::SymbolValue< Tag, internal::FixedInt< N > >::eval_impl(), Eigen::internal::evaluator< PartialReduxExpr< ArgType, MemberOp, Direction > >::evaluator(), f(), oomph::SuperLUSolver::factorise_serial(), Eigen::TriangularViewImpl< MatrixType_, Mode_, Dense >::fill(), Eigen::DefaultDevice::fill(), GelfandBratuElement< NNODE_1D >::fill_in_generic_dresidual_contribution(), GelfandBratuElement< NNODE_1D >::fill_in_generic_residual_contribution(), for(), oomph::RefineableLinearisedAxisymmetricQCrouzeixRaviartElement::further_build(), oomph::RefineableLinearisedQCrouzeixRaviartElement::further_build(), oomph::RefineableQSphericalCrouzeixRaviartElement::further_build(), Eigen::internal::gemmKernel(), oomph::CRDoubleMatrixHelpers::gershgorin_eigenvalue_estimate(), Eigen::IndexList< FirstType, OtherTypes >::get(), oomph::Problem::get_eigenproblem_matrices(), oomph::ElementWithMortaringStatusAtNodes< ELEMENT >::get_interpolated_mortared_status(), oomph::SpectralPeriodicOrbitElement< NNODE_1D >::get_interpolated_values(), oomph::Problem::get_jacobian(), get_options(), oomph::Problem::get_residuals(), Eigen::internal::GetMarketLine(), Eigen::MatrixMarketIterator< Scalar >::Getnextvalidmatrix(), PSD::getQuantileByRadius(), helpers::readFromCommandLine< std::string >(), Eigen::internal::unary_evaluator< SparseView< ArgType >, IteratorBased >::InnerIterator::incrementToNonZero(), Eigen::internal::unary_evaluator< SparseView< ArgType >, IndexBased >::InnerIterator::incrementToNonZero(), Eigen::internal::index_pair_first_statically_eq(), Eigen::internal::index_pair_second_statically_eq(), Eigen::internal::index_statically_eq(), Eigen::internal::index_statically_gt(), Eigen::internal::index_statically_lt(), Eigen::internal::index_statically_ne(), oomph::CRDoubleMatrixHelpers::inf_norm(), Eigen::internal::coeff_visitor< Derived >::init(), Eigen::internal::all_visitor< Scalar >::init(), Eigen::internal::any_visitor< Scalar >::init(), Eigen::internal::count_visitor< Scalar >::init(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, NaNPropagation, isInt >::initpacket(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, NaNPropagation, false >::initpacket(), integer_types_extra(), oomph::MGSolver< DIM >::interpolation_matrix_set(), oomph::HelmholtzMGPreconditioner< DIM >::interpolation_matrix_set(), is_default_constructible_and_assignable(), Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::Iterator::Iterator(), oomph::MinModLimiter::limit(), loadMarket(), loadMarketDense(), Eigen::ThreadLocal< T, Initialize, Release >::local(), main(), MakeAutoDiffScalar(), Eigen::internal::matrix_sqrt_quasi_triangular_1x1_off_diagonal_block(), matrix_sqrt_triangular(), oomph::TrilinosEpetraHelpers::multiply(), oomph::VorticityRecoveryHelpers::RecoveryHelper::npartial_derivative(), nullary_internal_logic(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, NaNPropagation, isInt >::operator()(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, PropagateNumbers, false >::operator()(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, NaNPropagation, false >::operator()(), Eigen::internal::all_visitor< Scalar >::operator()(), Eigen::internal::any_visitor< Scalar >::operator()(), Eigen::internal::count_visitor< Scalar >::operator()(), cast_test_impl< SrcType, DstType, RowsAtCompileTime, ColsAtCompileTime >::RandomOp::operator()(), Eigen::internal::auto_diff_special_op< DerivativeType, true >::operator+(), Eigen::internal::AmbiVector< Scalar_, StorageIndex_ >::Iterator::operator++(), Eigen::TensorBase< Derived, ReadOnlyAccessors >::operator-(), Eigen::internal::operator<<(), Eigen::Array< Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_ >::operator=(), Eigen::internal::tensor_symmetry_value_setter< Tensor_, Symmetry_, Flags >::operator=(), Eigen::IndexList< FirstType, OtherTypes >::operator[](), Eigen::IndexPairList< FirstType, OtherTypes >::operator[](), Eigen::SimplicialCholeskyBase< Derived >::ordering(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, NaNPropagation, isInt >::packet(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, PropagateNumbers, false >::packet(), Eigen::internal::minmax_coeff_visitor< Derived, is_min, NaNPropagation, false >::packet(), Eigen::internal::inner_product_evaluator< Func, Lhs, Rhs >::packet(), Eigen::TensorEvaluator< const TensorBroadcastingOp< Broadcast, ArgType >, Device >::packet(), packetmath(), packetmath_real(), Eigen::internal::pacos_float(), Eigen::internal::pasin_float(), Eigen::internal::patanh_double(), Eigen::internal::patanh_float(), Eigen::internal::pgather< bfloat16, Packet16bf >(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::pin_q_edge_value(), Eigen::internal::pnegate(), tetgenmesh::pointtype(), Eigen::internal::print_matrix(), Eigen::internal::simpl_chol_helper< Scalar, StorageIndex >::Stack::push(), rapidjson::GenericValue< Encoding, Allocator >::PushBack(), Eigen::internal::putDenseElt(), Eigen::internal::putMarketHeader(), Eigen::internal::PutMatrixElt(), qr_invertible(), quaternion(), Eigen::bfloat16_impl::raw_uint16_to_bfloat16(), ConstantMassFlowMaserBoundary::read(), SubcriticalMaserBoundary::read(), helpers::readArrayFromCommandLine(), helpers::readFromCommandLine(), helpers::readFromFile(), Eigen::Ref< const TPlainObjectType, Options, StrideType >::Ref(), Eigen::Replicate< MatrixType, RowFactor, ColFactor >::Replicate(), helpers::round(), Eigen::internal::random_int_impl< Scalar, IsSigned, false >::run(), casting_test< SrcScalar, TgtScalar >::run(), test_cast_helper< SrcPacket, TgtPacket, SrcCoeffRatio, TgtCoeffRatio, true >::run(), Eigen::internal::fixed_size_tensor_index_linearization_helper< Index, NumIndices, n, RowMajor >::run(), Eigen::internal::index_statically_eq_impl< DimensionList< Index, Rank > >::run(), Eigen::internal::index_statically_eq_impl< const DimensionList< Index, Rank > >::run(), Eigen::internal::index_statically_ne_impl< DimensionList< Index, Rank > >::run(), Eigen::internal::index_statically_ne_impl< const DimensionList< Index, Rank > >::run(), Eigen::internal::index_statically_gt_impl< DimensionList< Index, Rank > >::run(), Eigen::internal::index_statically_gt_impl< const DimensionList< Index, Rank > >::run(), Eigen::internal::index_statically_lt_impl< DimensionList< Index, Rank > >::run(), Eigen::internal::index_statically_lt_impl< const DimensionList< Index, Rank > >::run(), Eigen::internal::index_statically_eq_impl< IndexList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_statically_eq_impl< const IndexList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_statically_ne_impl< IndexList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_statically_ne_impl< const IndexList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_statically_gt_impl< IndexList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_statically_gt_impl< const IndexList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_statically_lt_impl< IndexList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_statically_lt_impl< const IndexList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_pair_first_statically_eq_impl< IndexPairList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_pair_first_statically_eq_impl< const IndexPairList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_pair_second_statically_eq_impl< IndexPairList< FirstType, OtherTypes... > >::run(), Eigen::internal::index_pair_second_statically_eq_impl< const IndexPairList< FirstType, OtherTypes... > >::run(), Eigen::internal::tensor_symmetry_assign_value< Tensor_ >::run(), Eigen::internal::Assignment< DstXprType, SrcXprType, Functor, Sparse2Dense, Weak >::run(), Eigen::internal::triangular_solve_matrix< Scalar, Index, OnTheLeft, Mode, Conjugate, TriStorageOrder, ColMajor, OtherInnerStride >::run(), Eigen::internal::triangular_solve_matrix< Scalar, Index, OnTheRight, Mode, Conjugate, TriStorageOrder, ColMajor, OtherInnerStride >::run(), Eigen::internal::TensorPrinter< Tensor, rank, Format, EnableIf >::run(), saveMarketDense(), Eigen::Serializer< DenseBase< Derived >, void >::serialize(), Eigen::Serializer< SparseMatrix< Scalar, Options, StorageIndex >, void >::serialize(), Eigen::Serializer< SparseVector< Scalar, Options, StorageIndex >, void >::serialize(), Eigen::Serializer< T, typename std::enable_if_t< std::is_trivial< T >::value &&std::is_standard_layout< T >::value > >::serialize(), Eigen::internal::serialize_impl< N, T1, Ts... >::serialize(), Eigen::internal::serialize_impl< N, T1, Ts... >::serialize_size(), Eigen::IndexList< FirstType, OtherTypes >::set(), Eigen::IndexPairList< FirstType, OtherTypes >::set(), Eigen::internal::tuple_coeff< Idx, ValueT >::set(), Eigen::internal::tuple_coeff< 0, ValueT >::set(), Eigen::MovableScalar< Scalar >::set(), set(), ConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions(), DDConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions(), RefineableDDConvectionProblem< NST_ELEMENT, AD_ELEMENT >::set_boundary_conditions(), RefineableSphereConvectionProblem< ELEMENT >::set_boundary_conditions(), oomph::SingularNavierStokesSolutionElement< WRAPPED_NAVIER_STOKES_ELEMENT >::set_c(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::set_dirichlet_value_on_node(), oomph::NavierStokesElementWithSingularity< BASIC_NAVIER_STOKES_ELEMENT >::set_dirichlet_value_on_pressure_dof(), PerturbedStateProblem< BASE_ELEMENT, PERTURBED_ELEMENT >::set_initial_condition(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::set_p_value(), oomph::TRaviartThomasDarcyElement< ORDER >::set_p_value(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::set_q_edge(), oomph::TRaviartThomasDarcyElement< ORDER >::set_q_edge(), oomph::TAxisymmetricPoroelasticityElement< ORDER >::set_q_internal(), oomph::TRaviartThomasDarcyElement< ORDER >::set_q_internal(), oomph::GeneralElasticityTensor::set_value(), oomph::NavierStokesElementWithSingularity< BASIC_NAVIER_STOKES_ELEMENT >::set_velocity_dirichlet_value_on_node(), tetgenmesh::setareabound(), Eigen::TriangularViewImpl< MatrixType_, Mode_, Dense >::setConstant(), tetgenmesh::setelemattribute(), tetgenmesh::setelemmarker(), Eigen::LevenbergMarquardt< FunctorType_ >::setExternalScaling(), Camera::setFovY(), PacketBlockSet< Scalar, StorageOrder, n >::setPacketBlock(), BaseParticle::setPeriodicComplexity(), tetgenmesh::setpoint2bgmtet(), tetgenmesh::setpoint2pbcpt(), tetgenmesh::setpoint2ppt(), tetgenmesh::setpoint2seg(), tetgenmesh::setpoint2sh(), tetgenmesh::setpoint2tet(), tetgenmesh::setpointtype(), Calibration::setPSD(), Material::setPSD(), CG< Coordinates, BaseFunction, Fields >::setRadius(), Eigen::SluMatrix::setScalarType(), tetgenmesh::setshell2badface(), tetgenmesh::setshellmark(), tetgenmesh::setshellpbcgroup(), tetgenmesh::setshelltype(), oomph::ILUZeroPreconditioner< CCDoubleMatrix >::setup(), oomph::ILUZeroPreconditioner< CRDoubleMatrix >::setup(), oomph::HelmholtzMGPreconditioner< DIM >::setup_coarsest_level_structures(), oomph::MGSolver< DIM >::setup_interpolation_matrices(), oomph::HelmholtzMGPreconditioner< DIM >::setup_interpolation_matrices(), oomph::MGSolver< DIM >::setup_interpolation_matrices_unstructured(), oomph::HelmholtzMGPreconditioner< DIM >::setup_interpolation_matrices_unstructured(), tetgenmesh::setvolumebound(), Eigen::Serializer< DenseBase< Derived >, void >::size(), Eigen::Serializer< SparseMatrix< Scalar, Options, StorageIndex >, void >::size(), Eigen::Serializer< SparseVector< Scalar, Options, StorageIndex >, void >::size(), Eigen::Serializer< T, typename std::enable_if_t< std::is_trivial< T >::value &&std::is_standard_layout< T >::value > >::size(), oomph::Problem::sparse_assemble_row_or_column_compressed(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_lists(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_maps(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_two_arrays(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_two_vectors(), oomph::Problem::sparse_assemble_row_or_column_compressed_with_vectors_of_pairs(), sparse_basic(), sparse_extra(), sphericalHarmonics::sphericalHarmonics(), svd_least_square(), swap(), Eigen::TensorEvaluator< const TensorCwiseTernaryOp< TernaryOp, Arg1Type, Arg2Type, Arg3Type >, Device >::TensorEvaluator(), Eigen::TensorEvaluator< const TensorSlicingOp< StartIndices, Sizes, ArgType >, Device >::TensorEvaluator(), Eigen::TensorEvaluator< const TensorStridingSlicingOp< StartIndices, StopIndices, Strides, ArgType >, Device >::TensorEvaluator(), test_apply_op(), test_concat(), test_cref_move_ctor(), test_device_memory(), test_gen_numeric_list(), test_get(), test_slice(), test_stl_iterators(), test_type2index_list(), test_type_cast(), Eigen::internal::lapacke_helpers::to_lapack(), to_string_padded(), helpers::toString(), Eigen::internal::transStoreC(), Eigen::internal::triSolveKernelLxK(), umeyama(), Eigen::internal::ldlt_inplace< Lower >::unblocked(), Eigen::internal::unary_evaluator< CwiseUnaryOp< UnaryOp, ArgType >, IteratorBased >::InnerIterator::value(), Eigen::internal::unary_evaluator< CwiseUnaryView< ViewOp, ArgType >, IteratorBased >::InnerIterator::value(), Eigen::internal::sparse_dense_outer_product_evaluator< LhsT, RhsT, NeedToTranspose >::InnerIterator::value(), Eigen::internal::sparse_diagonal_product_evaluator< SparseXprType, DiagonalCoeffType, SDP_AsScalarProduct >::InnerIterator::value(), Eigen::internal::unary_evaluator< TriangularView< ArgType, Mode >, IteratorBased >::InnerIterator::value(), Eigen::IndexList< FirstType, OtherTypes >::value_known_statically(), Eigen::IndexPairList< FirstType, OtherTypes >::value_known_statically(), Eigen::internal::tuple_coeff< 0, ValueT >::value_known_statically(), Eigen::internal::tuple_coeff< Idx, ValueT >::value_known_statically(), Eigen::IndexList< FirstType, OtherTypes >::values_statically_known_to_increase(), Eigen::internal::tuple_coeff< 0, ValueT >::values_up_to_known_statically(), Eigen::internal::tuple_coeff< Idx, ValueT >::values_up_to_known_statically(), Eigen::internal::tuple_coeff< Idx, ValueT >::values_up_to_statically_known_to_increase(), verify_eval_type(), and SolidProblem< ELEMENT_TYPE >::writeToVTK().