Eigen::AutoDiffJacobian< Functor > Class Template Reference

#include <AutoDiffJacobian.h>

Inheritance diagram for Eigen::AutoDiffJacobian< Functor >:

Public Types
enum	{ InputsAtCompileTime = InputType::RowsAtCompileTime , ValuesAtCompileTime = ValueType::RowsAtCompileTime }
typedef Functor::InputType	InputType
typedef Functor::ValueType	ValueType
typedef ValueType::Scalar	Scalar
typedef Matrix< Scalar, ValuesAtCompileTime, InputsAtCompileTime >	JacobianType
typedef JacobianType::Index	Index
typedef Matrix< Scalar, InputsAtCompileTime, 1 >	DerivativeType
typedef AutoDiffScalar< DerivativeType >	ActiveScalar
typedef Matrix< ActiveScalar, InputsAtCompileTime, 1 >	ActiveInput
typedef Matrix< ActiveScalar, ValuesAtCompileTime, 1 >	ActiveValue
Public Types inherited from Functor< Scalar_, NX, NY >
enum	{ InputsAtCompileTime = NX , ValuesAtCompileTime = NY }
enum	{ InputsAtCompileTime = NX , ValuesAtCompileTime = NY }
typedef Scalar_	Scalar
typedef Matrix< Scalar, InputsAtCompileTime, 1 >	InputType
typedef Matrix< Scalar, ValuesAtCompileTime, 1 >	ValueType
typedef Matrix< Scalar, ValuesAtCompileTime, InputsAtCompileTime >	JacobianType
typedef Scalar_	Scalar
typedef Matrix< Scalar, InputsAtCompileTime, 1 >	InputType
typedef Matrix< Scalar, ValuesAtCompileTime, 1 >	ValueType
typedef Matrix< Scalar, ValuesAtCompileTime, InputsAtCompileTime >	JacobianType

Public Member Functions
	AutoDiffJacobian ()
	AutoDiffJacobian (const Functor &f)
template<typename... T>
	AutoDiffJacobian (const T &... Values)
EIGEN_STRONG_INLINE void	operator() (const InputType &x, ValueType *v) const
template<typename... ParamsType>
void	operator() (const InputType &x, ValueType *v, JacobianType *_jac, const ParamsType &... Params) const
Public Member Functions inherited from Functor< Scalar_, NX, NY >
	Functor ()
	Functor (int inputs, int values)
int	inputs () const
int	values () const
	Functor ()
	Functor (int inputs_, int values_)
int	inputs () const
int	values () const

Additional Inherited Members
Public Attributes inherited from Functor< Scalar_, NX, NY >
const int	m_inputs
const int	m_values
int	m_inputs
int	m_values

Member Typedef Documentation

ActiveInput

template<typename Functor >

typedef Matrix<ActiveScalar, InputsAtCompileTime, 1> Eigen::AutoDiffJacobian< Functor >::ActiveInput

ActiveScalar

template<typename Functor >

typedef AutoDiffScalar<DerivativeType> Eigen::AutoDiffJacobian< Functor >::ActiveScalar

ActiveValue

template<typename Functor >

typedef Matrix<ActiveScalar, ValuesAtCompileTime, 1> Eigen::AutoDiffJacobian< Functor >::ActiveValue

DerivativeType

template<typename Functor >

typedef Matrix<Scalar, InputsAtCompileTime, 1> Eigen::AutoDiffJacobian< Functor >::DerivativeType

Index

template<typename Functor >

typedef JacobianType::Index Eigen::AutoDiffJacobian< Functor >::Index

InputType

template<typename Functor >

typedef Functor::InputType Eigen::AutoDiffJacobian< Functor >::InputType

JacobianType

template<typename Functor >

typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> Eigen::AutoDiffJacobian< Functor >::JacobianType

Scalar

template<typename Functor >

typedef ValueType::Scalar Eigen::AutoDiffJacobian< Functor >::Scalar

ValueType

template<typename Functor >

typedef Functor::ValueType Eigen::AutoDiffJacobian< Functor >::ValueType

Member Enumeration Documentation

anonymous enum

template<typename Functor >

anonymous enum

Enumerator
InputsAtCompileTime
ValuesAtCompileTime

{ InputsAtCompileTime = InputType::RowsAtCompileTime, ValuesAtCompileTime = ValueType::RowsAtCompileTime };

Constructor & Destructor Documentation

AutoDiffJacobian() [1/3]

template<typename Functor >

Eigen::AutoDiffJacobian< Functor >::AutoDiffJacobian ( )

inline

: Functor() {}

AutoDiffJacobian() [2/3]

template<typename Functor >

Eigen::AutoDiffJacobian< Functor >::AutoDiffJacobian ( const Functor &  f )

inline

: Functor(f) {}

AutoDiffJacobian() [3/3]

template<typename Functor >

template<typename... T>

Eigen::AutoDiffJacobian< Functor >::AutoDiffJacobian ( const T &...  Values )

inline

: Functor(Values...) {}

Member Function Documentation

operator()() [1/2]

template<typename Functor >

EIGEN_STRONG_INLINE void Eigen::AutoDiffJacobian< Functor >::operator() ( const InputType &  x, ValueType *  v  ) const

inline

{ this->operator()(x, v, 0); }

References Eigen::AutoDiffJacobian< Functor >::operator()(), and v.

Referenced by Eigen::AutoDiffJacobian< Functor >::operator()().

operator()() [2/2]

template<typename Functor >

template<typename... ParamsType>

void Eigen::AutoDiffJacobian< Functor >::operator() ( const InputType &  x, ValueType *  v, JacobianType *  _jac, const ParamsType &...  Params  ) const

inline

                                                                                                           {
    eigen_assert(v != 0);
 
    if (!_jac) {
      Functor::operator()(x, v, Params...);
      return;
    }
 
    JacobianType& jac = *_jac;
 
    ActiveInput ax = x.template cast<ActiveScalar>();
    ActiveValue av(jac.rows());
 
    if (InputsAtCompileTime == Dynamic)
      for (Index j = 0; j < jac.rows(); j++) av[j].derivatives().resize(x.rows());
 
    for (Index i = 0; i < jac.cols(); i++) ax[i].derivatives() = DerivativeType::Unit(x.rows(), i);
 
    Functor::operator()(ax, &av, Params...);
 
    for (Index i = 0; i < jac.rows(); i++) {
      (*v)[i] = av[i].value();
      jac.row(i) = av[i].derivatives();
    }
  }

References plotDoE::ax, Eigen::PlainObjectBase< Derived >::cols(), Eigen::Dynamic, eigen_assert, i, Eigen::AutoDiffJacobian< Functor >::InputsAtCompileTime, j, Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), v, and plotDoE::x.

---

The documentation for this class was generated from the following file:

• AutoDiffJacobian.h