Abstract class for the state representation. More...

#include <state-base.hpp>

Inheritance diagram for StateAbstractTpl< _Scalar >:

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.

Detailed Description

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

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()

Definition at line 46 of file state-base.hpp.

Constructor & Destructor Documentation

◆ StateAbstractTpl()

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

Initialize the state dimensions.

Parameters

[in]	nx	Dimension of state configuration tuple
[in]	ndx	Dimension of state tangent vector

Member Function Documentation

◆ diff()

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

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.

Parameters

[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 >.

◆ integrate()

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

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.

Parameters

[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 >.

◆ Jdiff()

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

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:

\(\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

[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 >.

◆ Jintegrate()

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

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:

\(\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

[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 >.

◆ JintegrateTransport()

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

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.

Parameters

[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 >.

◆ diff_dx()

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

Compute the state manifold differentiation.

Parameters

[in]	x0	Previous state point (size `nx`)
[in]	x1	Current state point (size `nx`)

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

◆ integrate_x()

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

Compute the state manifold integration.

Parameters

[in]	x	State point (size `nx`)
[in]	dx	Velocity vector (size `ndx`)

Returns: Next state point (size nx)

◆ Jdiff_Js()

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

Parameters

[in]	x0	Previous state point (size `nx`)
[in]	x1	Current state point (size `nx`)

Returns: Jacobians

◆ Jintegrate_Js()

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

[in]	x	State point (size `nx`)
[in]	dx	Velocity vector (size `ndx`)

Returns: Jacobians

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

/root/robotpkg/optimization/py-crocoddyl/work/crocoddyl-2.1.0/include/crocoddyl/core/fwd.hpp
/root/robotpkg/optimization/py-crocoddyl/work/crocoddyl-2.1.0/include/crocoddyl/core/state-base.hpp

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

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

Constructor & Destructor Documentation

◆ StateAbstractTpl()

Member Function Documentation

◆ diff()

◆ integrate()

◆ Jdiff()

◆ Jintegrate()

◆ JintegrateTransport()

◆ diff_dx()

◆ integrate_x()

◆ Jdiff_Js()

◆ Jintegrate_Js()

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