Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Loading...
Searching...
No Matches
Eigen Namespace Reference

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  DenseCoeffsBase< Derived, ReadOnlyAccessors >
class  DenseCoeffsBase< Derived, WriteAccessors >
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  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, ReadOnlyAccessors >
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  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  TensorConcatenationOp
 Tensor concatenation class. More...
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  TensorCustomBinaryOp
 Tensor custom class. More...
class  TensorCustomUnaryOp
 Tensor custom class. More...
class  TensorDevice
 Pseudo expression providing an operator = that will evaluate its argument on the specified computing 'device' (GPU, thread pool, ...) More...
class  TensorEvaluator
 A cost model used to limit the number of threads used for evaluating tensor expression. More...
class  TensorFixedSize
 The fixed sized version of the tensor class. More...
class  TensorGeneratorOp
 Tensor generator class. More...
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  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 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>
poly_eval (const Polynomials &poly, const T &x)
template<typename Polynomials, typename 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i0(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_i0()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i0e(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_i0e()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i1(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_i1()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of i1e(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_i1e()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of j0(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_j0()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of j1(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_j1()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k0(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_k0()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k0e(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_k0e()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k1(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_k1()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of k1e(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_k1e()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of y0(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_y0()

◆ 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
xis the argument
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of y1(T) for any scalar type T to be supported.
See also
ArrayBase::bessel_y1()

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

◆ 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
xis the exponent, it must be > 1
qis the shift, it must be > 0
Note
This function supports only float and double scalar types. To support other scalar types, the user has to provide implementations of zeta(T,T) for any scalar type T to be supported.
See also
ArrayBase::zeta()