#include <Eigen/SparseCore>

Include dependency graph for autodiff_scalar.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	Eigen::internal::auto_diff_special_op< _DerType, Enable >

struct	Eigen::internal::auto_diff_special_op< _DerType, false >

struct	Eigen::internal::auto_diff_special_op< _DerType, true >

class	Eigen::AutoDiffScalar< _DerType >

class	Eigen::AutoDiffScalar< _DerType >

struct	Eigen::internal::make_coherent_impl< A, B >

struct	Eigen::internal::make_coherent_impl< A, Matrix< B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols > >

struct	Eigen::internal::make_coherent_impl< A, SparseVector< B_Scalar, B_Options, B_Index > >

struct	Eigen::internal::make_coherent_impl< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, B >

struct	Eigen::internal::make_coherent_impl< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, Matrix< B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols > >

struct	Eigen::internal::make_coherent_impl< SparseVector< A_Scalar, A_Options, A_Index >, B >

struct	Eigen::internal::make_coherent_impl< SparseVector< A_Scalar, A_Options, A_Index >, SparseVector< B_Scalar, B_Options, B_Index > >

class	std::numeric_limits< Eigen::AutoDiffScalar< T & > >

class	std::numeric_limits< Eigen::AutoDiffScalar< T > >

struct	Eigen::NumTraits< AutoDiffScalar< DerType > >

struct	Eigen::NumTraits< AutoDiffScalar< SparseVector< DerType_ > > >

struct	Eigen::ScalarBinaryOpTraits< AutoDiffScalar< DerType >, typename DerType::Scalar, BinOp >

struct	Eigen::ScalarBinaryOpTraits< typename DerType::Scalar, AutoDiffScalar< DerType >, BinOp >

Namespaces
	Eigen

	Eigen::internal

	std

Macros
#define	EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC, CODE)

Enumerations
enum	{ AUTODIFF_IS_SUPPORTED_ONLY_WITH_EIGEN_3_3_0_OR_ABOVE = 666 }

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

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)

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

	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 const Eigen

	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

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

template<typename A , typename B >
void	Eigen::internal::make_coherent (const A &a, const B &b)

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

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

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

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

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

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

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

const T &	Eigen::y

Macro Definition Documentation

#define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY	(	FUNC,
		CODE
	)

Value:

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

Definition at line 615 of file autodiff_scalar.h.

Enumeration Type Documentation

anonymous enum

Enumerator
AUTODIFF_IS_SUPPORTED_ONLY_WITH_EIGEN_3_3_0_OR_ABOVE

Definition at line 16 of file autodiff_scalar.h.

Classes

Namespaces

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

Enumeration Type Documentation