#include "signals/Signal.h"

Classes
struct	State< T, PoseTypeSpec, PoseDim, TwistTypeSpec, TwistDim >
	Base type for all Model state representations. More...

struct	ScalarStateSignalSpec< T >
	Type specification for scalar state signals. More...

struct	VectorStateSignalSpec< T, d >
	Type specification for vector state signals. More...

struct	ManifoldStateSignalSpec< T, ManifoldType, PD, TD >
	Type specification for manifold state signals. More...

Macros
#define	MAKE_VECTOR_STATES(Dimension)

#define	MAKE_MANIF_STATES(Manif, Dimension, TangentDimension)

Typedefs
template<typename T>
using	ScalarStateType = State<T, ScalarSignalSpec<T>, 1, ScalarSignalSpec<T>, 1>

template<typename T, size_t d>
using	VectorStateType = State<T, VectorSignalSpec<T, d>, d, VectorSignalSpec<T, d>, d>

template<typename T, typename ManifoldType, size_t PD, size_t TD>
using	ManifoldStateType = State<T, ManifoldSignalSpec<T, ManifoldType>, PD, VectorSignalSpec<T, TD>, TD>

template<typename T>
using	ScalarStateSignal = Signal<T, ScalarStateSignalSpec<T>, ScalarStateSignalSpec<T>>

template<typename T, size_t d>
using	VectorStateSignal = Signal<T, VectorStateSignalSpec<T, d>, VectorStateSignalSpec<T, d>>

template<typename T, typename ManifoldType, size_t PD, size_t TD>
using	ManifoldStateSignal = Signal<T, ManifoldStateSignalSpec<T, ManifoldType, PD, TD>, VectorStateSignalSpec<T, TD>>

template<typename T>
using	ScalarState = ScalarStateType<T>

typedef ScalarState< double >	ScalardState

typedef ScalarStateSignal< double >	ScalardStateSignal

template<typename T>
using	Vector1State = VectorStateType<T, 1>

template<typename T>
using	Vector1StateSignal = VectorStateSignal<T, 1>

typedef Vector1State< double >	Vector1dState

typedef Vector1StateSignal< double >	Vector1dStateSignal

template<typename T>
using	Vector2State = VectorStateType<T, 2>

template<typename T>
using	Vector2StateSignal = VectorStateSignal<T, 2>

typedef Vector2State< double >	Vector2dState

typedef Vector2StateSignal< double >	Vector2dStateSignal

template<typename T>
using	Vector3State = VectorStateType<T, 3>

template<typename T>
using	Vector3StateSignal = VectorStateSignal<T, 3>

typedef Vector3State< double >	Vector3dState

typedef Vector3StateSignal< double >	Vector3dStateSignal

template<typename T>
using	Vector4State = VectorStateType<T, 4>

template<typename T>
using	Vector4StateSignal = VectorStateSignal<T, 4>

typedef Vector4State< double >	Vector4dState

typedef Vector4StateSignal< double >	Vector4dStateSignal

template<typename T>
using	Vector5State = VectorStateType<T, 5>

template<typename T>
using	Vector5StateSignal = VectorStateSignal<T, 5>

typedef Vector5State< double >	Vector5dState

typedef Vector5StateSignal< double >	Vector5dStateSignal

template<typename T>
using	Vector6State = VectorStateType<T, 6>

template<typename T>
using	Vector6StateSignal = VectorStateSignal<T, 6>

typedef Vector6State< double >	Vector6dState

typedef Vector6StateSignal< double >	Vector6dStateSignal

template<typename T>
using	Vector7State = VectorStateType<T, 7>

template<typename T>
using	Vector7StateSignal = VectorStateSignal<T, 7>

typedef Vector7State< double >	Vector7dState

typedef Vector7StateSignal< double >	Vector7dStateSignal

template<typename T>
using	Vector8State = VectorStateType<T, 8>

template<typename T>
using	Vector8StateSignal = VectorStateSignal<T, 8>

typedef Vector8State< double >	Vector8dState

typedef Vector8StateSignal< double >	Vector8dStateSignal

template<typename T>
using	Vector9State = VectorStateType<T, 9>

template<typename T>
using	Vector9StateSignal = VectorStateSignal<T, 9>

typedef Vector9State< double >	Vector9dState

typedef Vector9StateSignal< double >	Vector9dStateSignal

template<typename T>
using	Vector10State = VectorStateType<T, 10>

template<typename T>
using	Vector10StateSignal = VectorStateSignal<T, 10>

typedef Vector10State< double >	Vector10dState

typedef Vector10StateSignal< double >	Vector10dStateSignal

template<typename T>
using	SO2State = ManifoldStateType<T, SO2<T>, 2, 1>

