Chemical Data Processing Library C++ API - Version 1.1.1
Classes | Typedefs | Functions
CDPL::Math Namespace Reference

Contains classes and functions related to mathematics. More...

Classes

class  BFGSMinimizer
 Fletcher's implementation of the BFGS method. More...
 
class  BoundedMatrix
 
class  BoundedVector
 
class  CMatrix
 
struct  CommonType
 
struct  ComplexTraits
 
struct  CrossProductMatrixFromVector
 
class  CVector
 
struct  DiagonalMatrixFromVector
 
class  DirectAssignmentProxy
 
class  Expression
 
class  Grid
 
class  GridBinary1
 
struct  GridBinary1Traits
 
struct  GridBooleanBinaryFunctor
 
class  GridContainer
 
struct  GridCoordinatesMatrixTransformTraits
 
struct  GridCoordinatesTransformTraits
 
struct  GridCoordinatesTransformTraits< BoundedMatrix< T, 4, 4 > >
 
struct  GridCoordinatesTransformTraits< CMatrix< T, 4, 4 > >
 
struct  GridElementSum
 
struct  GridEquality
 
class  GridExpression
 
class  GridReference
 
struct  GridScalarUnaryFunctor
 
struct  GridTemporaryTraits
 
struct  GridTemporaryTraits< const GridReference< G > >
 
struct  GridTemporaryTraits< GridReference< G > >
 
struct  GridToleranceEquality
 
class  GridUnary
 
struct  GridUnaryTraits
 
class  HomogenousCoordsAdapter
 
class  IdentityMatrix
 
class  InitListMatrix
 
class  InitListVector
 
struct  IsScalar
 
struct  IsScalar< std::complex< T > >
 
class  KabschAlgorithm
 Implementation of the Kabsch algorithm [KABA]. More...
 
struct  Lower
 
class  Matrix
 
class  Matrix1VectorBinary
 
struct  Matrix1VectorBinaryTraits
 
class  Matrix2VectorBinary
 
struct  Matrix2VectorBinaryTraits
 
class  MatrixBinary1
 
struct  MatrixBinary1Traits
 
class  MatrixBinary2
 
struct  MatrixBinary2Traits
 
struct  MatrixBinaryFunctor
 
struct  MatrixBooleanBinaryFunctor
 
class  MatrixColumn
 
class  MatrixContainer
 
struct  MatrixElementSum
 
struct  MatrixEquality
 
class  MatrixExpression
 
struct  MatrixNorm1
 
struct  MatrixNormFrobenius
 
struct  MatrixNormInfinity
 
struct  MatrixProduct
 
class  MatrixRange
 
class  MatrixReference
 
class  MatrixRow
 
struct  MatrixScalarRealUnaryFunctor
 
struct  MatrixScalarUnaryFunctor
 
class  MatrixSlice
 
struct  MatrixTemporaryTraits
 
struct  MatrixTemporaryTraits< const MatrixColumn< M > >
 
struct  MatrixTemporaryTraits< const MatrixRange< M > >
 
struct  MatrixTemporaryTraits< const MatrixReference< M > >
 
struct  MatrixTemporaryTraits< const MatrixRow< M > >
 
struct  MatrixTemporaryTraits< const MatrixSlice< M > >
 
struct  MatrixTemporaryTraits< const MatrixTranspose< M > >
 
struct  MatrixTemporaryTraits< const TriangularAdapter< M, Tri > >
 
struct  MatrixTemporaryTraits< MatrixColumn< M > >
 
struct  MatrixTemporaryTraits< MatrixRange< M > >
 
struct  MatrixTemporaryTraits< MatrixReference< M > >
 
struct  MatrixTemporaryTraits< MatrixRow< M > >
 
struct  MatrixTemporaryTraits< MatrixSlice< M > >
 
struct  MatrixTemporaryTraits< MatrixTranspose< M > >
 
struct  MatrixTemporaryTraits< TriangularAdapter< M, Tri > >
 
struct  MatrixToleranceEquality
 
struct  MatrixTrace
 
class  MatrixTranspose
 
class  MatrixUnary
 
struct  MatrixUnaryTraits
 
struct  MatrixVectorBinaryFunctor
 
struct  MatrixVectorProduct
 
struct  MinimizerVariableArrayTraits
 
struct  MinimizerVariableArrayTraits< std::vector< V > >
 
struct  MinimizerVariableArrayTraits< VectorArray< V > >
 
class  MLRModel
 Performs Multiple Linear Regression [WLIREG] on a set of data points \( (y_i, \vec{X}_i) \). More...
 
class  Quaternion
 
class  QuaternionBinary1
 
struct  QuaternionBinary1Traits
 
class  QuaternionBinary2
 
struct  QuaternionBinary2Traits
 
struct  QuaternionBinaryFunctor
 
struct  QuaternionBooleanBinaryFunctor
 
struct  QuaternionConjugate
 
class  QuaternionContainer
 
struct  QuaternionDivision
 
struct  QuaternionElementSum
 
struct  QuaternionEquality
 
class  QuaternionExpression
 
struct  QuaternionInverse
 
struct  QuaternionNorm
 
struct  QuaternionNorm2
 
struct  QuaternionProduct
 
class  QuaternionReference
 
struct  QuaternionScalarRealUnaryFunctor
 
struct  QuaternionScalarUnaryFunctor
 
struct  QuaternionTemporaryTraits
 
struct  QuaternionTemporaryTraits< const QuaternionReference< Q > >
 
struct  QuaternionTemporaryTraits< const VectorQuaternionAdapter< V > >
 
struct  QuaternionTemporaryTraits< QuaternionReference< Q > >
 
struct  QuaternionTemporaryTraits< VectorQuaternionAdapter< V > >
 
struct  QuaternionToleranceEquality
 
class  QuaternionUnary1
 
struct  QuaternionUnary1Traits
 
class  QuaternionUnary2
 
struct  QuaternionUnary2Traits
 
struct  QuaternionUnaryFunctor
 
struct  QuaternionUnreal
 
class  QuaternionVectorAdapter
 
class  QuaternionVectorBinary
 
struct  QuaternionVectorBinaryFunctor
 
struct  QuaternionVectorBinaryTraits
 
struct  QuaternionVectorRotation
 
class  Range
 
class  RealQuaternion
 
class  RegularSpatialGrid
 
class  RotationMatrix
 
class  Scalar13QuaternionTernary
 
struct  Scalar13QuaternionTernaryFunctor
 
struct  Scalar13QuaternionTernaryTraits
 
class  Scalar1GridBinary
 
struct  Scalar1GridBinaryTraits
 
class  Scalar1MatrixBinary
 
struct  Scalar1MatrixBinaryTraits
 
struct  Scalar1QuaternionAddition
 
class  Scalar1QuaternionBinary1
 
struct  Scalar1QuaternionBinary1Traits
 
class  Scalar1QuaternionBinary2
 
struct  Scalar1QuaternionBinary2Traits
 
struct  Scalar1QuaternionBinaryFunctor
 
struct  Scalar1QuaternionSubtraction
 
class  Scalar1VectorBinary
 
struct  Scalar1VectorBinaryTraits
 
class  Scalar2GridBinary
 
struct  Scalar2GridBinaryTraits
 
class  Scalar2MatrixBinary
 
struct  Scalar2MatrixBinaryTraits
 
struct  Scalar2QuaternionAddition
 
class  Scalar2QuaternionBinary1
 
struct  Scalar2QuaternionBinary1Traits
 
class  Scalar2QuaternionBinary2
 
struct  Scalar2QuaternionBinary2Traits
 
struct  Scalar2QuaternionBinaryFunctor
 
struct  Scalar2QuaternionSubtraction
 
class  Scalar2VectorBinary
 
struct  Scalar2VectorBinaryTraits
 
struct  Scalar3GridBooleanTernaryFunctor
 
struct  Scalar3MatrixBooleanTernaryFunctor
 
struct  Scalar3QuaternionBooleanTernaryFunctor
 
class  Scalar3QuaternionTernary
 
struct  Scalar3QuaternionTernaryFunctor
 
struct  Scalar3QuaternionTernaryTraits
 
struct  Scalar3VectorBooleanTernaryFunctor
 
struct  ScalarAbsImpl
 
struct  ScalarAbsImpl< false >
 
struct  ScalarAddition
 
struct  ScalarAdditionAssignment
 
struct  ScalarAssignment
 
struct  ScalarBinaryAssignmentFunctor
 
struct  ScalarBinaryFunctor
 
struct  ScalarConjugation
 
struct  ScalarDivision
 
struct  ScalarDivisionAssignment
 
class  ScalarGrid
 
struct  ScalarImaginary
 
class  ScalarMatrix
 
struct  ScalarMultiplication
 
struct  ScalarMultiplicationAssignment
 
struct  ScalarNegation
 
struct  ScalarQuaternionDivision
 
struct  ScalarReal
 
struct  ScalarRealUnaryFunctor
 
struct  ScalarSubtraction
 
struct  ScalarSubtractionAssignment
 
struct  ScalarTraits
 
struct  ScalarUnaryFunctor
 
class  ScalarVector
 
class  ScalingMatrix
 
class  Slice
 
class  SparseContainerElement
 
class  SparseMatrix
 
class  SparseVector
 
class  TranslationMatrix
 
class  TriangularAdapter
 
struct  TypeTraits
 
struct  TypeTraits< SparseContainerElement< C > >
 
struct  TypeTraits< std::complex< T > >
 
struct  UnitLower
 
struct  UnitUpper
 
class  UnitVector
 
struct  Upper
 
class  Vector
 
struct  VectorAngleCosine
 
class  VectorArray
 An array for storing generic vector objects. More...
 
class  VectorArrayAlignmentCalculator
 
class  VectorBinary1
 
struct  VectorBinary1Traits
 
class  VectorBinary2
 
struct  VectorBinary2Traits
 
struct  VectorBinaryFunctor
 
struct  VectorBooleanBinaryFunctor
 
class  VectorContainer
 
struct  VectorCrossProduct
 
class  VectorElementAccessor
 
class  VectorElementAccessor< const E >
 
struct  VectorElementSum
 
struct  VectorEquality
 
class  VectorExpression
 
struct  VectorInnerProduct
 
struct  VectorIteratorTraits
 
struct  VectorIteratorTraits< const E >
 
class  VectorMatrixBinary
 
struct  VectorMatrixBinaryTraits
 
struct  VectorMatrixProduct
 
class  VectorMatrixUnary
 
struct  VectorMatrixUnaryFunctor
 
struct  VectorMatrixUnaryTraits
 
struct  VectorNorm1
 
struct  VectorNorm2
 
struct  VectorNormInfinity
 
struct  VectorNormInfinityIndex
 
class  VectorQuaternionAdapter
 
class  VectorRange
 
class  VectorReference
 
struct  VectorScalarBinaryFunctor
 
struct  VectorScalarIndexUnaryFunctor
 
struct  VectorScalarRealUnaryFunctor
 
struct  VectorScalarUnaryFunctor
 
class  VectorSlice
 
struct  VectorTemporaryTraits
 
struct  VectorTemporaryTraits< const HomogenousCoordsAdapter< V > >
 
struct  VectorTemporaryTraits< const MatrixColumn< M > >
 
struct  VectorTemporaryTraits< const MatrixRange< M > >
 
struct  VectorTemporaryTraits< const MatrixReference< M > >
 
struct  VectorTemporaryTraits< const MatrixRow< M > >
 
struct  VectorTemporaryTraits< const MatrixSlice< M > >
 
struct  VectorTemporaryTraits< const MatrixTranspose< M > >
 
struct  VectorTemporaryTraits< const QuaternionVectorAdapter< Q > >
 
struct  VectorTemporaryTraits< const TriangularAdapter< M, Tri > >
 
struct  VectorTemporaryTraits< const VectorRange< V > >
 
struct  VectorTemporaryTraits< const VectorReference< V > >
 
struct  VectorTemporaryTraits< const VectorSlice< V > >
 
struct  VectorTemporaryTraits< HomogenousCoordsAdapter< V > >
 
struct  VectorTemporaryTraits< MatrixColumn< M > >
 
struct  VectorTemporaryTraits< MatrixRange< M > >
 
struct  VectorTemporaryTraits< MatrixReference< M > >
 
struct  VectorTemporaryTraits< MatrixRow< M > >
 
struct  VectorTemporaryTraits< MatrixSlice< M > >
 
struct  VectorTemporaryTraits< MatrixTranspose< M > >
 
struct  VectorTemporaryTraits< QuaternionVectorAdapter< Q > >
 
struct  VectorTemporaryTraits< TriangularAdapter< M, Tri > >
 
struct  VectorTemporaryTraits< VectorRange< V > >
 
struct  VectorTemporaryTraits< VectorReference< V > >
 
struct  VectorTemporaryTraits< VectorSlice< V > >
 
struct  VectorToleranceEquality
 
class  VectorUnary
 
struct  VectorUnaryTraits
 
class  ZeroGrid
 
class  ZeroMatrix
 
class  ZeroVector
 

Typedefs

typedef ScalingMatrix< float > FScalingMatrix
 
typedef ScalingMatrix< doubleDScalingMatrix
 
typedef ScalingMatrix< long > LScalingMatrix
 
typedef ScalingMatrix< unsigned long > ULScalingMatrix
 
typedef RotationMatrix< float > FRotationMatrix
 
typedef RotationMatrix< doubleDRotationMatrix
 
typedef RotationMatrix< long > LRotationMatrix
 
typedef RotationMatrix< unsigned long > ULRotationMatrix
 
typedef TranslationMatrix< float > FTranslationMatrix
 
typedef TranslationMatrix< doubleDTranslationMatrix
 
typedef TranslationMatrix< long > LTranslationMatrix
 
typedef TranslationMatrix< unsigned long > ULTranslationMatrix
 
typedef ZeroGrid< float > FZeroGrid
 
typedef ZeroGrid< doubleDZeroGrid
 
typedef ScalarGrid< float > FScalarGrid
 
typedef ScalarGrid< doubleDScalarGrid
 
typedef Grid< float > FGrid
 An unbounded dense grid holding floating point values of type float. More...
 
