Classes
class	CartesianProduct
	Represents the Cartesian product of other `StateSpace`s. More...

class	CompoundStateHandle
	`StateHandle` for a `CartesianProduct`. More...

class	GeodesicInterpolator
	Interpolate by parallel transport along a geodesic between two states in a Lie group with an affine connection. More...

class	Interpolator
	Method of interpolating between two states in a `StateSpace`. More...

class	R
	Represents a N-dimensional real vector space with vector addition as the group operation. More...

class	RStateHandle
	`StateHandle` for a `Rn`. More...

class	ScopedState
	CRTP RAII wrapper for a `StateHandle`. More...

class	SE2
	The two-dimensional special Euclidean group SE(2), i.e. More...

class	SE2StateHandle
	`StateHandle` for a `SE2`. More...

class	SE3
	The three-dimensional special Euclidean group SE(3), i.e. More...

class	SE3StateHandle
	`StateHandle` for a `SE3`. More...

class	SO2
	The two-dimensional special orthogonal group SO(2), i.e. More...

class	SO2StateHandle
	`StateHandle` for a `SO2`. More...

class	SO3
	The two-dimensional special orthogonal group SO(3), i.e. More...

class	SO3StateHandle
	`StateHandle` for a `SO3`. More...

class	StateHandle
	Wrap a State with its StateSpace to provide convenient accessor methods. More...

class	StateSpace
	Represents a Lie group and its associated Lie algebra, i.e. More...

Typedefs
using	CartesianProductPtr = std::shared_ptr< CartesianProduct >

using	ConstCartesianProductPtr = std::shared_ptr< const CartesianProduct >

using	WeakCartesianProductPtr = std::weak_ptr< CartesianProduct >

using	WeakConstCartesianProductPtr = std::weak_ptr< const CartesianProduct >

using	UniqueCartesianProductPtr = std::unique_ptr< CartesianProduct >

using	UniqueConstCartesianProductPtr = std::unique_ptr< const CartesianProduct >

using	InterpolatorPtr = std::shared_ptr< Interpolator >

using	ConstInterpolatorPtr = std::shared_ptr< const Interpolator >

using	WeakInterpolatorPtr = std::weak_ptr< Interpolator >

using	WeakConstInterpolatorPtr = std::weak_ptr< const Interpolator >

using	UniqueInterpolatorPtr = std::unique_ptr< Interpolator >

using	UniqueConstInterpolatorPtr = std::unique_ptr< const Interpolator >

using	R0 = R< 0 >

using	R1 = R< 1 >

using	R2 = R< 2 >

using	R3 = R< 3 >

using	R6 = R< 6 >

using	Rn = R< Eigen::Dynamic >

using	StateSpacePtr = std::shared_ptr< StateSpace >

using	ConstStateSpacePtr = std::shared_ptr< const StateSpace >

using	WeakStateSpacePtr = std::weak_ptr< StateSpace >

using	WeakConstStateSpacePtr = std::weak_ptr< const StateSpace >

using	UniqueStateSpacePtr = std::unique_ptr< StateSpace >

using	UniqueConstStateSpacePtr = std::unique_ptr< const StateSpace >