From 4ec9631347401babbd3e7a4bcc19db2298af46ba Mon Sep 17 00:00:00 2001 From: "Documenter.jl" Date: Mon, 14 Oct 2024 06:51:46 +0000 Subject: [PATCH] build based on ea78ec4 --- previews/PR8/.documenter-siteinfo.json | 2 +- previews/PR8/about/index.html | 2 +- previews/PR8/contributing/index.html | 2 +- previews/PR8/groups/index.html | 2 +- previews/PR8/groups/translation/index.html | 2 +- previews/PR8/index.html | 2 +- previews/PR8/interface/actions/index.html | 26 ++++++------ previews/PR8/interface/group/index.html | 42 ++++++++++---------- previews/PR8/interface/operations/index.html | 32 +++++++-------- previews/PR8/news/index.html | 2 +- previews/PR8/notation/index.html | 2 +- previews/PR8/references/index.html | 2 +- previews/PR8/tutorials/getstarted/index.html | 2 +- 13 files changed, 60 insertions(+), 60 deletions(-) diff --git a/previews/PR8/.documenter-siteinfo.json b/previews/PR8/.documenter-siteinfo.json index d31acad2..0cb4d329 100644 --- a/previews/PR8/.documenter-siteinfo.json +++ b/previews/PR8/.documenter-siteinfo.json @@ -1 +1 @@ -{"documenter":{"julia_version":"1.10.5","generation_timestamp":"2024-10-13T14:33:57","documenter_version":"1.7.0"}} \ No newline at end of file +{"documenter":{"julia_version":"1.10.5","generation_timestamp":"2024-10-14T06:51:42","documenter_version":"1.7.0"}} \ No newline at end of file diff --git a/previews/PR8/about/index.html b/previews/PR8/about/index.html index da2195a0..c77ed9c9 100644 --- a/previews/PR8/about/index.html +++ b/previews/PR8/about/index.html @@ -1,2 +1,2 @@ -About · LieGroups.jl
GitHub
+About · LieGroups.jl
GitHub
diff --git a/previews/PR8/contributing/index.html b/previews/PR8/contributing/index.html index d5059886..5d8cfe58 100644 --- a/previews/PR8/contributing/index.html +++ b/previews/PR8/contributing/index.html @@ -1,2 +1,2 @@ -Contributing to LieGroups.jl · LieGroups.jl
GitHub

Contributing to LieGroups.jl

First, thanks for taking the time to contribute. Any contribution is appreciated and welcome.

The following is a set of guidelines to LieGroups.jl.

Table of contents

I just have a question

The developer can most easily be reached in the Julia Slack channel #manifolds. You can apply for the Julia Slack workspace here if you haven't joined yet. You can also ask your question on discourse.julialang.org.

How can I file an issue?

If you found a bug or want to propose a feature, please open an issue in within the GitHub repository.

How can I contribute?

Currently we are still consolidating most details and defaults, but feel free to contribute to these discussions within this repository.

Code style

Try to follow the documentation guidelines from the Julia documentation as well as Blue Style. Run JuliaFormatter.jl on the repository in the way set in the .JuliaFormatter.toml file, which enforces a number of conventions consistent with the Blue Style.

Please follow a few internal conventions:

  • Any implemented function should be accompanied by its mathematical formulae if a closed form exists.
  • A Lie group, a Lie group action or a Lie algebra should be implemented in it own file
  • an alphabetical order of functions in every file is preferable.
  • The preceding implies that the mutating variant of a function follows the non-mutating variant.
  • usually, both the allocating and the mutating variants of a function should be documented. For avoiding duplication, one doc string attached to both is preferrable
  • There should be no dangling = signs.
  • Always add a newline between things of different types (struct/method/const).
  • Always add a newline between methods for different functions (including allocating/mutating variants).
  • Prefer to have no newline between methods for the same function; when reasonable, merge the documentation strings.
  • All import/using/include should be in the main module file.
  • import is discouraged and the explicit full name, like Base.exp should be used when implementing functions

Concerning documentation

  • if possible provide both mathematical formulae and literature references using DocumenterCitations.jl and BibTeX where possible
  • Always document all input variables and keyword arguments
+Contributing to LieGroups.jl · LieGroups.jl
GitHub

Contributing to LieGroups.jl

First, thanks for taking the time to contribute. Any contribution is appreciated and welcome.

The following is a set of guidelines to LieGroups.jl.

Table of contents

I just have a question

The developer can most easily be reached in the Julia Slack channel #manifolds. You can apply for the Julia Slack workspace here if you haven't joined yet. You can also ask your question on discourse.julialang.org.

How can I file an issue?

If you found a bug or want to propose a feature, please open an issue in within the GitHub repository.

How can I contribute?

Currently we are still consolidating most details and defaults, but feel free to contribute to these discussions within this repository.

Code style

Try to follow the documentation guidelines from the Julia documentation as well as Blue Style. Run JuliaFormatter.jl on the repository in the way set in the .JuliaFormatter.toml file, which enforces a number of conventions consistent with the Blue Style.

Please follow a few internal conventions:

  • Any implemented function should be accompanied by its mathematical formulae if a closed form exists.
  • A Lie group, a Lie group action or a Lie algebra should be implemented in it own file
  • an alphabetical order of functions in every file is preferable.
  • The preceding implies that the mutating variant of a function follows the non-mutating variant.
  • usually, both the allocating and the mutating variants of a function should be documented. For avoiding duplication, one doc string attached to both is preferrable
  • There should be no dangling = signs.
  • Always add a newline between things of different types (struct/method/const).
  • Always add a newline between methods for different functions (including allocating/mutating variants).
  • Prefer to have no newline between methods for the same function; when reasonable, merge the documentation strings.
  • All import/using/include should be in the main module file.
  • import is discouraged and the explicit full name, like Base.exp should be used when implementing functions

Concerning documentation

  • if possible provide both mathematical formulae and literature references using DocumenterCitations.jl and BibTeX where possible
  • Always document all input variables and keyword arguments
diff --git a/previews/PR8/groups/index.html b/previews/PR8/groups/index.html index 71722808..bd2fe2e7 100644 --- a/previews/PR8/groups/index.html +++ b/previews/PR8/groups/index.html @@ -1,2 +1,2 @@ -List of Lie Groups · LieGroups.jl
GitHub
+List of Lie Groups · LieGroups.jl
GitHub
diff --git a/previews/PR8/groups/translation/index.html b/previews/PR8/groups/translation/index.html index 486348da..a5cee1c2 100644 --- a/previews/PR8/groups/translation/index.html +++ b/previews/PR8/groups/translation/index.html @@ -1,2 +1,2 @@ -Translation group · LieGroups.jl
GitHub
+Translation group · LieGroups.jl
GitHub
diff --git a/previews/PR8/index.html b/previews/PR8/index.html index b0a500c8..5d286cb2 100644 --- a/previews/PR8/index.html +++ b/previews/PR8/index.html @@ -1,2 +1,2 @@ -Home · LieGroups.jl
GitHub
+Home · LieGroups.jl
GitHub
diff --git a/previews/PR8/interface/actions/index.html b/previews/PR8/interface/actions/index.html index 710f9382..ede90191 100644 --- a/previews/PR8/interface/actions/index.html +++ b/previews/PR8/interface/actions/index.html @@ -1,26 +1,26 @@ -A group action · LieGroups.jl
GitHub

