Class MatrixLieGroup

Initializes the Lie group.

:param n: dimension of the matrix group. :param algebra: instance of :py:class:MatrixLieAlgebra

Overrides: object.__init__

           Converts an element of the group to the algebra. 
           Uses generic matrix logarithm plus projection.
       


:param g: 
:type g:  ``belongs``

:rtype:  ``belongs_algebra``

           Computes the distance between two points.
       
           In the case of Lie groups, this is done by 
           translating everything to the origin, computing the
           logmap, and using the norm defined in the Lie Algebra object.

       


:param a: 
:type a:  ``belongs``

:param b: 
:type b:  ``belongs``

Overrides: differentiable_manifold.DifferentiableManifold.distance

           This is the inverse of :py:func:`logmap_`. 
       
           In the case of Lie groups, this is implemented using
           the usual matrix exponential.

           Here the :py:func:`MatrixLieAlgebra.project` function
           is used to mitigate numerical errors. 
       


:param bv: 
:type bv:  ``belongs_ts``

:rtype:  ``belongs``

Overrides: differentiable_manifold.DifferentiableManifold.expmap

           Converts an element of the algebra to the group. 
       
           Uses generic matrix exponential.
       


:param a: 
:type a:  ``belongs_algebra``

:rtype:  ``belongs``

:param g: :type g: ``belongs``

:rtype: ``belongs``

Overrides: group.Group.inverse

           Returns the direction from base to target. 
       
           In the case of Lie groups, this is implemented
           by using the usual matrix logarithm at the origin.
           
           Here the :py:func:`MatrixLieAlgebra.project` function
           is used to mitigate numerical errors. 
       


:param base: 
:type base:  ``belongs``

:param target: 
:type target:  ``belongs``

:rtype:  ``belongs_ts``

Overrides: differentiable_manifold.DifferentiableManifold.logmap

:param h: :type h: ``belongs``

:param g: :type g: ``belongs``

Overrides: group.Group.multiply

           Projects the vector *x* to the tangent space at point *base*.
       
           In the case of Lie Groups, we do this by translating the
           vector to the origin, projecting it to the Lie Algebra,
           and then translating it back. 
       


:param bv: 
:type bv:  ``tuple(belongs,*)``

Overrides: differentiable_manifold.DifferentiableManifold.project_ts

Returns the manifold corresponding to the tangent bundle. The default gives a generic implementation. MatrixLieGroup have a different one.

Overrides: differentiable_manifold.DifferentiableManifold.tangent_bundle

(inherited documentation)

Returns the group unity.

Overrides: group.Group.unity

(inherited documentation)

           Find the velocity in local frame to go from *a* to *b* in 
           *delta* time. 
       


:param a: 
:type a:  ``belongs``

:param b: 
:type b:  ``belongs``

:rtype:  ``belongs_ts``