Template Class ActionModelNumDiffTpl

Inheritance Relationships

Base Type

Class Documentation

template<typename _Scalar>
class ActionModelNumDiffTpl : public crocoddyl::ActionModelAbstractTpl<_Scalar>

This class computes the numerical differentiation of an 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

ActionModelAbstractTpl(), calcDiff()

Public Types

typedef ActionDataAbstractTpl<Scalar> ActionDataAbstract
typedef ActionModelAbstractTpl<Scalar> Base
typedef ActionDataNumDiffTpl<Scalar> Data
typedef MathBaseTpl<Scalar> MathBase
typedef MathBaseTpl<Scalar>::VectorXs VectorXs
typedef MathBaseTpl<Scalar>::MatrixXs MatrixXs

Public Functions

explicit ActionModelNumDiffTpl(std::shared_ptr<Base> model, bool with_gauss_approx = false)

Initialize the numdiff action model.

Parameters:
  • model[in] 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 ~ActionModelNumDiffTpl() = default
virtual void calc(const std::shared_ptr<ActionDataAbstract> &data, const Eigen::Ref<const VectorXs> &x, const Eigen::Ref<const VectorXs> &u) override

Compute the next state and cost value.

Parameters:
  • data[in] 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<ActionDataAbstract> &data, const Eigen::Ref<const VectorXs> &x) override
virtual void calcDiff(const std::shared_ptr<ActionDataAbstract> &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 linear-quadratic approximation of the action model (i.e. dynamical system and cost function).

Parameters:
  • data[in] 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<ActionDataAbstract> &data, const Eigen::Ref<const VectorXs> &x) override
virtual std::shared_ptr<ActionDataAbstract> createData() override

Create the action data.

Returns:

the action data

virtual void quasiStatic(const std::shared_ptr<ActionDataAbstract> &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^q_x}\delta\mathbf{q}+\mathbf{f_u}\delta\mathbf{u}=\mathbf{0}\)

Parameters:
  • data[in] 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

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

Cast the 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:

ActionModelNumDiffTpl<NewScalar> An action model with the new scalar type.

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

Return the 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 diff-action numdiff model.

Parameters:

os[out] Output stream object

Public Members

EIGEN_MAKE_ALIGNED_OPERATOR_NEW typedef _Scalar Scalar

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