Merge branch 'dev-0.6' into kellertuer/JuMP-on-non-array-points

# Conflicts:
#	Changelog.md

Author: kellertuer

Changelog.md

@@ -8,20 +8,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [0.6.0] unreleased
 
-This is a breaking change since the JuMP extension is dropped. 
-
-### Changed
-
-* removed the JuMP extension, since it was a bit incomplete and hard to maintain, and not possible to extend to all manifolds. The main reason is, that matrices are a bit tough to represent in JuMP, which is vector based, and types points are nearly impossible to represent. Distinguishing between points and tangent vectors is also a bit hard to track.
- 
-## [0.5.35] April 3, 2026
+This is a breaking change since the JuMP extension is dropped.
 
 ### Changed
 
+* `NonlinearLeastSquaresObjective` is now called `ManifoldNonlinearLeastSquaresObjective` (#569).
+* This is a breaking release in order to move a few parts to a unified naming and since we
+discontinue the `JuMP` extension. (#532)
 * Improved formatting of the references in the Readme.md (#586)
 * Bump compat for RecursiveArrayTools.jl to include version 4
 * deactivate CompatHelper Action and solely use dependabot
 
+### Fixed
+
+* Fixed `show` methods of various state and stopping criteria to properly handle both `repr` and multiline printing (#569)
+* Unified all `show` methods and their human readable analoga `status_summary` throughout the package (#569)
+* Fixed some text descriptions of a few stopping criteria.
+* unify naming of fields, `debugDictionary` of the debug state is now called `debug_dictionary`
+* the `NesterovRule` now also stores an actual `AbstractRetractionMethod` instead of implicitly always using the default one.
+
+
 ## [0.5.34] March 3, 2026
 
 ### Fixed

_typos.toml

@@ -3,7 +3,7 @@ methodes = "methodes" # french
 Serie = "Serie" # french
 sur = "sur" # french
 cmo = "cmo" # often used abbreviation for constrained manifold objective
-
+nd = "nd" # like in 2nd
 [files]
 extend-exclude = [
 "tutorials/*.html",

docs/src/plans/index.md

@@ -28,7 +28,7 @@ The following symbols are used.
 | `:Activity` | [`DebugWhenActive`](@ref) | activity of the debug action stored within |
 | `:Basepoint` | [`TangentSpace`](@extref ManifoldsBase `ManifoldsBase.TangentSpace`) | the point the tangent space is at |
 | `:Cost` | generic |the cost function (within an objective, as pass down) |
-| `:Debug` | [`DebugSolverState`](@ref) | the stored `debugDictionary` |
+| `:Debug` | [`DebugSolverState`](@ref) | the stored `debug_dictionary` |
 | `:Gradient` | generic | the gradient function (within an objective, as pass down) |
 | `:Iterate` | generic | the (current) iterate, similar to [`set_iterate!`](@ref), within a state |
 | `:Manifold` | generic |the manifold (within a problem, as pass down) |

docs/src/plans/objective.md

@@ -115,7 +115,7 @@ AbstractManifoldFirstOrderObjective
 ManifoldFirstOrderObjective
 ManifoldAlternatingGradientObjective
 ManifoldStochasticGradientObjective
-NonlinearLeastSquaresObjective
+ManifoldNonlinearLeastSquaresObjective
 ```
 
 While the [`ManifoldFirstOrderObjective`](@ref) allows to provide different

src/Manopt.jl

@@ -8,6 +8,9 @@
 """
 module Manopt
 
+# When indenting something in print, use two spaces (or maybe \t later?)
+_MANOPT_INDENT = "  "
+
 import Base: &, copy, getindex, identity, length, setindex!, show, |
 import LinearAlgebra: reflect!
 import ManifoldsBase: embed!, plot_slope, prepare_check_result, find_best_slope_window
@@ -286,7 +289,7 @@ export AbstractDecoratedManifoldObjective,
     EmbeddedManifoldObjective,
     ScaledManifoldObjective,
     ManifoldCountObjective,
-    NonlinearLeastSquaresObjective,
+    ManifoldNonlinearLeastSquaresObjective,
     ManifoldAlternatingGradientObjective,
     ManifoldCostGradientObjective,
     ManifoldCostObjective,
@@ -341,6 +344,7 @@ export AbstractGradientSolverState,
     ProjectedGradientMethodState,
     ProximalBundleMethodState,
     ProximalGradientMethodState,
+    ProximalPointState,
     RecordSolverState,
     StepsizeState,
     StochasticGradientDescentState,
@@ -595,7 +599,7 @@ export render_asymptote
 #
 # Debugs
 export DebugSolverState, DebugAction, DebugGroup, DebugEntry, DebugEntryChange, DebugEvery
-export DebugChange, DebugGradientChange
+export DebugCallback, DebugChange, DebugGradientChange
 export DebugIterate, DebugIteration, DebugDivider, DebugTime
 export DebugFeasibility
 export DebugCost, DebugStoppingCriterion

src/helpers/LineSearchesTypes.jl

@@ -7,9 +7,7 @@ Wrapper for line searches available in the `LineSearches.jl` library.
 
     LineSearchesStepsize(M::AbstractManifold, linesearch; kwargs...
     LineSearchesStepsize(
-        linesearch;
-        retraction_method=ExponentialRetraction(),
-        vector_transport_method=ParallelTransport(),
+        linesearch; retraction_method=ExponentialRetraction(), vector_transport_method=ParallelTransport(),
     )
 
 Wrap `linesearch` (for example [`HagerZhang`](https://julianlsolvers.github.io/LineSearches.jl/latest/reference/linesearch.html#LineSearches.HagerZhang)
@@ -34,9 +32,7 @@ function LineSearchesStepsize(
         linesearch;
         initial_guess::AbstractInitialLinesearchGuess = ConstantInitialGuess(),
         retraction_method::AbstractRetractionMethod = default_retraction_method(M),
-        vector_transport_method::AbstractVectorTransportMethod = default_vector_transport_method(
-            M
-        ),
+        vector_transport_method::AbstractVectorTransportMethod = default_vector_transport_method(M),
         last_stepsize::Real = NaN,
     )
     return LineSearchesStepsize(
@@ -49,21 +45,32 @@ function LineSearchesStepsize(
 end
 function LineSearchesStepsize(
         linesearch;
-        initial_guess::AbstractInitialLinesearchGuess = ConstantInitialGuess(),
-        retraction_method::AbstractRetractionMethod = ExponentialRetraction(),
-        vector_transport_method::AbstractVectorTransportMethod = ParallelTransport(),
+        initial_guess::ILG = ConstantInitialGuess(),
+        retraction_method::RM = ExponentialRetraction(),
+        vector_transport_method::VTM = ParallelTransport(),
         last_stepsize::Real = NaN,
-    )
-    return LineSearchesStepsize{
-        typeof(linesearch), typeof(initial_guess), typeof(retraction_method), typeof(vector_transport_method), typeof(last_stepsize),
-    }(
+    ) where {ILG <: AbstractInitialLinesearchGuess, RM <: AbstractRetractionMethod, VTM <: AbstractVectorTransportMethod}
+    return LineSearchesStepsize{typeof(linesearch), ILG, RM, VTM, typeof(last_stepsize)}(
         linesearch, initial_guess, retraction_method, vector_transport_method, last_stepsize
     )
 end
-
 function Base.show(io::IO, cs::LineSearchesStepsize)
     return print(
         io,
         "LineSearchesStepsize($(cs.linesearch); initial_guess=$(cs.initial_guess), retraction_method=$(cs.retraction_method), vector_transport_method=$(cs.vector_transport_method), last_stepsize=$(cs.last_stepsize))",
     )
 end
+function status_summary(cs::LineSearchesStepsize; context::Symbol = :default)
+    (context === :short) && return repr(cs)
+    (context === :inline) && return "A linesearch stepsize wrapper for LineSearches.jl (last step size $(cs.last_stepsize))"
+    return """
+    A step size wrapper for LineSearches.jl
+    (last step size: $(cs.last_stepsize))
+
+    ## Parameters
+    * line search:            $(_MANOPT_INDENT)$(cs.linesearch)
+    * initial guess:          $(_MANOPT_INDENT)$(cs.initial_guess)
+    * retraction method:      $(_MANOPT_INDENT)$(cs.retraction_method)
+    * vector transport method:$(_MANOPT_INDENT)$(cs.vector_transport_method)
+    """
+end

src/helpers/test.jl

@@ -25,15 +25,28 @@ using ManifoldDiff
 # Dummy types
 struct DummyManifold <: AbstractManifold{ManifoldsBase.ℝ} end
 
-struct DummyDecoratedObjective{E, O <: AbstractManifoldObjective} <:
-    Manopt.AbstractDecoratedManifoldObjective{E, O}
+struct DummyDecoratedObjective{E, O <: AbstractManifoldObjective} <: Manopt.AbstractDecoratedManifoldObjective{E, O}
     objective::O
 end
-function DummyDecoratedObjective(
-        o::O
-    ) where {E <: AbstractEvaluationType, O <: AbstractManifoldObjective{E}}
+function DummyDecoratedObjective(o::O) where {E <: AbstractEvaluationType, O <: AbstractManifoldObjective{E}}
     return DummyDecoratedObjective{E, O}(o)
 end
+function Manopt.status_summary(
+        ddo::DummyDecoratedObjective; kwargs...
+    )
+    return "A dummy decorator for " * Manopt.status_summary(ddo.objective; kwargs...)
+end
+function Base.show(io::IO, ddo::DummyDecoratedObjective)
+    print(io, "DummyDecoratedObjective(")
+    print(io, ddo.objective)
+    return print(io, ")")
+end
+struct DummyEmptyDecoratedObjective{E, O <: AbstractManifoldObjective} <: Manopt.AbstractDecoratedManifoldObjective{E, O}
+    objective::O
+    function DummyEmptyDecoratedObjective(o::O) where {E <: AbstractEvaluationType, O <: AbstractManifoldObjective{E}}
+        return new{E, O}(o)
+    end
+end
 
 struct DummyProblem{M <: AbstractManifold} <: AbstractManoptProblem{M} end
 struct DummyStoppingCriteriaSet <: StoppingCriterionSet end
@@ -43,6 +56,8 @@ mutable struct DummyState <: AbstractManoptSolverState
     storage::Vector{Float64}
 end
 DummyState() = DummyState([])
+Manopt.status_summary(ds::DummyState; context = :Default) = "A Manopt Test state with storage $(ds.storage)"
+Base.show(io::IO, ds::DummyState) = print(io, "Manopt.Test.DummyState($(ds.storage))")
 Manopt.get_iterate(::DummyState) = NaN
 Manopt.set_parameter!(s::DummyState, ::Val, v) = s
 Manopt.set_parameter!(s::DummyState, ::Val{:StoppingCriterion}, v) = s

src/plans/adaptive_regularization_with_cubics_plan.jl

@@ -104,3 +104,21 @@ end
 function get_gradient_function(arcmo::AdaptiveRegularizationWithCubicsModelObjective)
     return (TpM, X) -> get_gradient(TpM, arcmo, X)
 end
+function Base.show(io::IO, arcmo::AdaptiveRegularizationWithCubicsModelObjective)
+    print(io, "AdaptiveRegularizationWithCubicsModelObjective(")
+    print(io, arcmo.objective); print(io, ", ")
+    print(io, arcmo.σ)
+    return print(io, ")")
+end
+function status_summary(arcmo::AdaptiveRegularizationWithCubicsModelObjective; context::Symbol = :default)
+    (context === :short) && return repr(arcmo)
+    (context === :inline) && return "The (tangent space) model for the adaptive regularization with cubics sub problem with parameter σ=$(arcmo.σ) for the objective $(status_summary(arcmo.objective; context = context))"
+    return """
+    The cubic polynomial based model for the sub problem of the Adaptive Regularization with cubics solver
+
+    ## Regularization parameter
+    σ = $(arcmo.σ)
+
+    ## Objective
+    $(_in_str(status_summary(arcmo.objective)))"""
+end

src/plans/alternating_gradient_plan.jl

@@ -149,3 +149,20 @@ function get_gradient!(
     mago.gradient!![k](M, X, p)
     return X
 end
+
+function Base.show(io::IO, mago::ManifoldAlternatingGradientObjective{E}) where {E}
+    print(io, "ManifoldAlternatingGradientObjective(")
+    print(io, mago.cost); print(io, ", "); print(io, mago.gradient!!); print(io, "; ")
+    print(io, _to_kw(E))
+    return print(io, ")")
+end
+function status_summary(mago::ManifoldAlternatingGradientObjective; context::Symbol = :default)
+    (context === :short) && (return repr(mago))
+    (context === :inline) && (return "An alternating gradient objective on a manifold.")
+    return """
+    An alternating gradient objective providing the gradient as components with which to alternate
+
+    ## Functions
+    * cost:    $(_MANOPT_INDENT)$(mago.cost)
+    * gradient:$(_MANOPT_INDENT)$(mago.gradient!!)"""
+end

src/plans/bundle_plan.jl

@@ -140,20 +140,20 @@ function get_reason(sc::StopWhenLagrangeMultiplierLess)
     return ""
 end
 
-function status_summary(sc::StopWhenLagrangeMultiplierLess)
+function status_summary(sc::StopWhenLagrangeMultiplierLess; context::Symbol = :default)
     s = (sc.at_iteration >= 0) ? "reached" : "not reached"
     msg = "Lagrange multipliers"
     isnothing(sc.names) && (msg *= " with tolerances $(sc.tolerances)")
     if !isnothing(sc.names)
         msg *= join(["$si < $bi" for (si, bi) in zip(sc.names, sc.tolerances)], ", ")
     end
-    return "$(msg) :\t$(s)"
+    return (_is_inline(context) ? "" : "A stopping criterion to stop when the Lagrange multipliers are less than $(sc.tolerances).\n$(_MANOPT_INDENT)") * "$(msg):$(_MANOPT_INDENT)$(s)"
 end
 function show(io::IO, sc::StopWhenLagrangeMultiplierLess)
     n = isnothing(sc.names) ? "" : ", $(names)"
     return print(
         io,
-        "StopWhenLagrangeMultiplierLess($(sc.tolerances); mode=:$(sc.mode)$n)\n    $(status_summary(sc))",
+        "StopWhenLagrangeMultiplierLess($(sc.tolerances); mode=:$(sc.mode)$n)",
     )
 end
 
@@ -181,6 +181,12 @@ mutable struct DebugWarnIfLagrangeMultiplierIncreases <: DebugAction
         return new(warn, Float64(Inf), tol)
     end
 end
-function show(io::IO, di::DebugWarnIfLagrangeMultiplierIncreases)
-    return print(io, "DebugWarnIfLagrangeMultiplierIncreases(; tol=\"$(di.tol)\")")
+function show(io::IO, d::DebugWarnIfLagrangeMultiplierIncreases)
+    m = (d.status === :No ? "" : ":$(d.status)")
+    return print(io, "DebugWarnIfLagrangeMultiplierIncreases($(m); tol=\"$(d.tol)\")")
+end
+function status_summary(d::DebugWarnIfLagrangeMultiplierIncreases; context::Symbol = :default)
+    (context === :short) && return repr(d)
+    m = (d.status === :Once) ? "once" : (d.status === :No ? "(inactive)" : "")
+    return "a DebugAction warning if the lagange multiplier increases in an iteration $m."
 end