Eigen-unsupported: Eigen Namespace Reference

Searching...

No Matches

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

Classes
class	aligned_allocator

class	AlignedBox

class	AlignedVector3
	A vectorization friendly 3D vector. More...

class	AMDOrdering

class	AngleAxis

class	ArithmeticSequence

class	Array

class	ArrayBase

class	ArrayWrapper

struct	ArrayXpr

class	AutoDiffScalar
	A scalar type replacement with automatic differentiation capability. More...

class	BDCSVD

class	BiCGSTAB

class	Block

class	BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >

class	BlockSparseMatrix
	A versatile sparse matrix representation where each element is a block. More...

class	CholmodBase

class	CholmodDecomposition

class	CholmodSimplicialLDLT

class	CholmodSimplicialLLT

class	CholmodSupernodalLLT

class	COLAMDOrdering

class	ColPivHouseholderQR

class	CommaInitializer

class	CompleteOrthogonalDecomposition

class	ComplexEigenSolver

class	ComplexSchur

class	ConjugateGradient

class	CwiseBinaryOp

class	CwiseNullaryOp

class	CwiseTernaryOp

class	CwiseUnaryOp

class	CwiseUnaryView

struct	Dense

class	DenseBase

class	DenseCoeffsBase< Derived, DirectAccessors >

class	DenseCoeffsBase< Derived, DirectWriteAccessors >

class	DGMRES
	A Restarted GMRES with deflation. This class implements a modification of the GMRES solver for sparse linear systems. The basis is built with modified Gram-Schmidt. At each restart, a few approximated eigenvectors corresponding to the smallest eigenvalues are used to build a preconditioner for the next cycle. This preconditioner for deflation can be combined with any other preconditioner, the IncompleteLUT for instance. The preconditioner is applied at right of the matrix and the combination is multiplicative. More...

class	Diagonal

class	DiagonalMatrix

class	DiagonalPreconditioner

class	DiagonalWrapper

class	DynamicSGroup
	Dynamic symmetry group. More...

class	DynamicSparseMatrix
	A sparse matrix class designed for matrix assembly purpose. More...

class	EigenBase

class	EigenSolver

class	EulerAngles
	Represents a rotation in a 3 dimensional space as three Euler angles. More...

class	EulerSystem
	Represents a fixed Euler rotation system. More...

class	ForceAlignedAccess

class	FullPivHouseholderQR

class	FullPivLU

class	GeneralizedEigenSolver

class	GeneralizedSelfAdjointEigenSolver

class	GMRES
	A GMRES solver for sparse square problems. More...

class	HessenbergDecomposition

class	Homogeneous

class	HouseholderQR

class	HouseholderSequence

class	HybridNonLinearSolver
	Finds a zero of a system of n nonlinear functions in n variables by a modification of the Powell hybrid method ("dogleg"). More...

class	Hyperplane

class	IdentityPreconditioner

class	IDRS
	The Induced Dimension Reduction method (IDR(s)) is a short-recurrences Krylov method for sparse square problems. More...

class	IncompleteCholesky

class	IncompleteLUT

class	IndexedView

class	InnerIterator

class	InnerStride

class	Inverse

class	IOFormat

class	IterationController
	Controls the iterations of the iterative solvers. More...

class	IterativeSolverBase

class	IterScaling
	iterative scaling algorithm to equilibrate rows and column norms in matrices More...

class	JacobiRotation

class	JacobiSVD

class	KdBVH
	A simple bounding volume hierarchy based on AlignedBox. More...

class	KroneckerProduct
	Kronecker tensor product helper class for dense matrices. More...

class	KroneckerProductBase
	The base class of dense and sparse Kronecker product. More...

class	KroneckerProductSparse
	Kronecker tensor product helper class for sparse matrices. More...

class	LDLT

class	LeastSquareDiagonalPreconditioner

class	LeastSquaresConjugateGradient

class	LevenbergMarquardt
	Performs non linear optimization over a non-linear function, using a variant of the Levenberg Marquardt algorithm. More...