An Interface Actions on Lie groups

LieGroups.AbstractLeftGroupActionType — Type
AbstractLeftGroupActionType <: AbstractGroupActionType

A type representing a (smooth) group action $σ: \mathcal G × \mathcal M → \mathcal M$ of a LieGroup $\mathcal G$ acting (from the left) on an AbstractManifold $\mathcal M$. with the following properties

  1. $σ(\mathrm e, p) = p$ holds for all $p ∈ \mathcal M$
  2. $σ(g, σ(h, p)) = σ(g∘h, p)$ holds for all $g,h ∈ \mathcal G$, $p ∈ \mathcal M$

where $∘$ denotes the group operation of the LieGroup $\mathcal G$. See also [HN12, Definition 9.1.11].

The type of action can be seen a bit better when writing the action as a family $σ_g(p)$: we obtain from the second property as

\[ σ_g(σ_h(p)) = σ_{gh}(p)\]

and see that $g$ appears on the left.

To emphasize the side the group operation is acting from, we sometimes write $σ^{\mathrm L}$. If the action is clear from context we write $σ(g, p) = g ⋅ p$.

One notable example of a left action is the inverse of an action of AbstractRightGroupActionType $σ^{\mathrm R}$, which is given by $τ_g = (σ^{\mathrm R}_g)^{-1} = σ^{\mathrm R}_{g^{-1}}$. We obtain

\[τ_g(τ_h(p)) +A group action · LieGroups.jl

GitHub

An Interface Actions on Lie groups

LieGroups.AbstractLeftGroupActionType — Type
AbstractLeftGroupActionType <: AbstractGroupActionType

A type representing a (smooth) group action $σ: \mathcal G × \mathcal M → \mathcal M$ of a LieGroup $\mathcal G$ acting (from the left) on an AbstractManifold $\mathcal M$. with the following properties

  1. $σ(\mathrm e, p) = p$ holds for all $p ∈ \mathcal M$
  2. $σ(g, σ(h, p)) = σ(g∘h, p)$ holds for all $g,h ∈ \mathcal G$, $p ∈ \mathcal M$

where $∘$ denotes the group operation of the LieGroup $\mathcal G$. See also [HN12, Definition 9.1.11].

The type of action can be seen a bit better when writing the action as a family $σ_g(p)$: we obtain from the second property as

\[ σ_g(σ_h(p)) = σ_{gh}(p)\]

and see that $g$ appears on the left.

To emphasize the side the group operation is acting from, we sometimes write $σ^{\mathrm L}$. If the action is clear from context we write $σ(g, p) = g ⋅ p$.

One notable example of a left action is the inverse of an action of AbstractRightGroupActionType $σ^{\mathrm R}$, which is given by $τ_g = (σ^{\mathrm R}_g)^{-1} = σ^{\mathrm R}_{g^{-1}}$. We obtain

\[τ_g(τ_h(p)) = σ^{\mathrm R}_{g^{-1}}(σ^{\mathrm R}_{h^{-1}}(p)) = σ^{\mathrm R}_{h^{-1}g^{-1}}(p) = σ^{\mathrm R}_{(gh)^{-1}}(p) -τ_{gh}(p).\]

Note

In function definitions we follow the idea of the family of actions and use the order (M, g, p) in function signatures.

source
LieGroups.AbstractRightGroupActionType — Type
AbstractRightGroupActionType <: AbstractGroupActionType

A type representing a (smooth) group action $σ: \mathcal M × \mathcal G → \mathcal M$ of a LieGroup $\mathcal G$ acting (from the right) on an AbstractManifold $\mathcal M$. with the following properties

  1. $σ(p, \mathrm e) = p$ holds for all $p ∈ \mathcal M$
  2. $σ(σ(p, g), h) = σ(p, g∘h)$ holds for all $g,h ∈ \mathcal G$, $p ∈ \mathcal M$

where $∘$ denotes the group operation of the LieGroup $\mathcal G$. See also [HN12, Remark 9.1.12].

The type of action can be seen a bit better when writing the action as a family $σ_g(p)$: we obtain from the second property as

\[ σ_g(σ_h(p)) = σ_{hg}(p)\]

and see that $g$ appears on the right.

To emphasize the side the group operation is acting from, we sometimes write $σ^{\mathrm R}$. If the action is clear from context we write $σ(p, g) = p ⋅ g$.

One notable example of a right action is the inverse of an action of AbstractLeftGroupActionType $σ^{\mathrm L}$, which is given by $τ_g = (σ^{\mathrm L}_g)^{-1} = σ^{\mathrm L}_{g^{-1}}$. We obtain

\[τ_g(τ_h(p)) +τ_{gh}(p).\]

Note

In function definitions we follow the idea of the family of actions and use the order (M, g, p) in function signatures.

source
LieGroups.AbstractRightGroupActionType — Type
AbstractRightGroupActionType <: AbstractGroupActionType

A type representing a (smooth) group action $σ: \mathcal M × \mathcal G → \mathcal M$ of a LieGroup $\mathcal G$ acting (from the right) on an AbstractManifold $\mathcal M$. with the following properties

  1. $σ(p, \mathrm e) = p$ holds for all $p ∈ \mathcal M$
  2. $σ(σ(p, g), h) = σ(p, g∘h)$ holds for all $g,h ∈ \mathcal G$, $p ∈ \mathcal M$

where $∘$ denotes the group operation of the LieGroup $\mathcal G$. See also [HN12, Remark 9.1.12].

The type of action can be seen a bit better when writing the action as a family $σ_g(p)$: we obtain from the second property as

\[ σ_g(σ_h(p)) = σ_{hg}(p)\]

and see that $g$ appears on the right.

To emphasize the side the group operation is acting from, we sometimes write $σ^{\mathrm R}$. If the action is clear from context we write $σ(p, g) = p ⋅ g$.

One notable example of a right action is the inverse of an action of AbstractLeftGroupActionType $σ^{\mathrm L}$, which is given by $τ_g = (σ^{\mathrm L}_g)^{-1} = σ^{\mathrm L}_{g^{-1}}$. We obtain

\[τ_g(τ_h(p)) = σ^{\mathrm L}_{g^{-1}}(σ^{\mathrm L}_{h^{-1}}(p)) = σ^{\mathrm L}_{g^{-1}h^{-1}}(p) = σ^{\mathrm L}_{(hg)^{-1}}(p) -τ_{hg}(p).\]

Note

In function definitions we follow the idea of the family of actions and use the order (M, g, p) in function signatures.

source

Functions for Lie group actions

LieGroups.diff_apply! — Method
diff_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
-diff_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)

Compute the differential $D_p σ_g(p): T_p\mathcal M → T_{σ_g(p)}\mathcal M$, where for a left group action we have $σ_g(p) = σ(g,p)$, for a right action $σ_g(p) = σ(p, g)$.

source
LieGroups.diff_apply — Method
diff_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
-diff_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)

Compute the differential $D_p σ_g(p): T_p\mathcal M → T_{σ_g(p)}\mathcal M$, where for a left group action we have $σ_g(p) = σ(g,p)$, for a right action $σ_g(p) = σ(p, g)$.

source
LieGroups.diff_group_apply! — Method
diff_group_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
-diff_group_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)

Compute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$, where we use the short hand notation $σ_p(g) = σ(g,p)$ for a left action, and for a right action $σ_p(g) = σ(p, g)$.

