Eigen::NumericalDiff< Functor_, mode > Class Template Reference

Inheritance diagram for Eigen::NumericalDiff< Functor_, mode >:

Public Types
enum	{   InputsAtCompileTime ,   ValuesAtCompileTime }
typedef Functor_	Functor
typedef Functor::InputType	InputType
typedef Functor::JacobianType	JacobianType
typedef Functor::Scalar	Scalar
typedef Functor::ValueType	ValueType

Public Member Functions
int	df (const InputType &_x, JacobianType &jac) const
	NumericalDiff (const Functor &f, Scalar _epsfcn=0.)
template<typename T0 >
	NumericalDiff (const T0 &a0)
template<typename T0 , typename T1 >
	NumericalDiff (const T0 &a0, const T1 &a1)
template<typename T0 , typename T1 , typename T2 >
	NumericalDiff (const T0 &a0, const T1 &a1, const T2 &a2)
	NumericalDiff (Scalar _epsfcn=0.)

Private Member Functions
NumericalDiff &	operator= (const NumericalDiff &)

Private Attributes
Scalar	epsfcn

Detailed Description

template<typename Functor_, NumericalDiffMode mode = Forward>
class Eigen::NumericalDiff< Functor_, mode >

This class allows you to add a method df() to your functor, which will use numerical differentiation to compute an approximate of the derivative for the functor. Of course, if you have an analytical form for the derivative, you should rather implement df() by yourself.

More information on http://en.wikipedia.org/wiki/Numerical_differentiation

Currently only "Forward" and "Central" scheme are implemented.

Definition at line 38 of file NumericalDiff.h.

Member Typedef Documentation

Functor

template<typename Functor_ , NumericalDiffMode mode = Forward>

typedef Functor_ Eigen::NumericalDiff< Functor_, mode >::Functor

Definition at line 41 of file NumericalDiff.h.

InputType

template<typename Functor_ , NumericalDiffMode mode = Forward>

typedef Functor::InputType Eigen::NumericalDiff< Functor_, mode >::InputType

Definition at line 43 of file NumericalDiff.h.

JacobianType

template<typename Functor_ , NumericalDiffMode mode = Forward>

typedef Functor::JacobianType Eigen::NumericalDiff< Functor_, mode >::JacobianType

Definition at line 45 of file NumericalDiff.h.

Scalar

template<typename Functor_ , NumericalDiffMode mode = Forward>

typedef Functor::Scalar Eigen::NumericalDiff< Functor_, mode >::Scalar

Definition at line 42 of file NumericalDiff.h.

ValueType

template<typename Functor_ , NumericalDiffMode mode = Forward>

typedef Functor::ValueType Eigen::NumericalDiff< Functor_, mode >::ValueType

Definition at line 44 of file NumericalDiff.h.

Member Enumeration Documentation

anonymous enum

template<typename Functor_ , NumericalDiffMode mode = Forward>

anonymous enum

Enumerator
InputsAtCompileTime
ValuesAtCompileTime

Definition at line 58 of file NumericalDiff.h.

         {
        InputsAtCompileTime = Functor::InputsAtCompileTime,
        ValuesAtCompileTime = Functor::ValuesAtCompileTime
    };

Constructor & Destructor Documentation

NumericalDiff() [1/5]

template<typename Functor_ , NumericalDiffMode mode = Forward>

Eigen::NumericalDiff< Functor_, mode >::NumericalDiff ( Scalar  _epsfcn = 0. )

inline

Definition at line 47 of file NumericalDiff.h.

: Functor(), epsfcn(_epsfcn) {}

NumericalDiff() [2/5]

template<typename Functor_ , NumericalDiffMode mode = Forward>

Eigen::NumericalDiff< Functor_, mode >::NumericalDiff ( const Functor &  f, Scalar  _epsfcn = 0.  )

inline

Definition at line 48 of file NumericalDiff.h.

: Functor(f), epsfcn(_epsfcn) {}

NumericalDiff() [3/5]

template<typename Functor_ , NumericalDiffMode mode = Forward>

template<typename T0 >

Eigen::NumericalDiff< Functor_, mode >::NumericalDiff ( const T0 &  a0 )

inline

Definition at line 52 of file NumericalDiff.h.

: Functor(a0), epsfcn(0) {}

NumericalDiff() [4/5]

template<typename Functor_ , NumericalDiffMode mode = Forward>

template<typename T0 , typename T1 >

Eigen::NumericalDiff< Functor_, mode >::NumericalDiff ( const T0 &  a0, const T1 &  a1  )

inline

Definition at line 54 of file NumericalDiff.h.

: Functor(a0, a1), epsfcn(0) {}

NumericalDiff() [5/5]

template<typename Functor_ , NumericalDiffMode mode = Forward>

template<typename T0 , typename T1 , typename T2 >

Eigen::NumericalDiff< Functor_, mode >::NumericalDiff ( const T0 &  a0, const T1 &  a1, const T2 &  a2  )

inline

Definition at line 56 of file NumericalDiff.h.

: Functor(a0, a1, a2), epsfcn(0) {}

Member Function Documentation

df()

template<typename Functor_ , NumericalDiffMode mode = Forward>

int Eigen::NumericalDiff< Functor_, mode >::df ( const InputType &  _x, JacobianType &  jac  ) const

inline

return the number of evaluation of functor

Definition at line 66 of file NumericalDiff.h.

    {
        using std::sqrt;
        using std::abs;
        /* Local variables */
        Scalar h;
        int nfev=0;
        const typename InputType::Index n = _x.size();
        const Scalar eps = sqrt(((std::max)(epsfcn,NumTraits<Scalar>::epsilon() )));
        ValueType val1, val2;
        InputType x = _x;
        // TODO : we should do this only if the size is not already known
        val1.resize(Functor::values());
        val2.resize(Functor::values());
 
        // initialization
        switch(mode) {
            case Forward:
                // compute f(x)
                Functor::operator()(x, val1); nfev++;
                break;
            case Central:
                // do nothing
                break;
            default:
                eigen_assert(false);
        };
 
        // Function Body
        for (int j = 0; j < n; ++j) {
            h = eps * abs(x[j]);
            if (h == 0.) {
                h = eps;
            }
            switch(mode) {
                case Forward:
                    x[j] += h;
                    Functor::operator()(x, val2);
                    nfev++;
                    x[j] = _x[j];
                    jac.col(j) = (val2-val1)/h;
                    break;
                case Central:
                    x[j] += h;
                    Functor::operator()(x, val2); nfev++;
                    x[j] -= 2*h;
                    Functor::operator()(x, val1); nfev++;
                    x[j] = _x[j];
                    jac.col(j) = (val2-val1)/(2*h);
                    break;
                default:
                    eigen_assert(false);
            };
        }
        return nfev;
    }

operator=()

template<typename Functor_ , NumericalDiffMode mode = Forward>

NumericalDiff& Eigen::NumericalDiff< Functor_, mode >::operator= ( const NumericalDiff< Functor_, mode > &  )

private

Member Data Documentation

epsfcn

template<typename Functor_ , NumericalDiffMode mode = Forward>

Scalar Eigen::NumericalDiff< Functor_, mode >::epsfcn

private

Definition at line 123 of file NumericalDiff.h.

---

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

• NumericalDiff.h