typedef Grid< doubleDGrid
 An unbounded dense grid holding floating point values of type double. More...
 
typedef ZeroMatrix< float > FZeroMatrix
 
typedef ZeroMatrix< doubleDZeroMatrix
 
typedef ZeroMatrix< long > LZeroMatrix
 
typedef ZeroMatrix< unsigned long > ULZeroMatrix
 
typedef ScalarMatrix< float > FScalarMatrix
 
typedef ScalarMatrix< doubleDScalarMatrix
 
typedef ScalarMatrix< long > LScalarMatrix
 
typedef ScalarMatrix< unsigned long > ULScalarMatrix
 
typedef IdentityMatrix< float > FIdentityMatrix
 
typedef IdentityMatrix< doubleDIdentityMatrix
 
typedef IdentityMatrix< long > LIdentityMatrix
 
typedef IdentityMatrix< unsigned long > ULIdentityMatrix
 
typedef Matrix< float > FMatrix
 An unbounded dense matrix holding floating point values of type float.. More...
 
typedef Matrix< doubleDMatrix
 An unbounded dense matrix holding floating point values of type double.. More...
 
typedef Matrix< long > LMatrix
 An unbounded dense matrix holding signed integers of type long. More...
 
typedef Matrix< unsigned long > ULMatrix
 An unbounded dense matrix holding unsigned integers of type unsigned long. More...
 
typedef CMatrix< float, 2, 2 > Matrix2F
 A bounded 2x2 matrix holding floating point values of type float. More...
 
typedef CMatrix< float, 3, 3 > Matrix3F
 A bounded 3x3 matrix holding floating point values of type float. More...
 
typedef CMatrix< float, 4, 4 > Matrix4F
 A bounded 4x4 matrix holding floating point values of type float. More...
 
typedef CMatrix< double, 2, 2 > Matrix2D
 A bounded 2x2 matrix holding floating point values of type double. More...
 
typedef CMatrix< double, 3, 3 > Matrix3D
 A bounded 3x3 matrix holding floating point values of type double. More...
 
typedef CMatrix< double, 4, 4 > Matrix4D
 A bounded 4x4 matrix holding floating point values of type double. More...
 
typedef CMatrix< long, 2, 2 > Matrix2L
 A bounded 2x2 matrix holding signed integers of type long. More...
 
typedef CMatrix< long, 3, 3 > Matrix3L
 A bounded 3x3 matrix holding signed integers of type long. More...
 
typedef CMatrix< long, 4, 4 > Matrix4L
 A bounded 4x4 matrix holding signed integers of type long. More...
 
typedef CMatrix< unsigned long, 2, 2 > Matrix2UL
 A bounded 2x2 matrix holding unsigned integers of type unsigned long. More...
 
typedef CMatrix< unsigned long, 3, 3 > Matrix3UL
 A bounded 3x3 matrix holding unsigned integers of type unsigned long. More...
 
typedef CMatrix< unsigned long, 4, 4 > Matrix4UL
 A bounded 4x4 matrix holding unsigned integers of type unsigned long. More...
 
typedef SparseMatrix< float > SparseFMatrix
 An unbounded sparse matrix holding floating point values of type float.. More...
 
typedef SparseMatrix< doubleSparseDMatrix
 An unbounded sparse matrix holding floating point values of type double.. More...
 
typedef SparseMatrix< long > SparseLMatrix
 An unbounded sparse matrix holding signed integers of type long. More...
 
typedef SparseMatrix< unsigned long > SparseULMatrix
 An unbounded sparse matrix holding unsigned integers of type unsigned long. More...
 
typedef Quaternion< float > FQuaternion
 
typedef Quaternion< doubleDQuaternion
 
typedef Quaternion< long > LQuaternion
 
typedef Quaternion< unsigned long > ULQuaternion
 
typedef RealQuaternion< float > FRealQuaternion
 
typedef RealQuaternion< doubleDRealQuaternion
 
typedef RealQuaternion< long > LRealQuaternion
 
typedef RealQuaternion< unsigned long > ULRealQuaternion
 
typedef RegularSpatialGrid< float > FRegularSpatialGrid
 An unbounded dense regular grid in 3D space holding floating point values of type float. More...
 
typedef RegularSpatialGrid< doubleDRegularSpatialGrid
 An unbounded dense regular grid in 3D space holding floating point values of type double. More...
 
typedef ScalarVector< float > FScalarVector
 
typedef ScalarVector< doubleDScalarVector
 
typedef ScalarVector< long > LScalarVector
 
typedef ScalarVector< unsigned long > ULScalarVector
 
typedef ZeroVector< float > FZeroVector
 
typedef ZeroVector< doubleDZeroVector
 
typedef ZeroVector< long > LZeroVector
 
typedef ZeroVector< unsigned long > ULZeroVector
 
typedef UnitVector< float > FUnitVector
 
typedef UnitVector< doubleDUnitVector
 
typedef UnitVector< long > LUnitVector
 
typedef UnitVector< unsigned long > ULUnitVector
 
typedef CVector< float, 2 > Vector2F
 A bounded 2 element vector holding floating point values of type float. More...
 
typedef CVector< float, 3 > Vector3F
 A bounded 3 element vector holding floating point values of type float. More...
 
typedef CVector< float, 4 > Vector4F
 A bounded 4 element vector holding floating point values of type float. More...
 
typedef CVector< double, 2 > Vector2D
 A bounded 2 element vector holding floating point values of type double. More...
 
typedef CVector< double, 3 > Vector3D
 A bounded 3 element vector holding floating point values of type double. More...
 
typedef CVector< double, 4 > Vector4D
 A bounded 4 element vector holding floating point values of type double. More...
 
typedef CVector< double, 7 > Vector7D
 A bounded 7 element vector holding floating point values of type double. More...
 
typedef CVector< long, 2 > Vector2L
 A bounded 2 element vector holding signed integers of type long. More...
 
typedef CVector< long, 3 > Vector3L
 A bounded 3 element vector holding signed integers of type long. More...
 
typedef CVector< long, 4 > Vector4L
 A bounded 4 element vector holding signed integers of type long. More...
 
typedef CVector< unsigned long, 2 > Vector2UL
 A bounded 2 element vector holding unsigned integers of type unsigned long. More...
 
typedef CVector< unsigned long, 3 > Vector3UL
 A bounded 3 element vector holding unsigned integers of type unsigned long. More...
 
typedef CVector< unsigned long, 4 > Vector4UL
 A bounded 4 element vector holding unsigned integers of type unsigned long. More...
 
typedef Vector< float > FVector
 An unbounded dense vector holding floating point values of type float. More...
 
typedef Vector< doubleDVector
 An unbounded dense vector holding floating point values of type double. More...
 
typedef Vector< long > LVector
 An unbounded dense vector holding signed integers of type long. More...
 
typedef Vector< unsigned long > ULVector
 An unbounded dense vector holding unsigned integers of type unsigned long. More...
 
typedef SparseVector< float > SparseFVector
 An unbounded sparse vector holding floating point values of type float. More...
 
typedef SparseVector< doubleSparseDVector
 An unbounded sparse vector holding floating point values of type double. More...
 
typedef SparseVector< long > SparseLVector
 An unbounded sparse vector holding signed integers of type long. More...
 
typedef SparseVector< unsigned long > SparseULVector
 An unbounded sparse vector holding unsigned integers of type unsigned long. More...
 
typedef VectorArray< Vector2FVector2FArray
 An array of Math::Vector2F objects. More...
 
typedef VectorArray< Vector3FVector3FArray
 An array of Math::Vector3F objects. More...
 
typedef VectorArray< Vector2DVector2DArray
 An array of Math::Vector2D objects. More...
 
typedef VectorArray< Vector3DVector3DArray
 An array of Math::Vector3D objects. More...
 
typedef VectorArray< Vector2LVector2LArray
 An array of Math::Vector2L objects. More...
 
typedef VectorArray< Vector3LVector3LArray
 An array of Math::Vector3L objects. More...
 
typedef VectorArray< Vector2ULVector2ULArray
 An array of Math::Vector2UL objects. More...
 
typedef VectorArray< Vector3ULVector3ULArray
 An array of Math::Vector3UL objects. More...
 

Functions

template<typename C >
DirectAssignmentProxy< const C > direct (const C &lvalue)
 
template<typename C >
DirectAssignmentProxy< C > direct (C &lvalue)
 
template<template< typename T1, typename T2 > class F, typename G , typename E >
void gridAssignGrid (G &g, const GridExpression< E > &e)
 
template<template< typename T1, typename T2 > class F, typename G , typename T >
void gridAssignScalar (G &g, const T &t)
 
template<typename G , typename E >
void gridSwap (G &g, GridExpression< E > &e)
 
template<typename E >
GridUnaryTraits< E, ScalarNegation< typename E::ValueType > >::ResultType operator- (const GridExpression< E > &e)
 
template<typename E >
const E & operator+ (const GridExpression< E > &e)
 