class	LLT

class	Map

class	Map< const Quaternion< _Scalar >, _Options >

class	Map< Quaternion< _Scalar >, _Options >

class	Map< SparseMatrixType >

class	MapBase< Derived, WriteAccessors >

class	MappedSparseMatrix

class	Matrix

class	MatrixBase

class	MatrixComplexPowerReturnValue
	Proxy for the matrix power of some matrix (expression). More...

struct	MatrixExponentialReturnValue
	Proxy for the matrix exponential of some matrix (expression). More...

class	MatrixFunctionReturnValue
	Proxy for the matrix function of some matrix (expression). More...

class	MatrixLogarithmReturnValue
	Proxy for the matrix logarithm of some matrix (expression). More...

class	MatrixMarketIterator
	Iterator to browse matrices from a specified folder. More...

class	MatrixPower
	Class for computing matrix powers. More...

class	MatrixPowerAtomic
	Class for computing matrix powers. More...

class	MatrixPowerParenthesesReturnValue
	Proxy for the matrix power of some matrix. More...

class	MatrixPowerReturnValue
	Proxy for the matrix power of some matrix (expression). More...

class	MatrixSquareRootReturnValue
	Proxy for the matrix square root of some matrix (expression). More...

class	MatrixWrapper

struct	MatrixXpr

class	MaxSizeVector
	The MaxSizeVector class. More...

class	MetisOrdering

class	MINRES
	A minimal residual solver for sparse symmetric problems. More...

class	NaturalOrdering

class	NestByValue

class	NoAlias

class	NumericalDiff

class	NumTraits

class	OuterStride

class	ParametrizedLine

class	PardisoLDLT

class	PardisoLLT

class	PardisoLU

class	PartialPivLU

class	PartialReduxExpr

class	PastixLDLT

class	PastixLLT

class	PastixLU

class	PermutationBase

class	PermutationMatrix

struct	PermutationStorage

class	PermutationWrapper

class	PlainObjectBase

class	PolynomialSolver
	A polynomial solver. More...

class	PolynomialSolverBase
	Defined to be inherited by polynomial solvers: it provides convenient methods such as. More...

class	Product

class	Quaternion

class	QuaternionBase

class	RandomSetter
	The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access. More...

class	RealQZ

class	RealSchur

class	Ref

class	Ref< SparseMatrixType, Options >

class	Ref< SparseVectorType >

class	Replicate

class	Reshaped

class	Reverse

class	Rotation2D

class	RotationBase

class	ScalarBinaryOpTraits

class	Select

class	SelfAdjointEigenSolver

class	SelfAdjointView

class	SGroup
	Symmetry group, initialized from template arguments. More...

class	SimplicialCholesky

class	SimplicialCholeskyBase

class	SimplicialLDLT

class	SimplicialLLT

class	SkylineInplaceLU
	Inplace LU decomposition of a skyline matrix and associated features. More...

class	SkylineMatrix
	The main skyline matrix class. More...

class	SkylineMatrixBase
	Base class of any skyline matrices or skyline expressions. More...

class	SkylineStorage

class	Solve

class	SolverBase

struct	SolverStorage

class	SolveWithGuess

struct	Sparse

class	SparseCompressedBase

class	SparseLU

class	SparseMapBase< Derived, WriteAccessors >

class	SparseMatrix

class	SparseMatrixBase

class	SparseQR

class	SparseSelfAdjointView

class	SparseSolverBase

class	SparseVector

class	SparseView

class	Spline
	A class representing multi-dimensional spline curves. More...

struct	SplineFitting
	Spline fitting methods. More...

struct	SplineTraits< Spline< _Scalar, _Dim, _Degree >, _DerivativeOrder >
	Compile-time attributes of the Spline class for fixed degree. More...

struct	SplineTraits< Spline< _Scalar, _Dim, _Degree >, Dynamic >
	Compile-time attributes of the Spline class for Dynamic degree. More...

