Abstract class for the state representation. More...
#include <state-base.hpp>
Public Types | |
typedef MathBaseTpl< Scalar > | MathBase |
typedef MathBase::MatrixXs | MatrixXs |
typedef MathBase::VectorXs | VectorXs |
Public Member Functions | |
StateAbstractTpl (const std::size_t nx, const std::size_t ndx) | |
Initialize the state dimensions. More... | |
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. More... | |
VectorXs | diff_dx (const Eigen::Ref< const VectorXs > &x0, const Eigen::Ref< const VectorXs > &x1) |
Compute the state manifold differentiation. More... | |
bool | get_has_limits () const |
Indicate if the state has defined limits. | |
const VectorXs & | get_lb () const |
Return the state lower bound. | |
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. | |
std::size_t | get_nx () const |
Return the dimension of the state tuple. | |
const VectorXs & | get_ub () const |
Return the state upper bound. | |
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. More... | |
VectorXs | integrate_x (const Eigen::Ref< const VectorXs > &x, const Eigen::Ref< const VectorXs > &dx) |
Compute the state manifold integration. More... | |
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. More... | |
std::vector< MatrixXs > | Jdiff_Js (const Eigen::Ref< const VectorXs > &x0, const Eigen::Ref< const VectorXs > &x1, const Jcomponent firstsecond=both) |
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. More... | |
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. More... | |
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. More... | |
virtual VectorXs | rand () const =0 |
Generate a random state. | |
void | set_lb (const VectorXs &lb) |
Modify the state lower bound. | |
void | set_ub (const VectorXs &ub) |
Modify the state upper bound. | |
virtual VectorXs | zero () const =0 |
Generate a zero state. | |
Public Attributes | |
EIGEN_MAKE_ALIGNED_OPERATOR_NEW typedef _Scalar | Scalar |
Protected Member Functions | |
void | update_has_limits () |
Protected Attributes | |
bool | has_limits_ |
Indicates whether any of the state limits is finite. | |
VectorXs | lb_ |
Lower state limits. | |
std::size_t | ndx_ |
State rate dimension. | |
std::size_t | nq_ |
Configuration dimension. | |
std::size_t | nv_ |
Velocity dimension. | |
std::size_t | nx_ |
State dimension. | |
VectorXs | ub_ |
Upper state limits. | |
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.
diff()
, integrate()
, Jdiff()
, Jintegrate()
and JintegrateTransport()
Definition at line 46 of file state-base.hpp.
StateAbstractTpl | ( | const std::size_t | nx, |
const std::size_t | ndx | ||
) |
Initialize the state dimensions.
[in] | nx | Dimension of state configuration tuple |
[in] | ndx | Dimension of state tangent vector |
|
pure virtual |
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.
[in] | x0 | Previous state point (size nx ) |
[in] | x1 | Current state point (size nx ) |
[out] | dxout | Difference between the current and previous state points (size ndx ) |
Implemented in StateMultibodyTpl< _Scalar >, StateVectorTpl< _Scalar >, and StateNumDiffTpl< _Scalar >.
|
pure virtual |
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.
[in] | x | State point (size nx ) |
[in] | dx | Velocity vector (size ndx ) |
[out] | xout | Next state point (size nx ) |
Implemented in StateMultibodyTpl< _Scalar >, StateVectorTpl< _Scalar >, and StateNumDiffTpl< _Scalar >.
|
pure virtual |
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:
where \(\mathbf{J}_{\mathbf{x}_{1}}\) and \(\mathbf{J}_{\mathbf{x}_{0}}\) are the Jacobian with respect to the current and previous state, respectively.
[in] | x0 | Previous state point (size nx ) |
[in] | x1 | Current state point (size nx ) |
[out] | Jfirst | Jacobian of the difference operation relative to the previous state point (size ndx \(\times\)ndx ) |
[out] | Jsecond | Jacobian of the difference operation relative to the current state point (size ndx \(\times\)ndx ) |
[in] | firstsecond | Argument (either x0 and / or x1) with respect to which the differentiation is performed. |
Implemented in StateNumDiffTpl< _Scalar >, StateMultibodyTpl< _Scalar >, and StateVectorTpl< _Scalar >.
|
pure virtual |
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:
where \(\mathbf{J}_{\delta\mathbf{x}}\) and \(\mathbf{J}_{\mathbf{x}}\) are the Jacobian with respect to the state and velocity, respectively.
[in] | x | State point (size nx ) |
[in] | dx | Velocity vector (size ndx ) |
[out] | Jfirst | Jacobian of the integration operation relative to the state point (size ndx \(\times\)ndx ) |
[out] | Jsecond | Jacobian of the integration operation relative to the velocity vector (size ndx \(\times\)ndx ) |
[in] | firstsecond | Argument (either x and / or dx) with respect to which the differentiation is performed |
[in] | op | Assignment operator which sets, adds, or removes the given Jacobian matrix |
Implemented in StateMultibodyTpl< _Scalar >, StateVectorTpl< _Scalar >, and StateNumDiffTpl< _Scalar >.
|
pure virtual |
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.
[in] | x | State point (size nx ). |
[in] | dx | Velocity vector (size ndx ) |
[out] | Jin | Input matrix (number of rows = nv ). |
[in] | firstsecond | Argument (either x or dx) with respect to which the differentiation of Jintegrate is performed. |
Implemented in StateNumDiffTpl< _Scalar >, StateMultibodyTpl< _Scalar >, and StateVectorTpl< _Scalar >.
VectorXs diff_dx | ( | const Eigen::Ref< const VectorXs > & | x0, |
const Eigen::Ref< const VectorXs > & | x1 | ||
) |
Compute the state manifold differentiation.
[in] | x0 | Previous state point (size nx ) |
[in] | x1 | Current state point (size nx ) |
ndx
) VectorXs integrate_x | ( | const Eigen::Ref< const VectorXs > & | x, |
const Eigen::Ref< const VectorXs > & | dx | ||
) |
Compute the state manifold integration.
[in] | x | State point (size nx ) |
[in] | dx | Velocity vector (size ndx ) |
nx
) std::vector<MatrixXs> Jdiff_Js | ( | const Eigen::Ref< const VectorXs > & | x0, |
const Eigen::Ref< const VectorXs > & | x1, | ||
const Jcomponent | firstsecond = both |
||
) |
[in] | x0 | Previous state point (size nx ) |
[in] | x1 | Current state point (size nx ) |
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.
[in] | x | State point (size nx ) |
[in] | dx | Velocity vector (size ndx ) |