template<typename E1 , typename E2 >
GridBinary1Traits< E1, E2, ScalarAddition< typename E1::ValueType, typename E2::ValueType > >::ResultType operator+ (const GridExpression< E1 > &e1, const GridExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
GridBinary1Traits< E1, E2, ScalarSubtraction< typename E1::ValueType, typename E2::ValueType > >::ResultType operator- (const GridExpression< E1 > &e1, const GridExpression< E2 > &e2)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2GridBinaryTraits< E, T, ScalarMultiplication< typename E::ValueType, T > >::ResultType >::type operator* (const GridExpression< E > &e, const T &t)
 
template<typename T , typename E >
std::enable_if< IsScalar< T >::value, typename Scalar1GridBinaryTraits< T, E, ScalarMultiplication< T, typename E::ValueType > >::ResultType >::type operator* (const T &t, const GridExpression< E > &e)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2GridBinaryTraits< E, T, ScalarDivision< typename E::ValueType, T > >::ResultType >::type operator/ (const GridExpression< E > &e, const T &t)
 
template<typename E1 , typename E2 >
GridEquality< E1, E2 >::ResultType operator== (const GridExpression< E1 > &e1, const GridExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
GridEquality< E1, E2 >::ResultType operator!= (const GridExpression< E1 > &e1, const GridExpression< E2 > &e2)
 
template<typename E1 , typename E2 , typename T >
std::enable_if< std::is_arithmetic< T >::value, typename GridToleranceEquality< E1, E2, T >::ResultType >::type equals (const GridExpression< E1 > &e1, const GridExpression< E2 > &e2, const T &eps)
 
template<typename E >
GridUnaryTraits< E, ScalarConjugation< typename E::ValueType > >::ResultType conj (const GridExpression< E > &e)
 
template<typename E >
GridUnaryTraits< E, ScalarConjugation< typename E::ValueType > >::ResultType herm (const GridExpression< E > &e)
 
template<typename E >
GridUnaryTraits< E, ScalarReal< typename E::ValueType > >::ResultType real (const GridExpression< E > &e)
 
template<typename E >
GridUnaryTraits< E, ScalarImaginary< typename E::ValueType > >::ResultType imag (const GridExpression< E > &e)
 
template<typename E1 , typename E2 >
GridBinary1Traits< E1, E2, ScalarDivision< typename E1::ValueType, typename E2::ValueType > >::ResultType elemDiv (const GridExpression< E1 > &e1, const GridExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
GridBinary1Traits< E1, E2, ScalarMultiplication< typename E1::ValueType, typename E2::ValueType > >::ResultType elemProd (const GridExpression< E1 > &e1, const GridExpression< E2 > &e2)
 
template<typename E >
GridElementSum< E >::ResultType sum (const GridExpression< E > &e)
 
template<typename C , typename T , typename E >
std::basic_ostream< C, T > & operator<< (std::basic_ostream< C, T > &os, const VectorExpression< E > &e)
 
template<typename C , typename T , typename E >
std::basic_ostream< C, T > & operator<< (std::basic_ostream< C, T > &os, const MatrixExpression< E > &e)
 
template<typename C , typename T , typename E >
std::basic_ostream< C, T > & operator<< (std::basic_ostream< C, T > &os, const QuaternionExpression< E > &e)
 
template<typename C , typename T , typename E >
std::basic_ostream< C, T > & operator<< (std::basic_ostream< C, T > &os, const GridExpression< E > &e)
 
template<typename M1 , typename V , typename M2 >
bool jacobiDiagonalize (MatrixExpression< M1 > &a, VectorExpression< V > &d, MatrixExpression< M2 > &v, std::size_t max_iter=50)
 Computes all eigenvalues and eigenvectors of a real symmetric matrix an using Jacobi's algorithm [WJACO ]. More...
 
template<typename E1 , typename E2 >
bool solveLower (const MatrixExpression< E1 > &e1, VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
bool solveUnitLower (const MatrixExpression< E1 > &e1, VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
bool solveLower (const MatrixExpression< E1 > &e1, MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
bool solveUnitLower (const MatrixExpression< E1 > &e1, MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
bool solveUpper (const MatrixExpression< E1 > &e1, VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
bool solveUnitUpper (const MatrixExpression< E1 > &e1, VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
bool solveUpper (const MatrixExpression< E1 > &e1, MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
bool solveUnitUpper (const MatrixExpression< E1 > &e1, MatrixExpression< E2 > &e2)
 
template<typename E >
E::SizeType luDecompose (MatrixExpression< E > &e)
 
template<typename E , typename PV , typename T >
E::SizeType luDecompose (MatrixExpression< E > &e, PV &pv, T &num_row_swaps)
 
template<typename E , typename PV >
void swapRows (VectorExpression< E > &e, const PV &pv)
 
template<typename E , typename PV >
void swapRows (MatrixExpression< E > &e, const PV &pv)
 
template<typename E1 , typename E2 >
bool luSubstitute (const MatrixExpression< E1 > &lu, VectorExpression< E2 > &b)
 
template<typename E1 , typename E2 , typename PV >
bool luSubstitute (const MatrixExpression< E1 > &lu, const PV &pv, VectorExpression< E2 > &b)
 
template<typename E1 , typename E2 >
bool luSubstitute (const MatrixExpression< E1 > &lu, MatrixExpression< E2 > &b)
 
template<typename E1 , typename E2 , typename PV >
bool luSubstitute (const MatrixExpression< E1 > &lu, const PV &pv, MatrixExpression< E2 > &b)
 
template<typename E >
E::ValueType det (const MatrixExpression< E > &e)
 
template<typename C >
C::ValueType det (const MatrixContainer< C > &c)
 
template<typename E , typename C >
bool invert (const MatrixExpression< E > &e, MatrixContainer< C > &c)
 
template<typename C >
bool invert (MatrixContainer< C > &c)
 
template<typename Tri , typename E >
TriangularAdapter< E, Tri > triang (MatrixExpression< E > &e)
 
template<typename Tri , typename E >
TriangularAdapter< const E, Tri > triang (const MatrixExpression< E > &e)
 
template<template< typename T1, typename T2 > class F, typename M , typename E >
void matrixAssignMatrix (M &m, const MatrixExpression< E > &e)
 
template<template< typename T1, typename T2 > class F, typename M , typename T >
void matrixAssignScalar (M &m, const T &t)
 
template<typename M , typename E >
void matrixSwap (M &m, MatrixExpression< E > &e)
 
template<typename E >
MatrixUnaryTraits< E, ScalarNegation< typename E::ValueType > >::ResultType operator- (const MatrixExpression< E > &e)
 
template<typename E >
const E & operator+ (const MatrixExpression< E > &e)
 
template<typename E1 , typename E2 >
MatrixBinary1Traits< E1, E2, ScalarAddition< typename E1::ValueType, typename E2::ValueType > >::ResultType operator+ (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
MatrixBinary1Traits< E1, E2, ScalarSubtraction< typename E1::ValueType, typename E2::ValueType > >::ResultType operator- (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2MatrixBinaryTraits< E, T, ScalarMultiplication< typename E::ValueType, T > >::ResultType >::type operator* (const MatrixExpression< E > &e, const T &t)
 
template<typename T , typename E >
std::enable_if< IsScalar< T >::value, typename Scalar1MatrixBinaryTraits< T, E, ScalarMultiplication< T, typename E::ValueType > >::ResultType >::type operator* (const T &t, const MatrixExpression< E > &e)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2MatrixBinaryTraits< E, T, ScalarDivision< typename E::ValueType, T > >::ResultType >::type operator/ (const MatrixExpression< E > &e, const T &t)
 
template<typename E1 , typename E2 >
MatrixEquality< E1, E2 >::ResultType operator== (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
MatrixEquality< E1, E2 >::ResultType operator!= (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 , typename T >
std::enable_if< std::is_arithmetic< T >::value, typename MatrixToleranceEquality< E1, E2, T >::ResultType >::type equals (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2, const T &eps)
 
template<typename E >
MatrixUnaryTraits< E, ScalarConjugation< typename E::ValueType > >::ResultType conj (const MatrixExpression< E > &e)
 
template<typename E >
MatrixUnaryTraits< E, ScalarConjugation< typename E::ValueType > >::ResultType herm (const MatrixExpression< E > &e)
 
template<typename E >
MatrixUnaryTraits< E, ScalarReal< typename E::ValueType > >::ResultType real (const MatrixExpression< E > &e)
 
template<typename E >
MatrixUnaryTraits< E, ScalarImaginary< typename E::ValueType > >::ResultType imag (const MatrixExpression< E > &e)
 
template<typename E1 , typename E2 >
VectorMatrixBinaryTraits< E1, E2, ScalarMultiplication< typename E1::ValueType, typename E2::ValueType > >::ResultType outerProd (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
MatrixBinary1Traits< E1, E2, ScalarDivision< typename E1::ValueType, typename E2::ValueType > >::ResultType elemDiv (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
MatrixBinary1Traits< E1, E2, ScalarMultiplication< typename E1::ValueType, typename E2::ValueType > >::ResultType elemProd (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
Matrix1VectorBinaryTraits< E1, E2, MatrixVectorProduct< E1, E2 > >::ResultType operator* (const MatrixExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
Matrix1VectorBinaryTraits< E1, E2, MatrixVectorProduct< E1, E2 > >::ResultType prod (const MatrixExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename C , typename E1 , typename E2 >
C & prod (const MatrixExpression< E1 > &e1, const VectorExpression< E2 > &e2, VectorContainer< C > &c)
 
template<typename E1 , typename E2 >
Matrix2VectorBinaryTraits< E1, E2, VectorMatrixProduct< E1, E2 > >::ResultType operator* (const VectorExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
Matrix2VectorBinaryTraits< E1, E2, VectorMatrixProduct< E1, E2 > >::ResultType prod (const VectorExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename C , typename E1 , typename E2 >
C & prod (const VectorExpression< E1 > &e1, const MatrixExpression< E2 > &e2, VectorContainer< C > &c)
 
template<typename E1 , typename E2 >
MatrixBinary2Traits< E1, E2, MatrixProduct< E1, E2 > >::ResultType operator* (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
MatrixBinary2Traits< E1, E2, MatrixProduct< E1, E2 > >::ResultType prod (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2)
 
template<typename C , typename E1 , typename E2 >
C & prod (const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2, MatrixContainer< C > &c)
 
template<typename E >
MatrixTrace< E >::ResultType trace (const MatrixExpression< E > &e)
 
template<typename E >
MatrixNorm1< E >::ResultType norm1 (const MatrixExpression< E > &e)
 
template<typename E >
MatrixNormFrobenius< E >::ResultType normFrob (const MatrixExpression< E > &e)
 
template<typename E >
MatrixNormInfinity< E >::ResultType normInf (const MatrixExpression< E > &e)
 
template<typename E >
VectorMatrixUnaryTraits< E, DiagonalMatrixFromVector< E > >::ResultType diag (const VectorExpression< E > &e)
 
template<typename E >
VectorMatrixUnaryTraits< E, CrossProductMatrixFromVector< E > >::ResultType cross (const VectorExpression< E > &e)
 
template<typename E >
MatrixTranspose< E > trans (MatrixExpression< E > &e)
 
template<typename E >
MatrixTranspose< const E > trans (const MatrixExpression< E > &e)
 
template<typename E >
MatrixElementSum< E >::ResultType sum (const MatrixExpression< E > &e)
 
template<typename M >
MatrixRow< M > row (MatrixExpression< M > &e, typename MatrixRow< M >::SizeType i)
 
template<typename M >
MatrixRow< const M > row (const MatrixExpression< M > &e, typename MatrixRow< const M >::SizeType i)
 
template<typename M >
MatrixColumn< M > column (MatrixExpression< M > &e, typename MatrixColumn< M >::SizeType j)
 
template<typename M >
MatrixColumn< const M > column (const MatrixExpression< M > &e, typename MatrixColumn< const M >::SizeType j)
 
template<typename E >
MatrixRange< E > range (MatrixExpression< E > &e, const typename MatrixRange< E >::RangeType &r1, const typename MatrixRange< E >::RangeType &r2)
 
template<typename E >
MatrixRange< const E > range (const MatrixExpression< E > &e, const typename MatrixRange< const E >::RangeType &r1, const typename MatrixRange< const E >::RangeType &r2)
 
template<typename E >
MatrixRange< E > range (MatrixExpression< E > &e, typename MatrixRange< E >::RangeType::SizeType start1, typename MatrixRange< E >::RangeType::SizeType stop1, typename MatrixRange< E >::RangeType::SizeType start2, typename MatrixRange< E >::RangeType::SizeType stop2)
 
template<typename E >
MatrixRange< const E > range (const MatrixExpression< E > &e, typename MatrixRange< const E >::RangeType::SizeType start1, typename MatrixRange< const E >::RangeType::SizeType stop1, typename MatrixRange< const E >::RangeType::SizeType start2, typename MatrixRange< const E >::RangeType::SizeType stop2)
 
template<typename E >
MatrixSlice< E > slice (MatrixExpression< E > &e, const typename MatrixSlice< E >::SliceType &s1, const typename MatrixSlice< E >::SliceType &s2)
 
template<typename E >
MatrixSlice< const E > slice (const MatrixExpression< E > &e, const typename MatrixSlice< const E >::SliceType &s1, const typename MatrixSlice< const E >::SliceType &s2)
 
template<typename E >
MatrixSlice< E > slice (MatrixExpression< E > &e, typename MatrixSlice< E >::SliceType::SizeType start1, typename MatrixSlice< E >::SliceType::DifferenceType stride1, typename MatrixSlice< E >::SliceType::SizeType size1, typename MatrixSlice< E >::SliceType::SizeType start2, typename MatrixSlice< E >::SliceType::DifferenceType stride2, typename MatrixSlice< E >::SliceType::SizeType size2)
 
template<typename E >
MatrixSlice< const E > slice (const MatrixExpression< E > &e, typename MatrixSlice< const E >::SliceType::SizeType start1, typename MatrixSlice< const E >::SliceType::DifferenceType stride1, typename MatrixSlice< const E >::SliceType::SizeType size1, typename MatrixSlice< const E >::SliceType::SizeType start2, typename MatrixSlice< const E >::SliceType::DifferenceType stride2, typename MatrixSlice< const E >::SliceType::SizeType size2)
 
template<typename T >
std::enable_if< IsScalar< T >::value, RealQuaternion< T > >::type quat (const T &t)
 
template<typename T1 , typename T2 >
Quaternion< typename CommonType< T1, T2 >::Type > quat (const T1 &t1, const T2 &t2)
 
template<typename T1 , typename T2 , typename T3 >
Quaternion< typename CommonType< typename CommonType< T1, T2 >::Type, T3 >::Type > quat (const T1 &t1, const T2 &t2, const T3 &t3)
 
template<typename T1 , typename T2 , typename T3 , typename T4 >
Quaternion< typename CommonType< typename CommonType< typename CommonType< T1, T2 >::Type, T3 >::Type, T4 >::Type > quat (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
 
template<typename E >
QuaternionVectorAdapter< E > vec (QuaternionExpression< E > &e)
 
template<typename E >
QuaternionVectorAdapter< const E > vec (const QuaternionExpression< E > &e)
 
template<template< typename T1, typename T2 > class F, typename Q , typename E >
void quaternionAssignQuaternion (Q &q, const QuaternionExpression< E > &e)
 
template<template< typename T1, typename T2 > class F, typename Q , typename T >
void quaternionAssignScalar (Q &q, const T &t)
 
template<typename Q , typename E >
void quaternionSwap (Q &q, QuaternionExpression< E > &e)
 
template<typename E >
QuaternionUnary1Traits< E, ScalarNegation< typename E::ValueType > >::ResultType operator- (const QuaternionExpression< E > &e)
 
template<typename E >
const E & operator+ (const QuaternionExpression< E > &e)
 
template<typename E1 , typename E2 >
QuaternionBinary1Traits< E1, E2, ScalarAddition< typename E1::ValueType, typename E2::ValueType > >::ResultType operator+ (const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2QuaternionBinary2Traits< E, T, Scalar2QuaternionAddition< E, T > >::ResultType >::type operator+ (const QuaternionExpression< E > &e, const T &t)
 
template<typename T , typename E >
std::enable_if< IsScalar< T >::value, typename Scalar1QuaternionBinary2Traits< T, E, Scalar1QuaternionAddition< T, E > >::ResultType >::type operator+ (const T &t, const QuaternionExpression< E > &e)
 
template<typename E1 , typename E2 >
QuaternionBinary1Traits< E1, E2, ScalarSubtraction< typename E1::ValueType, typename E2::ValueType > >::ResultType operator- (const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2QuaternionBinary2Traits< E, T, Scalar2QuaternionSubtraction< E, T > >::ResultType >::type operator- (const QuaternionExpression< E > &e, const T &t)
 
template<typename T , typename E >
std::enable_if< IsScalar< T >::value, typename Scalar1QuaternionBinary2Traits< T, E, Scalar1QuaternionSubtraction< T, E > >::ResultType >::type operator- (const T &t, const QuaternionExpression< E > &e)
 
template<typename E1 , typename E2 >
QuaternionBinary2Traits< E1, E2, QuaternionProduct< E1, E2 > >::ResultType operator* (const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2QuaternionBinary1Traits< E, T, ScalarMultiplication< typename E::ValueType, T > >::ResultType >::type operator* (const QuaternionExpression< E > &e, const T &t)
 
template<typename T , typename E >
std::enable_if< IsScalar< T >::value, typename Scalar1QuaternionBinary1Traits< T, E, ScalarMultiplication< T, typename E::ValueType > >::ResultType >::type operator* (const T &t, const QuaternionExpression< E > &e)
 
template<typename E1 , typename E2 >
Scalar3QuaternionTernaryTraits< E1, E2, typename QuaternionNorm2< E2 >::ResultType, QuaternionDivision< E1, E2, typename QuaternionNorm2< E2 >::ResultType > >::ResultType operator/ (const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2QuaternionBinary1Traits< E, T, ScalarDivision< typename E::ValueType, T > >::ResultType >::type operator/ (const QuaternionExpression< E > &e, const T &t)
 
template<typename T , typename E >
std::enable_if< IsScalar< T >::value, typename Scalar13QuaternionTernaryTraits< T, E, typename QuaternionNorm2< E >::ResultType, ScalarQuaternionDivision< T, E, typename QuaternionNorm2< E >::ResultType > >::ResultType >::type operator/ (const T &t, const QuaternionExpression< E > &e)
 
template<typename E1 , typename E2 >
QuaternionEquality< E1, E2 >::ResultType operator== (const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
QuaternionEquality< E1, E2 >::ResultType operator!= (const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
 
template<typename E1 , typename E2 , typename T >
std::enable_if< std::is_arithmetic< T >::value, typename QuaternionToleranceEquality< E1, E2, T >::ResultType >::type equals (const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2, const T &eps)
 
template<typename E1 , typename E2 >
QuaternionBinary1Traits< E1, E2, ScalarDivision< typename E1::ValueType, typename E2::ValueType > >::ResultType elemDiv (const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
QuaternionBinary1Traits< E1, E2, ScalarMultiplication< typename E1::ValueType, typename E2::ValueType > >::ResultType elemProd (const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
 
template<typename E >
E::ValueType real (const QuaternionExpression< E > &e)
 
template<typename E >
QuaternionUnary2Traits< E, QuaternionUnreal< E > >::ResultType unreal (const QuaternionExpression< E > &e)
 
template<typename E >
QuaternionUnary2Traits< E, QuaternionConjugate< E > >::ResultType conj (const QuaternionExpression< E > &e)
 
template<typename E >
Scalar2QuaternionBinary2Traits< E, typename QuaternionNorm2< E >::ResultType, QuaternionInverse< E, typename QuaternionNorm2< E >::ResultType > >::ResultType inv (const QuaternionExpression< E > &e)
 
template<typename E >
QuaternionNorm< E >::ResultType norm (const QuaternionExpression< E > &e)
 
template<typename E >
QuaternionNorm2< E >::ResultType norm2 (const QuaternionExpression< E > &e)
 
template<typename E >
QuaternionElementSum< E >::ResultType sum (const QuaternionExpression< E > &e)
 
Range< std::size_t > range (std::size_t start, std::size_t stop)
 
template<typename T , typename C , typename GD , typename XF , typename V >
interpolateTrilinear (const RegularSpatialGrid< T, C, GD, XF > &grid, const V &pos, bool local_pos)
 
Slice< std::size_t, std::ptrdiff_t > slice (std::size_t start, std::ptrdiff_t stride, std::size_t size)
 
template<typename T >
factorial (unsigned int n)
 Computes the factorial \( n! \) of the non-negative integer n. More...
 
template<typename T >
pythag (const T &a, const T &b)
 Computes \( \sqrt{a^2 + b^2} \) without destructive underflow or overflow. More...
 
template<typename T1 , typename T2 >
T1 sign (const T1 &a, const T2 &b)
 Returns the magnitude of parameter a times the sign of parameter b. More...
 
template<typename T >
lnGamma (const T &z)
 Computes \( \ln[\Gamma(z)] \) for \( z > 0 \). More...
 
template<typename T >
gammaQ (const T &a, const T &x)
 Computes the incomplete gamma function \( Q(a, x) = 1 - P(a, x) \) (see [NRIC] for details). More...
 
template<typename T >
generalizedBell (const T &x, const T &a, const T &b, const T &c)
 Computes the generalized bell function \( Bell(x) = \frac{1}{1 + |\frac{x-c}{a}|^{2b}} \) at x. More...
 
template<typename M1 , typename V1 , typename M2 , typename V2 , typename V3 >
void svBackSubstitution (const M1 &u, const V1 &w, const M2 &v, const V2 &b, V3 &x)
 Solves \( A \cdot X = B \) for a vector \( X \) where \( A \) is given by its Singular Value Decomposition [WSVD]. More...
 
template<typename A , typename W , typename V >
bool svDecompose (MatrixExpression< A > &a, VectorExpression< W > &w, MatrixExpression< V > &v, std::size_t max_iter=0)
 Computes the Singular Value Decomposition [WSVD] \( A = UWV^T \) of a \( M \times N \)-dimensional matrix a. More...
 
template<typename U , typename W , typename V , typename B , typename X >
void svSubstitute (const MatrixExpression< U > &u, const VectorExpression< W > &w, const MatrixExpression< V > &v, const VectorExpression< B > &b, VectorExpression< X > &x)
 Solves \( A \cdot X = B \) for a vector \( X \) where \( A \) is given by its Singular Value Decomposition [WSVD]. More...
 
template<typename U , typename W , typename V , typename B , typename X >
void svSubstitute (const MatrixExpression< U > &u, const VectorExpression< W > &w, const MatrixExpression< V > &v, const MatrixExpression< B > &b, MatrixExpression< X > &x)
 Solves \( A \cdot X = B \) for a matrix \( X \) where \( A \) is given by its Singular Value Decomposition [WSVD]. More...
 
template<typename T1 , typename T2 >
CVector< typename CommonType< T1, T2 >::Type, 2 > vec (const T1 &t1, const T2 &t2)
 
template<typename T1 , typename T2 , typename T3 >
CVector< typename CommonType< typename CommonType< T1, T2 >::Type, T3 >::Type, 3 > vec (const T1 &t1, const T2 &t2, const T3 &t3)
 
template<typename T1 , typename T2 , typename T3 , typename T4 >
CVector< typename CommonType< typename CommonType< typename CommonType< T1, T2 >::Type, T3 >::Type, T4 >::Type, 4 > vec (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
 
template<typename E >
VectorQuaternionAdapter< E > quat (VectorExpression< E > &e)
 
template<typename E >
VectorQuaternionAdapter< const E > quat (const VectorExpression< E > &e)
 
template<typename E >
HomogenousCoordsAdapter< E > homog (VectorExpression< E > &e)
 
template<typename E >
HomogenousCoordsAdapter< const E > homog (const VectorExpression< E > &e)
 
template<typename T , std::size_t Dim, typename T1 >
void transform (VectorArray< CVector< T, Dim > > &va, const CMatrix< T1, Dim, Dim > &xform)
 Transforms each \( N \)-dimensional vector in the array with the \( N \)-dimensional square matrix xform. More...
 
template<typename T , std::size_t Dim, typename T1 >
void transform (VectorArray< CVector< T, Dim > > &va, const CMatrix< T1, Dim+1, Dim+1 > &xform)
 Transforms each \( N \)-dimensional vector in the array with the \( N+1 \)-dimensional square matrix xform. More...
 
template<typename T , std::size_t Dim, typename T1 >
bool calcCentroid (const VectorArray< CVector< T, Dim > > &va, CVector< T1, Dim > &ctr)
 Calculates the centroid of the array elements. More...
 
template<typename T , std::size_t Dim>
calcRMSD (const VectorArray< CVector< T, Dim > > &va1, const VectorArray< CVector< T, Dim > > &va2)
 
template<typename T , std::size_t Dim, typename T1 >
calcRMSD (const VectorArray< CVector< T, Dim > > &va1, const VectorArray< CVector< T, Dim > > &va2, const CMatrix< T1, Dim+1, Dim+1 > &va1_xform)
 
template<template< typename T1, typename T2 > class F, typename V , typename E >
void vectorAssignVector (V &v, const VectorExpression< E > &e)
 
template<template< typename T1, typename T2 > class F, typename V , typename T >
void vectorAssignScalar (V &v, const T &t)
 
template<typename V , typename E >
void vectorSwap (V &v, VectorExpression< E > &e)
 
template<typename E >
VectorUnaryTraits< E, ScalarNegation< typename E::ValueType > >::ResultType operator- (const VectorExpression< E > &e)
 
template<typename E >
const E & operator+ (const VectorExpression< E > &e)
 
template<typename E1 , typename E2 >
VectorBinary1Traits< E1, E2, ScalarAddition< typename E1::ValueType, typename E2::ValueType > >::ResultType operator+ (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
VectorBinary1Traits< E1, E2, ScalarSubtraction< typename E1::ValueType, typename E2::ValueType > >::ResultType operator- (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2VectorBinaryTraits< E, T, ScalarMultiplication< typename E::ValueType, T > >::ResultType >::type operator* (const VectorExpression< E > &e, const T &t)
 
template<typename T , typename E >
std::enable_if< IsScalar< T >::value, typename Scalar1VectorBinaryTraits< T, E, ScalarMultiplication< T, typename E::ValueType > >::ResultType >::type operator* (const T &t, const VectorExpression< E > &e)
 
template<typename E , typename T >
std::enable_if< IsScalar< T >::value, typename Scalar2VectorBinaryTraits< E, T, ScalarDivision< typename E::ValueType, T > >::ResultType >::type operator/ (const VectorExpression< E > &e, const T &t)
 
template<typename E1 , typename E2 >
VectorEquality< E1, E2 >::ResultType operator== (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
VectorEquality< E1, E2 >::ResultType operator!= (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 , typename T >
std::enable_if< std::is_arithmetic< T >::value, typename VectorToleranceEquality< E1, E2, T >::ResultType >::type equals (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2, const T &eps)
 
template<typename E >
VectorUnaryTraits< E, ScalarConjugation< typename E::ValueType > >::ResultType conj (const VectorExpression< E > &e)
 
template<typename E >
VectorUnaryTraits< E, ScalarConjugation< typename E::ValueType > >::ResultType herm (const VectorExpression< E > &e)
 
template<typename E >
VectorUnaryTraits< E, ScalarReal< typename E::ValueType > >::ResultType real (const VectorExpression< E > &e)
 
template<typename E >
VectorUnaryTraits< E, ScalarImaginary< typename E::ValueType > >::ResultType imag (const VectorExpression< E > &e)
 
template<typename E1 , typename E2 >
VectorBinary1Traits< E1, E2, ScalarDivision< typename E1::ValueType, typename E2::ValueType > >::ResultType elemDiv (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
VectorBinary1Traits< E1, E2, ScalarMultiplication< typename E1::ValueType, typename E2::ValueType > >::ResultType elemProd (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
VectorBinary2Traits< E1, E2, VectorCrossProduct< E1, E2 > >::ResultType crossProd (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 >
VectorInnerProduct< E1, E2 >::ResultType innerProd (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E1 , typename E2 , typename T >
VectorAngleCosine< E1, E2, T >::ResultType angleCos (const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2, const T &sd, bool clamp=true)
 
template<typename E >
VectorElementSum< E >::ResultType sum (const VectorExpression< E > &e)
 
template<typename E >
VectorNorm1< E >::ResultType norm1 (const VectorExpression< E > &e)
 
template<typename E >
VectorNorm2< E >::ResultType norm2 (const VectorExpression< E > &e)
 
template<typename E >
VectorNormInfinity< E >::ResultType normInf (const VectorExpression< E > &e)
 
template<typename E >
VectorNormInfinityIndex< E >::ResultType normInfIndex (const VectorExpression< E > &e)
 
template<typename E >
VectorNorm2< E >::ResultType length (const VectorExpression< E > &e)
 
template<typename E >
const E & trans (const VectorExpression< E > &e)
 
template<typename E >
E & trans (VectorExpression< E > &e)
 
template<typename E1 , typename E2 >
QuaternionVectorBinaryTraits< E1, E2, QuaternionVectorRotation< E1, E2 > >::ResultType rotate (const QuaternionExpression< E1 > &e1, const VectorExpression< E2 > &e2)
 
template<typename E >
VectorIteratorTraits< E >::IteratorType vectorBegin (VectorExpression< E > &e)
 
template<typename E >
VectorIteratorTraits< E >::IteratorType vectorEnd (VectorExpression< E > &e)
 
template<typename E >
VectorIteratorTraits< const E >::IteratorType vectorBegin (const VectorExpression< E > &e)
 
template<typename E >
VectorIteratorTraits< const E >::IteratorType vectorEnd (const VectorExpression< E > &e)
 
template<typename E >
VectorRange< E > range (VectorExpression< E > &e, const typename VectorRange< E >::RangeType &r)
 
template<typename E >
VectorRange< const E > range (const VectorExpression< E > &e, const typename VectorRange< const E >::RangeType &r)
 
template<typename E >
VectorRange< E > range (VectorExpression< E > &e, typename VectorRange< E >::RangeType::SizeType start, typename VectorRange< E >::RangeType::SizeType stop)
 
template<typename E >
VectorRange< const E > range (const VectorExpression< E > &e, typename VectorRange< const E >::RangeType::SizeType start, typename VectorRange< const E >::RangeType::SizeType stop)
 
template<typename E >
VectorSlice< E > slice (VectorExpression< E > &e, const typename VectorSlice< E >::SliceType &s)
 
template<typename E >
VectorSlice< const E > slice (const VectorExpression< E > &e, const typename VectorSlice< const E >::SliceType &s)
 
template<typename E >
VectorSlice< E > slice (VectorExpression< E > &e, typename VectorSlice< E >::SliceType::SizeType start, typename VectorSlice< E >::SliceType::DifferenceType stride, typename VectorSlice< E >::SliceType::SizeType size)
 
template<typename E >
VectorSlice< const E > slice (const VectorExpression< E > &e, typename VectorSlice< const E >::SliceType::SizeType start, typename VectorSlice< const E >::SliceType::DifferenceType stride, typename VectorSlice< const E >::SliceType::SizeType size)
 

Detailed Description

Contains classes and functions related to mathematics.

Typedef Documentation

◆ FScalingMatrix

◆ DScalingMatrix

◆ LScalingMatrix

◆ ULScalingMatrix

◆ FRotationMatrix

◆ DRotationMatrix

◆ LRotationMatrix

◆ ULRotationMatrix

◆ FTranslationMatrix

◆ DTranslationMatrix

◆ LTranslationMatrix

◆ ULTranslationMatrix

◆ FZeroGrid

◆ DZeroGrid

◆ FScalarGrid

◆ DScalarGrid

◆ FGrid

typedef Grid<float> CDPL::Math::FGrid

An unbounded dense grid holding floating point values of type float.

◆ DGrid

An unbounded dense grid holding floating point values of type double.

◆ FZeroMatrix

◆ DZeroMatrix

◆ LZeroMatrix

◆ ULZeroMatrix

typedef ZeroMatrix<unsigned long> CDPL::Math::ULZeroMatrix

◆ FScalarMatrix

◆ DScalarMatrix

◆ LScalarMatrix

◆ ULScalarMatrix

typedef ScalarMatrix<unsigned long> CDPL::Math::ULScalarMatrix

◆ FIdentityMatrix

◆ DIdentityMatrix

◆ LIdentityMatrix

◆ ULIdentityMatrix

◆ FMatrix

typedef Matrix<float> CDPL::Math::FMatrix

An unbounded dense matrix holding floating point values of type float..

◆ DMatrix

An unbounded dense matrix holding floating point values of type double..

◆ LMatrix

typedef Matrix<long> CDPL::Math::LMatrix

An unbounded dense matrix holding signed integers of type long.

◆ ULMatrix

typedef Matrix<unsigned long> CDPL::Math::ULMatrix

An unbounded dense matrix holding unsigned integers of type unsigned long.

◆ Matrix2F

typedef CMatrix<float, 2, 2> CDPL::Math::Matrix2F

A bounded 2x2 matrix holding floating point values of type float.

◆ Matrix3F

typedef CMatrix<float, 3, 3> CDPL::Math::Matrix3F

A bounded 3x3 matrix holding floating point values of type float.

◆ Matrix4F

typedef CMatrix<float, 4, 4> CDPL::Math::Matrix4F

A bounded 4x4 matrix holding floating point values of type float.

◆ Matrix2D

A bounded 2x2 matrix holding floating point values of type double.

◆ Matrix3D

A bounded 3x3 matrix holding floating point values of type double.

◆ Matrix4D

A bounded 4x4 matrix holding floating point values of type double.

◆ Matrix2L

typedef CMatrix<long, 2, 2> CDPL::Math::Matrix2L

A bounded 2x2 matrix holding signed integers of type long.

◆ Matrix3L

typedef CMatrix<long, 3, 3> CDPL::Math::Matrix3L

A bounded 3x3 matrix holding signed integers of type long.

◆ Matrix4L

typedef CMatrix<long, 4, 4> CDPL::Math::Matrix4L

A bounded 4x4 matrix holding signed integers of type long.

◆ Matrix2UL

typedef CMatrix<unsigned long, 2, 2> CDPL::Math::Matrix2UL

A bounded 2x2 matrix holding unsigned integers of type unsigned long.

◆ Matrix3UL

typedef CMatrix<unsigned long, 3, 3> CDPL::Math::Matrix3UL

A bounded 3x3 matrix holding unsigned integers of type unsigned long.

◆ Matrix4UL

typedef CMatrix<unsigned long, 4, 4> CDPL::Math::Matrix4UL

A bounded 4x4 matrix holding unsigned integers of type unsigned long.

◆ SparseFMatrix

An unbounded sparse matrix holding floating point values of type float..

◆ SparseDMatrix

An unbounded sparse matrix holding floating point values of type double..

◆ SparseLMatrix

An unbounded sparse matrix holding signed integers of type long.

◆ SparseULMatrix

typedef SparseMatrix<unsigned long> CDPL::Math::SparseULMatrix

An unbounded sparse matrix holding unsigned integers of type unsigned long.

◆ FQuaternion

◆ DQuaternion

◆ LQuaternion

◆ ULQuaternion

typedef Quaternion<unsigned long> CDPL::Math::ULQuaternion

◆ FRealQuaternion

◆ DRealQuaternion

◆ LRealQuaternion

◆ ULRealQuaternion

◆ FRegularSpatialGrid

An unbounded dense regular grid in 3D space holding floating point values of type float.

◆ DRegularSpatialGrid

An unbounded dense regular grid in 3D space holding floating point values of type double.

◆ FScalarVector

◆ DScalarVector

◆ LScalarVector

◆ ULScalarVector

typedef ScalarVector<unsigned long> CDPL::Math::ULScalarVector

◆ FZeroVector

◆ DZeroVector

◆ LZeroVector

◆ ULZeroVector

typedef ZeroVector<unsigned long> CDPL::Math::ULZeroVector

◆ FUnitVector

◆ DUnitVector

◆ LUnitVector

◆ ULUnitVector

typedef UnitVector<unsigned long> CDPL::Math::ULUnitVector

◆ Vector2F

typedef CVector<float, 2> CDPL::Math::Vector2F

A bounded 2 element vector holding floating point values of type float.

◆ Vector3F

typedef CVector<float, 3> CDPL::Math::Vector3F

A bounded 3 element vector holding floating point values of type float.

◆ Vector4F

typedef CVector<float, 4> CDPL::Math::Vector4F

A bounded 4 element vector holding floating point values of type float.

◆ Vector2D

A bounded 2 element vector holding floating point values of type double.

◆ Vector3D

A bounded 3 element vector holding floating point values of type double.

◆ Vector4D

A bounded 4 element vector holding floating point values of type double.

◆ Vector7D

A bounded 7 element vector holding floating point values of type double.

◆ Vector2L

typedef CVector<long, 2> CDPL::Math::Vector2L

A bounded 2 element vector holding signed integers of type long.

◆ Vector3L

typedef CVector<long, 3> CDPL::Math::Vector3L

A bounded 3 element vector holding signed integers of type long.

◆ Vector4L

typedef CVector<long, 4> CDPL::Math::Vector4L

A bounded 4 element vector holding signed integers of type long.

◆ Vector2UL

typedef CVector<unsigned long, 2> CDPL::Math::Vector2UL

A bounded 2 element vector holding unsigned integers of type unsigned long.

◆ Vector3UL

typedef CVector<unsigned long, 3> CDPL::Math::Vector3UL

A bounded 3 element vector holding unsigned integers of type unsigned long.

◆ Vector4UL

typedef CVector<unsigned long, 4> CDPL::Math::Vector4UL

A bounded 4 element vector holding unsigned integers of type unsigned long.

◆ FVector

typedef Vector<float> CDPL::Math::FVector

An unbounded dense vector holding floating point values of type float.

◆ DVector

An unbounded dense vector holding floating point values of type double.

◆ LVector

typedef Vector<long> CDPL::Math::LVector

An unbounded dense vector holding signed integers of type long.

◆ ULVector

typedef Vector<unsigned long> CDPL::Math::ULVector

An unbounded dense vector holding unsigned integers of type unsigned long.

◆ SparseFVector

An unbounded sparse vector holding floating point values of type float.

◆ SparseDVector

An unbounded sparse vector holding floating point values of type double.

◆ SparseLVector

An unbounded sparse vector holding signed integers of type long.

◆ SparseULVector

typedef SparseVector<unsigned long> CDPL::Math::SparseULVector

An unbounded sparse vector holding unsigned integers of type unsigned long.

◆ Vector2FArray

An array of Math::Vector2F objects.

◆ Vector3FArray

An array of Math::Vector3F objects.

◆ Vector2DArray

An array of Math::Vector2D objects.

◆ Vector3DArray

An array of Math::Vector3D objects.

◆ Vector2LArray

An array of Math::Vector2L objects.

◆ Vector3LArray

An array of Math::Vector3L objects.

◆ Vector2ULArray

An array of Math::Vector2UL objects.

◆ Vector3ULArray

An array of Math::Vector3UL objects.

Function Documentation

◆ direct() [1/2]

template<typename C >
DirectAssignmentProxy<const C> CDPL::Math::direct ( const C &  lvalue)

◆ direct() [2/2]

template<typename C >
DirectAssignmentProxy<C> CDPL::Math::direct ( C &  lvalue)

◆ gridAssignGrid()

template<template< typename T1, typename T2 > class F, typename G , typename E >
void CDPL::Math::gridAssignGrid ( G &  g,
const GridExpression< E > &  e 
)

◆ gridAssignScalar()

template<template< typename T1, typename T2 > class F, typename G , typename T >
void CDPL::Math::gridAssignScalar ( G &  g,
const T &  t 
)

◆ gridSwap()

template<typename G , typename E >
void CDPL::Math::gridSwap ( G &  g,
GridExpression< E > &  e 
)

◆ operator-() [1/10]

template<typename E >
GridUnaryTraits<E, ScalarNegation<typename E::ValueType> >::ResultType CDPL::Math::operator- ( const GridExpression< E > &  e)

◆ operator+() [1/10]

template<typename E >
const E& CDPL::Math::operator+ ( const GridExpression< E > &  e)

◆ operator+() [2/10]

template<typename E1 , typename E2 >
GridBinary1Traits<E1, E2, ScalarAddition<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::operator+ ( const GridExpression< E1 > &  e1,
const GridExpression< E2 > &  e2 
)

◆ operator-() [2/10]

template<typename E1 , typename E2 >
GridBinary1Traits<E1, E2, ScalarSubtraction<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::operator- ( const GridExpression< E1 > &  e1,
const GridExpression< E2 > &  e2 
)

◆ operator*() [1/12]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2GridBinaryTraits<E, T, ScalarMultiplication<typename E::ValueType, T> >::ResultType>::type CDPL::Math::operator* ( const GridExpression< E > &  e,
const T &  t 
)

◆ operator*() [2/12]

template<typename T , typename E >
std::enable_if<IsScalar<T>::value, typename Scalar1GridBinaryTraits<T, E, ScalarMultiplication<T, typename E::ValueType> >::ResultType>::type CDPL::Math::operator* ( const T &  t,
const GridExpression< E > &  e 
)

◆ operator/() [1/6]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2GridBinaryTraits<E, T, ScalarDivision<typename E::ValueType, T> >::ResultType>::type CDPL::Math::operator/ ( const GridExpression< E > &  e,
const T &  t 
)

◆ operator==() [1/4]

template<typename E1 , typename E2 >
GridEquality<E1, E2>::ResultType CDPL::Math::operator== ( const GridExpression< E1 > &  e1,
const GridExpression< E2 > &  e2 
)

◆ operator!=() [1/4]

template<typename E1 , typename E2 >
GridEquality<E1, E2>::ResultType CDPL::Math::operator!= ( const GridExpression< E1 > &  e1,
const GridExpression< E2 > &  e2 
)

◆ equals() [1/4]

template<typename E1 , typename E2 , typename T >
std::enable_if<std::is_arithmetic<T>::value, typename GridToleranceEquality<E1, E2, T>::ResultType>::type CDPL::Math::equals ( const GridExpression< E1 > &  e1,
const GridExpression< E2 > &  e2,
const T &  eps 
)

◆ conj() [1/4]

template<typename E >
GridUnaryTraits<E, ScalarConjugation<typename E::ValueType> >::ResultType CDPL::Math::conj ( const GridExpression< E > &  e)

◆ herm() [1/3]

template<typename E >
GridUnaryTraits<E, ScalarConjugation<typename E::ValueType> >::ResultType CDPL::Math::herm ( const GridExpression< E > &  e)

◆ real() [1/4]

template<typename E >
GridUnaryTraits<E, ScalarReal<typename E::ValueType> >::ResultType CDPL::Math::real ( const GridExpression< E > &  e)

◆ imag() [1/3]

template<typename E >
GridUnaryTraits<E, ScalarImaginary<typename E::ValueType> >::ResultType CDPL::Math::imag ( const GridExpression< E > &  e)

◆ elemDiv() [1/4]

template<typename E1 , typename E2 >
GridBinary1Traits<E1, E2, ScalarDivision<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::elemDiv ( const GridExpression< E1 > &  e1,
const GridExpression< E2 > &  e2 
)

◆ elemProd() [1/4]

template<typename E1 , typename E2 >
GridBinary1Traits<E1, E2, ScalarMultiplication<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::elemProd ( const GridExpression< E1 > &  e1,
const GridExpression< E2 > &  e2 
)

◆ sum() [1/4]

template<typename E >
GridElementSum<E>::ResultType CDPL::Math::sum ( const GridExpression< E > &  e)

◆ operator<<() [1/4]

template<typename C , typename T , typename E >
std::basic_ostream<C, T>& CDPL::Math::operator<< ( std::basic_ostream< C, T > &  os,
const VectorExpression< E > &  e 
)

◆ operator<<() [2/4]

template<typename C , typename T , typename E >
std::basic_ostream<C, T>& CDPL::Math::operator<< ( std::basic_ostream< C, T > &  os,
const MatrixExpression< E > &  e 
)

◆ operator<<() [3/4]

template<typename C , typename T , typename E >
std::basic_ostream<C, T>& CDPL::Math::operator<< ( std::basic_ostream< C, T > &  os,
const QuaternionExpression< E > &  e 
)

◆ operator<<() [4/4]

template<typename C , typename T , typename E >
std::basic_ostream<C, T>& CDPL::Math::operator<< ( std::basic_ostream< C, T > &  os,
const GridExpression< E > &  e 
)

◆ jacobiDiagonalize()

template<typename M1 , typename V , typename M2 >
bool CDPL::Math::jacobiDiagonalize ( MatrixExpression< M1 > &  a,
VectorExpression< V > &  d,
MatrixExpression< M2 > &  v,
std::size_t  max_iter = 50 
)

Computes all eigenvalues and eigenvectors of a real symmetric matrix an using Jacobi's algorithm [WJACO ].

On output, elements of a above the diagonal are destroyed. The vector d returns the eigenvalues of a. The columns of matrix v contain, on output, the normalized eigenvectors of a. For implementation details see [NRIC].

Parameters
aThe real symmetric matrix for which to compute eigenvalues and eigenvectors.
dThe output vector which will contain the eigenvalues of a.
vThe matrix whose columns will contain the normalized eigenvectors of a.
max_iterThe maximum number of iterations to perform.
Returns
true if a is a non-empty symmetric matrix and convergence has been reached in max_iter iterations, and false otherwise.
Precondition
a is symmetric and non-empty, i.e. a().getSize1() == a().getSize2() && a().getSize1() != 0, and furthermore d().getSize() >= a().getSize1().
Exceptions
Base::SizeErrorif preconditions are violated.

◆ solveLower() [1/2]

template<typename E1 , typename E2 >
bool CDPL::Math::solveLower ( const MatrixExpression< E1 > &  e1,
VectorExpression< E2 > &  e2 
)

◆ solveUnitLower() [1/2]

template<typename E1 , typename E2 >
bool CDPL::Math::solveUnitLower ( const MatrixExpression< E1 > &  e1,
VectorExpression< E2 > &  e2 
)

◆ solveLower() [2/2]

template<typename E1 , typename E2 >
bool CDPL::Math::solveLower ( const MatrixExpression< E1 > &  e1,
MatrixExpression< E2 > &  e2 
)

◆ solveUnitLower() [2/2]

template<typename E1 , typename E2 >
bool CDPL::Math::solveUnitLower ( const MatrixExpression< E1 > &  e1,
MatrixExpression< E2 > &  e2 
)

◆ solveUpper() [1/2]

template<typename E1 , typename E2 >
bool CDPL::Math::solveUpper ( const MatrixExpression< E1 > &  e1,
VectorExpression< E2 > &  e2 
)

◆ solveUnitUpper() [1/2]

template<typename E1 , typename E2 >
bool CDPL::Math::solveUnitUpper ( const MatrixExpression< E1 > &  e1,
VectorExpression< E2 > &  e2 
)

◆ solveUpper() [2/2]

template<typename E1 , typename E2 >
bool CDPL::Math::solveUpper ( const MatrixExpression< E1 > &  e1,
MatrixExpression< E2 > &  e2 
)

◆ solveUnitUpper() [2/2]

template<typename E1 , typename E2 >
bool CDPL::Math::solveUnitUpper ( const MatrixExpression< E1 > &  e1,
MatrixExpression< E2 > &  e2 
)

◆ luDecompose() [1/2]

template<typename E >
E::SizeType CDPL::Math::luDecompose ( MatrixExpression< E > &  e)

◆ luDecompose() [2/2]

template<typename E , typename PV , typename T >
E::SizeType CDPL::Math::luDecompose ( MatrixExpression< E > &  e,
PV &  pv,
T &  num_row_swaps 
)

◆ swapRows() [1/2]

template<typename E , typename PV >
void CDPL::Math::swapRows ( VectorExpression< E > &  e,
const PV &  pv 
)

◆ swapRows() [2/2]

template<typename E , typename PV >
void CDPL::Math::swapRows ( MatrixExpression< E > &  e,
const PV &  pv 
)

◆ luSubstitute() [1/4]

template<typename E1 , typename E2 >
bool CDPL::Math::luSubstitute ( const MatrixExpression< E1 > &  lu,
VectorExpression< E2 > &  b 
)

◆ luSubstitute() [2/4]

template<typename E1 , typename E2 , typename PV >
bool CDPL::Math::luSubstitute ( const MatrixExpression< E1 > &  lu,
const PV &  pv,
VectorExpression< E2 > &  b 
)

◆ luSubstitute() [3/4]

template<typename E1 , typename E2 >
bool CDPL::Math::luSubstitute ( const MatrixExpression< E1 > &  lu,
MatrixExpression< E2 > &  b 
)

◆ luSubstitute() [4/4]

template<typename E1 , typename E2 , typename PV >
bool CDPL::Math::luSubstitute ( const MatrixExpression< E1 > &  lu,
const PV &  pv,
MatrixExpression< E2 > &  b 
)

◆ det() [1/2]

template<typename E >
E::ValueType CDPL::Math::det ( const MatrixExpression< E > &  e)

◆ det() [2/2]

template<typename C >
C::ValueType CDPL::Math::det ( const MatrixContainer< C > &  c)

◆ invert() [1/2]

template<typename E , typename C >
bool CDPL::Math::invert ( const MatrixExpression< E > &  e,
MatrixContainer< C > &  c 
)

◆ invert() [2/2]

template<typename C >
bool CDPL::Math::invert ( MatrixContainer< C > &  c)

◆ triang() [1/2]

template<typename Tri , typename E >
TriangularAdapter<E, Tri> CDPL::Math::triang ( MatrixExpression< E > &  e)

◆ triang() [2/2]

template<typename Tri , typename E >
TriangularAdapter<const E, Tri> CDPL::Math::triang ( const MatrixExpression< E > &  e)

◆ matrixAssignMatrix()

template<template< typename T1, typename T2 > class F, typename M , typename E >
void CDPL::Math::matrixAssignMatrix ( M &  m,
const MatrixExpression< E > &  e 
)

◆ matrixAssignScalar()

template<template< typename T1, typename T2 > class F, typename M , typename T >
void CDPL::Math::matrixAssignScalar ( M &  m,
const T &  t 
)

◆ matrixSwap()

template<typename M , typename E >
void CDPL::Math::matrixSwap ( M &  m,
MatrixExpression< E > &  e 
)

◆ operator-() [3/10]

template<typename E >
MatrixUnaryTraits<E, ScalarNegation<typename E::ValueType> >::ResultType CDPL::Math::operator- ( const MatrixExpression< E > &  e)

◆ operator+() [3/10]

template<typename E >
const E& CDPL::Math::operator+ ( const MatrixExpression< E > &  e)

◆ operator+() [4/10]

template<typename E1 , typename E2 >
MatrixBinary1Traits<E1, E2, ScalarAddition<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::operator+ ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ operator-() [4/10]

template<typename E1 , typename E2 >
MatrixBinary1Traits<E1, E2, ScalarSubtraction<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::operator- ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ operator*() [3/12]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2MatrixBinaryTraits<E, T, ScalarMultiplication<typename E::ValueType, T> >::ResultType>::type CDPL::Math::operator* ( const MatrixExpression< E > &  e,
const T &  t 
)

◆ operator*() [4/12]

template<typename T , typename E >
std::enable_if<IsScalar<T>::value, typename Scalar1MatrixBinaryTraits<T, E, ScalarMultiplication<T, typename E::ValueType> >::ResultType>::type CDPL::Math::operator* ( const T &  t,
const MatrixExpression< E > &  e 
)

◆ operator/() [2/6]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2MatrixBinaryTraits<E, T, ScalarDivision<typename E::ValueType, T> >::ResultType>::type CDPL::Math::operator/ ( const MatrixExpression< E > &  e,
const T &  t 
)

◆ operator==() [2/4]

template<typename E1 , typename E2 >
MatrixEquality<E1, E2>::ResultType CDPL::Math::operator== ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ operator!=() [2/4]

template<typename E1 , typename E2 >
MatrixEquality<E1, E2>::ResultType CDPL::Math::operator!= ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ equals() [2/4]

template<typename E1 , typename E2 , typename T >
std::enable_if<std::is_arithmetic<T>::value, typename MatrixToleranceEquality<E1, E2, T>::ResultType>::type CDPL::Math::equals ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2,
const T &  eps 
)

◆ conj() [2/4]

template<typename E >
MatrixUnaryTraits<E, ScalarConjugation<typename E::ValueType> >::ResultType CDPL::Math::conj ( const MatrixExpression< E > &  e)

◆ herm() [2/3]

template<typename E >
MatrixUnaryTraits<E, ScalarConjugation<typename E::ValueType> >::ResultType CDPL::Math::herm ( const MatrixExpression< E > &  e)

◆ real() [2/4]

template<typename E >
MatrixUnaryTraits<E, ScalarReal<typename E::ValueType> >::ResultType CDPL::Math::real ( const MatrixExpression< E > &  e)

◆ imag() [2/3]

template<typename E >
MatrixUnaryTraits<E, ScalarImaginary<typename E::ValueType> >::ResultType CDPL::Math::imag ( const MatrixExpression< E > &  e)

◆ outerProd()

template<typename E1 , typename E2 >
VectorMatrixBinaryTraits<E1, E2, ScalarMultiplication<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::outerProd ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ elemDiv() [2/4]

template<typename E1 , typename E2 >
MatrixBinary1Traits<E1, E2, ScalarDivision<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::elemDiv ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ elemProd() [2/4]

template<typename E1 , typename E2 >
MatrixBinary1Traits<E1, E2, ScalarMultiplication<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::elemProd ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ operator*() [5/12]

template<typename E1 , typename E2 >
Matrix1VectorBinaryTraits<E1, E2, MatrixVectorProduct<E1, E2> >::ResultType CDPL::Math::operator* ( const MatrixExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ prod() [1/6]

template<typename E1 , typename E2 >
Matrix1VectorBinaryTraits<E1, E2, MatrixVectorProduct<E1, E2> >::ResultType CDPL::Math::prod ( const MatrixExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ prod() [2/6]

template<typename C , typename E1 , typename E2 >
C& CDPL::Math::prod ( const MatrixExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2,
VectorContainer< C > &  c 
)

◆ operator*() [6/12]

template<typename E1 , typename E2 >
Matrix2VectorBinaryTraits<E1, E2, VectorMatrixProduct<E1, E2> >::ResultType CDPL::Math::operator* ( const VectorExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ prod() [3/6]

template<typename E1 , typename E2 >
Matrix2VectorBinaryTraits<E1, E2, VectorMatrixProduct<E1, E2> >::ResultType CDPL::Math::prod ( const VectorExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ prod() [4/6]

template<typename C , typename E1 , typename E2 >
C& CDPL::Math::prod ( const VectorExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2,
VectorContainer< C > &  c 
)

◆ operator*() [7/12]

template<typename E1 , typename E2 >
MatrixBinary2Traits<E1, E2, MatrixProduct<E1, E2> >::ResultType CDPL::Math::operator* ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ prod() [5/6]

template<typename E1 , typename E2 >
MatrixBinary2Traits<E1, E2, MatrixProduct<E1, E2> >::ResultType CDPL::Math::prod ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2 
)

◆ prod() [6/6]

template<typename C , typename E1 , typename E2 >
C& CDPL::Math::prod ( const MatrixExpression< E1 > &  e1,
const MatrixExpression< E2 > &  e2,
MatrixContainer< C > &  c 
)

◆ trace()

template<typename E >
MatrixTrace<E>::ResultType CDPL::Math::trace ( const MatrixExpression< E > &  e)

◆ norm1() [1/2]

template<typename E >
MatrixNorm1<E>::ResultType CDPL::Math::norm1 ( const MatrixExpression< E > &  e)

◆ normFrob()

template<typename E >
MatrixNormFrobenius<E>::ResultType CDPL::Math::normFrob ( const MatrixExpression< E > &  e)

◆ normInf() [1/2]

template<typename E >
MatrixNormInfinity<E>::ResultType CDPL::Math::normInf ( const MatrixExpression< E > &  e)

◆ diag()

template<typename E >
VectorMatrixUnaryTraits<E, DiagonalMatrixFromVector<E> >::ResultType CDPL::Math::diag ( const VectorExpression< E > &  e)

◆ cross()

template<typename E >
VectorMatrixUnaryTraits<E, CrossProductMatrixFromVector<E> >::ResultType CDPL::Math::cross ( const VectorExpression< E > &  e)

◆ trans() [1/4]

template<typename E >
MatrixTranspose<E> CDPL::Math::trans ( MatrixExpression< E > &  e)

◆ trans() [2/4]

template<typename E >
MatrixTranspose<const E> CDPL::Math::trans ( const MatrixExpression< E > &  e)

◆ sum() [2/4]

template<typename E >
MatrixElementSum<E>::ResultType CDPL::Math::sum ( const MatrixExpression< E > &  e)

◆ row() [1/2]

template<typename M >
MatrixRow<M> CDPL::Math::row ( MatrixExpression< M > &  e,
typename MatrixRow< M >::SizeType  i 
)

◆ row() [2/2]

template<typename M >
MatrixRow<const M> CDPL::Math::row ( const MatrixExpression< M > &  e,
typename MatrixRow< const M >::SizeType  i 
)

◆ column() [1/2]

template<typename M >
MatrixColumn<M> CDPL::Math::column ( MatrixExpression< M > &  e,
typename MatrixColumn< M >::SizeType  j 
)

◆ column() [2/2]

template<typename M >
MatrixColumn<const M> CDPL::Math::column ( const MatrixExpression< M > &  e,
typename MatrixColumn< const M >::SizeType  j 
)

◆ range() [1/9]

template<typename E >
MatrixRange<E> CDPL::Math::range ( MatrixExpression< E > &  e,
const typename MatrixRange< E >::RangeType &  r1,
const typename MatrixRange< E >::RangeType &  r2 
)

◆ range() [2/9]

template<typename E >
MatrixRange<const E> CDPL::Math::range ( const MatrixExpression< E > &  e,
const typename MatrixRange< const E >::RangeType &  r1,
const typename MatrixRange< const E >::RangeType &  r2 
)

◆ range() [3/9]

template<typename E >
MatrixRange<E> CDPL::Math::range ( MatrixExpression< E > &  e,
typename MatrixRange< E >::RangeType::SizeType  start1,
typename MatrixRange< E >::RangeType::SizeType  stop1,
typename MatrixRange< E >::RangeType::SizeType  start2,
typename MatrixRange< E >::RangeType::SizeType  stop2 
)

◆ range() [4/9]

template<typename E >
MatrixRange<const E> CDPL::Math::range ( const MatrixExpression< E > &  e,
typename MatrixRange< const E >::RangeType::SizeType  start1,
typename MatrixRange< const E >::RangeType::SizeType  stop1,
typename MatrixRange< const E >::RangeType::SizeType  start2,
typename MatrixRange< const E >::RangeType::SizeType  stop2 
)

◆ slice() [1/9]

template<typename E >
MatrixSlice<E> CDPL::Math::slice ( MatrixExpression< E > &  e,
const typename MatrixSlice< E >::SliceType &  s1,
const typename MatrixSlice< E >::SliceType &  s2 
)

◆ slice() [2/9]

template<typename E >
MatrixSlice<const E> CDPL::Math::slice ( const MatrixExpression< E > &  e,
const typename MatrixSlice< const E >::SliceType &  s1,
const typename MatrixSlice< const E >::SliceType &  s2 
)

◆ slice() [3/9]

template<typename E >
MatrixSlice<E> CDPL::Math::slice ( MatrixExpression< E > &  e,
typename MatrixSlice< E >::SliceType::SizeType  start1,
typename MatrixSlice< E >::SliceType::DifferenceType  stride1,
typename MatrixSlice< E >::SliceType::SizeType  size1,
typename MatrixSlice< E >::SliceType::SizeType  start2,
typename MatrixSlice< E >::SliceType::DifferenceType  stride2,
typename MatrixSlice< E >::SliceType::SizeType  size2 
)

◆ slice() [4/9]

template<typename E >
MatrixSlice<const E> CDPL::Math::slice ( const MatrixExpression< E > &  e,
typename MatrixSlice< const E >::SliceType::SizeType  start1,
typename MatrixSlice< const E >::SliceType::DifferenceType  stride1,
typename MatrixSlice< const E >::SliceType::SizeType  size1,
typename MatrixSlice< const E >::SliceType::SizeType  start2,
typename MatrixSlice< const E >::SliceType::DifferenceType  stride2,
typename MatrixSlice< const E >::SliceType::SizeType  size2 
)

◆ quat() [1/6]

template<typename T >
std::enable_if<IsScalar<T>::value, RealQuaternion<T> >::type CDPL::Math::quat ( const T &  t)

◆ quat() [2/6]

template<typename T1 , typename T2 >
Quaternion<typename CommonType<T1, T2>::Type> CDPL::Math::quat ( const T1 &  t1,
const T2 &  t2 
)

◆ quat() [3/6]

template<typename T1 , typename T2 , typename T3 >
Quaternion<typename CommonType<typename CommonType<T1, T2>::Type, T3>::Type> CDPL::Math::quat ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3 
)

◆ quat() [4/6]

template<typename T1 , typename T2 , typename T3 , typename T4 >
Quaternion<typename CommonType<typename CommonType<typename CommonType<T1, T2>::Type, T3>::Type, T4>::Type> CDPL::Math::quat ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4 
)

◆ vec() [1/5]

template<typename E >
QuaternionVectorAdapter<E> CDPL::Math::vec ( QuaternionExpression< E > &  e)

◆ vec() [2/5]

template<typename E >
QuaternionVectorAdapter<const E> CDPL::Math::vec ( const QuaternionExpression< E > &  e)

◆ quaternionAssignQuaternion()

template<template< typename T1, typename T2 > class F, typename Q , typename E >
void CDPL::Math::quaternionAssignQuaternion ( Q &  q,
const QuaternionExpression< E > &  e 
)

◆ quaternionAssignScalar()

template<template< typename T1, typename T2 > class F, typename Q , typename T >
void CDPL::Math::quaternionAssignScalar ( Q &  q,
const T &  t 
)

◆ quaternionSwap()

template<typename Q , typename E >
void CDPL::Math::quaternionSwap ( Q &  q,
QuaternionExpression< E > &  e 
)

◆ operator-() [5/10]

template<typename E >
QuaternionUnary1Traits<E, ScalarNegation<typename E::ValueType> >::ResultType CDPL::Math::operator- ( const QuaternionExpression< E > &  e)

◆ operator+() [5/10]

template<typename E >
const E& CDPL::Math::operator+ ( const QuaternionExpression< E > &  e)

◆ operator+() [6/10]

template<typename E1 , typename E2 >
QuaternionBinary1Traits<E1, E2, ScalarAddition<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::operator+ ( const QuaternionExpression< E1 > &  e1,
const QuaternionExpression< E2 > &  e2 
)

◆ operator+() [7/10]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2QuaternionBinary2Traits<E, T, Scalar2QuaternionAddition<E, T> >::ResultType>::type CDPL::Math::operator+ ( const QuaternionExpression< E > &  e,
const T &  t 
)

◆ operator+() [8/10]

template<typename T , typename E >
std::enable_if<IsScalar<T>::value, typename Scalar1QuaternionBinary2Traits<T, E, Scalar1QuaternionAddition<T, E> >::ResultType>::type CDPL::Math::operator+ ( const T &  t,
const QuaternionExpression< E > &  e 
)

◆ operator-() [6/10]

template<typename E1 , typename E2 >
QuaternionBinary1Traits<E1, E2, ScalarSubtraction<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::operator- ( const QuaternionExpression< E1 > &  e1,
const QuaternionExpression< E2 > &  e2 
)

◆ operator-() [7/10]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2QuaternionBinary2Traits<E, T, Scalar2QuaternionSubtraction<E, T> >::ResultType>::type CDPL::Math::operator- ( const QuaternionExpression< E > &  e,
const T &  t 
)

◆ operator-() [8/10]

template<typename T , typename E >
std::enable_if<IsScalar<T>::value, typename Scalar1QuaternionBinary2Traits<T, E, Scalar1QuaternionSubtraction<T, E> >::ResultType>::type CDPL::Math::operator- ( const T &  t,
const QuaternionExpression< E > &  e 
)

◆ operator*() [8/12]

template<typename E1 , typename E2 >
QuaternionBinary2Traits<E1, E2, QuaternionProduct<E1, E2> >::ResultType CDPL::Math::operator* ( const QuaternionExpression< E1 > &  e1,
const QuaternionExpression< E2 > &  e2 
)

◆ operator*() [9/12]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2QuaternionBinary1Traits<E, T, ScalarMultiplication<typename E::ValueType, T> >::ResultType>::type CDPL::Math::operator* ( const QuaternionExpression< E > &  e,
const T &  t 
)

◆ operator*() [10/12]

template<typename T , typename E >
std::enable_if<IsScalar<T>::value, typename Scalar1QuaternionBinary1Traits<T, E, ScalarMultiplication<T, typename E::ValueType> >::ResultType>::type CDPL::Math::operator* ( const T &  t,
const QuaternionExpression< E > &  e 
)

◆ operator/() [3/6]

template<typename E1 , typename E2 >
Scalar3QuaternionTernaryTraits<E1, E2, typename QuaternionNorm2<E2>::ResultType, QuaternionDivision<E1, E2, typename QuaternionNorm2<E2>::ResultType> >::ResultType CDPL::Math::operator/ ( const QuaternionExpression< E1 > &  e1,
const QuaternionExpression< E2 > &  e2 
)

◆ operator/() [4/6]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2QuaternionBinary1Traits<E, T, ScalarDivision<typename E::ValueType, T> >::ResultType>::type CDPL::Math::operator/ ( const QuaternionExpression< E > &  e,
const T &  t 
)

◆ operator/() [5/6]

template<typename T , typename E >
std::enable_if<IsScalar<T>::value, typename Scalar13QuaternionTernaryTraits<T, E, typename QuaternionNorm2<E>::ResultType, ScalarQuaternionDivision<T, E, typename QuaternionNorm2<E>::ResultType> >::ResultType>::type CDPL::Math::operator/ ( const T &  t,
const QuaternionExpression< E > &  e 
)

◆ operator==() [3/4]

template<typename E1 , typename E2 >
QuaternionEquality<E1, E2>::ResultType CDPL::Math::operator== ( const QuaternionExpression< E1 > &  e1,
const QuaternionExpression< E2 > &  e2 
)

◆ operator!=() [3/4]

template<typename E1 , typename E2 >
QuaternionEquality<E1, E2>::ResultType CDPL::Math::operator!= ( const QuaternionExpression< E1 > &  e1,
const QuaternionExpression< E2 > &  e2 
)

◆ equals() [3/4]

template<typename E1 , typename E2 , typename T >
std::enable_if<std::is_arithmetic<T>::value, typename QuaternionToleranceEquality<E1, E2, T>::ResultType>::type CDPL::Math::equals ( const QuaternionExpression< E1 > &  e1,
const QuaternionExpression< E2 > &  e2,
const T &  eps 
)

◆ elemDiv() [3/4]

template<typename E1 , typename E2 >
QuaternionBinary1Traits<E1, E2, ScalarDivision<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::elemDiv ( const QuaternionExpression< E1 > &  e1,
const QuaternionExpression< E2 > &  e2 
)

◆ elemProd() [3/4]

template<typename E1 , typename E2 >
QuaternionBinary1Traits<E1, E2, ScalarMultiplication<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::elemProd ( const QuaternionExpression< E1 > &  e1,
const QuaternionExpression< E2 > &  e2 
)

◆ real() [3/4]

template<typename E >
E::ValueType CDPL::Math::real ( const QuaternionExpression< E > &  e)

◆ unreal()

template<typename E >
QuaternionUnary2Traits<E, QuaternionUnreal<E> >::ResultType CDPL::Math::unreal ( const QuaternionExpression< E > &  e)

◆ conj() [3/4]

template<typename E >
QuaternionUnary2Traits<E, QuaternionConjugate<E> >::ResultType CDPL::Math::conj ( const QuaternionExpression< E > &  e)

◆ inv()

template<typename E >
Scalar2QuaternionBinary2Traits<E, typename QuaternionNorm2<E>::ResultType, QuaternionInverse<E, typename QuaternionNorm2<E>::ResultType> >::ResultType CDPL::Math::inv ( const QuaternionExpression< E > &  e)

◆ norm()

template<typename E >
QuaternionNorm<E>::ResultType CDPL::Math::norm ( const QuaternionExpression< E > &  e)

◆ norm2() [1/2]

template<typename E >
QuaternionNorm2<E>::ResultType CDPL::Math::norm2 ( const QuaternionExpression< E > &  e)

◆ sum() [3/4]

template<typename E >
QuaternionElementSum<E>::ResultType CDPL::Math::sum ( const QuaternionExpression< E > &  e)

◆ range() [5/9]

Range<std::size_t> CDPL::Math::range ( std::size_t  start,
std::size_t  stop 
)
inline

◆ interpolateTrilinear()

template<typename T , typename C , typename GD , typename XF , typename V >
T CDPL::Math::interpolateTrilinear ( const RegularSpatialGrid< T, C, GD, XF > &  grid,
const V pos,
bool  local_pos 
)

◆ slice() [5/9]

Slice<std::size_t, std::ptrdiff_t> CDPL::Math::slice ( std::size_t  start,
std::ptrdiff_t  stride,
std::size_t  size 
)
inline

◆ factorial()

template<typename T >
T CDPL::Math::factorial ( unsigned int  n)

Computes the factorial \( n! \) of the non-negative integer n.

Parameters
nThe non-negative integer for which to compute the factorial.
Returns
The computed factorial of n.

◆ pythag()

template<typename T >
T CDPL::Math::pythag ( const T &  a,
const T &  b 
)

Computes \( \sqrt{a^2 + b^2} \) without destructive underflow or overflow.

Parameters
aThe variable a.
bThe variable b.
Returns
The result of computing \( \sqrt{a^2 + b^2} \).

◆ sign()

template<typename T1 , typename T2 >
T1 CDPL::Math::sign ( const T1 &  a,
const T2 &  b 
)

Returns the magnitude of parameter a times the sign of parameter b.

Parameters
aThe parameter a.
bThe parameter b.
Returns
a times the sign of parameter b.

◆ lnGamma()

template<typename T >
T CDPL::Math::lnGamma ( const T &  z)

Computes \( \ln[\Gamma(z)] \) for \( z > 0 \).

Parameters
zThe argument to the gamma function.
Returns
The computed logarithm of the gamma function value for z.

◆ gammaQ()

template<typename T >
T CDPL::Math::gammaQ ( const T &  a,
const T &  x 
)

Computes the incomplete gamma function \( Q(a, x) = 1 - P(a, x) \) (see [NRIC] for details).

Parameters
aThe function argument a.
xThe function argument x.
Returns
The computed value of the incomplete gamma function.

◆ generalizedBell()

template<typename T >
T CDPL::Math::generalizedBell ( const T &  x,
const T &  a,
const T &  b,
const T &  c 
)

Computes the generalized bell function \( Bell(x) = \frac{1}{1 + |\frac{x-c}{a}|^{2b}} \) at x.

Parameters
xThe generalized bell function argument
aControls the width of the curve at \(f(x) = 0.5 \).
bControls the slope of the curve at \( x = c - a \) and \( x = c + a \).
cLocates the center of the curve.
Returns
The generalized bell function value at x.

◆ svBackSubstitution()

template<typename M1 , typename V1 , typename M2 , typename V2 , typename V3 >
void CDPL::Math::svBackSubstitution ( const M1 &  u,
const V1 &  w,
const M2 &  v,
const V2 &  b,
V3 &  x 
)

Solves \( A \cdot X = B \) for a vector \( X \) where \( A \) is given by its Singular Value Decomposition [WSVD].

The \( M \times N \)-dimensional matrix \( A \) is specified by its singular value decomposition \( A = UWV^T \), where \( U \) is given by the \( M \times N \)-dimensional matrix u, \( W \) by the \( N \)-dimensional vector w, and \( V \) is given by the \( N \times N \)-dimensional matrix v. The right-hand side vector \( B \) is given by the \( M \)-dimensional vector b, and x is the \( N \)-dimensional output solution vector \( X \). No input quantities are destroyed, so the routine may be called sequentially with different arguments b. For implementation details see [NRIC].

Parameters
uThe \( M \times N \)-dimensional matrix \( U \).
wThe \( N \)-dimensional vector \( W \) holding the singular values of \( A \).
vThe \( N \times N \)-dimensional matrix \( V \).
bThe \( M \)-dimensional right-hand side vector \( B \).
xThe \( N \)-dimensional output solution vector \( X \).
Precondition
w.size() == u.size2(), v.size1() == u.size2() && v.size2() == c.size2(), and b.size() == u.size1().
See also
svDecomposition()

◆ svDecompose()

template<typename A , typename W , typename V >
bool CDPL::Math::svDecompose ( MatrixExpression< A > &  a,
VectorExpression< W > &  w,
MatrixExpression< V > &  v,
std::size_t  max_iter = 0 
)

Computes the Singular Value Decomposition [WSVD] \( A = UWV^T \) of a \( M \times N \)-dimensional matrix a.

The matrix \( U \) replaces a on output. The diagonal matrix of singular values \( W \) is output as the \( N \)-dimensional vector w. The matrix \( V \) (not the transpose \( V^T \)) is output as the \( N \times N \)-dimensional matrix v. For implementation details see [NRIC].

Parameters
aThe decomposed \( M \times N \)-matrix \( A \) which will be replaced by \( U \) on output.
wThe \( N \)-dimensional output vector \( W \) holding the singular values.
vThe \( N \times N \)-dimensional output matrix \( V \).
max_iterThe maximum number of iterations to perform, or 0 if no limit.
Returns
true if convergence has been reached in max_iter iterations, and false otherwise.
Precondition
w().getSize() >= a().getSize2(), v().getSize1() >= a().getSize2() and v().getSize2() >= a().getSize2().
Exceptions
Base::SizeErrorif preconditions are violated.

◆ svSubstitute() [1/2]

template<typename U , typename W , typename V , typename B , typename X >
void CDPL::Math::svSubstitute ( const MatrixExpression< U > &  u,
const VectorExpression< W > &  w,
const MatrixExpression< V > &  v,
const VectorExpression< B > &  b,
VectorExpression< X > &  x 
)

Solves \( A \cdot X = B \) for a vector \( X \) where \( A \) is given by its Singular Value Decomposition [WSVD].

The \( M \times N \)-dimensional matrix \( A \) is specified by its singular value decomposition \( A = UWV^T \), where \( U \) is given by the \( M \times N \)-dimensional matrix u, \( W \) by the \( N \)-dimensional vector w, and \( V \) is provided by the \( N \times N \)-dimensional matrix v. The right-hand side vector \( B \) is given by the \( M \)-dimensional vector b, and x is the \( N \)-dimensional output solution vector \( X \). No input quantities are destroyed, so the routine may be called sequentially with different arguments b. For implementation details see [NRIC].

Parameters
uThe \( M \times N \)-dimensional matrix \( U \).
wThe \( N \)-dimensional vector \( W \) holding the singular values of \( A \).
vThe \( N \times N \)-dimensional matrix \( V \).
bThe \( M \)-dimensional right-hand side vector \( B \).
xThe \( N \)-dimensional output solution vector \( X \).
Precondition
w.getSize() == u.getSize2(), v.getSize1() == u.getSize2() && v.getSize2() == u.getSize2(), x.getSize() == u.getSize2()) and b.getSize() == u.getSize1().
See also
svDecomposition()

◆ svSubstitute() [2/2]

template<typename U , typename W , typename V , typename B , typename X >
void CDPL::Math::svSubstitute ( const MatrixExpression< U > &  u,
const VectorExpression< W > &  w,
const MatrixExpression< V > &  v,
const MatrixExpression< B > &  b,
MatrixExpression< X > &  x 
)

Solves \( A \cdot X = B \) for a matrix \( X \) where \( A \) is given by its Singular Value Decomposition [WSVD].

The \( M \times N \)-dimensional matrix \( A \) is specified by its singular value decomposition \( A = UWV^T \), where \( U \) is given by the \( M \times N \)-dimensional matrix u, \( W \) by the \( N \)-dimensional vector w, and \( V \) is provided by the \( N \times N \)-dimensional matrix v. The \( M \times P \)-dimensional right-hand side matrix \( B \) is given by b, and x is the \( N \times P \)-dimensional output solution matrix \( X \). No input quantities are destroyed, so the routine may be called sequentially with different arguments b. For implementation details see [NRIC].

Parameters
uThe \( M \times N \)-dimensional matrix \( U \).
wThe \( N \)-dimensional vector \( W \) holding the singular values of \( A \).
vThe \( N \times N \)-dimensional matrix \( V \).
bThe \( M \times P \)-dimensional right-hand side matrix \( B \).
xThe \( N \times P \)-dimensional output solution matrix \( X \).
Precondition
w().getSize() == u().getSize2(), v().getSize1() == u().getSize2() && v().getSize2() == u().getSize2(), x().getSize1() == u().getSize2() and b().getSize1() == u().getSize1() && b().getSize2() == x().getSize2().
Exceptions
Base::SizeErrorif preconditions are violated.
See also
svDecomposition()

◆ vec() [3/5]

template<typename T1 , typename T2 >
CVector<typename CommonType<T1, T2>::Type, 2> CDPL::Math::vec ( const T1 &  t1,
const T2 &  t2 
)

◆ vec() [4/5]

template<typename T1 , typename T2 , typename T3 >
CVector<typename CommonType<typename CommonType<T1, T2>::Type, T3>::Type, 3> CDPL::Math::vec ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3 
)

◆ vec() [5/5]

template<typename T1 , typename T2 , typename T3 , typename T4 >
CVector<typename CommonType<typename CommonType<typename CommonType<T1, T2>::Type, T3>::Type, T4>::Type, 4> CDPL::Math::vec ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4 
)

◆ quat() [5/6]

template<typename E >
VectorQuaternionAdapter<E> CDPL::Math::quat ( VectorExpression< E > &  e)

◆ quat() [6/6]

template<typename E >
VectorQuaternionAdapter<const E> CDPL::Math::quat ( const VectorExpression< E > &  e)

◆ homog() [1/2]

template<typename E >
HomogenousCoordsAdapter<E> CDPL::Math::homog ( VectorExpression< E > &  e)

◆ homog() [2/2]

template<typename E >
HomogenousCoordsAdapter<const E> CDPL::Math::homog ( const VectorExpression< E > &  e)

◆ transform() [1/2]

template<typename T , std::size_t Dim, typename T1 >
void CDPL::Math::transform ( VectorArray< CVector< T, Dim > > &  va,
const CMatrix< T1, Dim, Dim > &  xform 
)

Transforms each \( N \)-dimensional vector in the array with the \( N \)-dimensional square matrix xform.

Parameters
vaThe vectors to transform.
xformThe transformation matrix.

◆ transform() [2/2]

template<typename T , std::size_t Dim, typename T1 >
void CDPL::Math::transform ( VectorArray< CVector< T, Dim > > &  va,
const CMatrix< T1, Dim+1, Dim+1 > &  xform 
)

Transforms each \( N \)-dimensional vector in the array with the \( N+1 \)-dimensional square matrix xform.

Parameters
vaThe vectors to transform.
xformThe transformation matrix.
Note
The missing vector element is taken to be 1.0.

◆ calcCentroid()

template<typename T , std::size_t Dim, typename T1 >
bool CDPL::Math::calcCentroid ( const VectorArray< CVector< T, Dim > > &  va,
CVector< T1, Dim > &  ctr 
)

Calculates the centroid of the array elements.

Parameters
vaThe vectors for which to calculate the centroid.
ctrStores the calculated centroid.
Returns
true if the array is not empty, and false otherwise.

◆ calcRMSD() [1/2]

template<typename T , std::size_t Dim>
T CDPL::Math::calcRMSD ( const VectorArray< CVector< T, Dim > > &  va1,
const VectorArray< CVector< T, Dim > > &  va2 
)

◆ calcRMSD() [2/2]

template<typename T , std::size_t Dim, typename T1 >
T CDPL::Math::calcRMSD ( const VectorArray< CVector< T, Dim > > &  va1,
const VectorArray< CVector< T, Dim > > &  va2,
const CMatrix< T1, Dim+1, Dim+1 > &  va1_xform 
)

◆ vectorAssignVector()

template<template< typename T1, typename T2 > class F, typename V , typename E >
void CDPL::Math::vectorAssignVector ( V v,
const VectorExpression< E > &  e 
)

◆ vectorAssignScalar()

template<template< typename T1, typename T2 > class F, typename V , typename T >
void CDPL::Math::vectorAssignScalar ( V v,
const T &  t 
)

◆ vectorSwap()

template<typename V , typename E >
void CDPL::Math::vectorSwap ( V v,
VectorExpression< E > &  e 
)

◆ operator-() [9/10]

template<typename E >
VectorUnaryTraits<E, ScalarNegation<typename E::ValueType> >::ResultType CDPL::Math::operator- ( const VectorExpression< E > &  e)

◆ operator+() [9/10]

template<typename E >
const E& CDPL::Math::operator+ ( const VectorExpression< E > &  e)

◆ operator+() [10/10]

template<typename E1 , typename E2 >
VectorBinary1Traits<E1, E2, ScalarAddition<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::operator+ ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ operator-() [10/10]

template<typename E1 , typename E2 >
VectorBinary1Traits<E1, E2, ScalarSubtraction<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::operator- ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ operator*() [11/12]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2VectorBinaryTraits<E, T, ScalarMultiplication<typename E::ValueType, T> >::ResultType>::type CDPL::Math::operator* ( const VectorExpression< E > &  e,
const T &  t 
)

◆ operator*() [12/12]

template<typename T , typename E >
std::enable_if<IsScalar<T>::value, typename Scalar1VectorBinaryTraits<T, E, ScalarMultiplication<T, typename E::ValueType> >::ResultType>::type CDPL::Math::operator* ( const T &  t,
const VectorExpression< E > &  e 
)

◆ operator/() [6/6]

template<typename E , typename T >
std::enable_if<IsScalar<T>::value, typename Scalar2VectorBinaryTraits<E, T, ScalarDivision<typename E::ValueType, T> >::ResultType>::type CDPL::Math::operator/ ( const VectorExpression< E > &  e,
const T &  t 
)

◆ operator==() [4/4]

template<typename E1 , typename E2 >
VectorEquality<E1, E2>::ResultType CDPL::Math::operator== ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ operator!=() [4/4]

template<typename E1 , typename E2 >
VectorEquality<E1, E2>::ResultType CDPL::Math::operator!= ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ equals() [4/4]

template<typename E1 , typename E2 , typename T >
std::enable_if<std::is_arithmetic<T>::value, typename VectorToleranceEquality<E1, E2, T>::ResultType>::type CDPL::Math::equals ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2,
const T &  eps 
)

◆ conj() [4/4]

template<typename E >
VectorUnaryTraits<E, ScalarConjugation<typename E::ValueType> >::ResultType CDPL::Math::conj ( const VectorExpression< E > &  e)

◆ herm() [3/3]

template<typename E >
VectorUnaryTraits<E, ScalarConjugation<typename E::ValueType> >::ResultType CDPL::Math::herm ( const VectorExpression< E > &  e)

◆ real() [4/4]

template<typename E >
VectorUnaryTraits<E, ScalarReal<typename E::ValueType> >::ResultType CDPL::Math::real ( const VectorExpression< E > &  e)

◆ imag() [3/3]

template<typename E >
VectorUnaryTraits<E, ScalarImaginary<typename E::ValueType> >::ResultType CDPL::Math::imag ( const VectorExpression< E > &  e)

◆ elemDiv() [4/4]

template<typename E1 , typename E2 >
VectorBinary1Traits<E1, E2, ScalarDivision<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::elemDiv ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ elemProd() [4/4]

template<typename E1 , typename E2 >
VectorBinary1Traits<E1, E2, ScalarMultiplication<typename E1::ValueType, typename E2::ValueType> >::ResultType CDPL::Math::elemProd ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ crossProd()

template<typename E1 , typename E2 >
VectorBinary2Traits<E1, E2, VectorCrossProduct<E1, E2> >::ResultType CDPL::Math::crossProd ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ innerProd()

template<typename E1 , typename E2 >
VectorInnerProduct<E1, E2>::ResultType CDPL::Math::innerProd ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ angleCos()

template<typename E1 , typename E2 , typename T >
VectorAngleCosine<E1, E2, T>::ResultType CDPL::Math::angleCos ( const VectorExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2,
const T &  sd,
bool  clamp = true 
)

◆ sum() [4/4]

template<typename E >
VectorElementSum<E>::ResultType CDPL::Math::sum ( const VectorExpression< E > &  e)

◆ norm1() [2/2]

template<typename E >
VectorNorm1<E>::ResultType CDPL::Math::norm1 ( const VectorExpression< E > &  e)

◆ norm2() [2/2]

template<typename E >
VectorNorm2<E>::ResultType CDPL::Math::norm2 ( const VectorExpression< E > &  e)

◆ normInf() [2/2]

template<typename E >
VectorNormInfinity<E>::ResultType CDPL::Math::normInf ( const VectorExpression< E > &  e)

◆ normInfIndex()

template<typename E >
VectorNormInfinityIndex<E>::ResultType CDPL::Math::normInfIndex ( const VectorExpression< E > &  e)

◆ length()

template<typename E >
VectorNorm2<E>::ResultType CDPL::Math::length ( const VectorExpression< E > &  e)

◆ trans() [3/4]

template<typename E >
const E& CDPL::Math::trans ( const VectorExpression< E > &  e)

◆ trans() [4/4]

template<typename E >
E& CDPL::Math::trans ( VectorExpression< E > &  e)

◆ rotate()

template<typename E1 , typename E2 >
QuaternionVectorBinaryTraits<E1, E2, QuaternionVectorRotation<E1, E2> >::ResultType CDPL::Math::rotate ( const QuaternionExpression< E1 > &  e1,
const VectorExpression< E2 > &  e2 
)

◆ vectorBegin() [1/2]

template<typename E >
VectorIteratorTraits<E>::IteratorType CDPL::Math::vectorBegin ( VectorExpression< E > &  e)

◆ vectorEnd() [1/2]

template<typename E >
VectorIteratorTraits<E>::IteratorType CDPL::Math::vectorEnd ( VectorExpression< E > &  e)

◆ vectorBegin() [2/2]

template<typename E >
VectorIteratorTraits<const E>::IteratorType CDPL::Math::vectorBegin ( const VectorExpression< E > &  e)

◆ vectorEnd() [2/2]

template<typename E >
VectorIteratorTraits<const E>::IteratorType CDPL::Math::vectorEnd ( const VectorExpression< E > &  e)

◆ range() [6/9]

template<typename E >
VectorRange<E> CDPL::Math::range ( VectorExpression< E > &  e,
const typename VectorRange< E >::RangeType &  r 
)

◆ range() [7/9]

template<typename E >
VectorRange<const E> CDPL::Math::range ( const VectorExpression< E > &  e,
const typename VectorRange< const E >::RangeType &  r 
)

◆ range() [8/9]

template<typename E >
VectorRange<E> CDPL::Math::range ( VectorExpression< E > &  e,
typename VectorRange< E >::RangeType::SizeType  start,
typename VectorRange< E >::RangeType::SizeType  stop 
)

◆ range() [9/9]

template<typename E >
VectorRange<const E> CDPL::Math::range ( const VectorExpression< E > &  e,
typename VectorRange< const E >::RangeType::SizeType  start,
typename VectorRange< const E >::RangeType::SizeType  stop 
)

◆ slice() [6/9]

template<typename E >
VectorSlice<E> CDPL::Math::slice ( VectorExpression< E > &  e,
const typename VectorSlice< E >::SliceType &  s 
)

◆ slice() [7/9]

template<typename E >
VectorSlice<const E> CDPL::Math::slice ( const VectorExpression< E > &  e,
const typename VectorSlice< const E >::SliceType &  s 
)

◆ slice() [8/9]

template<typename E >
VectorSlice<E> CDPL::Math::slice ( VectorExpression< E > &  e,
typename VectorSlice< E >::SliceType::SizeType  start,
typename VectorSlice< E >::SliceType::DifferenceType  stride,
typename VectorSlice< E >::SliceType::SizeType  size 
)

◆ slice() [9/9]

template<typename E >
VectorSlice<const E> CDPL::Math::slice ( const VectorExpression< E > &  e,
typename VectorSlice< const E >::SliceType::SizeType  start,
typename VectorSlice< const E >::SliceType::DifferenceType  stride,
typename VectorSlice< const E >::SliceType::SizeType  size 
)