class	SPQR

class	StaticSGroup
	Static symmetry group. More...

struct	StdMapTraits

class	Stride

class	SuperILU

class	SuperLU

class	SuperLUBase

class	SVDBase

class	Tensor
	The tensor class. More...

class	TensorAssignOp

class	TensorAsyncDevice
	Pseudo expression providing an operator = that will evaluate its argument asynchronously on the specified device. Currently only ThreadPoolDevice implements proper asynchronous execution, while the default and GPU devices just run the expression synchronously and call m_done() on completion.. More...

class	TensorBase
	The tensor base class. More...

class	TensorBroadcastingOp

class	TensorChippingOp

class	TensorConcatenationOp
	Tensor concatenation class. More...

class	TensorContractionOp

class	TensorConversionOp
	Tensor conversion class. This class makes it possible to vectorize type casting operations when the number of scalars per packet in the source and the destination type differ. More...

class	TensorConvolutionOp

class	TensorCostModel
	A cost model used to limit the number of threads used for evaluating tensor expression. More...

class	TensorCustomBinaryOp
	Tensor custom class. More...

class	TensorCustomUnaryOp
	Tensor custom class. More...

class	TensorCwiseBinaryOp
	Tensor binary expression. More...

class	TensorCwiseNullaryOp
	Tensor nullary expression. More...

class	TensorCwiseUnaryOp
	Tensor unary expression. More...

class	TensorDevice
	Pseudo expression providing an operator = that will evaluate its argument on the specified computing 'device' (GPU, thread pool, ...) More...

struct	TensorEvaluator
	The tensor evaluator class. More...

class	TensorFFTOp
	Tensor FFT class. More...

class	TensorFixedSize
	The fixed sized version of the tensor class. More...

class	TensorForcedEvalOp
	Tensor reshaping class. More...

class	TensorGeneratorOp
	Tensor generator class. More...