source
LieGroups.diff_group_apply — Method
diff_group_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
-diff_group_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)

Compute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$, where we use the short hand notation $σ_p(g) = σ(g,p)$ for a left action, and for a right action $σ_p(g) = σ(p, g)$.

source
LieGroups.switch — Method
switch(T::AbstractGroupActionType)

Return the object representing an AbstractGroupActionType related to a group operation action that switched the side, that is it turns a left action type into its corresponding right action type.

source
LieGroups.switch — Method
 switch(A::AbstractGroupAction{T})

Return the group operation action representing the similar AbstractGroupAction of AbstractGroupActionType T but acting from the other side. It switches left to right and vice versa. This is done by returning the group action with the “switched” type of T.

source
Manifolds.apply! — Method
apply(A::AbstractGroupAction{T, L, M}, g, p)
-apply!(A::AbstractGroupAction{T, L, M}, q, g, p)

Apply the group action induced by $g ∈ \mathcal G$ to $p ∈ \mathcal M$, where the kind of group action is indicated by the AbstractGroupActionType T. This can be perfomed in-place of q.

source
Manifolds.apply — Method
apply(A::AbstractGroupAction{T, L, M}, g, p)
-apply!(A::AbstractGroupAction{T, L, M}, q, g, p)

Apply the group action induced by $g ∈ \mathcal G$ to $p ∈ \mathcal M$, where the kind of group action is indicated by the AbstractGroupActionType T. This can be perfomed in-place of q.

source

Generic Lie group actions

For certain types of actions, a general implementation can be provided. These interfaces are documented here.

LieGroups.InverseLeftGroupOperation — Type
InverseLeftGroupOperation <: AbstractRightGroupActionType

A type for the AbstractLeftGroupActionType when acting on the group itself given by the inverse of a LeftGroupOperation $σ_h$ as

\[τ_h(g) \coloneqq σ_h^{-1}(g) = σ(h^{-1},g) = h^{-1}∘g\]

Note that while in naming it is the inverse of the left action, it's properties yield that is is an AbstractRightGroupActionType, since

\[τ_g(τ_h(p)) +τ_{hg}(p).\]

Note

In function definitions we follow the idea of the family of actions and use the order (M, g, p) in function signatures.

source

Functions for Lie group actions

LieGroups.diff_apply! — Method
diff_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
+diff_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)

Compute the differential $D_p σ_g(p): T_p\mathcal M → T_{σ_g(p)}\mathcal M$, where for a left group action we have $σ_g(p) = σ(g,p)$, for a right action $σ_g(p) = σ(p, g)$.

source
LieGroups.diff_apply — Method
diff_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
+diff_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)

Compute the differential $D_p σ_g(p): T_p\mathcal M → T_{σ_g(p)}\mathcal M$, where for a left group action we have $σ_g(p) = σ(g,p)$, for a right action $σ_g(p) = σ(p, g)$.

source
LieGroups.diff_group_apply! — Method
diff_group_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
+diff_group_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)

Compute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$, where we use the short hand notation $σ_p(g) = σ(g,p)$ for a left action, and for a right action $σ_p(g) = σ(p, g)$.

source
LieGroups.diff_group_apply — Method
diff_group_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
+diff_group_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)

Compute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$, where we use the short hand notation $σ_p(g) = σ(g,p)$ for a left action, and for a right action $σ_p(g) = σ(p, g)$.

source
LieGroups.switch — Method
switch(T::AbstractGroupActionType)

Return the object representing an AbstractGroupActionType related to a group operation action that switched the side, that is it turns a left action type into its corresponding right action type.

source
LieGroups.switch — Method
 switch(A::AbstractGroupAction{T})

Return the group operation action representing the similar AbstractGroupAction of AbstractGroupActionType T but acting from the other side. It switches left to right and vice versa. This is done by returning the group action with the “switched” type of T.

source
Manifolds.apply! — Method
apply(A::AbstractGroupAction{T, L, M}, g, p)
+apply!(A::AbstractGroupAction{T, L, M}, q, g, p)

Apply the group action induced by $g ∈ \mathcal G$ to $p ∈ \mathcal M$, where the kind of group action is indicated by the AbstractGroupActionType T. This can be perfomed in-place of q.

source
Manifolds.apply — Method
apply(A::AbstractGroupAction{T, L, M}, g, p)
+apply!(A::AbstractGroupAction{T, L, M}, q, g, p)

Apply the group action induced by $g ∈ \mathcal G$ to $p ∈ \mathcal M$, where the kind of group action is indicated by the AbstractGroupActionType T. This can be perfomed in-place of q.

source

Generic Lie group actions

For certain types of actions, a general implementation can be provided. These interfaces are documented here.

LieGroups.InverseLeftGroupOperation — Type
InverseLeftGroupOperation <: AbstractRightGroupActionType

A type for the AbstractLeftGroupActionType when acting on the group itself given by the inverse of a LeftGroupOperation $σ_h$ as

\[τ_h(g) \coloneqq σ_h^{-1}(g) = σ(h^{-1},g) = h^{-1}∘g\]

Note that while in naming it is the inverse of the left action, it's properties yield that is is an AbstractRightGroupActionType, since

\[τ_g(τ_h(p)) = σ^{\mathrm L}_{g^{-1}}(σ^{\mathrm L}_{h^{-1}}(p)) = σ^{\mathrm L}_{g^{-1}h^{-1}}(p) = σ^{\mathrm L}_{(hg)^{-1}}(p) -τ_{hg}(p).\]

for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.

Note

Some literature also calls this by itself the right group operation action.

source
LieGroups.InverseRightGroupOperation — Type
InverseRightGroupOperation <: AbstractLeftGroupActionType

A type for the AbstractLeftGroupActionType when acting on the group itself given by the inverse of a RightGroupOperation $σ_h$ as

\[τ_h(g) \coloneqq σ_h^{-1}(g) = σ(h^{-1},g) = g∘h^{-1}\]

Note that while in naming it is the inverse of the right action, it's properties yield that is is an AbstractLeftGroupActionType, since

\[τ_g(τ_h(p)) +τ_{hg}(p).\]

for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.

Note

Some literature also calls this by itself the right group operation action.

source
LieGroups.InverseRightGroupOperation — Type
InverseRightGroupOperation <: AbstractLeftGroupActionType

A type for the AbstractLeftGroupActionType when acting on the group itself given by the inverse of a RightGroupOperation $σ_h$ as

\[τ_h(g) \coloneqq σ_h^{-1}(g) = σ(h^{-1},g) = g∘h^{-1}\]

Note that while in naming it is the inverse of the right action, it's properties yield that is is an AbstractLeftGroupActionType, since

\[τ_g(τ_h(p)) = σ^{\mathrm R}_{g^{-1}}(σ^{\mathrm R}_{h^{-1}}(p)) = σ^{\mathrm R}_{h^{-1}g^{-1}}(p) = σ^{\mathrm R}_{(gh)^{-1}}(p) -τ_{gh}(p).\]

for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.

source
Base.inv — Method
inv(::GroupOperationAction)

return the inverse group operation action, that is, use the type representing the inverse operation.

source
Manifolds.apply! — Method
apply(A::GroupOperationAction, g, h)
-apply!(A::GroupOperationAction, k, g, h)

apply the stored group operation action, using compose $∘$. this can be done in-place of k.

source
Manifolds.apply — Method
apply(A::GroupOperationAction, g, h)
-apply!(A::GroupOperationAction, k, g, h)

