Merge branch 'master' into dev-0.6

# Conflicts:
#	Changelog.md
#	Project.toml
#	src/plans/proximal_gradient_plan.jl

Author: kellertuer

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
-      - uses: codecov/codecov-action@v6
+      - uses: codecov/codecov-action@v7
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           file: ./lcov.info

.github/workflows/spell_check.yml

@@ -10,4 +10,4 @@ jobs:
       - name: Checkout Actions Repository
         uses: actions/checkout@v6
       - name: Check spelling
-        uses: crate-ci/typos@v1.46.0
+        uses: crate-ci/typos@v1.47.0

Changelog.md

@@ -34,6 +34,18 @@ This is a breaking change since the JuMP extension is dropped.
 * the plotting functions to `Asymptote`. They can now be found in the separate package [`ManifoldAsymptote.jl`]()
   this way, `Manopt.jl` has less dependencies, especially the color and colorschemes dependencies are dropped
 
+## [0.5.39] June 3, 2026
+
+### Fixed
+
+* a small bug where debug statements were printed even though they should not be due to `DebugEvery` and unified warnings to print independent of `DebugEvery`. (#609)
+
+## [0.5.38] May 19, 2026
+
+### Changed
+
+* the `:convex` backtracking strategy for `proximal_gradient_method` now entails a slightly different condition whenever the upper bound on the sectional curvature of the manifold, input via the `k_max` kwarg, is positive. This comes with a "tolerance" type parameter, `δ`, which must be positive.
+
 ## [0.5.37] May 5, 2026
 
 ### Changed
@@ -148,7 +160,6 @@ Moved the documentation glossaries to using the new [Glossaries.jl](https://gith
   This also allows finally to run single test files without installing all packages manually, but instead just switching to and instantiating the test environment. (#550)
 * for compatibility, state also `[source]` entries consistently in the sub `Project.toml` files. (#550)
 
-
 ## [0.5.28] November 17, 2025
 
 ### Changed

Project.toml

@@ -1,6 +1,6 @@
 name = "Manopt"
 uuid = "0fc0a36d-df90-57f3-8f93-d78a9fc72bb5"
-version = "0.5.37"
+version = "0.6.0"
 
 [workspace]
 projects = ["test", "docs", "tutorials"]

src/plans/debug.jl

@@ -636,7 +636,7 @@ function (d::DebugEntryChange)(
     end
     x = get_storage(d.storage, d.field)
     v = d.distance(p, st, getproperty(st, d.field), x)
-    Printf.format(d.io, Printf.Format(d.format), v)
+    (k > 0) && Printf.format(d.io, Printf.Format(d.format), v)
     d.storage(p, st, k)
     return nothing
 end
@@ -992,15 +992,15 @@ end
 function (d::DebugTime)(::AbstractManoptProblem, ::AbstractManoptSolverState, k)
     if k == 0 || d.last_time == Nanosecond(0) # init
         d.last_time = Nanosecond(time_ns())
-    else
+    elseif k > 0
         t = time_ns()
         p = Nanosecond(t) - d.last_time
         Printf.format(
             d.io, Printf.Format(d.format), canonicalize(round(p, d.time_accuracy))
         )
-    end
-    if d.mode == :iterative
-        d.last_time = Nanosecond(time_ns())
+        if d.mode == :iterative
+            d.last_time = Nanosecond(time_ns())
+        end
     end
     return nothing
 end
@@ -1068,7 +1068,6 @@ end
 function (d::DebugWarnIfCostIncreases)(
         p::AbstractManoptProblem, st::AbstractManoptSolverState, k::Int
     )
-    (k < 0) && (return nothing)
     if d.status !== :No
         cost = get_cost(p, get_iterate(st))
         if cost > d.old_cost + d.tol
@@ -1300,7 +1299,7 @@ end
 function (d::DebugWarnIfStepsizeCollapsed)(
         amp::AbstractManoptProblem, st::AbstractManoptSolverState, k::Int
     )
-    (k < 1) && (return nothing)
+    (k == 0) && (return nothing)
     if d.status !== :No
         if get_last_stepsize(amp, st, k) ≤ d.stop_when_stepsize_less
             @warn "Backtracking stopped because the stepsize fell below the threshold $(d.stop_when_stepsize_less)."

src/plans/proximal_gradient_plan.jl

@@ -405,6 +405,8 @@ A functor for backtracking line search in proximal gradient methods.
 * `sufficient_decrease=0.5`: sufficient decrease parameter
 * `contraction_factor=0.5`: step size reduction factor
 * `strategy=:nonconvex`: backtracking strategy, either `:convex` or `:nonconvex`
+* `k_max=0.0`: an upper bound to the sectional curvatures of the manifold, only for the `:convex` strategy
+* `δ=1e-2`: parameter for backtracking in case `k_max > 0`, only for the `:convex` strategy
 """
 mutable struct ProximalGradientMethodBacktrackingStepsize{P, T} <: Stepsize
     initial_stepsize::T
@@ -415,33 +417,39 @@ mutable struct ProximalGradientMethodBacktrackingStepsize{P, T} <: Stepsize
     last_stepsize::T
     stop_when_stepsize_less::T
     warm_start_factor::T
-    function ProximalGradientMethodBacktrackingStepsize(;
-            initial_stepsize::T, sufficient_decrease::T, contraction_factor::T, strategy::Symbol,
-            candidate_point::P, last_stepsize::T, stop_when_stepsize_less::T, warm_start_factor::T
-        ) where {P, T <: Real}
-        return new{P, T}(
-            initial_stepsize, sufficient_decrease, contraction_factor, strategy,
-            candidate_point, last_stepsize, stop_when_stepsize_less, warm_start_factor
-        )
-    end
+    k_max::T
+    δ::T
+
     function ProximalGradientMethodBacktrackingStepsize(
             M::AbstractManifold;
-            p = rand(M),
-            initial_stepsize::Real = 1.0, sufficient_decrease::Real = 0.5, contraction_factor::Real = 0.5,
-            strategy::Symbol = :nonconvex, stop_when_stepsize_less::Real = 1.0e-8, warm_start_factor::Real = 1.0,
+            initial_stepsize::T = 1.0, sufficient_decrease::T = 0.5, contraction_factor::T = 0.5,
+            strategy::Symbol = :nonconvex, stop_when_stepsize_less::T = 1.0e-8, warm_start_factor::T = 1.0,
+            k_max::T = 0.0,
+            δ::T = 1.0e-2,
+        ) where {T}
+        0 < sufficient_decrease < 1 ||
+            throw(DomainError(sufficient_decrease, "sufficient_decrease must be in (0, 1)"))
+        0 < contraction_factor < 1 ||
+            throw(DomainError(contraction_factor, "contraction_factor must be in (0, 1)"))
+        initial_stepsize > 0 ||
+            throw(DomainError(initial_stepsize, "initial_stepsize must be positive"))
+        strategy in [:convex, :nonconvex] ||
+            throw(DomainError(strategy, "strategy must be either :convex or :nonconvex"))
+        stop_when_stepsize_less > 0 || throw(
+            DomainError(
+                stop_when_stepsize_less, "stop_when_stepsize_less must be positive"
+            ),
         )
-        T = promote_type(typeof(initial_stepsize), typeof(sufficient_decrease), typeof(contraction_factor), typeof(stop_when_stepsize_less), typeof(warm_start_factor))
-        0 < sufficient_decrease < 1 || throw(DomainError(sufficient_decrease, "sufficient_decrease ($(sufficient_decrease)) must be in (0, 1)"))
-        0 < contraction_factor < 1 || throw(DomainError(contraction_factor, "contraction_factor ($(contraction_factor)) must be in (0, 1)"))
-        initial_stepsize > 0 || throw(DomainError(initial_stepsize, "initial_stepsize ($(initial_stepsize)) must be positive"))
-        strategy in [:convex, :nonconvex] || throw(DomainError(strategy, "strategy (:$(strategy)) must be either :convex or :nonconvex"))
-        stop_when_stepsize_less > 0 || throw(DomainError(stop_when_stepsize_less, "stop_when_stepsize_less ($(stop_when_stepsize_less)) must be positive"))
-        warm_start_factor > 0 || throw(DomainError(warm_start_factor, "warm_start_factor ($(warm_start_factor)) must be positive"))
-        return ProximalGradientMethodBacktrackingStepsize(;
-            initial_stepsize = convert(T, initial_stepsize), sufficient_decrease = convert(T, sufficient_decrease),
-            contraction_factor = convert(T, contraction_factor), strategy = strategy, candidate_point = p,
-            last_stepsize = convert(T, initial_stepsize), stop_when_stepsize_less = convert(T, stop_when_stepsize_less),
-            warm_start_factor = convert(T, warm_start_factor),
+        warm_start_factor > 0 ||
+            throw(DomainError(warm_start_factor, "warm_start_factor must be positive"))
+
+        (k_max > 0 && δ ≤ 0) &&
+            throw(DomainError(δ, "the tolerance parameter δ must be positive if k_max > 0"))
+
+        p = rand(M)
+        return new{typeof(p), T}(
+            initial_stepsize, sufficient_decrease, contraction_factor, strategy, p,
+            initial_stepsize, stop_when_stepsize_less, warm_start_factor, k_max, δ
         )
     end
 end
@@ -455,6 +463,7 @@ function Base.show(io::IO, pgb::ProximalGradientMethodBacktrackingStepsize)
     print(io, ", strategy = :$(pgb.strategy), candidate_point = ", pgb.candidate_point)
     print(io, ", last_stepsize = ", pgb.last_stepsize, ", stop_when_stepsize_less = ", pgb.stop_when_stepsize_less)
     print(io, ", warm_start_factor = ", pgb.warm_start_factor)
+    print(io, ", k_max = ", pgb.k_max, ", δ = ", pgb.δ)
     return print(io, ")")
 end
 function status_summary(pgb::ProximalGradientMethodBacktrackingStepsize; context::Symbol = :default)
@@ -521,8 +530,11 @@ function (s::ProximalGradientMethodBacktrackingStepsize)(
             g_p = get_cost_smooth(M, objective, p)
             g_q = get_cost_smooth(M, objective, candidate_point)
 
+
+            ζ_δ = s.k_max ≤ zero(eltype(s.k_max)) ? one(eltype(s.k_max)) : π / (2 + s.δ) * cot(π / (2 + s.δ))
+
             # Convex descent condition
-            if g_q <= g_p + inner(M, p, X, log_p_q) + (1 / 2λ) * squared_distance
+            if g_q <= g_p + inner(M, p, X, log_p_q) + (ζ_δ / 2λ) * squared_distance
                 s.last_stepsize = λ
                 return λ
             end
@@ -551,7 +563,7 @@ where ``G_{λ}(p) = (1/λ) * $(_tex(:log))_p(T_{λ}(p))`` is the gradient mappin
 For the convex case, the condition is:
 
 ```math
-g(T_{λ}(p)) ≤ g(p) + ⟨$(_tex(:grad)) g(p), $(_tex(:log))_p T_{λ}(p)⟩ + $(_tex(:frac, "1", "2λ")) $(_math(:distance))^2(p, T_{λ}(p))
+g(T_{λ}(p)) ≤ g(p) + ⟨$(_tex(:grad)) g(p), $(_tex(:log))_p T_{λ}(p)⟩ + $(_tex(:frac, "ζ_δ", "2λ")) $(_math(:distance))^2(p, T_{λ}(p))
 ```
 
 Returns a stepsize `λ` that satisfies the specified condition.

src/solvers/convex_bundle_method.jl

@@ -329,6 +329,7 @@ function status_summary(cbms::ConvexBundleMethodState; context::Symbol = :defaul
     * bundle cap size:                                  $(cbms.bundle_cap)
     * current bundle size:                              $(length(cbms.bundle))
     * curvature upper bound:                            $(cbms.k_max)
+    * curvature lower bound:                            $(cbms.k_min)
     * descent test parameter:                           $(cbms.m)
     * diameter:                                         $(cbms.diameter)
     * inverse retraction:                               $(cbms.inverse_retraction_method)

test/solvers/test_proximal_gradient_method.jl

@@ -21,6 +21,20 @@ using Manopt, Manifolds, Test, ManifoldDiff
         # Trigger manually
         sc1.at_iteration = 2
         @test length(get_reason(sc1)) > 0
+
+        pgms.last_stepsize = 1.0
+        g(M, q) = distance(M, q, p)^2
+        grad_g(M, q) = -2 * log(M, q, p)
+        h(M, q) = distance(M, q, p)
+        prox_h(M, λ, q) = ManifoldDiff.prox_distance(M, λ, p, q, 1)
+        f(M, q) = g(M, q) + h(M, q)
+        ob = ManifoldProximalGradientObjective(f, g, grad_g, prox_h)
+        mp = DefaultManoptProblem(M, ob)
+
+        @test sc1.last_change < sc1.threshold
+        @test sc1.at_iteration == 2
+        @test sc1(mp, pgms, 2) == true
+        pgms.last_stepsize = 0.0
     end
     @testset "Proximal Gradient Backtracking" begin
         pgb = Manopt.ProximalGradientMethodBacktrackingStepsize(M)
@@ -78,6 +92,9 @@ using Manopt, Manifolds, Test, ManifoldDiff
         @test_throws DomainError Manopt.ProximalGradientMethodBacktrackingStepsize(
             M; warm_start_factor = -1.0
         )
+        @test_throws DomainError Manopt.ProximalGradientMethodBacktrackingStepsize(
+            M; initial_stepsize = 1.0, strategy = :convex, stop_when_stepsize_less = 2.0, k_max = 1.0, δ = -1.0
+        )
 
         @testset "Backtracking Warnings" begin
             dw1 = DebugWarnIfStepsizeCollapsed(:Once)
@@ -205,7 +222,9 @@ using Manopt, Manifolds, Test, ManifoldDiff
             inverse_retraction_method = ProjectionInverseRetraction(),
             stepsize = ProximalGradientMethodBacktracking(;
                 initial_stepsize = 1.0,
-                strategy = :convex
+                strategy = :convex,
+                k_max = 1.0,
+                δ = 1.0e-2,
             ),
             return_state = true
         )