Template Class StateAbstractTpl

Inheritance Relationships

Base Type

Derived Types

Class Documentation

template<typename _Scalar>
class StateAbstractTpl : public crocoddyl::StateBase

Abstract class for the state representation.

A state is represented by its operators: difference, integrates, transport and their derivatives. The difference operator returns the value of \(\mathbf{x}_{1}\ominus\mathbf{x}_{0}\) operation. Instead the integrate operator returns the value of \(\mathbf{x}\oplus\delta\mathbf{x}\). These operators are used to compared two points on the state manifold \(\mathcal{M}\) or to advance the state given a tangential velocity ( \(T_\mathbf{x} \mathcal{M}\)). Therefore the points \(\mathbf{x}\), \(\mathbf{x}_{0}\) and \(\mathbf{x}_{1}\) belong to the manifold \(\mathcal{M}\); and \(\delta\mathbf{x}\) or \(\mathbf{x}_{1}\ominus\mathbf{x}_{0}\) lie on its tangential space.

See also

diff(), integrate(), Jdiff(), Jintegrate() and JintegrateTransport()

Subclassed by crocoddyl::StateMultibodyTpl< _Scalar >, crocoddyl::StateNumDiffTpl< _Scalar >, crocoddyl::StateVectorTpl< _Scalar >

Public Types

typedef MathBaseTpl<Scalar> MathBase
typedef MathBase::VectorXs VectorXs
typedef MathBase::MatrixXs MatrixXs

Public Functions

StateAbstractTpl(const std::size_t nx, const std::size_t ndx)

Initialize the state dimensions.

Parameters:

  • nx – [in] Dimension of state configuration tuple

  • ndx – [in] Dimension of state tangent vector

StateAbstractTpl()
virtual ~StateAbstractTpl()
virtual VectorXs zero() const = 0

Generate a zero state.

virtual VectorXs rand() const = 0

Generate a random state.

virtual void diff(const Eigen::Ref<const VectorXs> &x0, const Eigen::Ref<const VectorXs> &x1, Eigen::Ref<VectorXs> dxout) const = 0

Compute the state manifold differentiation.

The state differentiation is defined as:

\[\begin{equation*} \delta\mathbf{x} = \mathbf{x}_{1} \ominus \mathbf{x}_{0}, \end{equation*}\]
where \(\mathbf{x}_{1}\), \(\mathbf{x}_{0}\) are the current and previous state which lie in a manifold \(\mathcal{M}\), and \(\delta\mathbf{x} \in T_\mathbf{x} \mathcal{M}\) is the rate of change in the state in the tangent space of the manifold.

Parameters:

  • x0 – [in] Previous state point (size nx)

  • x1 – [in] Current state point (size nx)

  • dxout – [out] Difference between the current and previous state points (size ndx)

virtual void integrate(const Eigen::Ref<const VectorXs> &x, const Eigen::Ref<const VectorXs> &dx, Eigen::Ref<VectorXs> xout) const = 0

Compute the state manifold integration.

The state integration is defined as:

\[\begin{equation*} \mathbf{x}_{next} = \mathbf{x} \oplus \delta\mathbf{x}, \end{equation*}\]
where \(\mathbf{x}\), \(\mathbf{x}_{next}\) are the current and next state which lie in a manifold \(\mathcal{M}\), and \(\delta\mathbf{x} \in T_\mathbf{x} \mathcal{M}\) is the rate of change in the state in the tangent space of the manifold.

Parameters:

  • x – [in] State point (size nx)

  • dx – [in] Velocity vector (size ndx)

  • xout – [out] Next state point (size nx)

virtual void safe_diff(const Eigen::Ref<const VectorXs> &x0, const Eigen::Ref<const VectorXs> &x1, Eigen::Ref<VectorXs> dxout) const

Sanitized diff operator that neutralises invalid components and propagates NaNs where the result cannot be trusted”.

Parameters:

  • x0 – Current state (size nx).

  • x1 – Next state (size nx)

  • dxout – x1 - x0 value with NaNs on invalid entries (size ndx)

virtual void safe_integrate(const Eigen::Ref<const VectorXs> &x, const Eigen::Ref<const VectorXs> &dx, Eigen::Ref<VectorXs> xout) const

Sanitized integrate operator that clamps invalid inputs and marks affected configuration or velocity entries with NaNs.