apply the stored group operation action, using compose $∘$. this can be done in-place of k.

source

Literature

[HN12]
J. Hilgert and K.-H. Neeb. Structure and Geometry of Lie Groups (Springer Monographs in Mathematics, 2012).
+τ_{gh}(p).\]

for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.

source
Base.inv — Method
inv(::GroupOperationAction)

return the inverse group operation action, that is, use the type representing the inverse operation.

source
Manifolds.apply! — Method
apply(A::GroupOperationAction, g, h)
+apply!(A::GroupOperationAction, k, g, h)

apply the stored group operation action, using compose $∘$. this can be done in-place of k.

source
Manifolds.apply — Method
apply(A::GroupOperationAction, g, h)
+apply!(A::GroupOperationAction, k, g, h)

apply the stored group operation action, using compose $∘$. this can be done in-place of k.

source

Literature

[HN12]
J. Hilgert and K.-H. Neeb. Structure and Geometry of Lie Groups (Springer Monographs in Mathematics, 2012).
diff --git a/previews/PR8/interface/group/index.html b/previews/PR8/interface/group/index.html index 0c03f34a..dec1269a 100644 --- a/previews/PR8/interface/group/index.html +++ b/previews/PR8/interface/group/index.html @@ -1,22 +1,22 @@ -A Lie group and algebra · LieGroups.jl
GitHub

The interface for Lie Groups and Lie algebras

LieGroups.LieGroup — Type
LieGroup{𝔽, O<:AbstractGroupOperation, M<:AbstractManifold{𝔽}}

Represent a Lie Group $\mathcal G$.

A Lie Group $\mathcal G$ is a group endowed with the structure of a manifold such that the group operations $∘: \mathcal G×\mathcal G → \mathcal G$, see compose and the inverse operation $⋅^{-1}: \mathcal G → \mathcal G$, see inv are smooth, see for example [HN12, Definition 9.1.1].

Lie groups are named after the Norwegian mathematician Marius Sophus Lie (1842–1899).

Fields

Constructor

LieGroup(M::AbstractManifold, op::AbstractGroupOperation)

Generate a Lie group based on a manifold M and a group operation op, where vectors by default are stored in the Lie Algebra.

source
LieGroups.LieAlgebra — Type
LieAlgebra{𝔽, G} <: AbstractManifold{𝔽}

Represent the Lie Algebra $\mathfrak g$, that is a $𝔽$vector space with an associated lie_bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$ which fulfills

  1. $[X,X] = 0$ for all $X ∈ \mathfrak g$
  2. The Jacobi identity holds $[X, [Y,Z]] = [[X,Y],Z] = [Y, [X,Z]]$ holds for all $X, Y, Z ∈ \mathfrak g$.

The Lie algebras considered here are those related to a LieGroup $\mathcal G$, namely the tangent space the tangent space $T_{\mathrm e}\mathcal G$ at the Identity, this is internally just a const of the corresponding TangentSpace.

Constructor

LieAlgebra(G::LieGroup)

Return the Lie Algebra belonging to the LieGroup G.

source

Functions on Lie Groups

Base.adjoint — Function
adjoint(G::LieGroup, g X)
-adjoint!(G::LieGroup, Y, g, X)

Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm e$. The operation can be performed in-place of Y.

\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm e) [X], \qquad X ∈ \mathfrak g.\]

see [HN12, Section 9.2.3].

On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.

source
LieGroups.adjoint! — Function
adjoint(G::LieGroup, g X)
-adjoint!(G::LieGroup, Y, g, X)

Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm e$. The operation can be performed in-place of Y.

\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm e) [X], \qquad X ∈ \mathfrak g.\]

see [HN12, Section 9.2.3].

On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.

source
LieGroups.conjugate — Function
conjugate(G::LieGroup, g, h)
-conjugate!(G::LieGroup, k, g, h)

Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.

source
LieGroups.conjugate! — Function
conjugate(G::LieGroup, g, h)
-conjugate!(G::LieGroup, k, g, h)

Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.

source
LieGroups.diff_conjugate — Function
diff_conjugate(G::LieGroup, g, h, X)
-diff_conjugate!(G::LieGroup, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.

\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]

source
LieGroups.diff_conjugate! — Function
diff_conjugate(G::LieGroup, g, h, X)
-diff_conjugate!(G::LieGroup, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.

\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]

source
Base.exp — Function
exp(G::LieGroup, g, X, t::Number=1)
-exp!(G::LieGroup, h, g, X, t::Number=1)

Compute the Lie group exponential map given by

\[\exp_g X = g∘\exp_{\mathcal G}(X)\]

where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.

Note

If g is the Identity the Lie group exponential function is computed directly. Implementing the Lie group exponential function introduces a default implementation for this function.

Note

The Lie group exponential map is usually different from the exponential map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) exponential map, use exp(base_manifoldG, g, X).

source
exp(G::LieGroup, e::Identity, X)
-exp!(G::LieGroup, h, e::Identity, X)

Compute the (Lie group) exponential function

\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]

where $γ_X$ is the unique solution of the initial value problem

\[γ(0) = \mathrm e, \quad γ'(t) = γ(t)⋅X.\]

The computation can be performed in-place of h.

See also [HN12, Definition 9.2.2].

source
ManifoldsBase.exp! — Function
exp(G::LieGroup, g, X, t::Number=1)
-exp!(G::LieGroup, h, g, X, t::Number=1)

Compute the Lie group exponential map given by

\[\exp_g X = g∘\exp_{\mathcal G}(X)\]

where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.

Note

If g is the Identity the Lie group exponential function is computed directly. Implementing the Lie group exponential function introduces a default implementation for this function.

Note

The Lie group exponential map is usually different from the exponential map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) exponential map, use exp(base_manifoldG, g, X).

source
exp(G::LieGroup, e::Identity, X)
-exp!(G::LieGroup, h, e::Identity, X)

Compute the (Lie group) exponential function

\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]

where $γ_X$ is the unique solution of the initial value problem

\[γ(0) = \mathrm e, \quad γ'(t) = γ(t)⋅X.\]

The computation can be performed in-place of h.

See also [HN12, Definition 9.2.2].

source
Manifolds.identity_element — Function
identity_element(G::LieGroup)
-identity_element!(G::LieGroup, g)

Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of g.

source
LieGroups.identity_element! — Function
identity_element(G::LieGroup)
-identity_element!(G::LieGroup, g)

Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of g.

source
Base.isapprox — Function
isapprox(M::LieGroup, g, h; kwargs...)

Check if points g and h from LieGroup are approximately equal. this function calls the corresponding isapprox on the AbstractManifold after handling the cases where one or more of the points are the Identity. All keyword argments are passed to this function as well.

source
ManifoldsBase.is_point — Method
is_point(G::LieGroup, g; kwargs...)

Check whether g is a valid point on the Lie Group G. This falls back to checking whether g is a valid point on G.manifold, unless g is an Identity. Then, it is checked whether it is the idenity element corresponding to G.

source
Base.log — Function
log(G::LieGroup, g, h)
-log!(G::LieGroup, X, g, h)

Compute the Lie group logarithmic map

\[\log_g h = ∘\log_{\mathcal G}(g^{-1}∘h)\]

where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.

Note

If g is the Identity the Lie group logarithmic function is computed directly. Implementing the Lie group logarithmic function introduces a default implementation for this function.

Note

The Lie group logarithmic map is usually different from the logarithmic map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) logarithmic map, use log(base_manifoldG, g, h).

