manif is a Lie theory library for stateestimation targeted at robotics applications. It is developed as a headeronly C++11 library with Python 3 wrappers.
At the moment, it provides the groups:
Other Lie groups can and will be added, contributions are welcome.
manif is based on the mathematical presentation of the Lie theory available in this paper. We recommend every user of manif to read the paper (17 pages) before starting to use the library. The paper provides a thorough introduction to Lie theory, in a simplified way so as to make the entrance to Lie theory easy for the average roboticist who is interested in designing rigorous and elegant state estimation algorithms.
You may also find the following video online, 'Lie theory for the roboticist', a lecture given at IRIUPC. In a rush? Check out our Lie group cheat sheet.
It provides analytic computation of Jacobians for all the operations listed below.
Get quickly started with manif following our 'quick start' guides for both C++ and Python.
Operation  Code  

Base Operation  
Inverse  X.inverse() 

Composition 
X * Y X.compose(Y)


Hat  w.hat() 

Act on vector  X.act(v) 

Retract to group element  w.exp() 

Lift to tangent space  X.log() 

Manifold Adjoint  X.adj() 

Tangent adjoint  w.smallAdj() 

Composed Operation  
Manifold right plus 
X + w X.plus(w) X.rplus(w)


Manifold left plus 
w + X w.plus(X) w.lplus(X)


Manifold right minus 
X  Y X.minus(Y) X.rminus(Y)


Manifold left minus  X.lminus(Y) 

Between  X.between(Y) 

Inner Product  w.inner(t) 

Norm 
w.weightedNorm() w.squaredWeightedNorm()

Above, represent group elements,
represent elements in the Lie algebra of the Lie group,
or w,t
represent the same elements of the tangent space
but expressed in Cartesian coordinates in ,
and or v
represents any element of .
All operations come with their respective analytical Jacobian matrices. Throughout manif, Jacobians are differentiated with respect to a local perturbation on the tangent space. These Jacobians map tangent spaces, as described in this paper.
Currently, manif implements the right Jacobian, whose definition reads:
The Jacobians of any of the aforementionned operations can then be evaluated:
in C++,
SE3d X = SE3d::Random();
SE3Tangentd w = SE3Tangentd::Random();
SE3d::Jacobian J_o_x, J_o_w;
auto X_plus_w = X.plus(w, J_o_x, J_o_w);
in Python,
X = SE3.Random()
w = SE3Tangentd.Random()
J_o_x = np.zeros((SE3.DoF, SE3.DoF))
J_o_w = np.zeros((SE3.DoF, SE3.DoF))
X_plus_w = X.plus(w, J_o_x, J_o_w)
The documentation is available online at the accompanying website. Both the C++ and the Python APIs are documented.
Do you want to build it locally? Find out how on the dedicated page.
Note: throughout the code documentation we refer to 'the paper' which you can find on the dedicated page.
We provide some selfcontained and selfexplained C++ examples to help you get started.
You prefer Python? The same examples are also available in Python.
Check out our related publications and how to cite them.
Find out who's already using manif.
Want to contribute? Great! Check out our contribution guidelines.