Update for Manifolds v0.11 (#72)

mateuszbaran · kellertuer · web-flow · commit e65f47bfc104 · 2025-10-09T12:58:29.000+02:00
* Update for Manifolds v0.11
* update changelog
* update readme
* remove interlink
* fix typo
* Make sure tutorials run on most recent version.
* fix apostrophe
* Update NEWS.md

---------

Co-authored-by: Ronny Bergmann &lt;git@ronnybergmann.net&gt;
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -11,14 +11,13 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        julia-version: ["lts", "1", "pre"]
+        julia-version: ["lts", "1"]
         os: [ubuntu-latest, macOS-latest]
     steps:
       - uses: actions/checkout@v4
       - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.julia-version }}
-          arch: x64
       - uses: julia-actions/cache@v2
       - uses: julia-actions/julia-buildpkg@latest
       - uses: julia-actions/julia-runtest@latest
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
@@ -0,0 +1,21 @@
+name: nightly
+on:
+  pull_request:
+
+jobs:
+  test:
+    name: Julia ${{ matrix.julia-version }} - ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        julia-version: ["pre"]
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: julia-actions/setup-julia@v2
+        with:
+          version: ${{ matrix.julia-version }}
+      - uses: julia-actions/julia-buildpkg@latest
+      - uses: julia-actions/julia-runtest@latest
+        env:
+          fail_ci_if_error: false
diff --git a/NEWS.md b/NEWS.md
@@ -5,6 +5,12 @@ All notable Changes to the Julia package `LieGroups.jl` will be documented in th
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.5] 2025-10-09
+
+### Changed
+
+* `LieGroups.jl` now requires `ManifoldsBase.jl` v2.0 and `Manifolds.jl` v0.11.
+
 ## [0.1.4] 2025-10-02
 
 ### Added
diff --git a/Project.toml b/Project.toml
@@ -1,7 +1,7 @@
 name = "LieGroups"
 uuid = "6774de46-80ba-43f8-ba42-e41071ccfc5f"
 authors = ["Seth Axen <seth.axen@gmail.com>", "Mateusz Baran <mateuszbaran89@gmail.com>", "Ronny Bergmann <git@ronnybergmann.net>", "Yueh-Hua Tu", "Olivier Verdier <olivier.verdier@gmail.com>"]
-version = "0.1.4"
+version = "0.1.5"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -20,8 +20,8 @@ LieGroupsRecursiveArrayToolsExt = "RecursiveArrayTools"
 [compat]
 Aqua = "0.8"
 LinearAlgebra = "1.10"
-Manifolds = "0.10.16"
-ManifoldsBase = "1.2"
+Manifolds = "0.11"
+ManifoldsBase = "2"
 Quaternions = "0.7.6"
 Random = "1.10"
 RecursiveArrayTools = "2, 3"
diff --git a/Readme.md b/Readme.md
@@ -26,8 +26,7 @@ using Pkg; Pkg.add("LieGroups")
 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 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/) for a comprehensive list.