source
log(G::LieGroup, e::Identity, g)
-log!(G::LieGroup, X, e::Identity, g)

Compute the (Lie group) logarithmic function $\log_{\mathcal G}: \mathcal G → \mathfrak g$, which is the inverse of the Lie group exponential function The compuation can be performed in-place of X.

source
ManifoldsBase.log! — Function
log(G::LieGroup, g, h)
-log!(G::LieGroup, X, g, h)

Compute the Lie group logarithmic map

\[\log_g h = ∘\log_{\mathcal G}(g^{-1}∘h)\]

where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.

Note

If g is the Identity the Lie group logarithmic function is computed directly. Implementing the Lie group logarithmic function introduces a default implementation for this function.

Note

The Lie group logarithmic map is usually different from the logarithmic map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) logarithmic map, use log(base_manifoldG, g, h).

source
log(G::LieGroup, e::Identity, g)
-log!(G::LieGroup, X, e::Identity, g)

Compute the (Lie group) logarithmic function $\log_{\mathcal G}: \mathcal G → \mathfrak g$, which is the inverse of the Lie group exponential function The compuation can be performed in-place of X.

source

Functions on Lie algebras

ManifoldsBase.is_point — Method
is_point(𝔤::LieAlgebra, X; kwargs...)

Check whether X is a valid point on the Lie Algebra 𝔤. This falls back to checking whether X is a valid point on the tangent space at the identity_element`](G)onG.manifoldon the [LieGroup](@ref) ofG`

source
LieGroups.lie_bracket — Function
lie_bracket!(𝔤::LieAlgebra, X, Y)
-lie_bracket!(𝔤::LieAlgebra, Z, X, Y)

Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$ which fulfills

  1. $[X,X] = 0$ for all $X ∈ \mathfrak g$
  2. The Jacobi identity holds $[X, [Y,Z]] = [[X,Y],Z] = [Y, [X,Z]]$ holds for all $X, Y, Z ∈ \mathfrak g$.

The computation can be done in-place of Z.

source
LieGroups.lie_bracket! — Function
lie_bracket!(𝔤::LieAlgebra, X, Y)
-lie_bracket!(𝔤::LieAlgebra, Z, X, Y)

Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$ which fulfills

  1. $[X,X] = 0$ for all $X ∈ \mathfrak g$
  2. The Jacobi identity holds $[X, [Y,Z]] = [[X,Y],Z] = [Y, [X,Z]]$ holds for all $X, Y, Z ∈ \mathfrak g$.

The computation can be done in-place of Z.

source

Literature

[HN12]
J. Hilgert and K.-H. Neeb. Structure and Geometry of Lie Groups (Springer Monographs in Mathematics, 2012).
+A Lie group and algebra · LieGroups.jl
GitHub

The interface for Lie Groups and Lie algebras

LieGroups.LieGroup — Type
LieGroup{𝔽, O<:AbstractGroupOperation, M<:AbstractManifold{𝔽}}

Represent a Lie Group $\mathcal G$.

A Lie Group $\mathcal G$ is a group endowed with the structure of a manifold such that the group operations $∘: \mathcal G×\mathcal G → \mathcal G$, see compose and the inverse operation $⋅^{-1}: \mathcal G → \mathcal G$, see inv are smooth, see for example [HN12, Definition 9.1.1].

Lie groups are named after the Norwegian mathematician Marius Sophus Lie (1842–1899).

Fields

Constructor

LieGroup(M::AbstractManifold, op::AbstractGroupOperation)

Generate a Lie group based on a manifold M and a group operation op, where vectors by default are stored in the Lie Algebra.

source
LieGroups.LieAlgebra — Type
LieAlgebra{𝔽, G} <: AbstractManifold{𝔽}

Represent the Lie Algebra $\mathfrak g$, that is a $𝔽$vector space with an associated lie_bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$ which fulfills

  1. $[X,X] = 0$ for all $X ∈ \mathfrak g$
  2. The Jacobi identity holds $[X, [Y,Z]] = [[X,Y],Z] = [Y, [X,Z]]$ holds for all $X, Y, Z ∈ \mathfrak g$.

The Lie algebras considered here are those related to a LieGroup $\mathcal G$, namely the tangent space the tangent space $T_{\mathrm e}\mathcal G$ at the Identity, this is internally just a const of the corresponding TangentSpace.

Constructor

LieAlgebra(G::LieGroup)

Return the Lie Algebra belonging to the LieGroup G.

source

Functions on Lie Groups

Base.adjoint — Function
adjoint(G::LieGroup, g X)
+adjoint!(G::LieGroup, Y, g, X)

Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm e$. The operation can be performed in-place of Y.

\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm e) [X], \qquad X ∈ \mathfrak g.\]

see [HN12, Section 9.2.3].

On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.

source
LieGroups.adjoint! — Function
adjoint(G::LieGroup, g X)
+adjoint!(G::LieGroup, Y, g, X)

Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm e$. The operation can be performed in-place of Y.

\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm e) [X], \qquad X ∈ \mathfrak g.\]

see [HN12, Section 9.2.3].

On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.

source
LieGroups.conjugate — Function
conjugate(G::LieGroup, g, h)
+conjugate!(G::LieGroup, k, g, h)

Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.

source
LieGroups.conjugate! — Function
conjugate(G::LieGroup, g, h)
+conjugate!(G::LieGroup, k, g, h)

Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.

source
LieGroups.diff_conjugate — Function
diff_conjugate(G::LieGroup, g, h, X)
+diff_conjugate!(G::LieGroup, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.

\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]

source
LieGroups.diff_conjugate! — Function
diff_conjugate(G::LieGroup, g, h, X)
+diff_conjugate!(G::LieGroup, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.

\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]

source
Base.exp — Function
exp(G::LieGroup, g, X, t::Number=1)
+exp!(G::LieGroup, h, g, X, t::Number=1)

Compute the Lie group exponential map given by

\[\exp_g X = g∘\exp_{\mathcal G}(X)\]

where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.

Note

If g is the Identity the Lie group exponential function is computed directly. Implementing the Lie group exponential function introduces a default implementation for this function.

Note

The Lie group exponential map is usually different from the exponential map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) exponential map, use exp(base_manifoldG, g, X).

source
exp(G::LieGroup, e::Identity, X)
+exp!(G::LieGroup, h, e::Identity, X)

Compute the (Lie group) exponential function

\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]

where $γ_X$ is the unique solution of the initial value problem

\[γ(0) = \mathrm e, \quad γ'(t) = γ(t)⋅X.\]

The computation can be performed in-place of h.

See also [HN12, Definition 9.2.2].

source
ManifoldsBase.exp! — Function
exp(G::LieGroup, g, X, t::Number=1)
+exp!(G::LieGroup, h, g, X, t::Number=1)

Compute the Lie group exponential map given by

\[\exp_g X = g∘\exp_{\mathcal G}(X)\]

where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.

Note

If g is the Identity the Lie group exponential function is computed directly. Implementing the Lie group exponential function introduces a default implementation for this function.

Note

The Lie group exponential map is usually different from the exponential map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) exponential map, use exp(base_manifoldG, g, X).

source
exp(G::LieGroup, e::Identity, X)
+exp!(G::LieGroup, h, e::Identity, X)