template<typename T>
using	SO2StateSignal = ManifoldStateSignal<T, SO2<T>, 2, 1>

typedef SO2State< double >	SO2dState

typedef SO2StateSignal< double >	SO2dStateSignal

template<typename T>
using	SO3State = ManifoldStateType<T, SO3<T>, 4, 3>

template<typename T>
using	SO3StateSignal = ManifoldStateSignal<T, SO3<T>, 4, 3>

typedef SO3State< double >	SO3dState

typedef SO3StateSignal< double >	SO3dStateSignal

template<typename T>
using	SE2State = ManifoldStateType<T, SE2<T>, 4, 3>

template<typename T>
using	SE2StateSignal = ManifoldStateSignal<T, SE2<T>, 4, 3>

typedef SE2State< double >	SE2dState

typedef SE2StateSignal< double >	SE2dStateSignal

template<typename T>
using	SE3State = ManifoldStateType<T, SE3<T>, 7, 6>

template<typename T>
using	SE3StateSignal = ManifoldStateSignal<T, SE3<T>, 7, 6>

typedef SE3State< double >	SE3dState

typedef SE3StateSignal< double >	SE3dStateSignal

Functions
template<typename T, typename PTS, size_t PD, typename TTS, size_t TD>
State< T, PTS, PD, TTS, TD >	operator+ (const State< T, PTS, PD, TTS, TD > &l, const State< T, TTS, TD, TTS, TD > &r)
	Add a tangent space state (twist and derivative of twist) to the current state.

template<typename T, typename PTS, size_t PD, typename TTS, size_t TD>
State< T, TTS, TD, TTS, TD >	operator- (const State< T, PTS, PD, TTS, TD > &l, const State< T, PTS, PD, TTS, TD > &r)
	Subtract a tangent space state (twist and derivative of twist) from the current state.

template<typename T, typename PTS, size_t PD, typename TTS, size_t TD>
State< T, PTS, PD, TTS, TD >	operator* (const double &l, const State< T, PTS, PD, TTS, TD > &r)
	Scale the state (pose and twist) by a scalar.

template<typename T, typename PTS, size_t PD, typename TTS, size_t TD>
State< T, PTS, PD, TTS, TD >	operator* (const State< T, PTS, PD, TTS, TD > &l, const double &r)
	Scale the state (pose and twist) by a scalar.

template<typename T>
std::ostream &	operator<< (std::ostream &os, const ScalarStateType< T > &x)

template<typename T>
ScalarStateType< T >	operator/ (const ScalarStateType< T > &l, const double &r)
	Scale the state (pose and twist) by a scalar.

template<typename T, size_t d>
std::ostream &	operator<< (std::ostream &os, const VectorStateType< T, d > &x)

template<typename T, size_t d>
VectorStateType< T, d >	operator/ (const VectorStateType< T, d > &l, const double &r)
	Scale the state (pose and twist) by a scalar.

template<typename T, typename ManifoldType, size_t PD, size_t TD>
std::ostream &	operator<< (std::ostream &os, const ManifoldStateType< T, ManifoldType, PD, TD > &x)

template<typename T>
std::ostream &	operator<< (std::ostream &os, const ScalarStateSignal< T > &x)

template<typename T, size_t d>
std::ostream &	operator<< (std::ostream &os, const VectorStateSignal< T, d > &x)

template<typename T, typename ManifoldType, size_t PD, size_t TD>
std::ostream &	operator<< (std::ostream &os, const ManifoldStateSignal< T, ManifoldType, PD, TD > &x)

Macro Definition Documentation

◆ MAKE_MANIF_STATES

#define MAKE_MANIF_STATES	(	Manif,
		Dimension,
		TangentDimension )

Value:

    template<typename T>                                                                                               \
    using Manif##State = ManifoldStateType<T, Manif<T>, Dimension, TangentDimension>;                                  \
    template<typename T>                                                                                               \
    using Manif##StateSignal = ManifoldStateSignal<T, Manif<T>, Dimension, TangentDimension>;                          \
    typedef Manif##State<double>       Manif##dState;                                                                  \
    typedef Manif##StateSignal<double> Manif##dStateSignal;

◆ MAKE_VECTOR_STATES

#define MAKE_VECTOR_STATES ( Dimension )

Value:

    template<typename T>                                                                                               \
    using Vector##Dimension##State = VectorStateType<T, Dimension>;                                                    \
    template<typename T>                                                                                               \
    using Vector##Dimension##StateSignal = VectorStateSignal<T, Dimension>;                                            \
    typedef Vector##Dimension##State<double>       Vector##Dimension##dState;                                          \
    typedef Vector##Dimension##StateSignal<double> Vector##Dimension##dStateSignal;