AutoDiffScalar.h File Reference

#include "./InternalHeaderCheck.h"

Go to the source code of this file.

Classes
struct	Eigen::internal::maybe_coherent_pad_helper< DerivativeType, OtherDerivativeType, EnableIf >
struct	Eigen::internal::maybe_coherent_pad_helper< DerivativeType, OtherDerivativeType, std::enable_if_t< enum_ge_not_dynamic(DerivativeType::SizeAtCompileTime, OtherDerivativeType::SizeAtCompileTime)> >
class	Eigen::AutoDiffScalar< DerivativeType >
	A scalar type replacement with automatic differentiation capability. More...
struct	Eigen::internal::auto_diff_special_op< DerivativeType, true >
struct	Eigen::internal::auto_diff_special_op< DerivativeType, false >
struct	Eigen::ScalarBinaryOpTraits< AutoDiffScalar< DerType >, typename DerType::Scalar, BinOp >
struct	Eigen::ScalarBinaryOpTraits< typename DerType::Scalar, AutoDiffScalar< DerType >, BinOp >
struct	Eigen::CleanedUpDerType< DerType >
struct	Eigen::NumTraits< AutoDiffScalar< DerType > >
struct	Eigen::internal::is_identically_zero_impl< AutoDiffScalar< DerivativeType > >
class	std::numeric_limits< Eigen::AutoDiffScalar< T > >
class	std::numeric_limits< Eigen::AutoDiffScalar< T & > >

Namespaces
	Eigen
	Namespace containing all symbols from the Eigen library.
	Eigen::internal
	Namespace containing low-level routines from the Eigen library.

Macros
#define	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC, CODE)

Functions
template<typename DerivativeType , typename OtherDerivativeType >
maybe_coherent_pad_helper< DerivativeType, OtherDerivativeType >::type	Eigen::internal::MaybeCoherentPad (const DerivativeType &x, const OtherDerivativeType &y)
template<typename Op , typename LhsDerivativeType , typename RhsDerivativeType >
auto	Eigen::internal::MakeCoherentCwiseBinaryOp (const LhsDerivativeType &x, const RhsDerivativeType &y, Op op=Op())
template<typename NewDerType >
AutoDiffScalar< NewDerType >	Eigen::MakeAutoDiffScalar (const typename NewDerType::Scalar &value, const NewDerType &der)
template<typename DerType >
const AutoDiffScalar< DerType > &	Eigen::conj (const AutoDiffScalar< DerType > &x)
template<typename DerType >
const AutoDiffScalar< DerType > &	Eigen::real (const AutoDiffScalar< DerType > &x)
template<typename DerType >
DerType::Scalar	Eigen::imag (const AutoDiffScalar< DerType > &)
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type()	Eigen::min (const AutoDiffScalar< DerType > &x, const T &y)
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type()	Eigen::max (const AutoDiffScalar< DerType > &x, const T &y)
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type()	Eigen::min (const T &x, const AutoDiffScalar< DerType > &y)
template<typename DerType , typename T >
CleanedUpDerType< DerType >::type()	Eigen::max (const T &x, const AutoDiffScalar< DerType > &y)
template<typename DerType >
CleanedUpDerType< DerType >::type()	Eigen::min (const AutoDiffScalar< DerType > &x, const AutoDiffScalar< DerType > &y)
template<typename DerType >
CleanedUpDerType< DerType >::type()	Eigen::max (const AutoDiffScalar< DerType > &x, const AutoDiffScalar< DerType > &y)
	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(abs2
	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(cos
	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(exp
	Eigen::EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY (log, using std::log;return Eigen::MakeAutoDiffScalar(log(x.value()), x.derivatives() *(Scalar(1)/x.value()));) template< typename DerType > inline auto pow(const Eigen
template<typename DerTypeA , typename DerTypeB >
AutoDiffScalar< Matrix< typename internal::traits< internal::remove_all_t< DerTypeA > >::Scalar, Dynamic, 1 > >	Eigen::atan2 (const AutoDiffScalar< DerTypeA > &a, const AutoDiffScalar< DerTypeB > &b)
	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()))));) EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(asin
	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(tanh
	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(cosh

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

Macro Definition Documentation

EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY

#define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY	(		FUNC,
			CODE
	)

Value:

  template <typename DerType>                                                                        \
  inline auto FUNC(const Eigen::AutoDiffScalar<DerType>& x) {                                        \
    using namespace Eigen;                                                                           \
    typedef typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar Scalar; \
    EIGEN_UNUSED_VARIABLE(sizeof(Scalar));                                                           \
    CODE;                                                                                            \
  }