Compute the (Lie group) exponential function

\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]

where $γ_X$ is the unique solution of the initial value problem

\[γ(0) = \mathrm e, \quad γ'(t) = γ(t)⋅X.\]

The computation can be performed in-place of h.

See also [HN12, Definition 9.2.2].

source
Manifolds.identity_element — Function
identity_element(G::LieGroup)
+identity_element!(G::LieGroup, g)

Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of g.

source
LieGroups.identity_element! — Function
identity_element(G::LieGroup)
+identity_element!(G::LieGroup, g)

Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of g.

source
Base.isapprox — Function
isapprox(M::LieGroup, g, h; kwargs...)

Check if points g and h from LieGroup are approximately equal. this function calls the corresponding isapprox on the AbstractManifold after handling the cases where one or more of the points are the Identity. All keyword argments are passed to this function as well.

source
ManifoldsBase.is_point — Method
is_point(G::LieGroup, g; kwargs...)

Check whether g is a valid point on the Lie Group G. This falls back to checking whether g is a valid point on G.manifold, unless g is an Identity. Then, it is checked whether it is the idenity element corresponding to G.

source
Base.log — Function
log(G::LieGroup, g, h)
+log!(G::LieGroup, X, g, h)

Compute the Lie group logarithmic map

\[\log_g h = ∘\log_{\mathcal G}(g^{-1}∘h)\]

where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.

Note

If g is the Identity the Lie group logarithmic function is computed directly. Implementing the Lie group logarithmic function introduces a default implementation for this function.

Note

The Lie group logarithmic map is usually different from the logarithmic map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) logarithmic map, use log(base_manifoldG, g, h).

source
log(G::LieGroup, e::Identity, g)
+log!(G::LieGroup, X, e::Identity, g)

Compute the (Lie group) logarithmic function $\log_{\mathcal G}: \mathcal G → \mathfrak g$, which is the inverse of the Lie group exponential function The compuation can be performed in-place of X.

source
ManifoldsBase.log! — Function
log(G::LieGroup, g, h)
+log!(G::LieGroup, X, g, h)

Compute the Lie group logarithmic map

\[\log_g h = ∘\log_{\mathcal G}(g^{-1}∘h)\]

where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.

Note

If g is the Identity the Lie group logarithmic function is computed directly. Implementing the Lie group logarithmic function introduces a default implementation for this function.

Note

The Lie group logarithmic map is usually different from the logarithmic map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) logarithmic map, use log(base_manifoldG, g, h).

source
log(G::LieGroup, e::Identity, g)
+log!(G::LieGroup, X, e::Identity, g)

Compute the (Lie group) logarithmic function $\log_{\mathcal G}: \mathcal G → \mathfrak g$, which is the inverse of the Lie group exponential function The compuation can be performed in-place of X.

source

Functions on Lie algebras

ManifoldsBase.is_point — Method
is_point(𝔤::LieAlgebra, X; kwargs...)

Check whether X is a valid point on the Lie Algebra 𝔤. This falls back to checking whether X is a valid point on the tangent space at the identity_element`](G)onG.manifoldon the [LieGroup](@ref) ofG`

source
LieGroups.lie_bracket — Function
lie_bracket!(𝔤::LieAlgebra, X, Y)
+lie_bracket!(𝔤::LieAlgebra, Z, X, Y)

Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$ which fulfills

  1. $[X,X] = 0$ for all $X ∈ \mathfrak g$
  2. The Jacobi identity holds $[X, [Y,Z]] = [[X,Y],Z] = [Y, [X,Z]]$ holds for all $X, Y, Z ∈ \mathfrak g$.

The computation can be done in-place of Z.

source
LieGroups.lie_bracket! — Function
lie_bracket!(𝔤::LieAlgebra, X, Y)
+lie_bracket!(𝔤::LieAlgebra, Z, X, Y)

Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$ which fulfills

  1. $[X,X] = 0$ for all $X ∈ \mathfrak g$
  2. The Jacobi identity holds $[X, [Y,Z]] = [[X,Y],Z] = [Y, [X,Z]]$ holds for all $X, Y, Z ∈ \mathfrak g$.

The computation can be done in-place of Z.

source

Literature

[HN12]
J. Hilgert and K.-H. Neeb. Structure and Geometry of Lie Groups (Springer Monographs in Mathematics, 2012).
diff --git a/previews/PR8/interface/operations/index.html b/previews/PR8/interface/operations/index.html index a00369b7..70eadf29 100644 --- a/previews/PR8/interface/operations/index.html +++ b/previews/PR8/interface/operations/index.html @@ -1,18 +1,18 @@ -A group operation · LieGroups.jl
GitHub

Lie group operations

LieGroups.AbstractGroupOperation — Type
AbstractGroupOperation

Represent a type of group operation for a LieGroup $\mathcal G$, that is a smooth binary operation $∘ : \mathcal G × \mathcal G → \mathcal G$ on elements of a Lie group $\mathcal G$.

source
LieGroups.Identity — Type
Identity{O<:AbstractGroupOperation}

Represent the group identity element $e ∈ \mathcal G$ on a LieGroup $\mathcal G$ with AbstractGroupOperation of type O.

Similar to the philosophy that points are agnostic of their group at hand, the identity does not store the group $\mathcal G$ it belongs to. However it depends on the type of the AbstractGroupOperation used.

See also identity_element on how to obtain the corresponding AbstractManifoldPoint or array representation.

Constructors

Identity(::LieGroup{𝔽,O}) where {𝔽,M,O<:AbstractGroupOperation}
+A group operation · LieGroups.jl
GitHub
Lie group operations
LieGroups.AbstractGroupOperation — Type
AbstractGroupOperation
Represent a type of group operation for a LieGroup $\mathcal G$, that is a smooth binary operation $∘ : \mathcal G × \mathcal G → \mathcal G$ on elements of a Lie group $\mathcal G$.
source
LieGroups.Identity — Type
Identity{O<:AbstractGroupOperation}
Represent the group identity element $e ∈ \mathcal G$ on a LieGroup $\mathcal G$ with AbstractGroupOperation of type O.
Similar to the philosophy that points are agnostic of their group at hand, the identity does not store the group $\mathcal G$ it belongs to. However it depends on the type of the AbstractGroupOperation used.
See also identity_element on how to obtain the corresponding AbstractManifoldPoint or array representation.
Constructors
Identity(::LieGroup{𝔽,O}) where {𝔽,M,O<:AbstractGroupOperation}
 Identity(o::AbstractGroupOperation)
