v0.1.0

LieGroups v0.1.0

Diff since v0.0.3

Everything denoted by “formerly” refers to the previous name in Manifolds.jl.
Several structs have been changed from the pre-release, so these are breaking.

Added

• LieAlgebra
• LieGroup (formerly GroupManifold) as well as the concrete groups
  • TranslationGroup
  • SpecialEuclideanGroup (formerly SpecialEuclidean) including
    • SpecialEuclideanMatrixPoint and SpecialEuclideanMatrixTangentVector when representing the points as affine (abstract) matrices
    • SpecialEuclideanProductPoint and SpecialEuclideanProductTangentVector when representing them in a product structure, that is as an ArrayPartition from RecursiveArrayTools.
    • neither of those types is necessary, besides for conversion between both. The product representation differs for the left and right semidirect product, while the affine matrix variant does not.
  • SpecialOrthogonalGroup (formerly SpecialOrthogonal)
  • SpecialUnitaryGroup (formerly SpecialUnitary)
  • OrthogonalGroup (formerly Orthogonal)
  • UnitaryGroup (formerly Unitary) also for quaternions.
  • GeneralLinearGroup (formerly GeneralLinear)
  • HeisenbergGroup
  • LeftSemidirectProductLieGroup (formerly SemidirectProductGroup)
  • ⋉ (alias for LeftSemidirectProductGroupOperation when a default_left_action(G,H) is defined for the two groups)
  • PowerLieGroup (formerly PowerGroup)
  • PowerGroupOperation to internally avoid ambiguities. Since the constructor always expects a Lie group, this is only necessary internally
  • ProductLieGroup (formerly ProductGroup)
  • RightSemidirectProductLieGroup
  • SpecialLinearGroup (formerly SpecialLinear)
  • SymplecticGroup
  • CircleGroup now with even three representations: Real line (mod 2π), Complex and plane circle
  • ⋊ (alias for RightSemidirectProductGroupOperation when a default_right_action(G,H) is defined for the two groups)
  • a ValidationLieGroup verifying input and output of all interface functions, similar to the ValidationManifold which can also be used internally.
• AbstractGroupOperation as well as its concrete subtypes
  • AdditionGroupOperation (formerly AdditionOperation)
  • MatrixMultiplicationGroupOperation (formerly MultiplicationOperation)
  • PowerGroupOperation (formerly the Lie group was stored inside a power manifold)
  • ProductGroupOperation (formerly the Lie groups were stored inside a product manifold)
  • LeftSemidirectProductGroupOperation (this was formerly only implicitly stored in the SemidirectProductGroup)
  • RightSemidirectProductGroupOperation
• AbstractGroupActionType with its 2 specific (new) abstract subtypes
  • AbstractLeftGroupActionType
  • AbstractRightGroupActionType
• For the group operation actions there are now
  • LeftGroupOperationAction (formerly LeftForwardAction)
  • RightGroupOperationAction (formerly RightBackwardAction)
  • InverseLeftGroupOperationAction (formerly RightForwardAction)
  • InverseRightGroupOperationAction (formerly LeftBackwardAction)
• DefaultLieAlgebraOrthogonalBasis (replaces VeeOrthogonalBasis, which is still available in ManifoldsBase.jl)
• AbstractLieGroupPoint and AbstractLieAlgebraTangentVector as abstract types to introduce point and Lie algebra tangent vector representations
• Identity
• applyand apply!
• base_manifold to access the manifold within a Lie group
• compose and compose!
• conjugate and conjugate!
• diff_apply, diff_apply!, diff_group_apply, and diff_group_apply! (formerly apply_diff_[group][!])
• diff_conjugate and diff_conjugate!
• diff_left_compose, diff_left_compose!, diff_right_compose, diff_right_compose! (formerly translate_diff with different sides)
• exp(G::LieGroup, g, X) and exp!(G::LieGroup, h, g, X) (formerly exp_inv and exp_inv!)
• exp(G::LieGroup, X) and exp!(G::LieGroup, h, X) (formerly exp_lie and exp_lie!)
• hat and hat!, with slightly different signatures, since the base point is omitted.
• identity_element and identity_element!
• inv and inv! (inv(::AbstractGroupAction) was formerly switch_direction)
• inv_left_compose, inv_left_compose! and inv_right_compose, inv_right_compose! (these functions correspond to inverse_translate with corresponding direction and side)
• is_identity
• lie_bracket and lie_bracket!
• jacobian_conjugate (formerly adjoint_matrix, which is now a special case of this)
• log(G::LieGroup, g, h) and log!(G::LieGroup, X, g, h) (formerly log_inv and log_inv!)
• log(G::LieGroup, ::Identity, g) and log!(G::LieGroup, X, ::Identity, g) (formerly log_lie and log_lie!)
• switch (formerly switch_side)
• vee and vee!, with slightly different signatures, since the base point is omitted.

Compared to Manifolds.jl

• all translate functions are not implemented here, since you can just use compose. The differentials are implemented as listed above with respect to both left and right argument of compose
• all inverse_apply functions are not implemented here, since it is recommended to use apply(inv(A), g, p) as a replacement.

Merged pull requests:

• Add a ValidationLieGroup (#22) (@kellertuer)
• Implement a default for jacobian_conjugate (#23) (@kellertuer)
• A get-started tutorial (#24) (@kellertuer)
• Add symplectic group (#28) (@kellertuer)
• Port remaining groups (part 1/3): Quaternion Unitary (#29) (@kellertuer)
• Port remaining groups (part 2/3): Special Linear (#30) (@kellertuer)
• Port remaining groups (Part 3/3): The Circle group (#31) (@kellertuer)

Closed issues:

• Add action of the special orthogonal group on more manifolds. (#25)
• Add symplectic group (#26)
• Implement generic jacobian_conjugate (#20)