class	TensorImagePatchOp
	Patch extraction specialized for image processing. This assumes that the input has a least 3 dimensions ordered as follow: 1st dimension: channels (of size d) 2nd dimension: rows (of size r) 3rd dimension: columns (of size c) There can be additional dimensions such as time (for video) or batch (for bulk processing after the first 3. Calling the image patch code with patch_rows and patch_cols is equivalent to calling the regular patch extraction code with parameters d, patch_rows, patch_cols, and 1 for all the additional dimensions. More...

class	TensorIndexTupleOp
	Tensor + Index Pair class. More...

class	TensorInflationOp
	Tensor inflation class. More...

class	TensorMap
	A tensor expression mapping an existing array of data. More...

class	TensorPaddingOp
	Tensor padding class. At the moment only padding with a constant value is supported. More...

class	TensorPatchOp
	Tensor patch class. More...

class	TensorReductionOp
	Tensor reduction class. More...

class	TensorRef
	A reference to a tensor expression The expression will be evaluated lazily (as much as possible). More...

class	TensorReshapingOp
	Tensor reshaping class. More...

class	TensorReverseOp
	Tensor reverse elements class. More...

class	TensorScanOp
	Tensor scan class. More...

class	TensorShufflingOp
	Tensor shuffling class. More...

class	TensorStridingOp
	Tensor striding class. More...

class	TensorTraceOp
	Tensor Trace class. More...

class	TensorVolumePatchOp
	Patch extraction specialized for processing of volumetric data. This assumes that the input has a least 4 dimensions ordered as follows: More...

class	Transform

class	Translation

class	Transpose

class	Transpositions

struct	TranspositionsStorage

class	TriangularBase

class	TriangularView

class	TriangularViewImpl< _MatrixType, _Mode, Dense >

class	TriangularViewImpl< MatrixType, Mode, Sparse >

class	Tridiagonalization

class	Triplet

class	UmfPackLU

class	UniformScaling

class	VectorBlock

class	VectorwiseOp

class	WithFormat

Typedefs
typedef EulerAngles< double, EulerSystemXYX >	EulerAnglesXYXd


typedef EulerAngles< float, EulerSystemXYX >	EulerAnglesXYXf


typedef EulerAngles< double, EulerSystemXYZ >	EulerAnglesXYZd


typedef EulerAngles< float, EulerSystemXYZ >	EulerAnglesXYZf


typedef EulerAngles< double, EulerSystemXZX >	EulerAnglesXZXd


typedef EulerAngles< float, EulerSystemXZX >	EulerAnglesXZXf


typedef EulerAngles< double, EulerSystemXZY >	EulerAnglesXZYd


typedef EulerAngles< float, EulerSystemXZY >	EulerAnglesXZYf


typedef EulerAngles< double, EulerSystemYXY >	EulerAnglesYXYd


typedef EulerAngles< float, EulerSystemYXY >	EulerAnglesYXYf


typedef EulerAngles< double, EulerSystemYXZ >	EulerAnglesYXZd


typedef EulerAngles< float, EulerSystemYXZ >	EulerAnglesYXZf


typedef EulerAngles< double, EulerSystemYZX >	EulerAnglesYZXd


typedef EulerAngles< float, EulerSystemYZX >	EulerAnglesYZXf


typedef EulerAngles< double, EulerSystemYZY >	EulerAnglesYZYd


typedef EulerAngles< float, EulerSystemYZY >	EulerAnglesYZYf


typedef EulerAngles< double, EulerSystemZXY >	EulerAnglesZXYd


typedef EulerAngles< float, EulerSystemZXY >	EulerAnglesZXYf


typedef EulerAngles< double, EulerSystemZXZ >	EulerAnglesZXZd


typedef EulerAngles< float, EulerSystemZXZ >	EulerAnglesZXZf


typedef EulerAngles< double, EulerSystemZYX >	EulerAnglesZYXd


typedef EulerAngles< float, EulerSystemZYX >	EulerAnglesZYXf


typedef EulerAngles< double, EulerSystemZYZ >	EulerAnglesZYZd


typedef EulerAngles< float, EulerSystemZYZ >	EulerAnglesZYZf


typedef EulerSystem< EULER_X, EULER_Y, EULER_X >	EulerSystemXYX


typedef EulerSystem< EULER_X, EULER_Y, EULER_Z >	EulerSystemXYZ


typedef EulerSystem< EULER_X, EULER_Z, EULER_X >	EulerSystemXZX


typedef EulerSystem< EULER_X, EULER_Z, EULER_Y >	EulerSystemXZY


typedef EulerSystem< EULER_Y, EULER_X, EULER_Y >	EulerSystemYXY


typedef EulerSystem< EULER_Y, EULER_X, EULER_Z >	EulerSystemYXZ


typedef EulerSystem< EULER_Y, EULER_Z, EULER_X >	EulerSystemYZX


typedef EulerSystem< EULER_Y, EULER_Z, EULER_Y >	EulerSystemYZY


typedef EulerSystem< EULER_Z, EULER_X, EULER_Y >	EulerSystemZXY


typedef EulerSystem< EULER_Z, EULER_X, EULER_Z >	EulerSystemZXZ


typedef EulerSystem< EULER_Z, EULER_Y, EULER_X >	EulerSystemZYX


typedef EulerSystem< EULER_Z, EULER_Y, EULER_Z >	EulerSystemZYZ


typedef Spline< double, 2 >	Spline2d
	2D double B-spline with dynamic degree.

typedef Spline< float, 2 >	Spline2f
	2D float B-spline with dynamic degree.

typedef Spline< double, 3 >	Spline3d
	3D double B-spline with dynamic degree.

typedef Spline< float, 3 >	Spline3f
	3D float B-spline with dynamic degree.

Enumerations
enum	EulerAxis { EULER_X , EULER_Y , EULER_Z }
	Representation of a fixed signed rotation axis for EulerSystem. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename PointArrayType, typename KnotVectorType>
void	ChordLengths (const PointArrayType &pts, KnotVectorType &chord_lengths)
	Computes chord length parameters which are required for spline interpolation.

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

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

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

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

template<typename KnotVectorType>
void	KnotAveraging (const KnotVectorType &parameters, DenseIndex degree, KnotVectorType &knots)
	Computes knot averages.

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.

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

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

template<typename MatrixType, typename ResultType>
void	matrix_sqrt_quasi_triangular (const MatrixType &arg, ResultType &result)
	Compute matrix square root of quasi-triangular matrix.

template<typename MatrixType, typename ResultType>
void	matrix_sqrt_triangular (const MatrixType &arg, ResultType &result)
	Compute matrix square root of triangular matrix.

template<typename Polynomials, typename T>
T	poly_eval (const Polynomials &poly, const T &x)

template<typename Polynomials, typename T>
T	poly_eval_horner (const Polynomials &poly, const T &x)

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

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

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

Detailed Description

Namespace containing all symbols from the Eigen library.

Function Documentation

◆ bessel_i0()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_i0()

◆ bessel_i0e()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_i0e()

◆ bessel_i1()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_i1()

◆ bessel_i1e()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_i1e()

◆ bessel_j0()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_j0()

◆ bessel_j1()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_j1()

◆ bessel_k0()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_k0()

◆ bessel_k0e()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_k0e()

◆ bessel_k1()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_k1()

◆ bessel_k1e()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_k1e()

◆ bessel_y0()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_y0()

◆ bessel_y1()

template<typename Derived>

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

inline

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

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

Parameters

x	is the argument

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

See also: ArrayBase::bessel_y1()

◆ betainc() [1/2]

template<typename ADerived, typename BDerived, typename XDerived>

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

inline

[c++11]

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

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

◆ betainc() [2/2]

template<typename ArgADerived, typename ArgBDerived, typename ArgXDerived>

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

inline

[c++11]

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

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

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

See also: Eigen::betainc(), Eigen::lgamma()

◆ 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

◆ 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

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

Eigen::Scalar

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

◆ gamma_sample_der_alpha()

template<typename AlphaDerived, typename SampleDerived>

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

inline

[c++11]

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

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

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

See also: Eigen::igamma(), Eigen::lgamma()

◆ igamma()

template<typename Derived, typename ExponentDerived>

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

inline

[c++11]

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

This function computes the coefficient-wise incomplete gamma function.

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

See also: Eigen::igammac(), Eigen::lgamma()

◆ igamma_der_a()

template<typename Derived, typename ExponentDerived>

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

inline

[c++11]

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

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

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

See also: Eigen::igamma(), Eigen::lgamma()

◆ igammac()

template<typename Derived, typename ExponentDerived>

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

inline

[c++11]

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

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

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

See also: Eigen::igamma(), Eigen::lgamma()

◆ polygamma()

template<typename DerivedN, typename DerivedX>

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

inline

[c++11]

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

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

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

See also: Eigen::digamma()

◆ zeta()

template<typename DerivedX, typename DerivedQ>

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

inline

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

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

Parameters

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

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

See also: ArrayBase::zeta()

Classes

Typedefs

Enumerations

Functions

Detailed Description

Function Documentation

◆ bessel_i0()

◆ bessel_i0e()

◆ bessel_i1()

◆ bessel_i1e()

◆ bessel_j0()

◆ bessel_j1()

◆ bessel_k0()

◆ bessel_k0e()

◆ bessel_k1()

◆ bessel_k1e()

◆ bessel_y0()

◆ bessel_y1()

◆ betainc() [1/2]

◆ betainc() [2/2]

◆ BVIntersect() [1/2]

◆ BVIntersect() [2/2]

◆ BVMinimize() [1/2]

◆ BVMinimize() [2/2]

◆ gamma_sample_der_alpha()

◆ igamma()

◆ igamma_der_a()

◆ igammac()

◆ polygamma()

◆ zeta()