-Identity(::Type{AbstractGroupOperation})
create the identity of the corresponding subtype O<:AbstractGroupOperation
source
LieGroups.compose — Function
compose(G::LieGroup, g, h)
-compose!(G::LieGroup, k, g, h)
Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.
Info
This function also handles the case where g or/and h are the Identity(G). Since this would lead to ambiguities when implementing a new group operations, this function calls _compose and compose!, respectively, which is meant for the actual computation of group operations on (non-Identity` but maybe its numerical representation) elements.
source
LieGroups.compose! — Function
compose(G::LieGroup, g, h)
-compose!(G::LieGroup, k, g, h)
Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.
Info
This function also handles the case where g or/and h are the Identity(G). Since this would lead to ambiguities when implementing a new group operations, this function calls _compose and compose!, respectively, which is meant for the actual computation of group operations on (non-Identity` but maybe its numerical representation) elements.
source
LieGroups.diff_inv — Function
diff_inv(G::LieGroup, g, X)
-diff_inv!(G::LieGroup, Y, g, X)
Compute the differential of the function $ι_{\mathcal G}(p) = p^-1$, where $Dι_{\mathcal G}(p): \mathfrak g → \mathfrak g$. This can be done in-place of Y.
source
LieGroups.diff_inv! — Function
diff_inv(G::LieGroup, g, X)
-diff_inv!(G::LieGroup, Y, g, X)
Compute the differential of the function $ι_{\mathcal G}(p) = p^-1$, where $Dι_{\mathcal G}(p): \mathfrak g → \mathfrak g$. This can be done in-place of Y.
source
LieGroups.diff_left_compose — Function
diff_left_compose(G::LieGroup, g, h, X)
-diff_left_compose!(G::LieGroup, Y, g, h, X)
Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.
source
LieGroups.diff_left_compose! — Function
diff_left_compose(G::LieGroup, g, h, X)
-diff_left_compose!(G::LieGroup, Y, g, h, X)
Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.
source
LieGroups.diff_right_compose — Function
diff_right_compose(G::LieGroup, h, g, X)
-diff_right_compose!(G::LieGroup, Y, h, g, X)
Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.
source
LieGroups.diff_right_compose! — Function
diff_right_compose(G::LieGroup, h, g, X)
-diff_right_compose!(G::LieGroup, Y, h, g, X)
Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.
source
LieGroups.inv_left_compose — Function
inv_left_compose(G::LieGroup, g, h)
-inv_left_compose!(G::LieGroup, k, g, h)
Compute the inverse of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is, compute $λ_g^{-1}(h) = g^{-1}∘h$. This can be done in-place of k.
source
LieGroups.inv_left_compose! — Function
compose(G::LieGroup, g, h)
-compose!(G::LieGroup, k, g, h)
Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.
Info
This function also handles the case where g or/and h are the Identity(G). Since this would lead to ambiguities when implementing a new group operations, this function calls _compose and compose!, respectively, which is meant for the actual computation of group operations on (non-Identity` but maybe its numerical representation) elements.
source
LieGroups.inv_right_compose — Function
inv_right_compose(G::LieGroup, h, g)
-inv_right_compose!(G::LieGroup, k, h, g)
Compute the inverse of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.
source
LieGroups.inv_right_compose! — Function
inv_right_compose(G::LieGroup, h, g)
-inv_right_compose!(G::LieGroup, k, h, g)
Compute the inverse of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.
source
Base.inv — Method
inv(G::LieGroup, g)
-inv!(G::LieGroup, h, g)
Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm e$, where $\mathrm e$ denotes the Identity.
This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).
source
LieGroups.inv! — Function
inv(G::LieGroup, g)
-inv!(G::LieGroup, h, g)
Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm e$, where $\mathrm e$ denotes the Identity.
This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).
source
For some generic group operations, an easy generic implementation can be provided. This section lists these specific cases and what is implemented for these.
Additive Group operation
LieGroups.AdditionGroupOperation — Type
AdditionGroupOperation <: AbstractGroupOperation
A group operation that is realised introducing defaults that fall back to + and - being overloaded, for example _compose(G::LieGroup{𝔽,AdditionGroupOperation}, a,b) = a+b
source

+Identity(::Type{AbstractGroupOperation})

create the identity of the corresponding subtype O<:AbstractGroupOperation

source
LieGroups.compose — Function
compose(G::LieGroup, g, h)
+compose!(G::LieGroup, k, g, h)

Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.

Info

This function also handles the case where g or/and h are the Identity(G). Since this would lead to ambiguities when implementing a new group operations, this function calls _compose and compose!, respectively, which is meant for the actual computation of group operations on (non-Identity` but maybe its numerical representation) elements.

source
LieGroups.compose! — Function
compose(G::LieGroup, g, h)
+compose!(G::LieGroup, k, g, h)

Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.

Info

This function also handles the case where g or/and h are the Identity(G). Since this would lead to ambiguities when implementing a new group operations, this function calls _compose and compose!, respectively, which is meant for the actual computation of group operations on (non-Identity` but maybe its numerical representation) elements.

source
LieGroups.diff_inv — Function
diff_inv(G::LieGroup, g, X)
+diff_inv!(G::LieGroup, Y, g, X)

Compute the differential of the function $ι_{\mathcal G}(p) = p^-1$, where $Dι_{\mathcal G}(p): \mathfrak g → \mathfrak g$. This can be done in-place of Y.

source
LieGroups.diff_inv! — Function
diff_inv(G::LieGroup, g, X)
+diff_inv!(G::LieGroup, Y, g, X)

Compute the differential of the function $ι_{\mathcal G}(p) = p^-1$, where $Dι_{\mathcal G}(p): \mathfrak g → \mathfrak g$. This can be done in-place of Y.

source
LieGroups.diff_left_compose — Function
diff_left_compose(G::LieGroup, g, h, X)
+diff_left_compose!(G::LieGroup, Y, g, h, X)

Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.

source
LieGroups.diff_left_compose! — Function
diff_left_compose(G::LieGroup, g, h, X)
+diff_left_compose!(G::LieGroup, Y, g, h, X)

Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.

source
LieGroups.diff_right_compose — Function
diff_right_compose(G::LieGroup, h, g, X)
+diff_right_compose!(G::LieGroup, Y, h, g, X)

Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.

source
LieGroups.diff_right_compose! — Function
diff_right_compose(G::LieGroup, h, g, X)
+diff_right_compose!(G::LieGroup, Y, h, g, X)

Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.

source
LieGroups.inv_left_compose — Function
inv_left_compose(G::LieGroup, g, h)
+inv_left_compose!(G::LieGroup, k, g, h)

Compute the inverse of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is, compute $λ_g^{-1}(h) = g^{-1}∘h$. This can be done in-place of k.

source
LieGroups.inv_left_compose! — Function
compose(G::LieGroup, g, h)
+compose!(G::LieGroup, k, g, h)

Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.

Info

This function also handles the case where g or/and h are the Identity(G). Since this would lead to ambiguities when implementing a new group operations, this function calls _compose and compose!, respectively, which is meant for the actual computation of group operations on (non-Identity` but maybe its numerical representation) elements.

source
LieGroups.inv_right_compose — Function
inv_right_compose(G::LieGroup, h, g)
+inv_right_compose!(G::LieGroup, k, h, g)

Compute the inverse of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.

source
LieGroups.inv_right_compose! — Function
inv_right_compose(G::LieGroup, h, g)
+inv_right_compose!(G::LieGroup, k, h, g)

Compute the inverse of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.

source
Base.inv — Method
inv(G::LieGroup, g)
+inv!(G::LieGroup, h, g)

Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm e$, where $\mathrm e$ denotes the Identity.

This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).

source
LieGroups.inv! — Function
inv(G::LieGroup, g)
+inv!(G::LieGroup, h, g)

Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm e$, where $\mathrm e$ denotes the Identity.

This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).

source

For some generic group operations, an easy generic implementation can be provided. This section lists these specific cases and what is implemented for these.

Additive Group operation

LieGroups.AdditionGroupOperation — Type
AdditionGroupOperation <: AbstractGroupOperation

A group operation that is realised introducing defaults that fall back to + and - being overloaded, for example _compose(G::LieGroup{𝔽,AdditionGroupOperation}, a,b) = a+b

