Exotica
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Eigen Namespace Reference

Namespaces

 internal
 

Classes

class  AutoDiffChainHessian
 
class  AutoDiffChainHessianSparse
 
class  AutoDiffChainJacobian
 
class  AutoDiffChainJacobianSparse
 
class  AutoDiffScalar
 
class  FiniteDiffChainHessian
 
class  FiniteDiffChainJacobian
 
struct  NumTraits< AutoDiffScalar< DerType > >
 
struct  NumTraits< AutoDiffScalar< SparseVector< DerType_ > > >
 
struct  ScalarBinaryOpTraits< AutoDiffScalar< DerType >, typename DerType::Scalar, BinOp >
 
struct  ScalarBinaryOpTraits< typename DerType::Scalar, AutoDiffScalar< DerType >, BinOp >
 

Typedefs

typedef Eigen::Ref< Eigen::VectorXd > VectorXdRef
 
typedef Eigen::Ref< Eigen::MatrixXd > MatrixXdRef
 
template<typename T >
using MatrixType = Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >
 

Enumerations

enum  NumericalDiffMode { Forward, Central }
 

Functions

template<typename NewDerType >
AutoDiffScalar< NewDerType > MakeAutoDiffScalar (const typename NewDerType::Scalar &value, const NewDerType &der)
 
template<typename DerType >
const AutoDiffScalar< DerType > & conj (const AutoDiffScalar< DerType > &x)
 
template<typename DerType >
const AutoDiffScalar< DerType > & real (const AutoDiffScalar< DerType > &x)
 
