Template Class DifferentialActionModelNumDiffTpl

Inheritance Relationships

Base Type

Class Documentation

template<typename _Scalar>
class DifferentialActionModelNumDiffTpl : public crocoddyl::DifferentialActionModelAbstractTpl<_Scalar>

This class computes the numerical differentiation of a differential action model.

It computes the Jacobian of the cost, its residual and dynamics via numerical differentiation. It considers that the action model owns a cost residual and the cost is the square of this residual, i.e., \(\ell(\mathbf{x},\mathbf{u})=\frac{1}{2}\|\mathbf{r}(\mathbf{x},\mathbf{u})\|^2\), where \(\mathbf{r}(\mathbf{x},\mathbf{u})\) is the residual vector. The Hessian is computed only through the Gauss-Newton approximation, i.e.,

\[\begin{split}\begin{eqnarray*} \mathbf{\ell}_\mathbf{xx} &=& \mathbf{R_x}^T\mathbf{R_x} \\ \mathbf{\ell}_\mathbf{uu} &=& \mathbf{R_u}^T\mathbf{R_u} \\ \mathbf{\ell}_\mathbf{xu} &=& \mathbf{R_x}^T\mathbf{R_u} \end{eqnarray*}\end{split}\]
where the Jacobians of the cost residuals are denoted by \(\mathbf{R_x}\) and \(\mathbf{R_u}\). Note that this approximation ignores the tensor products (e.g., \(\mathbf{R_{xx}}\mathbf{r}\)).

Finally, in the case that the cost does not have a residual, we set the Hessian to zero, i.e., \(\mathbf{L_{xx}} = \mathbf{L_{xu}} = \mathbf{L_{uu}} = \mathbf{0}\).

See also

DifferentialActionModelAbstractTpl(), calcDiff()

Public Types

typedef MathBaseTpl<Scalar> MathBase
typedef DifferentialActionModelAbstractTpl<Scalar> Base
typedef DifferentialActionDataNumDiffTpl<Scalar> Data
typedef DifferentialActionDataAbstractTpl<Scalar> DifferentialActionDataAbstract
typedef MathBase::VectorXs VectorXs
typedef MathBase::MatrixXs MatrixXs

Public Functions

EIGEN_MAKE_ALIGNED_OPERATOR_NEW CROCODDYL_DERIVED_CAST (DifferentialActionModelBase, DifferentialActionModelNumDiffTpl) typedef _Scalar Scalar
explicit DifferentialActionModelNumDiffTpl(std::shared_ptr<Base> model, const bool with_gauss_approx = false)

Initialize the numdiff differential action model.

Parameters:
  • model[in] Differential action model that we want to apply the numerical differentiation

  • with_gauss_approx[in] True if we want to use the Gauss approximation for computing the Hessians

virtual ~DifferentialActionModelNumDiffTpl() = default
virtual void calc(const std::shared_ptr<DifferentialActionDataAbstract> &data, const Eigen::Ref<const VectorXs> &x, const Eigen::Ref<const VectorXs> &u) override

Compute the system acceleration and cost value.

Parameters:
  • data[in] Differential action data

  • x[in] State point \(\mathbf{x}\in\mathbb{R}^{ndx}\)

  • u[in] Control input \(\mathbf{u}\in\mathbb{R}^{nu}\)

virtual void calc(const std::shared_ptr<DifferentialActionDataAbstract> &data, const Eigen::Ref<const VectorXs> &x) override
virtual void calcDiff(const std::shared_ptr<DifferentialActionDataAbstract> &data, const Eigen::Ref<const VectorXs> &x, const Eigen::Ref<const VectorXs> &u) override

Compute the derivatives of the dynamics and cost functions.

It computes the partial derivatives of the dynamical system and the cost function. It assumes that calc() has been run first. This function builds a quadratic approximation of the time-continuous action model (i.e. dynamical system and cost function).

Parameters:
  • data[in] Differential action data

  • x[in] State point \(\mathbf{x}\in\mathbb{R}^{ndx}\)

  • u[in] Control input \(\mathbf{u}\in\mathbb{R}^{nu}\)

virtual void calcDiff(const std::shared_ptr<DifferentialActionDataAbstract> &data, const Eigen::Ref<const VectorXs> &x) override
virtual std::shared_ptr<DifferentialActionDataAbstract> createData() override

Create the differential action data.

Returns:

the differential action data

template<typename NewScalar>
DifferentialActionModelNumDiffTpl<NewScalar> cast() const

Cast the diff-action numdiff model to a different scalar type.

It is useful for operations requiring different precision or scalar types.

Template Parameters:

NewScalar – The new scalar type to cast to.

Returns:

DifferentialActionModelNumDiffTpl<NewScalar> A differential-action model with the new scalar type.

virtual void quasiStatic(const std::shared_ptr<DifferentialActionDataAbstract> &data, Eigen::Ref<VectorXs> u, const Eigen::Ref<const VectorXs> &x, const std::size_t maxiter = 100, const Scalar tol = Scalar(1e-9)) override

Computes the quasic static commands.

The quasic static commands are the ones produced for a the reference posture as an equilibrium point, i.e. for \(\mathbf{f}(\mathbf{q},\mathbf{v}=\mathbf{0},\mathbf{u})=\mathbf{0}\)

Parameters:
  • data[in] Differential action data

  • u[out] Quasic static commands

  • x[in] State point (velocity has to be zero)

  • maxiter[in] Maximum allowed number of iterations

  • tol[in] Tolerance

const std::shared_ptr<Base> &get_model() const

Return the differential acton model that we use to numerical differentiate.

const Scalar get_disturbance() const

Return the disturbance constant used in the numerical differentiation routine.

void set_disturbance(const Scalar disturbance)

Modify the disturbance constant used in the numerical differentiation routine.

bool get_with_gauss_approx()

Identify if the Gauss approximation is going to be used or not.

virtual void print(std::ostream &os) const override

Print relevant information of the action numdiff model.

Parameters:

os[out] Output stream object

Protected Attributes

bool has_control_limits_

Indicates whether any of the control limits is finite

std::size_t nr_

< Indicates whether any of the control limits

std::size_t nu_

< Dimension of the cost residual

std::shared_ptr<StateAbstract> state_

< Control dimension

VectorXs u_lb_

< Model of the state

VectorXs u_ub_

< Lower control limits