Port remaining groups (Part 3/3): The Circle group (#31)

* initial commit of the n progress circle group in 3 variants
* Test suite CircleGroup

---------

Co-authored-by: LeoSchreiter <[email protected]>
Co-authored-by: plc99 <[email protected]>
Co-authored-by: Mateusz Baran <[email protected]>

Author: 4 people

.github/workflows/changelog.yml

@@ -1,10 +1,10 @@
-name: Check Changelog
+name: Check News entry
 on:
   pull_request:
 
 jobs:
   Check-Changelog:
-    name: Check Changelog Action
+    name: Check that the News.md was updated
     runs-on: ubuntu-latest
     steps:
       - uses: tarides/changelog-check-action@v3

NEWS.md

@@ -32,6 +32,7 @@ Everything denoted by “formerly” refers to the previous name in [`Manifolds.
   * `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`](https://juliamanifolds.github.io/ManifoldsBase.jl/stable/manifolds/#A-manifold-for-validation) which can also be used internally.
 * `AbstractGroupOperation` as well as its concrete subtypes

Project.toml

@@ -1,7 +1,7 @@
 name = "LieGroups"
 uuid = "6774de46-80ba-43f8-ba42-e41071ccfc5f"
 authors = ["Seth Axen <[email protected]>", "Mateusz Baran <[email protected]>", "Ronny Bergmann <[email protected]>", "Yueh-Hua Tu", "Olivier Verdier <[email protected]>"]
-version = "0.0.3"
+version = "0.1.0"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -20,8 +20,8 @@ LieGroupsRecursiveArrayToolsExt = "RecursiveArrayTools"
 [compat]
 Aqua = "0.8"
 LinearAlgebra = "1.10"
-Manifolds = "0.10.15"
-ManifoldsBase = "1"
+Manifolds = "0.10.16"
+ManifoldsBase = "1.0.3"
 Quaternions = "0.7.6"
 Random = "1.10"
 RecursiveArrayTools = "2, 3"

Readme.md

@@ -21,14 +21,11 @@ In Julia you can install this package by typing
 using Pkg; Pkg.add("LieGroups")
 ```
 
-in the Julia REPL.
+in the Julia REPL. For a first start, see the [get started tutorial](https://juliamanifolds.github.io/LieGroups.jl/stable/tutorials/getstarted/).
 
 > [!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 of same name, for example `Identity`.
-While `LieGroups.jl` depends on `Manifolds.jl`, it is not recommended to load both into the same namespace, that is, doing `using Manifolds.jl, LieGroups.jl`, since then these conflicts might lead to unforeseen errors, where you would need to specify the namespace to resolve this ambiguity.
+While `LieGroups.jl` depends on `Manifolds.jl`, it is not recommended to load both into the same name space, that is, doing `using Manifolds.jl, LieGroups.jl`, since then these conflicts might lead to unforeseen errors, where you would need to specify the name space to resolve this ambiguity.
 > 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.
-
-See [#5](https://github.com/JuliaManifolds/LieGroups.jl/issues/5) for an overview of features that we plan to implement.
-Feel free to add to this list with opening further issues.

docs/make.jl

@@ -136,6 +136,8 @@ makedocs(;
     format=Documenter.HTML(;
         prettyurls=(get(ENV, "CI", nothing) == "true") || ("--prettyurls" ∈ ARGS),
         assets=["assets/favicon.ico", "assets/citations.css", "assets/link-icons.css"],
+        size_threshold_warn=200 * 2^10, # raise slightly from 100 to 200 KiB
+        size_threshold=300 * 2^10,      # raise slightly 200 to to 300 KiB
     ),
     modules=[LieGroups],
     authors="Seth Axen, Mateusz Baran, Ronny Bergmann, Olivier Verdier, and contributors",
@@ -146,6 +148,7 @@ makedocs(;
         (tutorials_in_menu ? [tutorials_menu] : [])...,
         "Lie groups" => [
             "List of Lie groups" => "groups/index.md",
+            "Circle Group" => "groups/circle_group.md",
             "General linear group" => "groups/general_linear.md",
             "Heisenberg group" => "groups/heisenberg_group.md",
             "Orthogonal group" => "groups/orthogonal_group.md",

docs/src/about.md

@@ -1,4 +1,28 @@
 # About LieGroups.jl
 
-`LieGroups.jl` is a “spin-off” from [`Manifolds.jl](https://juliamanifolds.github.io/Manifolds.jl/stable/), where `GroupManifolds` where implemented around 2021.
-Around the same time, [Yueh-Hua Tu](https://github.com/yuehhua) started a package `LieGroups.jl`, which was continued than here with a full rewrite to use the manifolds from `Manifolds.jl`.
+The package `LieGroups.jl` in its current form started in 2024 as a “spin-off” from [`Manifolds.jl`](@extref Manifolds :std:doc:`index`), where a type `GroupManifolds` was a predecessor of the
+main [`LieGroup`](@ref) type of this package. That approach started around 2021 by [Seth Axen](https://sethaxen.com).
+At about the same, [Yueh-Hua Tu](https://github.com/yuehhua) started a package `LieGroups.jl`,
+which was continued then here with a full rewrite in order to base all Lie groups on a
+manifold from [`Manifolds.jl`](@extref Manifolds :std:doc:`index`).
+
+The current main developers are [Ronny Bergmann](https://ronnybergmann.net) and [Mateusz Baran](https://github.com/mateuszbaran).
+
+## Contributors
+
+Thanks to the following contributors to `LieGroups.jl`:
+
+* [Paula Conrad](https://github.com/plc99) and [Leonard Schreiter](https://github.com/LeoSchreiter) implemented the [Circle group](@ref CircleGroup) as part of their student assistant project.
+* [Olivier Verdier](https://www.olivierverdier.com) helped in the design and some mathematical explanations
+
+as well as [contributors](https://github.com/JuliaManifolds/LieGroups.jl/graphs/contributors) providing small extensions, finding small bugs and mistakes and fixing them by opening [PR](https://github.com/JuliaManifolds/LieGroups.jl/pulls)s. Thanks to all of you.
+
+If you want to contribute a manifold or algorithm or have any questions, visit
+the [GitHub repository](https://github.com/JuliaManifolds/LieGroups.jl/)
+to clone/fork the repository or open an issue.
+
+## Work using LieGroups.jl
+
+If `LieGroups.jl` is useful within another package or in your project, we would like to list that here.
+Please [open an issue](https://github.com/JuliaManifolds/LieGroups.jl/issues/new).
+It would be great to collect anything and anyone using `LieGroups.jl` in this list.

docs/src/groups/circle_group.md

@@ -0,0 +1,31 @@
+# The circle group
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["groups/circle_group.jl"]
+Order = [:type, :function]
+```
+
+# [Representation on the real line](@id circle-group-real)
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["groups/circle_group_real.jl"]
+Order = [:type, :function]
+```
+
+# [Representation on the complex plane](@id circle-group-complex)
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["groups/circle_group_complex.jl"]
+Order = [:type, :function]
+```
+
+# [Representation on the 2D-plane](@id circle-group-plane)
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["groups/circle_group_sphere.jl"]
+Order = [:type, :function]
+```

docs/src/groups/index.md

@@ -1,17 +1,16 @@
 # An overview of Lie groups
 
-# Alphabetical list of Lie groups
-
 | Group | Manifold | ``∘`` | Comment |
 |:------|:---------|:---------:|:------|
+| [`CircleGroup`](@ref) | real or complex [`Circle`](@extref `Manifolds.Circle`), [`Sphere`](@extref `Manifolds.Sphere`) | [`*`](@ref AbelianMultiplicationGroupOperation) | |
 | [`GeneralLinearGroup`](@ref) | [`InvertibleMatrices`](@extref `Manifolds.InvertibleMatrices`) | [`*`](@ref MatrixMultiplicationGroupOperation) | |
 | [`HeisenbergGroup`](@ref) | [`HeisenbergMatrices`](@extref `Manifolds.HeisenbergMatrices`) | [`*`](@ref MatrixMultiplicationGroupOperation) | |
 | [`OrthogonalGroup`](@ref) | [`OrthogonalMatrices`](@extref `Manifolds.OrthogonalMatrices`) | [`*`](@ref MatrixMultiplicationGroupOperation) | This can be interpreted as all rotations and reflections. |
 | [`PowerLieGroup`](@ref) | [`PowerManifold`](@extref `ManifoldsBase.PowerManifold`) | [`∘`](@ref PowerGroupOperation) | [`^`](@ref PowerLieGroup) is a constructor |
 | [`ProductLieGroup`](@ref) | [`ProductManifold`](@extref `ManifoldsBase.ProductManifold`) | [`∘`](@ref ProductGroupOperation) | [`×`](@ref LinearAlgebra.cross(::AbstractGroupOperation...)) of two Lie groups is a constructor |
 | [`LeftSemidirectProductLieGroup`](@ref) | [`ProductManifold`](@extref `ManifoldsBase.ProductManifold`) | [`∘`](@ref LeftSemidirectProductGroupOperation) | [`⋉`](@ref ⋉(L1::LieGroup, L2::LieGroup)) of 2 Lie groups is a constructor, similarly [`⋊`](@ref ⋊(L1::LieGroup, L2::LieGroup)) for the right variant |
 | [`SpecialEuclideanGroup`](@ref) | [`Rotations`](@extref `Manifolds.Rotations`)[`⋉`](@ref LeftSemidirectProductGroupOperation)[`Euclidean`](@extref `Manifolds.Rotations`) | [`∘`](@ref LeftSemidirectProductGroupOperation) | Analogously you can also use a [`⋊`](@ref RightSemidirectProductGroupOperation) if you prefer tuples `(t,R)` having the rotation matrix in the second component |
-| [`SpecialLinearGroup`](@ref) | [`GeneralUnitaryMatrices`](@extref `Manifolds.GeneralUnitaryMatrices`) with determinant one | [`*`](@ref MatrixMultiplicationGroupOperation) | |
+| [`SpecialLinearGroup`](@ref) | [`DeterminantOneMatrices`](@extref `Manifolds.DeterminantOneMatrices`) | [`*`](@ref MatrixMultiplicationGroupOperation) | |
 | [`SpecialOrthogonalGroup`](@ref) | [`Rotations`](@extref `Manifolds.Rotations`) | [`*`](@ref MatrixMultiplicationGroupOperation) | |
 | [`SpecialUnitaryGroup`](@ref) | [`GeneralUnitaryMatrices`](@extref `Manifolds.GeneralUnitaryMatrices`) | [`*`](@ref MatrixMultiplicationGroupOperation) | |
 | [`SymplecticGroup`](@ref) | [`SymplecticMatrices`](@extref `Manifolds.SymplecticMatrices`) | [`*`](@ref MatrixMultiplicationGroupOperation) | |

docs/src/index.md

@@ -10,7 +10,7 @@ CurrentModule = LieGroups
 LieGroups.LieGroups
 ```
 
-The implemented [Lie groups](https://en.wikipedia.org/wiki/Lie_group) are implemented using the interface for manifolds in [`ManifoldsBase.jl`](@extref ManifoldsBase :doc:`index`) together with additional interfaces [for Lie groups](interface/group.md) and [Lie algebras](interface/algebra.md) as well as internally using the manifolds implemented in [`Manifolds.jl`](@extref Manifolds :doc:`index`).
+The implemented [Lie groups](https://en.wikipedia.org/wiki/Lie_group) use the interface for manifolds in [`ManifoldsBase.jl`](@extref ManifoldsBase :doc:`index`) together with an [interface for Lie groups](interface/group.md) and [Lie algebras](interface/algebra.md) as well as internally using the manifolds implemented in [`Manifolds.jl`](@extref Manifolds :doc:`index`).
 
 For more general information about the history of and contributions to the package see the [About](about.md) page.
 

docs/src/interface/operations.md

@@ -12,6 +12,9 @@ The following sections collect these.
 
 
 * an [`AdditionGroupOperation`](@ref)
+* an [`AbelianMultiplicationGroupOperation`](@ref) and
+* a [`MatrixMultiplicationGroupOperation`](@ref)
+
 
 ## [Additive group operation](@id addition-operation-sec)
 
@@ -21,6 +24,7 @@ Pages = ["addition_operation.jl"]
 Order = [:type, :function]
 ```
 
+
 ## [Multiplication group operation](@id multiplication-operation-sec)
 
 ```@autodocs
@@ -29,6 +33,17 @@ Pages = ["multiplication_operation.jl"]
 Order = [:type, :function]
 ```
 
+## [Abelian multiplication group operation](@id multiplication-operationabelian-sec)
+Since the commutativity of some Lie groups leads to a significant simplification of computations on those groups, the [`abelian multiplication group operation`](@ref multiplication-operationabelian-sec) optimizes these cases.
+Additionally, it provides an interface for the abelian Lie groups. Some of these can are represented by `isbits`-types,
+which don't have mutating variants of the functions.
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["multiplication_operation_abelian.jl"]
+Order = [:type, :function]
+```
+
 ## Literature
 
 ```@bibliography