Parameters:

  • x – Current state (size nx).

  • dx – Displacement of the state (size ndx).

  • xout – x + dx value with NaNs on invalid entries (size nx).

virtual void Jdiff(const Eigen::Ref<const VectorXs> &x0, const Eigen::Ref<const VectorXs> &x1, Eigen::Ref<MatrixXs> Jfirst, Eigen::Ref<MatrixXs> Jsecond, const Jcomponent firstsecond = both) const = 0

Compute the Jacobian of the state manifold differentiation.

The state differentiation is defined as:

\[\begin{equation*} \delta\mathbf{x} = \mathbf{x}_{1} \ominus \mathbf{x}_{0}, \end{equation*}\]
where \(\mathbf{x}_{1}\), \(\mathbf{x}_{0}\) are the current and previous state which lie in a manifold \(\mathcal{M}\), and \(\delta\mathbf{x} \in T_\mathbf{x} \mathcal{M}\) is the rate of change in the state in the tangent space of the manifold.

The Jacobians lie in the tangent space of manifold, i.e. \(\mathbb{R}^{\textrm{ndx}\times\textrm{ndx}}\). Note that the state is represented as a tuple of nx values and its dimension is ndx. Calling \(\boldsymbol{\Delta}(\mathbf{x}_{0}, \mathbf{x}_{1}) \), the difference function, these Jacobians satisfy the following relationships:

  • \(\boldsymbol{\Delta}(\mathbf{x}_{0},\mathbf{x}_{0}\oplus\delta\mathbf{y}) - \boldsymbol{\Delta}(\mathbf{x}_{0},\mathbf{x}_{1}) = \mathbf{J}_{\mathbf{x}_{1}}\delta\mathbf{y} + \mathbf{o}(\mathbf{x}_{0})\).

  • \(\boldsymbol{\Delta}(\mathbf{x}_{0}\oplus\delta\mathbf{y},\mathbf{x}_{1}) - \boldsymbol{\Delta}(\mathbf{x}_{0},\mathbf{x}_{1}) = \mathbf{J}_{\mathbf{x}_{0}}\delta\mathbf{y} + \mathbf{o}(\mathbf{x}_{0})\),

where \(\mathbf{J}_{\mathbf{x}_{1}}\) and \(\mathbf{J}_{\mathbf{x}_{0}}\) are the Jacobian with respect to the current and previous state, respectively.

Parameters:

  • x0 – [in] Previous state point (size nx)

  • x1 – [in] Current state point (size nx)

  • Jfirst – [out] Jacobian of the difference operation relative to the previous state point (size ndx \(\times\)ndx)

  • Jsecond – [out] Jacobian of the difference operation relative to the current state point (size ndx \(\times\)ndx)

  • firstsecond – [in] Argument (either x0 and / or x1) with respect to which the differentiation is performed.

virtual void Jintegrate(const Eigen::Ref<const VectorXs> &x, const Eigen::Ref<const VectorXs> &dx, Eigen::Ref<MatrixXs> Jfirst, Eigen::Ref<MatrixXs> Jsecond, const Jcomponent firstsecond = both, const AssignmentOp op = setto) const = 0

Compute the Jacobian of the state manifold integration.

The state integration is defined as:

\[\begin{equation*} \mathbf{x}_{next} = \mathbf{x} \oplus \delta\mathbf{x}, \end{equation*}\]
where \(\mathbf{x}\), \(\mathbf{x}_{next}\) are the current and next state which lie in a manifold \(\mathcal{M}\), and \(\delta\mathbf{x} \in T_\mathbf{x} \mathcal{M}\) is the rate of change in the state in the tangent space of the manifold.

The Jacobians lie in the tangent space of manifold, i.e. \(\mathbb{R}^{\textrm{ndx}\times\textrm{ndx}}\). Note that the state is represented as a tuple of nx values and its dimension is ndx. Calling \( \mathbf{f}(\mathbf{x}, \delta\mathbf{x}) \), the integrate function, these Jacobians satisfy the following relationships:

  • \(\mathbf{f}(\mathbf{x}\oplus\delta\mathbf{y},\delta\mathbf{x})\ominus\mathbf{f}(\mathbf{x},\delta\mathbf{x}) = \mathbf{J}_\mathbf{x}\delta\mathbf{y} + \mathbf{o}(\delta\mathbf{x})\).

  • \(\mathbf{f}(\mathbf{x},\delta\mathbf{x}+\delta\mathbf{y})\ominus\mathbf{f}(\mathbf{x},\delta\mathbf{x}) = \mathbf{J}_{\delta\mathbf{x}}\delta\mathbf{y} + \mathbf{o}(\delta\mathbf{x})\),