+> This is a rework of the features from [`Manifolds.jl`](https://juliamanifolds.github.io/Manifolds.jl/stable/).
+> See [transition from Manifolds.jl](https://juliamanifolds.github.io/LieGroups.jl/stable/tutorials/transition/) for a comprehensive list how to update your code.
 > 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.
diff --git a/docs/Project.toml b/docs/Project.toml
@@ -10,6 +10,7 @@ RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
 Documenter = "1"
 DocumenterCitations = "1.3"
 DocumenterInterLinks = "1"
+LieGroups = "0.1.5"
 LinearAlgebra = "1.11"
 
 [sources]
diff --git a/docs/src/tutorials/transition.md b/docs/src/tutorials/transition.md
@@ -1,6 +1,6 @@
 # Transition from `GroupManifolds` in `Manifolds.jl`
 
-One predecessor of `LieGroups.jl` are the [`GroupManifold`](@extref `Manifolds.GroupManifold`)s in `Manifolds.jl`.
+One predecessor of `LieGroups.jl` are the `GroupManifold`s in `Manifolds.jl`.
 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.
diff --git a/ext/LieGroupsRecursiveArrayToolsExt/special_galilean_group_RAT_ext.jl b/ext/LieGroupsRecursiveArrayToolsExt/special_galilean_group_RAT_ext.jl
@@ -2,7 +2,7 @@ using LieGroups: SpecialGalileanGroup
 using StaticArrays
 using LinearAlgebra
 
-# Internal function to compute the skew-symmetric matrix as an SMatrix used for perfomance.
+# Internal function to compute the skew-symmetric matrix as an SMatrix used for performance.
 # Can be replaced with hat(SO(3), v) once that works without allocations.
 function _skew(v::AbstractVector{T}) where {T <: Real}
     return SMatrix{3, 3, T}(0, v[3], -v[2], -v[3], 0, v[1], v[2], -v[1], 0)
diff --git a/src/LieGroups.jl b/src/LieGroups.jl
@@ -44,14 +44,6 @@ using ManifoldsBase:
     tangent_vector_type
 using StaticArrays
 #
-#
-# = Compatibility (and a bit of type piracy for now)
-# The following imports are necessary to use Manifolds.jl 0.10 with Lie groups
-# The line is removed when the Groups are removed from possibly 0.11
-import Manifolds: apply, apply!, compose, identity_element, is_identity
-# Both define the following structs, so these for now lead to asking for explicit prefixes
-# Manifolds: Identity, TranslationGroup
-#
 include("documentation_glossary.jl")
 include("utils.jl")
 include("interface.jl")
diff --git a/src/groups/circle_group_sphere.jl b/src/groups/circle_group_sphere.jl
@@ -1,18 +1,18 @@
 #
 #circle group represented as vectors in ℝ^2, operation: adding angles in the unit circle
 #
-function CircleGroup(M::Sphere{ManifoldsBase.TypeParameter{Tuple{1}}, ℝ})
+function CircleGroup(M::Sphere{ℝ, ManifoldsBase.TypeParameter{Tuple{1}}})
     return LieGroup{ℝ, AbelianMultiplicationGroupOperation, typeof(M)}(
         M, AbelianMultiplicationGroupOperation()
     )
 end
 
-function CircleGroup(::Euclidean{ManifoldsBase.TypeParameter{Tuple{2}}, ℝ})
+function CircleGroup(::Euclidean{ℝ, ManifoldsBase.TypeParameter{Tuple{2}}})
     return CircleGroup(Sphere(1))
 end
 
 const _PlanarCircleGroup = LieGroup{
-    ℝ, AbelianMultiplicationGroupOperation, <:Sphere{ManifoldsBase.TypeParameter{Tuple{1}}, ℝ},
+    ℝ, AbelianMultiplicationGroupOperation, <:Sphere{ℝ, ManifoldsBase.TypeParameter{Tuple{1}}},
 }
 
 #=
diff --git a/src/groups/orthogonal_group.jl b/src/groups/orthogonal_group.jl
@@ -16,7 +16,7 @@ const OrthogonalGroup{T} = LieGroup{
 
 function OrthogonalGroup(n::Int; kwargs...)
     R = OrthogonalMatrices(n; kwargs...)
-    return OrthogonalGroup{typeof(R).parameters[1]}(R, MatrixMultiplicationGroupOperation())
+    return OrthogonalGroup{typeof(R).parameters[2]}(R, MatrixMultiplicationGroupOperation())
 end
 
 const OrthogonalLieAlgebra{T} = LieAlgebra{
diff --git a/src/groups/special_euclidean_group.jl b/src/groups/special_euclidean_group.jl
@@ -6,7 +6,7 @@ const LeftSpecialEuclideanGroupOperation = LeftSemidirectProductGroupOperation{
 const LeftSpecialEuclideanGroup{T} = LieGroup{
     ℝ,
     <:LeftSpecialEuclideanGroupOperation,
-    <:ProductManifold{ℝ, Tuple{<:Rotations{T}, <:Euclidean{T, ℝ}}},
+    <:ProductManifold{ℝ, Tuple{<:Rotations{T}, <:Euclidean{ℝ, T}}},
 }
 
 # for (t, g)
@@ -16,7 +16,7 @@ const RightSpecialEuclideanGroupOperation = RightSemidirectProductGroupOperation
 const RightSpecialEuclideanGroup{T} = LieGroup{
     ℝ,
     <:RightSpecialEuclideanGroupOperation,
-    <:ProductManifold{ℝ, Tuple{<:Euclidean{T, ℝ}, <:Rotations{T}}},
+    <:ProductManifold{ℝ, Tuple{<:Euclidean{ℝ, T}, <:Rotations{T}}},
 }
 
 """
diff --git a/src/groups/special_galilean_group.jl b/src/groups/special_galilean_group.jl
@@ -46,11 +46,11 @@ const SpecialGalileanGroup{T} = LieGroup{
     <:ProductManifold{
         ℝ,
         Tuple{
-            <:ProductManifold{ℝ, Tuple{<:Rotations{T}, <:Euclidean{T, ℝ}}},
+            <:ProductManifold{ℝ, Tuple{<:Rotations{T}, <:Euclidean{ℝ, T}}},
             <:ProductManifold{
                 ℝ,
                 Tuple{
-                    <:Euclidean{T, ℝ}, <:Euclidean{ManifoldsBase.TypeParameter{Tuple{1}}, ℝ},
+                    <:Euclidean{ℝ, T}, <:Euclidean{ℝ, ManifoldsBase.TypeParameter{Tuple{1}}},
                 },
             },
         },
diff --git a/src/groups/special_orthogonal_group.jl b/src/groups/special_orthogonal_group.jl
@@ -16,7 +16,7 @@ const SpecialOrthogonalGroup{T} = LieGroup{
 
 function SpecialOrthogonalGroup(n::Int; kwargs...)
     R = Rotations(n; kwargs...)
-    return SpecialOrthogonalGroup{typeof(R).parameters[1]}(
+    return SpecialOrthogonalGroup{typeof(R).parameters[2]}(
         R, MatrixMultiplicationGroupOperation()
     )
 end
diff --git a/src/groups/special_unitary_group.jl b/src/groups/special_unitary_group.jl
@@ -13,12 +13,12 @@ All keyword arguments in `kwargs...` are passed on to [`Rotations`](@extref `Man
 const SpecialUnitaryGroup{T} = LieGroup{
     ManifoldsBase.ℂ,
     MatrixMultiplicationGroupOperation,
-    GeneralUnitaryMatrices{T, ℂ, DeterminantOneMatrixType},
+    GeneralUnitaryMatrices{ℂ, T, DeterminantOneMatrixType},
 }
 
 function SpecialUnitaryGroup(n::Int; kwargs...)
     GU = GeneralUnitaryMatrices(n, ℂ, DeterminantOneMatrixType; kwargs...)
-    return SpecialUnitaryGroup{typeof(GU).parameters[1]}(
+    return SpecialUnitaryGroup{typeof(GU).parameters[2]}(
         GU, MatrixMultiplicationGroupOperation()
     )
 end
diff --git a/src/groups/symplectic_group.jl b/src/groups/symplectic_group.jl
@@ -23,12 +23,12 @@ where ``⋅^+`` denotes the [`symplectic_inverse`](@extref `Manifolds.symplectic
 See [BendokatZimmermann:2021; Section 2](@cite) for more information.
 """
 const SymplecticGroup{𝔽, T} = LieGroup{
-    𝔽, MatrixMultiplicationGroupOperation, SymplecticMatrices{T, 𝔽},
+    𝔽, MatrixMultiplicationGroupOperation, SymplecticMatrices{𝔽, T},
 }
 
 function SymplecticGroup(n::Int, field::AbstractNumbers = ℝ; kwargs...)
     S = SymplecticMatrices(n, field; kwargs...)
-    return SymplecticGroup{field, typeof(S).parameters[1]}(
+    return SymplecticGroup{field, typeof(S).parameters[2]}(
         S, MatrixMultiplicationGroupOperation()
     )
 end
diff --git a/src/groups/translation_group.jl b/src/groups/translation_group.jl
@@ -13,11 +13,11 @@ are passed on to [`Euclidean`](@extref `Manifolds.Euclidean`) as well
 
 We denote the Lie algebra of ``$(_math(:T))(n)`` by ``$(_math(:t))(n)``.
 """
-const TranslationGroup{𝔽, T} = LieGroup{𝔽, AdditionGroupOperation, Euclidean{T, 𝔽}}
+const TranslationGroup{𝔽, T} = LieGroup{𝔽, AdditionGroupOperation, Euclidean{𝔽, T}}
 
 function TranslationGroup(n::Int...; kwargs...)
     Rn = Euclidean(n...; kwargs...)
-    return TranslationGroup{typeof(Rn).parameters[[2, 1]]...}(Rn, AdditionGroupOperation())
+    return TranslationGroup{typeof(Rn).parameters...}(Rn, AdditionGroupOperation())
 end
 
 function Base.show(io::IO, G::TranslationGroup{𝔽}) where {𝔽}
diff --git a/src/groups/unitary_group.jl b/src/groups/unitary_group.jl
@@ -1,5 +1,5 @@
 """
-    UnitaryGroup{T}
+    UnitaryGroup{𝔽, T}
 
 The special orthogonal group ``$(_math(:U))(n)`` is the Lie group consisting of the [`MatrixMultiplicationGroupOperation`](@ref) on the
 manifold of rotations [`UnitaryMatrices`](@extref `Manifolds.GeneralUnitaryMatrices`) with absolute value of the determinant equal to one.
@@ -11,12 +11,12 @@ Generate unitary group ``$(_math(:U))(n)``.
 All keyword arguments in `kwargs...` are passed on to [`Rotations`](@extref `Manifolds.Rotations`) as well.
 """
 const UnitaryGroup{𝔽, T} = LieGroup{
-    𝔽, MatrixMultiplicationGroupOperation, UnitaryMatrices{T, 𝔽},
+    𝔽, MatrixMultiplicationGroupOperation, UnitaryMatrices{𝔽, T},
 }
 
 function UnitaryGroup(n::Int, 𝔽::AbstractNumbers = ManifoldsBase.ℂ; kwargs...)
     U = UnitaryMatrices(n, 𝔽; kwargs...)
-    return UnitaryGroup{𝔽, typeof(U).parameters[1]}(U, MatrixMultiplicationGroupOperation())
+    return UnitaryGroup{𝔽, typeof(U).parameters[2]}(U, MatrixMultiplicationGroupOperation())
 end
 
 function ManifoldsBase.check_size(
@@ -118,7 +118,7 @@ implementations where
 * certain functions are the same for all sizes `T` as long as the field `𝔽` is the same
 """
 const CommonUnitarySubGroup{𝔽, T} = LieGroup{
-    𝔽, MatrixMultiplicationGroupOperation, <:GeneralUnitaryMatrices{T, 𝔽},
+    𝔽, MatrixMultiplicationGroupOperation, <:GeneralUnitaryMatrices{𝔽, T},
 }
 
 #
diff --git a/src/interface.jl b/src/interface.jl
@@ -1003,7 +1003,7 @@ see also [`rand(::LieAlgebra; kwargs...)`](@ref)
 
 For both cases, you can provide the type ``T`` for the tangent vector and/or point ``PT``,
 if you want to generate a random point in a certain representation.
-For the in-place variants the type is inferred from `pX´ and `X`, respectively.
+For the in-place variants the type is inferred from `pX` and `X`, respectively.
 """
 
 function ManifoldsBase.project!(G::AbstractLieGroup, g, p)
diff --git a/tutorials/.gitignore b/tutorials/.gitignore
@@ -1 +1,3 @@
 /.quarto/
+
+**/*.quarto_ipynb
diff --git a/tutorials/Project.toml b/tutorials/Project.toml
@@ -8,7 +8,7 @@ Rotations = "6038ab10-8711-5258-84ad-4b1120ba62dc"
 LieGroups = {path = ".."}
 
 [compat]
-LieGroups = "0.1"
-Manifolds = "0.10.14"
+LieGroups = "0.1.5"
+Manifolds = "0.11"
 RecursiveArrayTools = "3.31"
 Rotations = "1.7"

Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,18 @@`
`1`	`1`	`#`
`2`	`2`	`#circle group represented as vectors in ℝ^2, operation: adding angles in the unit circle`
`3`	`3`	`#`
`4`		`-function CircleGroup(M::Sphere{ManifoldsBase.TypeParameter{Tuple{1}}, ℝ})`
	`4`	`+function CircleGroup(M::Sphere{ℝ, ManifoldsBase.TypeParameter{Tuple{1}}})`
`5`	`5`	`return LieGroup{ℝ, AbelianMultiplicationGroupOperation, typeof(M)}(`
`6`	`6`	`M, AbelianMultiplicationGroupOperation()`
`7`	`7`	`)`
`8`	`8`	`end`
`9`	`9`
`10`		`-function CircleGroup(::Euclidean{ManifoldsBase.TypeParameter{Tuple{2}}, ℝ})`
	`10`	`+function CircleGroup(::Euclidean{ℝ, ManifoldsBase.TypeParameter{Tuple{2}}})`
`11`	`11`	`return CircleGroup(Sphere(1))`
`12`	`12`	`end`
`13`	`13`
`14`	`14`	`const _PlanarCircleGroup = LieGroup{`
`15`		`- ℝ, AbelianMultiplicationGroupOperation, <:Sphere{ManifoldsBase.TypeParameter{Tuple{1}}, ℝ},`
	`15`	`+ ℝ, AbelianMultiplicationGroupOperation, <:Sphere{ℝ, ManifoldsBase.TypeParameter{Tuple{1}}},`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`#=`