Basic API

[joansola]

This is a first attempt. Derived classes must implement all methods:

template <Size vector_size; Size manifold_size>
class manifold {
typedef Matrix<Scalar, vector_size, 1> VectorType;
typedef Matrix<Scalar, manifold_size, 1> ManifoldType;
typedef Matrix<Scalar, vector_size, vector_size> JacobianType;

// First, a bunch of static methods:

// lift and retract
static VectorType lift(ManifoldType);
static ManifoldType retract(VectorType);

// inverse and compose
static ManifoldType inverse(ManifoldType);
static ManifoldType compose(ManifoldType m1, ManifoldType m2);
static ManifoldType between(ManifoldType m1, ManifoldType m2);

// right plus and minus
static ManifoldType rplus(ManifoldType, VectorType);
static VectorType rminus(Manifoldtype, ManifoldType);

// left plus and minus
static ManifoldType lplus(VectorType, ManifoldType);
static VectorType lminus(Manifoldtype, ManifoldType);

// left and right Jacobians
static JacobianType Jr(VectorType);
static JacobianType Jr_inv(VectorType);
static JacobianType Jl(VectorType);
static JacobianType Jl_inv(VectorType);

// Basic Jacobians
static JacobianType inverse_jac(ManifoldType);
static JacobianType compose_jac_m1(ManifoldType m1, ManifoldType m2);
static JacobianType compose_jac_m2(ManifoldType m1, ManifoldType m2);
// Other Jacobians might be added

// Action of the manifold on vectors
static VectorType operator * (ManifoldType, VectorType)
// other operations might be added

// then actions applied on objects
ManifoldType inverse();
ManifoldType rplus(VectorType);
ManifoldType lplus(VectorType);
VectorType rminus(ManifoldType);
// etc, replicate most of the statics, but using the manifold object as the first input param

[joansola]

It's more probably this (I'm not sure about CRTP):

template<typename ManifoldType, typename VectorType>
class manifold {
...
}

[joansola]

Actually, this looks far more CRTP:

template<typename Derived>
class manifold {
typedef Derived::ManifoldType ManifoldType;
typedef Matrix<ManifoldType::Scalar, ManifoldType::VectorSize, 1> VectorType;
typedef Matrix<ManifoldType::Scalar, ManifoldType::VectorSize, ManifoldType::VectorSize> JacobianType;
...
}

you see my point...

[artivis]

Thanks for this first feedback.

Let us put aside the Jacs at first because I'm not sure yet how to deal with their type (how to define it and forward it to the crtp base class).

I propose we first agree on the semantic, then the overall API and finally on the implementation.
For instance, in your comments, the result of a lift is of type VectorType. So far I have called it a Tangent...

[artivis]

Closing this since the API is fairly stable now.