where \(\mathbf{J}_{\delta\mathbf{x}}\) and \(\mathbf{J}_{\mathbf{x}}\) are the Jacobian with respect to the state and velocity, respectively.

Parameters:

  • x – [in] State point (size nx)

  • dx – [in] Velocity vector (size ndx)

  • Jfirst – [out] Jacobian of the integration operation relative to the state point (size ndx \(\times\)ndx)

  • Jsecond – [out] Jacobian of the integration operation relative to the velocity vector (size ndx \(\times\)ndx)

  • firstsecond – [in] Argument (either x and / or dx) with respect to which the differentiation is performed

  • op – [in] Assignment operator which sets, adds, or removes the given Jacobian matrix

virtual void JintegrateTransport(const Eigen::Ref<const VectorXs> &x, const Eigen::Ref<const VectorXs> &dx, Eigen::Ref<MatrixXs> Jin, const Jcomponent firstsecond) const = 0

Parallel transport from integrate(x, dx) to x.

This function performs the parallel transportation of an input matrix whose columns are expressed in the tangent space at \(\mathbf{x}\oplus\delta\mathbf{x}\) to the tangent space at \(\mathbf{x}\) point.

Parameters:

  • x – [in] State point (size nx).

  • dx – [in] Velocity vector (size ndx)

  • Jin – [out] Input matrix (number of rows = nv).

  • firstsecond – [in] Argument (either x or dx) with respect to which the differentiation of Jintegrate is performed.

VectorXs diff_dx(const Eigen::Ref<const VectorXs> &x0, const Eigen::Ref<const VectorXs> &x1)

Compute the state manifold differentiation.

Parameters:

  • x0 – [in] Previous state point (size nx)

  • x1 – [in] Current state point (size nx)

Returns:

Difference between the current and previous state points (size ndx)

VectorXs integrate_x(const Eigen::Ref<const VectorXs> &x, const Eigen::Ref<const VectorXs> &dx)

Compute the state manifold integration.

Parameters:

  • x – [in] State point (size nx)

  • dx – [in] Velocity vector (size ndx)

Returns:

Next state point (size nx)

std::vector<MatrixXs> Jdiff_Js(const Eigen::Ref<const VectorXs> &x0, const Eigen::Ref<const VectorXs> &x1, const Jcomponent firstsecond = both)
Parameters:

  • x0 – [in] Previous state point (size nx)

  • x1 – [in] Current state point (size nx)

Returns:

Jacobians

std::vector<MatrixXs> Jintegrate_Js(const Eigen::Ref<const VectorXs> &x, const Eigen::Ref<const VectorXs> &dx, const Jcomponent firstsecond = both)

Compute the Jacobian of the state manifold integration.

Parameters:

  • x – [in] State point (size nx)

  • dx – [in] Velocity vector (size ndx)

Returns:

Jacobians

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

Print relevant information of the state model.

Parameters:

os – [out] Output stream object

std::size_t get_nx() const

Return the dimension of the state tuple.

std::size_t get_ndx() const

Return the dimension of the tangent space of the state manifold.

std::size_t get_nq() const

Return the dimension of the configuration tuple.

std::size_t get_nv() const

Return the dimension of tangent space of the configuration manifold.

const VectorXs &get_lb() const

Return the state lower bound.

const VectorXs &get_ub() const

Return the state upper bound.

bool get_has_limits() const

Indicate if the state has defined limits.

void set_lb(const VectorXs &lb)

Modify the state lower bound.

void set_ub(const VectorXs &ub)

Modify the state upper bound.

Public Members

EIGEN_MAKE_ALIGNED_OPERATOR_NEW typedef _Scalar Scalar

Protected Functions

void update_has_limits()

Protected Attributes

std::size_t nx_

State dimension.

std::size_t ndx_

State rate dimension.

std::size_t nq_

Configuration dimension.

std::size_t nv_

Velocity dimension.

VectorXs lb_

Lower state limits.

VectorXs ub_

Upper state limits.

bool has_limits_

Indicates whether any of the state limits is finite.

Friends

template<class Scalar>
friend std::ostream &operator<<(std::ostream &os, const ActionModelAbstractTpl<Scalar> &model)

Print information on the state model.