From dcfdab32c4e97d8268f547875011532b24d3be02 Mon Sep 17 00:00:00 2001 From: sblelong Date: Sat, 27 Jun 2026 15:38:19 +0200 Subject: [PATCH 01/11] Add injectivity radius for the LogarithmicInverseRetraction and the ProjectionInverseRetraction on the Sphere --- src/manifolds/Sphere.jl | 34 ++++++++++++++++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/src/manifolds/Sphere.jl b/src/manifolds/Sphere.jl index 314171fee6..f2bc6583b8 100644 --- a/src/manifolds/Sphere.jl +++ b/src/manifolds/Sphere.jl @@ -301,7 +301,7 @@ _doc_injectivity_radius_sphere_projection = raw""" injectivity_radius(M::Sphere, p, ::ProjectionRetraction) Return the injectivity radius for the [`ProjectionRetraction`](@extref `ManifoldsBase.ProjectionRetraction`) on the -[`AbstractSphere`](@ref), which is globally ``\frac{π}{2}``. +[`AbstractSphere`](@ref), which is globally ``\infty``. """ @doc "$(_doc_injectivity_radius_sphere_projection)" @@ -318,7 +318,7 @@ function injectivity_radius(M::AbstractSphere, p, m::AbstractRetractionMethod) return _injectivity_radius(M, p, m) end _injectivity_radius(::AbstractSphere, ::ExponentialRetraction) = π -_injectivity_radius(::AbstractSphere, ::ProjectionRetraction) = π / 2 +_injectivity_radius(::AbstractSphere, ::ProjectionRetraction) = typemax(Float64) @doc raw""" inverse_retract(M::AbstractSphere, p, q, ::ProjectionInverseRetraction) @@ -337,6 +337,36 @@ function inverse_retract_project!(::AbstractSphere, X, p, q) return (X .= q ./ real(dot(p, q)) .- p) end +_doc_injectivity_radius_sphere_inverse_projection = raw""" + injectivity_radius(M::AbstractSphere, p, ::ProjectionInverseRetraction) + +Return the injectivity radius for the [`ProjectionInverseRetraction`](@extref `ManifoldsBase.ProjectionInverseRetraction`) on the [`AbstractSphere`](@ref), which is the largest geodesic distance ``ξ`` such that the inverse projection retraction from `p` is invertible whenever ``d_{𝕊^{d-1}}(p,q) ≤ ξ``. This is globally ``\frac{\pi}{2}``. +""" + +@doc "$(_doc_injectivity_radius_sphere_inverse_projection)" +injectivity_radius(::AbstractSphere, ::ProjectionInverseRetraction) + +@doc "$(_doc_injectivity_radius_sphere_inverse_projection)" +injectivity_radius(::AbstractSphere, p, ::ProjectionInverseRetraction) + +function injectivity_radius(M::AbstractSphere, m::AbstractInverseRetractionMethod) + return _injectivity_radius(M, m) +end +function injectivity_radius(M::AbstractSphere, p, m::AbstractInverseRetractionMethod) + return _injectivity_radius(M, p, m) +end + +function _injectivity_radius(M::AbstractSphere, m::LogarithmicInverseRetraction) + return injectivity_radius(M, ExponentialRetraction()) +end +function _injectivity_radius(M::AbstractSphere, p, m::LogarithmicInverseRetraction) + return injectivity_radius(M, p, ExponentialRetraction()) +end +_injectivity_radius(::AbstractSphere, ::ProjectionInverseRetraction) = π / 2 +function _injectivity_radius(M::AbstractSphere, p, m::ProjectionInverseRetraction) + return _injectivity_radius(M, m) +end + """ is_flat(M::AbstractSphere) From 68af73f806cebdb2f9030e7bb97dbc78a4751d07 Mon Sep 17 00:00:00 2001 From: sblelong Date: Sun, 28 Jun 2026 17:34:31 +0200 Subject: [PATCH 02/11] Fix docs and tests --- src/manifolds/Sphere.jl | 10 +++++----- test/manifolds/test_sphere.jl | 4 +++- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/manifolds/Sphere.jl b/src/manifolds/Sphere.jl index f2bc6583b8..1c2ef11920 100644 --- a/src/manifolds/Sphere.jl +++ b/src/manifolds/Sphere.jl @@ -286,7 +286,7 @@ function get_vector_orthonormal!(M::AbstractSphere{ℝ}, Y, p, c, ::RealNumbers) end _doc_injectivity_radius_sphere = raw""" - injectivity_radius(M::AbstractSphere[, p, ::ExponentialRetraction]) + injectivity_radius(M::AbstractSphere[, p, ::StabilizedRetraction]) Return the injectivity radius for the [`AbstractSphere`](@ref) `M`, which is globally ``π``. """ @@ -317,8 +317,8 @@ end function injectivity_radius(M::AbstractSphere, p, m::AbstractRetractionMethod) return _injectivity_radius(M, p, m) end -_injectivity_radius(::AbstractSphere, ::ExponentialRetraction) = π -_injectivity_radius(::AbstractSphere, ::ProjectionRetraction) = typemax(Float64) +_injectivity_radius(::AbstractSphere, ::StabilizedRetraction) = π +_injectivity_radius(::AbstractSphere, ::ProjectionRetraction) = Inf @doc raw""" inverse_retract(M::AbstractSphere, p, q, ::ProjectionInverseRetraction) @@ -357,10 +357,10 @@ function injectivity_radius(M::AbstractSphere, p, m::AbstractInverseRetractionMe end function _injectivity_radius(M::AbstractSphere, m::LogarithmicInverseRetraction) - return injectivity_radius(M, ExponentialRetraction()) + return injectivity_radius(M, StabilizedRetraction()) end function _injectivity_radius(M::AbstractSphere, p, m::LogarithmicInverseRetraction) - return injectivity_radius(M, p, ExponentialRetraction()) + return injectivity_radius(M, p, StabilizedRetraction()) end _injectivity_radius(::AbstractSphere, ::ProjectionInverseRetraction) = π / 2 function _injectivity_radius(M::AbstractSphere, p, m::ProjectionInverseRetraction) diff --git a/test/manifolds/test_sphere.jl b/test/manifolds/test_sphere.jl index 227751fb4d..91a5f724d9 100644 --- a/test/manifolds/test_sphere.jl +++ b/test/manifolds/test_sphere.jl @@ -48,7 +48,9 @@ using ManifoldDiff (get_vectors, DefaultOrthonormalBasis()) => :Orthonormal, (get_vectors, DefaultOrthogonalBasis()) => :Orthogonal, injectivity_radius => π, - (injectivity_radius, ProjectionRetraction()) => π / 2, + (injectivity_radius, ProjectionRetraction()) => Inf, + (injectivitiy_radius, LogarithmicInverseRetraction()) => π, + (injectivity_radius, ProjectionInverseRetraction()) => π / 2, is_default_metric => EuclideanMetric(), log => X, norm => π / 4, parallel_transport_to => parallel_transport_to(M, p, X, q), From 610082e42c15b796bed8978f668166c05edb4637 Mon Sep 17 00:00:00 2001 From: sblelong Date: Sun, 28 Jun 2026 19:15:17 +0200 Subject: [PATCH 03/11] Introducing bijectivity radii for the Sphere (according to #900) --- src/Manifolds.jl | 6 +++++- src/manifolds/Sphere.jl | 27 ++++++++++++++++++++++++++- 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/src/Manifolds.jl b/src/Manifolds.jl index 07c075b6fa..9936105913 100644 --- a/src/Manifolds.jl +++ b/src/Manifolds.jl @@ -308,6 +308,7 @@ using ManifoldsBase: SoftmaxRetraction, SoftmaxInverseRetraction, StabilizedRetraction, + StabilizedInverseRetraction, StopForwardingType, TangentSpace, TangentSpaceType, @@ -756,7 +757,10 @@ export AbstractInverseRetractionMethod, PolarLightInverseRetraction, ProjectionInverseRetraction, ShootingInverseRetraction, - SoftmaxInverseRetraction + SoftmaxInverseRetraction, + StabilizedInverseRetraction +# Bijectivity radii are exported here to be tested, but this should be removed if bijectivity radii get moved to ManifoldsBase. +export bijectivity_radius # Estimation methods for median and mean export AbstractApproximationMethod, GradientDescentEstimation, diff --git a/src/manifolds/Sphere.jl b/src/manifolds/Sphere.jl index 1c2ef11920..dd5ae2865c 100644 --- a/src/manifolds/Sphere.jl +++ b/src/manifolds/Sphere.jl @@ -306,7 +306,6 @@ Return the injectivity radius for the [`ProjectionRetraction`](@extref `Manifold @doc "$(_doc_injectivity_radius_sphere_projection)" injectivity_radius(::AbstractSphere, ::ProjectionRetraction) - @doc "$(_doc_injectivity_radius_sphere_projection)" injectivity_radius(::AbstractSphere, p, ::ProjectionRetraction) @@ -367,6 +366,32 @@ function _injectivity_radius(M::AbstractSphere, p, m::ProjectionInverseRetractio return _injectivity_radius(M, m) end +_doc_bijectivity_radius_sphere = raw""" + bijectivity_radius(M::AbstractSphere[, p, m::Union{AbstractRetractionMethod, AbstractInverseRetractionMethod}]) + +Return the bijectivity radius for the abstract sphere `M` endowed with (inverse) retraction method `m`, which is the smallest radius applicable to both the tangent spaces and the Riemannian metric for which the (inverse) retraction `m` has a well-defined inverse. This radius is computed as the minimum between the injectivity radius of `M` endowed with (inverse) retraction method `m` (at `p`), and the injectivity radius of the inverse of `m` (at `p`). +""" + +@doc "$(_doc_bijectivity_radius_sphere)" +bijectivity_radius(::AbstractSphere, ::Union{AbstractRetractionMethod, AbstractInverseRetractionMethod}) +@doc"$(_doc_bijectivity_radius_sphere)" +bijectivity_radius(::AbstractSphere, p, ::Union{AbstractRetractionMethod, AbstractInverseRetractionMethod}) + +function bijectivity_radius(M::AbstractSphere, m::Union{AbstractRetractionMethod, AbstractInverseRetractionMethod}) + if m ∈ (StabilizedRetraction(), StabilizedInverseRetraction()) + return injectivity_radius(M) + elseif m ∈ (ProjectionRetraction(), ProjectionInverseRetraction()) + return injectivity_radius(M, ProjectionInverseRetraction()) + end +end +function bijectivity_radius(M::AbstractSphere, p, m::Union{AbstractRetractionMethod, AbstractInverseRetractionMethod}) + if m ∈ (StabilizedRetraction(), StabilizedInverseRetraction()) + return injectivity_radius(M, p) + elseif m ∈ (ProjectionRetraction(), ProjectionInverseRetraction()) + return injectivity_radius(M, p, ProjectionInverseRetraction()) + end +end + """ is_flat(M::AbstractSphere) From 8369cbd015caf9352c681f18564c0a5032122b75 Mon Sep 17 00:00:00 2001 From: sblelong Date: Sun, 28 Jun 2026 19:28:03 +0200 Subject: [PATCH 04/11] Make `StabilizedInverseRetraction` the default retraction for an AbstractSphere (external ref to `StabilizedInverseRetraction` is pending typo fix in ManifoldsBase) --- src/manifolds/Sphere.jl | 9 +++++++++ test/manifolds/test_sphere.jl | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/src/manifolds/Sphere.jl b/src/manifolds/Sphere.jl index dd5ae2865c..178d7eb771 100644 --- a/src/manifolds/Sphere.jl +++ b/src/manifolds/Sphere.jl @@ -504,6 +504,15 @@ we use a stabilized version as default that projects onto the sphere afterwards, """ default_retraction_method(::AbstractSphere) = StabilizedRetraction(ExponentialRetraction()) +""" + default_inverse_retraction_method(M::AbstractSphere) + +The default inverse retraction on the sphere is usually the logarithmic map. However, for +numerical stability reasons, we use a stabilized version as default, see [`default_retraction_method(::AbstractSphere)`](@ref) +and [`StabilizedInverseRetraction`](@extref `ManifoldsBase.StabilizedInverseRetraction`). +""" +default_inverse_retraction_method(::AbstractSphere) = StabilizedInverseRetraction(LogarithmicInverseRetraction()) + function mid_point!(S::Sphere, q, p1, p2) q .= p1 .+ p2 project!(S, q, q) diff --git a/test/manifolds/test_sphere.jl b/test/manifolds/test_sphere.jl index 91a5f724d9..e9da151d2d 100644 --- a/test/manifolds/test_sphere.jl +++ b/test/manifolds/test_sphere.jl @@ -39,7 +39,7 @@ using ManifoldDiff # Expectations Dict( :atol => 1.0e-7, - default_inverse_retraction_method => LogarithmicInverseRetraction(), + default_inverse_retraction_method => StabilizedInverseRetraction(), default_retraction_method => StabilizedRetraction(), default_vector_transport_method => ParallelTransport(), distance => π / 4, @@ -49,7 +49,7 @@ using ManifoldDiff (get_vectors, DefaultOrthogonalBasis()) => :Orthogonal, injectivity_radius => π, (injectivity_radius, ProjectionRetraction()) => Inf, - (injectivitiy_radius, LogarithmicInverseRetraction()) => π, + (injectivity_radius, StabilizedInverseRetraction()) => π, (injectivity_radius, ProjectionInverseRetraction()) => π / 2, is_default_metric => EuclideanMetric(), log => X, norm => π / 4, From f8bd4740869708980d9b81f5265ac59818f3bb60 Mon Sep 17 00:00:00 2001 From: sblelong Date: Mon, 6 Jul 2026 09:18:13 +0200 Subject: [PATCH 05/11] Fix a typo in the doc of test_manifold --- ext/ManifoldsTestExt/ManifoldsTestExt.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/ManifoldsTestExt/ManifoldsTestExt.jl b/ext/ManifoldsTestExt/ManifoldsTestExt.jl index 6a096ab081..cf3dfd2a3a 100644 --- a/ext/ManifoldsTestExt/ManifoldsTestExt.jl +++ b/ext/ManifoldsTestExt/ManifoldsTestExt.jl @@ -63,7 +63,7 @@ Possible entries of the `expectations` dictionary are * for `injectivity_radius` - you can provide the global test for just the function, - you can provide the radius for a specific point with `(injectivity_radius, p)` - - you can provide a global or local one for retractions as well usinr `(injectivity_radius, rm)` and `injectivity_radius, p, rm`, respectively + - you can provide a global or local one for retractions as well using `(injectivity_radius, rm)` and `injectivity_radius, p, rm`, respectively * for `get_basis`, the key is a tuple of the function and the basis, e.g. `(get_basis, B) => ...` to the expected basis * for `get_coordinates` the key is a tuple of the function and the basis, e.g. `(get_coordinates, B) => c` * for `get_vector` the key is a tuple of the function, the coordinate vector, and the basis, e.g. `(get_vector, c, B) => X` From f3016aca6eb78c5ff2b1656a08db8070c40ebe9c Mon Sep 17 00:00:00 2001 From: sblelong Date: Mon, 6 Jul 2026 09:45:03 +0200 Subject: [PATCH 06/11] Unit tests for injectivity radii of inverse retractions --- ext/ManifoldsTestExt/ManifoldsTestExt.jl | 13 ++++++++++++- test/manifolds/test_sphere.jl | 4 ++-- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/ext/ManifoldsTestExt/ManifoldsTestExt.jl b/ext/ManifoldsTestExt/ManifoldsTestExt.jl index cf3dfd2a3a..7dd2616591 100644 --- a/ext/ManifoldsTestExt/ManifoldsTestExt.jl +++ b/ext/ManifoldsTestExt/ManifoldsTestExt.jl @@ -315,7 +315,18 @@ function Manifolds.Test.test_manifold(M::AbstractManifold, properties::Dict, exp name = "injectivity_radius(M, p, $rm)", # shorten name within large suite ) end - + for irm in inverse_retraction_methods + ismissing(irm) && continue + expected_irm = get_expectation(expectations, (injectivity_radius, points[1], irm)) + expected_irm_global = get_expectation(expectations, (injectivity_radius, irm)) + Manifolds.Test.test_injectivity_radius( + M, points[1]; + expected_value = expected_irm, + expected_global_value = expected_irm_global, + retraction_method = irm, + name = "injectivity_radius(M, p, $irm)", + ) + end end if (inner in functions) && !ismissing(vector) expected_inner = get_expectation(expectations, inner) diff --git a/test/manifolds/test_sphere.jl b/test/manifolds/test_sphere.jl index e9da151d2d..f6d816f82e 100644 --- a/test/manifolds/test_sphere.jl +++ b/test/manifolds/test_sphere.jl @@ -49,8 +49,8 @@ using ManifoldDiff (get_vectors, DefaultOrthogonalBasis()) => :Orthogonal, injectivity_radius => π, (injectivity_radius, ProjectionRetraction()) => Inf, - (injectivity_radius, StabilizedInverseRetraction()) => π, - (injectivity_radius, ProjectionInverseRetraction()) => π / 2, + # (injectivity_radius, StabilizedInverseRetraction()) => π, + # (injectivity_radius, ProjectionInverseRetraction()) => π / 2, is_default_metric => EuclideanMetric(), log => X, norm => π / 4, parallel_transport_to => parallel_transport_to(M, p, X, q), From 5470f333037a41f60e419a8c4ce5b1adffda2c74 Mon Sep 17 00:00:00 2001 From: sblelong Date: Mon, 6 Jul 2026 09:52:45 +0200 Subject: [PATCH 07/11] LogarithmicInverseRetraction() is default again for the Sphere --- src/manifolds/Sphere.jl | 9 --------- test/manifolds/test_sphere.jl | 4 ++-- 2 files changed, 2 insertions(+), 11 deletions(-) diff --git a/src/manifolds/Sphere.jl b/src/manifolds/Sphere.jl index 178d7eb771..dd5ae2865c 100644 --- a/src/manifolds/Sphere.jl +++ b/src/manifolds/Sphere.jl @@ -504,15 +504,6 @@ we use a stabilized version as default that projects onto the sphere afterwards, """ default_retraction_method(::AbstractSphere) = StabilizedRetraction(ExponentialRetraction()) -""" - default_inverse_retraction_method(M::AbstractSphere) - -The default inverse retraction on the sphere is usually the logarithmic map. However, for -numerical stability reasons, we use a stabilized version as default, see [`default_retraction_method(::AbstractSphere)`](@ref) -and [`StabilizedInverseRetraction`](@extref `ManifoldsBase.StabilizedInverseRetraction`). -""" -default_inverse_retraction_method(::AbstractSphere) = StabilizedInverseRetraction(LogarithmicInverseRetraction()) - function mid_point!(S::Sphere, q, p1, p2) q .= p1 .+ p2 project!(S, q, q) diff --git a/test/manifolds/test_sphere.jl b/test/manifolds/test_sphere.jl index f6d816f82e..eac0c0a2b6 100644 --- a/test/manifolds/test_sphere.jl +++ b/test/manifolds/test_sphere.jl @@ -33,7 +33,7 @@ using ManifoldDiff :InvalidVectors => [p], :NormalVectors => [V], :Covectors => [ξ], - :RetractionMethods => [ExponentialRetraction(), ProjectionRetraction()], + :RetractionMethods => [StabilizedRetraction(), ProjectionRetraction()], :VectorTransportMethods => [ParallelTransport(), SchildsLadderTransport(), PoleLadderTransport()] ), # Expectations @@ -48,7 +48,7 @@ using ManifoldDiff (get_vectors, DefaultOrthonormalBasis()) => :Orthonormal, (get_vectors, DefaultOrthogonalBasis()) => :Orthogonal, injectivity_radius => π, - (injectivity_radius, ProjectionRetraction()) => Inf, + # (injectivity_radius, ProjectionRetraction()) => Inf, # (injectivity_radius, StabilizedInverseRetraction()) => π, # (injectivity_radius, ProjectionInverseRetraction()) => π / 2, is_default_metric => EuclideanMetric(), From 6e57ba6e0dafc3fa9a978242dad3e51b142ac987 Mon Sep 17 00:00:00 2001 From: sblelong Date: Mon, 6 Jul 2026 09:55:24 +0200 Subject: [PATCH 08/11] Adjust expected values for unit tests --- test/manifolds/test_sphere.jl | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/manifolds/test_sphere.jl b/test/manifolds/test_sphere.jl index eac0c0a2b6..5dbc53113c 100644 --- a/test/manifolds/test_sphere.jl +++ b/test/manifolds/test_sphere.jl @@ -39,7 +39,7 @@ using ManifoldDiff # Expectations Dict( :atol => 1.0e-7, - default_inverse_retraction_method => StabilizedInverseRetraction(), + default_inverse_retraction_method => LogarithmicInverseRetraction(), default_retraction_method => StabilizedRetraction(), default_vector_transport_method => ParallelTransport(), distance => π / 4, @@ -48,9 +48,9 @@ using ManifoldDiff (get_vectors, DefaultOrthonormalBasis()) => :Orthonormal, (get_vectors, DefaultOrthogonalBasis()) => :Orthogonal, injectivity_radius => π, - # (injectivity_radius, ProjectionRetraction()) => Inf, - # (injectivity_radius, StabilizedInverseRetraction()) => π, - # (injectivity_radius, ProjectionInverseRetraction()) => π / 2, + (injectivity_radius, ProjectionRetraction()) => Inf, + (injectivity_radius, LogarithmicInverseRetraction()) => π, + (injectivity_radius, ProjectionInverseRetraction()) => π / 2, is_default_metric => EuclideanMetric(), log => X, norm => π / 4, parallel_transport_to => parallel_transport_to(M, p, X, q), From becf285d2d1d7d6aef2984703b135bcaa7bfd7db Mon Sep 17 00:00:00 2001 From: sblelong Date: Mon, 6 Jul 2026 10:36:23 +0200 Subject: [PATCH 09/11] Update changelog --- NEWS.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/NEWS.md b/NEWS.md index 1ceb0c929d..57cb4f7f66 100644 --- a/NEWS.md +++ b/NEWS.md @@ -5,6 +5,15 @@ All notable changes to ´Manifolds.jl´ will be documented in this file. 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.11.29] 2026-07-06 + +### Added + +* `injectivity_radius(M, p, m)` and `injectivity_radius(M, m)` where `m` is an `AbstractInverseRetractionMethod` and `M` is a `Sphere` are introduced. +* `injectivity_radius(M, m)` where `M` is a `Sphere` and `m` is a `LogarithmicInverseRetraction` or a `ProjectionInverseRetraction`. +* `bijectivity_radius(M, p, m)` and `bijectivity_radius(M, m)` are defined for `Sphere`s. +* `Manifolds.Test.test_manifold` now tests injectivity radii for inverse retractions. + ## [0.11.28] 2026-06-15 ### Added From cce40b4e77e5632bd68cf1815e9cdc8751a6ac7e Mon Sep 17 00:00:00 2001 From: sblelong Date: Mon, 6 Jul 2026 10:50:49 +0200 Subject: [PATCH 10/11] Update changelog --- NEWS.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/NEWS.md b/NEWS.md index c179c18caa..20c7f97d25 100644 --- a/NEWS.md +++ b/NEWS.md @@ -5,6 +5,15 @@ All notable changes to ´Manifolds.jl´ will be documented in this file. 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.11.30] Unreleased + +### Added + +* `injectivity_radius(M, p, m)` and `injectivity_radius(M, m)` where `m` is an `AbstractInverseRetractionMethod` and `M` is a `Sphere` are introduced. +* `injectivity_radius(M, m)` where `M` is a `Sphere` and `m` is a `LogarithmicInverseRetraction` or a `ProjectionInverseRetraction`. +* `bijectivity_radius(M, p, m)` and `bijectivity_radius(M, m)` are defined for `Sphere`s. +* `Manifolds.Test.test_manifold` now tests injectivity radii for inverse retractions. + ## [0.11.29] Unreleased ### Fixed From 048e25327cc4b8ae55a75a10e315fb49bac72e84 Mon Sep 17 00:00:00 2001 From: sblelong Date: Tue, 7 Jul 2026 18:08:06 +0200 Subject: [PATCH 11/11] Injectivity radius for StabilizedRetraction --- src/Manifolds.jl | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/Manifolds.jl b/src/Manifolds.jl index 9936105913..588958daed 100644 --- a/src/Manifolds.jl +++ b/src/Manifolds.jl @@ -570,6 +570,14 @@ Note that volume density is well-defined only for `X` for which `exp(M, p, X)` i """ volume_density(::AbstractManifold, p, X) +# TODO: Move this to ManifoldsBase.jl once testing is successful. +function injectivity_radius(M::AbstractManifold, m::StabilizedRetraction) + return injectivity_radius(M, m.retraction) +end +function injectivity_radius(M::AbstractManifold, p, m::StabilizedRetraction) + return injectivity_radius(M, p, m.retraction) +end + # functions populated with methods by extensions function solve_chart_log_bvp end