source
diff --git a/previews/PR8/news/index.html b/previews/PR8/news/index.html index e5dfa74f..59febcbb 100644 --- a/previews/PR8/news/index.html +++ b/previews/PR8/news/index.html @@ -1,2 +1,2 @@ -Changelog · LieGroups.jl
GitHub

Changelog

All notable Changes to the Julia package LieGroups.jl will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

[0.1.0] - unreleased

Everything denoted by “formerly” refers to the previous name in Manifolds.jl.

Added

  • LieAlgebra
  • LieGroup (formerly GroupManifold) as well as the concrete groups
    • AdditiveGroup (formerly TranslationGroup)
  • AbstractGroupOperation as well as its concrete subtypes
    • AdditionGroupOperation (formerly AdditionOperation)
  • AbstractGroupActionType with its 2 specific (new) abstract
    • AbstractLeftGroupActionType
    • AbstractRightGroupActionType
  • For the group operation actions there are now
    • LeftGroupOperation (formerly LeftForwardAction)
    • RightGroupOperation (formerly RightBackwardAction)
    • InverseLeftGroupOperation (formerly RightForwardAction)
    • InverseRightGroupOperation (formerly LeftBackwardAction)
  • 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_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, ::Identity, X) and exp!(G::LieGroup, h, ::Identity, X) (formerly exp_lie and exp_lie!)
  • Identity
  • idenity_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! (formerly lie_bracket)
  • 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)

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.

Old Changelog pre 0.1.0

Two previous releases where done by Yueh-Hua Tu in 2022 before he was so kind to transfer the development to the JuliaManifolds GitHub organisation.

All notable changes to this project will be documented in this file.

[0.0.2]

  • fix SE{3} and add jacobian
  • define dof and dim for Lie algebra and jacobian of inv
  • add action for SE{N}
  • add se3_location example
+Changelog · LieGroups.jl
GitHub

Changelog

All notable Changes to the Julia package LieGroups.jl will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

[0.1.0] - unreleased

Everything denoted by “formerly” refers to the previous name in Manifolds.jl.

Added

  • LieAlgebra
  • LieGroup (formerly GroupManifold) as well as the concrete groups
    • AdditiveGroup (formerly TranslationGroup)
  • AbstractGroupOperation as well as its concrete subtypes
    • AdditionGroupOperation (formerly AdditionOperation)
  • AbstractGroupActionType with its 2 specific (new) abstract
    • AbstractLeftGroupActionType
    • AbstractRightGroupActionType
  • For the group operation actions there are now
    • LeftGroupOperation (formerly LeftForwardAction)
    • RightGroupOperation (formerly RightBackwardAction)
    • InverseLeftGroupOperation (formerly RightForwardAction)
    • InverseRightGroupOperation (formerly LeftBackwardAction)
  • 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_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, ::Identity, X) and exp!(G::LieGroup, h, ::Identity, X) (formerly exp_lie and exp_lie!)
  • Identity
  • idenity_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! (formerly lie_bracket)
  • 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)

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.

Old Changelog pre 0.1.0

Two previous releases where done by Yueh-Hua Tu in 2022 before he was so kind to transfer the development to the JuliaManifolds GitHub organisation.

All notable changes to this project will be documented in this file.

[0.0.2]

  • fix SE{3} and add jacobian
  • define dof and dim for Lie algebra and jacobian of inv
  • add action for SE{N}
  • add se3_location example
diff --git a/previews/PR8/notation/index.html b/previews/PR8/notation/index.html index 13ea0dcd..5fbe7b3d 100644 --- a/previews/PR8/notation/index.html +++ b/previews/PR8/notation/index.html @@ -1,2 +1,2 @@ -Notation · LieGroups.jl
GitHub

Notation on LIe Groups

For most of the notation used throughout this package, we follow [HN12]

SymbolDescriptionAlso usedComment
$∘$a group operation
$c:\mathcal G → \mathcal G, c_g$the conjugation map (with g)
$\mathrm{e}$identity element of a group
$g, h, k$elements on a (Lie) group. Sometimes called points.$g_1, g_2, ...$
$\mathfrak g$a Lie algebra
$\mathcal{G}$a (Lie) group
$λ_g: \mathcal G → \mathcal G$the left multiplication map $λ_g(h) = g∘h$
$\mathcal M$a manifold$\mathcal M_1, \mathcal M_2,\ldots,\mathcal N$
$\operatorname{Exp}$the matrix exponential
$\operatorname{Log}$the matrix logarithm
$ρ_g: \mathcal G → \mathcal G$the right multiplication map $ρ_g(h) = h∘g$
$σ: \mathcal G × \mathcal M$a left group actionwe use $σ_g(p)$ if the group element is fixed
$τ: \mathcal M × \mathcal G$a right group action$σ_\mathrm{R}$we use $τ_g(p)$ if the group element is fixed
$T_p \mathcal M$the tangent space at $p$
+Notation · LieGroups.jl
GitHub

Notation on LIe Groups

For most of the notation used throughout this package, we follow [HN12]

SymbolDescriptionAlso usedComment
$∘$a group operation
$c:\mathcal G → \mathcal G, c_g$the conjugation map (with g)
$\mathrm{e}$identity element of a group
$g, h, k$elements on a (Lie) group. Sometimes called points.$g_1, g_2, ...$
$\mathfrak g$a Lie algebra
$\mathcal{G}$a (Lie) group
$λ_g: \mathcal G → \mathcal G$the left multiplication map $λ_g(h) = g∘h$
$\mathcal M$a manifold$\mathcal M_1, \mathcal M_2,\ldots,\mathcal N$
$\operatorname{Exp}$the matrix exponential
$\operatorname{Log}$the matrix logarithm
$ρ_g: \mathcal G → \mathcal G$the right multiplication map $ρ_g(h) = h∘g$
$σ: \mathcal G × \mathcal M$a left group actionwe use $σ_g(p)$ if the group element is fixed
$τ: \mathcal M × \mathcal G$a right group action$σ_\mathrm{R}$we use $τ_g(p)$ if the group element is fixed
$T_p \mathcal M$the tangent space at $p$
diff --git a/previews/PR8/references/index.html b/previews/PR8/references/index.html index 2bd4727f..7c717c79 100644 --- a/previews/PR8/references/index.html +++ b/previews/PR8/references/index.html @@ -1,2 +1,2 @@ -References · LieGroups.jl
GitHub

Literature

This is all literature mentioned / referenced in the LieGroups.jl documentation. You find a small reference section at the end of every documentation page that contains the corresponding references as well.

[HN12]
J. Hilgert and K.-H. Neeb. Structure and Geometry of Lie Groups (Springer Monographs in Mathematics, 2012).
+References · LieGroups.jl
GitHub

Literature

This is all literature mentioned / referenced in the LieGroups.jl documentation. You find a small reference section at the end of every documentation page that contains the corresponding references as well.

[HN12]
J. Hilgert and K.-H. Neeb. Structure and Geometry of Lie Groups (Springer Monographs in Mathematics, 2012).
diff --git a/previews/PR8/tutorials/getstarted/index.html b/previews/PR8/tutorials/getstarted/index.html index 1a9b4e2c..ec8bec4d 100644 --- a/previews/PR8/tutorials/getstarted/index.html +++ b/previews/PR8/tutorials/getstarted/index.html @@ -1,2 +1,2 @@ -- · LieGroups.jl
GitHub
+- · LieGroups.jl
GitHub