template<typename DerType >
DerType::Scalar imag (const AutoDiffScalar< DerType > &)
 
 return (x<=y ? ADS(x) :ADS(y))
 
 return (x >=y ? ADS(x) :ADS(y))
 
 return (x< y ? ADS(x) :ADS(y))
 
 return (x > y ? ADS(x) :ADS(y))
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (abs, using std::abs;return Eigen::MakeAutoDiffScalar(abs(x.value()), x.derivatives() *(x.value()< 0 ? -1 :1));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sqrt, using std::sqrt;Scalar sqrtx=sqrt(x.value());return Eigen::MakeAutoDiffScalar(sqrtx, x.derivatives() *(Scalar(0.5)/sqrtx));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sin, using std::sin;using std::cos;return Eigen::MakeAutoDiffScalar(sin(x.value()), x.derivatives() *cos(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (log, using std::log;return Eigen::MakeAutoDiffScalar(log(x.value()), x.derivatives() *(Scalar(1)/x.value()));) template< typename DerType > inline const Eigen
 
template<typename DerTypeA , typename DerTypeB >
const AutoDiffScalar< Matrix< typename internal::traits< typename internal::remove_all< DerTypeA >::type >::Scalar, Dynamic, 1 > > atan2 (const AutoDiffScalar< DerTypeA > &a, const AutoDiffScalar< DerTypeB > &b)
 
template<typename DerTypeA , typename DerTypeB >
const AutoDiffScalar< SparseVector< typename internal::traits< typename internal::remove_all< DerTypeA >::type >::Scalar > > atan2 (const AutoDiffScalar< DerTypeA > &a, const AutoDiffScalar< DerTypeB > &b)
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (tan, using std::tan;using std::cos;return Eigen::MakeAutoDiffScalar(tan(x.value()), x.derivatives() *(Scalar(1)/numext::abs2(cos(x.value()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(asin
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (acos, using std::sqrt;using std::acos;return Eigen::MakeAutoDiffScalar(acos(x.value()), x.derivatives() *(Scalar(-1)/sqrt(1 - numext::abs2(x.value()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(tanh
 
 EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (sinh, using std::sinh;using std::cosh;return Eigen::MakeAutoDiffScalar(sinh(x.value()), x.derivatives() *cosh(x.value()));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cosh
 
Eigen::VectorXd VectorTransform (double px=0.0, double py=0.0, double pz=0.0, double qx=0.0, double qy=0.0, double qz=0.0, double qw=1.0)
 
Eigen::VectorXd IdentityTransform ()
 
template<typename Scalar , int rank, typename sizeType >
MatrixType< Scalar > TensorToMatrix (const Eigen::Tensor< Scalar, rank > &tensor, const sizeType rows, const sizeType cols)
 
template<typename Scalar , typename... Dims>
Eigen::Tensor< Scalar, sizeof...(Dims)> MatrixToTensor (const MatrixType< Scalar > &matrix, Dims... dims)
 

Variables

const typedef Eigen::Ref< const Eigen::VectorXd > & VectorXdRefConst
 Convenience wrapper for storing references to sub-matrices/vectors. More...
 
const typedef Eigen::Ref< const Eigen::MatrixXd > & MatrixXdRefConst
 
const T & y
 
Scalar expx = exp(x.value())
 

Typedef Documentation

◆ MatrixType

template<typename T >
using Eigen::MatrixType = typedef Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>

◆ MatrixXdRef

typedef Eigen::Ref<Eigen::MatrixXd> Eigen::MatrixXdRef

◆ VectorXdRef

typedef Eigen::Ref<Eigen::VectorXd> Eigen::VectorXdRef

Enumeration Type Documentation

◆ NumericalDiffMode

enum Eigen::NumericalDiffMode
Enumerator
Forward 
Central 

Function Documentation

◆ atan2() [1/2]

template<typename DerTypeA , typename DerTypeB >
const AutoDiffScalar<Matrix<typename internal::traits<typename internal::remove_all<DerTypeA>::type>::Scalar, Dynamic, 1> > Eigen::atan2 ( const AutoDiffScalar< DerTypeA > &  a,
const AutoDiffScalar< DerTypeB > &  b 
)
inline

◆ atan2() [2/2]

template<typename DerTypeA , typename DerTypeB >
const AutoDiffScalar<SparseVector<typename internal::traits<typename internal::remove_all<DerTypeA>::type>::Scalar> > Eigen::atan2 ( const AutoDiffScalar< DerTypeA > &  a,
const AutoDiffScalar< DerTypeB > &  b 
)
inline

◆ conj()

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [1/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [2/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [3/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [4/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [5/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [6/7]

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

◆ EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY() [7/7]

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

◆ IdentityTransform()

Eigen::VectorXd Eigen::IdentityTransform ( )

◆ imag()

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

◆ MakeAutoDiffScalar()

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

◆ MatrixToTensor()

template<typename Scalar , typename... Dims>
Eigen::Tensor<Scalar, sizeof...(Dims)> Eigen::MatrixToTensor ( const MatrixType< Scalar > &  matrix,
Dims...  dims 
)
inline

◆ real()

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

◆ return() [1/4]

Eigen::return ( x  ,
y ?   ADSx) :ADS(y 
)

◆ return() [2/4]

Eigen::return ( x >=y ?   ADSx) :ADS(y)

◆ return() [3/4]

Eigen::return ( )

◆ return() [4/4]

Eigen::return ( x<=y ?   ADSx) :ADS(y)

◆ TensorToMatrix()

template<typename Scalar , int rank, typename sizeType >
MatrixType<Scalar> Eigen::TensorToMatrix ( const Eigen::Tensor< Scalar, rank > &  tensor,
const sizeType  rows,
const sizeType  cols 
)
inline

◆ VectorTransform()

Eigen::VectorXd Eigen::VectorTransform ( double  px = 0.0,
double  py = 0.0,
double  pz = 0.0,
double  qx = 0.0,
double  qy = 0.0,
double  qz = 0.0,
double  qw = 1.0 
)

Variable Documentation

◆ expx

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

◆ MatrixXdRefConst

const typedef Eigen::Ref<const Eigen::MatrixXd>& Eigen::MatrixXdRefConst

◆ VectorXdRefConst

const typedef Eigen::Ref<const Eigen::VectorXd>& Eigen::VectorXdRefConst

Convenience wrapper for storing references to sub-matrices/vectors.

◆ y

const AutoDiffScalar< DerType > & Eigen::y
Initial value:
{
typedef AutoDiffScalar<typename Eigen::internal::remove_all<DerType>::type::PlainObject> ADS
Eigen::AutoDiffScalar
Definition: autodiff_scalar.h:48
Generated on Fri Jul 23 2021 12:11:41 for Exotica by   doxygen 1.8.17