Introduce the general linear group and the multiplication group operation.

.codecov.yml

@@ -0,0 +1,2 @@
+ignore:
+  - "src/documentation_glossary.jl" # exclude this since it is just use to create the docs and code cov goes bogus on this.

NEWS.md

@@ -13,7 +13,7 @@ Everything denoted by “formerly” refers to the previous name in [`Manifolds.
 
 * `LieAlgebra`
 * `LieGroup` (formerly `GroupManifold`) as well as the concrete groups
-  * `AdditiveGroup` (formerly `TranslationGroup`)
+  * `TranslationGroup`
 * `AbstractGroupOperation` as well as its concrete subtypes
   * `AdditionGroupOperation` (formerly `AdditionOperation`)
 * `AbstractGroupActionType` with its 2 specific (new) abstract
@@ -29,6 +29,7 @@ Everything denoted by “formerly” refers to the previous name in [`Manifolds.
 * `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, ::Identity, X)` and `exp!(G::LieGroup, h, ::Identity, X)` (formerly `exp_lie` and `exp_lie!`)

Project.toml

@@ -11,8 +11,8 @@ ManifoldsBase = "3362f125-f0bb-47a3-aa74-596ffd7ef2fb"
 [compat]
 Aqua = "0.8"
 LinearAlgebra = "1.6"
-Manifolds = "0.10"
-ManifoldsBase = "0.15.16"
+Manifolds = "0.10.5"
+ManifoldsBase = "0.15.20"
 Test = "1.6"
 julia = "1.6"
 

Readme.md

@@ -5,11 +5,15 @@
     </picture>
 </div>
 
-[![](https://img.shields.io/badge/docs-dev-blue.svg)](https://juliamanifolds.github.io/Manifolds.jl/latest/)
+[![](https://img.shields.io/badge/docs-dev-blue.svg)](https://juliamanifolds.github.io/LieGroups.jl/dev/)
 [![Code Style: Blue](https://img.shields.io/badge/code%20style-blue-4495d1.svg)](https://github.com/invenia/BlueStyle) [![CI](https://github.com/JuliaManifolds/LieGroups.jl/actions/workflows/ci.yml/badge.svg)](https://github.com/JuliaManifolds/LieGroups.jl/actions?query=workflow%3ACI+branch%3Amain) [![codecov.io](http://codecov.io/github/JuliaManifolds/LieGroups.jl/coverage.svg?branch=main)](https://codecov.io/gh/JuliaManifolds/LieGroups.jl/)
 
 This is a package to rework the Lie group features of [`Manifolds.jl`](https://juliamanifolds.github.io/Manifolds.jl/stable/) in a unified way into a separate package.
 
+> [!NOTE]
+> Since this is a rework of the features from [`Manifolds.jl`](https://juliamanifolds.github.io/Manifolds.jl/stable/), both `LieGroups.jl` and `Manifolds.jl` 0.10 export a few types. For that reason it's not recommended to load both packages in a productive environment, unless you are aware, which variables you want to import wherefrom.
+> see [transition from Manifolds.jl](https://juliamanifolds.github.io/LieGroups.jl/stable/tutorials/transition-from-manifoldsjl.html) for a comprehensive list.
+
 This especially also includes a few different choices in default behaviour that
 is different from the [`Manifolds.jl`](https://juliamanifolds.github.io/Manifolds.jl/stable/) one. For purely manifold-based operations, any Lie group still is “build upon” a Riemannian manifold.
 

docs/make.jl

@@ -99,7 +99,11 @@ for (md_file, doc_file) in [("CONTRIBUTING.md", "contributing.md"), ("NEWS.md",
 end
 
 ## Build tutorials menu
-tutorials_menu = "How to..." => ["Get started with Lie Groups" => "index.md"]
+tutorials_menu =
+    "How to..." => [
+        "🚀 Get Started with LieGroups.jl" => "tutorials/getstarted.md",
+        "Transistion from `GroupManifolds`" => "tutorials/transition.md",
+    ]
 # (e) finally make docs
 bib = CitationBibliography(joinpath(@__DIR__, "src", "references.bib"); style=:alpha)
 links = InterLinks(
@@ -118,16 +122,17 @@ makedocs(;
         "Home" => "index.md",
         "About" => "about.md",
         (tutorials_in_menu ? [tutorials_menu] : [])...,
+        "Lie groups" => [
+            "List of Lie Groups" => "groups/index.md",
+            "General Linear" => "groups/general_linear.md",
+            "Translation group" => "groups/translation.md",
+        ],
         "Interfaces" => [
             "Lie group" => "interface/group.md",
             "Lie algebra" => "interface/algebra.md",
             "Group operation" => "interface/operations.md",
             "Group action" => "interface/actions.md",
         ],
-        "Lie groups" => [
-            "List of Lie Groups" => "groups/index.md",
-            "Translation group" => "groups/translation.md",
-        ],
         "Contributing to LieGroups.jl" => "contributing.md",
         "Notation" => "notation.md",
         "Changelog" => "news.md",

docs/src/groups/general_linear.md

@@ -0,0 +1,7 @@
+# The general linear group
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["groups/general_linear_group.jl"]
+Order = [:type, :function]
+```

docs/src/groups/index.md

@@ -4,4 +4,5 @@
 
 | Group | Manifold | ``∘`` | Comment |
 |:------|:---------|:---------:|:------|
+| [`GeneralLinearGroup`](@ref) | [`InvertibleMatrices`](@extref `Manifolds.InvertibleMatrices`) | [`*`](@ref MatrixMultiplicationGroupOperation) | |
 | [`TranslationGroup`](@ref) | [`Euclidean`](@extref `Manifolds.Euclidean`) | [`+`](@ref AdditionGroupOperation) | |

docs/src/interface/operations.md

@@ -17,6 +17,14 @@ The following sections collect these.
 
 ```@autodocs
 Modules = [LieGroups]
-Pages = ["addition.jl"]
+Pages = ["addition_operation.jl"]
+Order = [:type, :function]
+```
+
+## [Multiplication group operation](@id multiplication-operation-sec)
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["multiplication_operation.jl"]
 Order = [:type, :function]
 ```

docs/src/notation.md

@@ -3,7 +3,7 @@
 In this package,the notation introduced in [Manifolds.jl Notation](https://juliamanifolds.github.io/Manifolds.jl/latest/misc/notation.html) is used with the following additional parts.
 
 | Symbol | Description | Also used | Comment |
-|:--:|:--------------- |:--:|:-- |
+|:----:|:--------------- |:----:|:--- |
 | ``∘`` | a group operation | | |
 | ``c_g:\mathcal G → \mathcal G`` | the conjugation map (with `g`) | | |
 | ``\mathrm{e}`` | identity element of a group | | |

docs/src/tutorials/getstarted.md

@@ -0,0 +1 @@
+# 🚀 Get Started with LieGroups.jl

docs/src/tutorials/transition.md

@@ -0,0 +1,45 @@
+# Transition from `GroupManifolds` in `Manifolds.jl`
+
+One predecessor of `LieGroups.jl` are the [`GroupManifold`]()s in `Manifoldsjl`.
+While this package provides the same features, one reason for a new package is,
+that a “restart” offers the opportunity to put the main focus for the functions in this package
+really on Lie groups.
+
+This tutorial provides an overview of the necessary changes to your code if you based it on the predecessor.
+
+## Table of function names and its successors
+
+The following table lists all functions related to `GroupManifolds` and their new names
+or replacements here in `LieGroups.jl`. In this code `G` always refers to the `GroupManifold`
+in the first column and the [`LieGroup`](@ref) in the second.
+Lie group elements (points) are always `g,h`,
+Lie algebra elements (vectors) always `X, Y`.
+
+New functions and types in this package are only mentioned, if they are worth a comment and if something changed.
+
+The list is alphabetical, but first lists types, then functions
+
+| `Manifolds.jl` | `LieGroups.jl` | Comment |
+|:---------- |:---------- |:-------------- |
+| `AdditionOperation` | [`AdditionGroupOperation`](@ref) | |
+| `LeftForwardAction` | [`LeftGroupOperation`](@ref)
+| `RightBackwardAction` | [`RightGroupOperation`](@ref) | |
+| `LeftBackwardAction` | [`InverseRightGroupOperation`](@ref) | note that this is now also aa [`AbstractLeftGroupActionType`](@ref) |
+| | [`LieAlgebra`](@ref)`(G)` | new to emphasize its menifold- and vector structure as well as for a few dispatch methods. |
+| `GroupManifold(M, op)` | [`LieGroup`](@ref)`(M, op)` | |
+| `RightForwardAction` | [`InverseLeftGroupOperation`](@ref) | note that this is an [`AbstractRightGroupActionType`](@ref) |
+| `adjoint` | [`adjoint`](@ref) | now implemented with a default, when you provide [`diff_conjugate!`](@ref).
+| `apply_diff` | [`diff_apply`](@ref) | modifiers (diff) come first, consistent with [`ManifoldsDiff.jl`](https://juliamanifolds.github.io/ManifoldDiff.jl/stable/) |
+| `apply_diff_group` | [`diff_group_apply`](@ref) | modifiers (diff/group) come first, consistent with [`ManifoldsDiff.jl`](https://juliamanifolds.github.io/ManifoldDiff.jl/stable/) |
+| | [`conjugate`](@ref), [`diff_conjugate`](@ref) | a new function to model ``c_g: \mathcal G → \mathcal G`` given by ``c_g(h) = g∘h∘g^{-1}`` |
+| `exp(G, g, X)` | `exp(`[`base_manifold`](@ref base_manifold(G::LieGroup))`(G), g, X)` | the previous defaults whenever not agreeing with the invariant one can now be accessed on the internal manifold |
+| `exp_inv(G, g, X)` | [`exp`](@ref exp(G::LieGroup, g, X, t::Number))`(G, g, X)`  | the exponential map invariant to the group operation is the default on Lie groups here |
+| `exp_lie(G, X)` | [`exp`](@ref exp(G::LieGroup, e::Identity, X, t::Number))`(G, `[`Identity`](@ref)`(G), X)` | the (matrix) exponential is now the one at the [`Identity`](@ref)`(G)`, since there it agrees with the invariant one |
+| `invervse_translate(G, g, h, c)` | [`inv_left_compose`](@ref)`(G, g, h)`, [`inv_right_compose`](@ref)`(G, g, h)` | compute ``g^{-1}∘h`` and ``g∘h^{-1}``, resp. |
+| `log(G, g, h)` | `log(`[`base_manifold`](@ref base_manifold(G::LieGroup))`(G), g, h)` | you can now access the previous defaults on the internal manifold whenever they do not agree with the invariant one |
+| `log_inv(G, g, h)` | [`log`](@ref log(G::LieGroup, g, h))`(G, g, h)` | the logarithmic map invariant to the group operation is the default on Lie groups here |
+| `log_lie(G, g)` | [`log`](@ref log(G::LieGroup, e::Identity, g))`(G, `[`Identity`](@ref)`(G), g)` | the (matrix) logarithm is now the one at the identity, since there it agrees with the invariant one |
+| `switch_direction(A)` | [`inv`](@ref inv(::AbstractGroupAction))`(A)` | switches from an action to its inverse action (formerly the direction forward/backward, sometimes even left/right, do not confuse with the side left/right). |
+| `switch_side(A)` | [`switch`](@ref switch(::AbstractGroupAction))`(A)` | switches from a left action to its corresponding right action. |
+| `translate(G, g, h)` | [`compose`](@ref)`(G, g, h)` | unified to `compose` |
+| `translate_diff(G, g, X, c)` | [`diff_left_compose`](@ref)`(G, g, h, X)`, [`diff_right_compose`](@ref)`(G, g, h, X)` | for compose ``∘(g,h)` we specify now whether we take the derivative with respect to the left (`g`) or right (`h`) argument

src/LieGroups.jl

@@ -14,27 +14,31 @@ include("documentation_glossary.jl")
 include("interface.jl")
 include("Lie_algebra/Lie_algebra_interface.jl")
 # Generic Operations
-include("group_operations/addition.jl")
+include("group_operations/addition_operation.jl")
+include("group_operations/multiplication_operation.jl")
 
 # Actions
 include("group_actions/group_action_interface.jl")
 include("group_actions/group_operation_action.jl")
 
 # Lie groups
 include("groups/translation_group.jl")
+include("groups/general_linear_group.jl")
 
 export LieGroup, LieAlgebra
 
 export AbstractGroupOperation, Identity
 export AdditionGroupOperation
+export AbstractMultiplicationGroupOperation
+export MatrixMultiplicationGroupOperation
 
 export AbstractGroupActionType, AbstractGroupAction
 export AbstractLeftGroupActionType, AbstractRightGroupActionType
 export LeftGroupOperation, RightGroupOperation
 export InverseLeftGroupOperation, InverseRightGroupOperation
 export GroupOperationAction
 
-export TranslationGroup
+export TranslationGroup, GeneralLinearGroup
 
 export adjoint, adjoint!, apply, apply!
 export base_lie_group, base_manifold

src/Lie_algebra/Lie_algebra_interface.jl

@@ -63,9 +63,6 @@ function ManifoldsBase.is_point(𝔤::LieAlgebra, X; kwargs...)
     return ManifoldsBase.is_vector(G.manifold, e, X; kwargs...)
 end
 
-# Move this line already to ManifoldsBase? On Fibers of course.
-LinearAlgebra.norm(𝔤::LieAlgebra, X) = LinearAlgebra.norm(𝔤.manifold, 𝔤.point, X)
-# Non-mutating case with single number -> avoid ambiguity
 LinearAlgebra.norm(𝔤::LieAlgebra, X::Real) = LinearAlgebra.norm(𝔤.manifold, 𝔤.point, X)
 function LinearAlgebra.norm(
     G::LieGroup{𝔽,O}, ::Identity{O}, X

src/documentation_glossary.jl

@@ -51,6 +51,7 @@ end
 # LaTeX
 # Define LaTeX shortcuts
 _tex(args...; kwargs...) = glossary(:LaTeX, args...; kwargs...)
+define!(:LaTeX, :big, raw"\big")
 define!(:LaTeX, :bigl, raw"\bigl")
 define!(:LaTeX, :bigr, raw"\bigr")
 define!(:LaTeX, :Big, raw"\Big")
@@ -59,11 +60,32 @@ define!(:LaTeX, :Bigr, raw"\Bigr")
 define!(:LaTeX, :def, raw"\coloneqq")
 define!(:LaTeX, :Cal, (letter) -> raw"\mathcal " * "$letter")
 define!(:LaTeX, :exp, raw"\exp")
+define!(:LaTeX, :frac, (a, b) -> raw"\frac" * "{$a}{$b}")
 define!(:LaTeX, :Frak, (letter) -> raw"\mathfrak " * "$letter")
+define!(:LaTeX, :l, "") # lazy fallback for sets
+define!(:LaTeX, :r, "") # lazy fallback for sets
 define!(:LaTeX, :log, raw"\log")
 define!(:LaTeX, :qquad, raw"\qquad")
 define!(:LaTeX, :quad, raw"\quad")
-define!(:LaTeX, :rm, (letter) -> raw"\mathrm " * "$letter")
+define!(:LaTeX, :rm, (letter) -> raw"\mathrm" * "{$letter}")
+define!(
+    :LaTeX,
+    :Set,
+    (content, size="") ->
+        _tex(Symbol("$(size)l")) *
+        raw"\{ " *
+        "$(content)" *
+        _tex(Symbol("$(size)r")) *
+        raw" \}",
+)
+define!(
+    :LaTeX,
+    :SetDef,
+    (elem, cond, size="") ->
+        _tex(:Set, elem * raw"\ " * _tex(Symbol("$(size)")) * raw"|\ " * "$(cond)", size),
+)
+define!(:LaTeX, :sum, raw"\sum")
+define!(:LaTeX, :transp, raw"\mathm{T}")
 #
 # ---
 # Mathematics and semantic symbols

src/group_operations/addition.jl → src/group_operations/addition_operation.jl

@@ -125,7 +125,7 @@ Base.exp(
 
 @doc "$(_doc_exp_add)"
 function ManifoldsBase.exp!(
-    G::LieGroup{𝔽,AdditionGroupOperation},
+    ::LieGroup{𝔽,AdditionGroupOperation},
     g,
     ::Identity{AdditionGroupOperation},
     X,