Finish further Record Actions

Author: kellertuer

src/plans/first_order_plan.jl

@@ -1214,15 +1214,21 @@ function (r::RecordGradient{T})(
     return record_or_reset!(r, get_gradient(s), k)
 end
 show(io::IO, ::RecordGradient{T}) where {T} = print(io, "RecordGradient($T)")
-
+function status_summary(rg::RecordGradient; context::Symbol = :default)
+    (context === :short) && return ":Gradient"
+    return "A RecordAction to record the current gradient"
+end
 @doc """
-    RecordGradientNorm <: RecordAction
+    RecordGradientNorm{R<:Real} <: RecordAction
 
 record the norm of the current gradient
+
+## Constructor
+    RecordGradientNorm(r::Type{<:Real}=Float64)
 """
-mutable struct RecordGradientNorm <: RecordAction
-    recorded_values::Array{Float64, 1}
-    RecordGradientNorm() = new(Array{Float64, 1}())
+mutable struct RecordGradientNorm{R <: Real} <: RecordAction
+    recorded_values::Array{R, 1}
+    RecordGradientNorm(r::Type{<:Real}) = new{r}(Array{r, 1}())
 end
 function (r::RecordGradientNorm)(
         mp::AbstractManoptProblem, ast::AbstractManoptSolverState, k::Int
@@ -1231,16 +1237,28 @@ function (r::RecordGradientNorm)(
     return record_or_reset!(r, norm(M, get_iterate(ast), get_gradient(ast)), k)
 end
 show(io::IO, ::RecordGradientNorm) = print(io, "RecordGradientNorm()")
+function status_summary(rg::RecordGradientNorm; context::Symbol = :default)
+    (context === :short) && return ":GradientNorm"
+    return "A RecordAction to record the current gradient norm"
+end
 
 @doc """
     RecordStepsize <: RecordAction
 
-record the step size
+record the step size.
+
+## Constructor
+    RecordStepsise(r::Type{<:Real}=Float64)
 """
-mutable struct RecordStepsize <: RecordAction
-    recorded_values::Array{Float64, 1}
-    RecordStepsize() = new(Array{Float64, 1}())
+mutable struct RecordStepsize{R <: Real} <: RecordAction
+    recorded_values::Array{R, 1}
+    RecordStepsize(r::Type{<:Real} = Float64) = new{r}(Array{r, 1}())
 end
 function (r::RecordStepsize)(p::AbstractManoptProblem, s::AbstractGradientSolverState, k)
     return record_or_reset!(r, get_last_stepsize(p, s, k), k)
 end
+show(io::IO, ::RecordStepsize{R}) where {R} = print(io, "RecordStepsize($R)")
+function status_summary(rg::RecordStepsize{R}; context::Symbol = :default) where {R}
+    (context === :short) && return ":Stepsize"
+    return "A RecordAction to record the current stepsize (of type $R)"
+end

src/plans/proximal_plan.jl

@@ -333,17 +333,25 @@ end
 #
 # Record
 @doc """
-    RecordProximalParameter <: RecordAction
+    RecordProximalParameter{R <: Real} <: RecordAction
 
 record the current iterates proximal point algorithm parameter given by in
 [`AbstractManoptSolverState`](@ref)s `o.λ`.
+
+## Constructor
+    RecordProximalParameter(r::Type{<:Real}=Float64)
 """
-mutable struct RecordProximalParameter <: RecordAction
-    recorded_values::Array{Float64, 1}
-    RecordProximalParameter() = new(Array{Float64, 1}())
+mutable struct RecordProximalParameter{R <: Real} <: RecordAction
+    recorded_values::Array{R, 1}
+    RecordProximalParameter(r::Type{<:Real}) = new{r}(Array{r, 1}())
 end
 function (r::RecordProximalParameter)(
         ::AbstractManoptProblem, cpps::CyclicProximalPointState, k::Int
     )
     return record_or_reset!(r, cpps.λ(k), k)
 end
+show(io::IO, ::RecordProximalParameter{R}) where {R} = print(io, "RecordProximalParameter($R)")
+function status_summary(rg::RecordProximalParameter{R}; context::Symbol = :default) where {R}
+    (context === :short) && return ":ProximalParameter"
+    return "A RecordAction to record the current proximal parameter (of type $R)"
+end

src/plans/record.jl

@@ -264,14 +264,25 @@ function show(io::IO, re::RecordEvery)
     return print(io, "RecordEvery($(re.record), $(re.every), $(re.always_update))")
 end
 function status_summary(re::RecordEvery; context::Symbol = :default)
-    if context
-    s = ""
-    if re.record isa RecordGroup
-        s = status_summary(re.record)[3:(end - 2)]
-    else
-        s = "$(re.record)"
+    if context === :short
+        s = ""
+        if re.record isa RecordGroup
+            s = status_summary(re.record)[3:(end - 2)]
+        else
+            s = "$(re.record)"
+        end
+        return "[$s, $(re.every)]"
     end
-    return "[$s, $(re.every)]"
+    s = ""
+    (re.every % 10 == 2) && (s = "every $(re.every)nd")
+    (re.every % 10 == 3) && (s = "every $(re.every)rd")
+    (re.every % 10 ∉ [2, 3]) && (s = "every $(re.every)th")
+    (re.every == 1) && (s = "every")
+    (context === :inline) && return "A RecordAction that records its inner action $s iteration"
+    return """
+    A RecordAction that records $s iteration with\n
+    $(_in_str(status_summary(re.record; context = context); indent = 1))
+    """
 end
 get_record(r::RecordEvery) = get_record(r.record)
 get_record(r::RecordEvery, k) = get_record(r.record, k)
@@ -352,7 +363,7 @@ end
 function status_summary(rg::RecordGroup; context::Symbol = :default)
     (context === :short) && (return "[ $(join(["$(status_summary(ri))" for ri in rg.group], ", ")) ]")
     (context === :inline) && (return "A group of $(length(rg.group)) RecordActions")
-    return "A group of $(length(rg.group)) RecordActions:\n $(join( ["* $(status_summary(ri; context=context))" for ri in rg.group], "\n"))\n"
+    return "A group of $(length(rg.group)) RecordActions:\n $(join(["* $(status_summary(ri; context = context))" for ri in rg.group], "\n"))\n"
 end
 function show(io::IO, rg::RecordGroup)
     s = join(["$(ri)" for ri in rg.group], ", ")
@@ -433,7 +444,15 @@ end
 function show(io::IO, rsr::RecordSubsolver{R}) where {R}
     return print(io, "RecordSubsolver(; record=$(rsr.record), record_type=$R)")
 end
-status_summary(::RecordSubsolver) = ":Subsolver"
+function status_summary(::RecordSubsolver{R}; context::Symbol = :default) where {R}
+    (context === :short) && return ":Subsolver"
+    (context === :inline) && return "A RecordAction to specify something to record from each subolver run"
+    return
+    """
+    A RecordAction to record elements of type $R in from each subsolver run
+
+    """
+end
 
 @doc """
     RecordWhenActive <: RecordAction
@@ -736,8 +755,10 @@ function (r::RecordIteration)(::AbstractManoptProblem, ::AbstractManoptSolverSta
     return record_or_reset!(r, k, k)
 end
 show(io::IO, ::RecordIteration) = print(io, "RecordIteration()")
-status_summary(::RecordIteration) = ":Iteration"
-
+function status_summary(::RecordIteration; context::Symbol = :default)
+    (context === :short) && return ":Iteration"
+    return "A RecordAction to record the current iteration number"
+end
 @doc """
     RecordStoppingReason <: RecordAction
 
@@ -929,15 +950,15 @@ create a [`RecordAction`](@ref) where
 * a [`RecordAction`](@ref) is passed through
 * a [`Symbol`] creates
   * `:Change`        to record the change of the iterates, see [`RecordChange`](@ref)
+  * `:Cost`          to record the current cost function value
   * `:Gradient`      to record the gradient, see [`RecordGradient`](@ref)
   * `:GradientNorm   to record the norm of the gradient, see [`RecordGradientNorm`](@ref)
   * `:Iterate`       to record the iterate
   * `:Iteration`     to record the current iteration number
-  * `IterativeTime`  to record the time iteratively
-  * `:Cost`          to record the current cost function value
+  * `:IterativeTime` to record the times taken for each iteration.
+  * `:ProximalParameter` to record the proximal parameter, see [`RecordProximalParameter`](@ref)
   * `:Stepsize`      to record the current step size
   * `:Time`          to record the total time taken after every iteration
-  * `:IterativeTime` to record the times taken for each iteration.
 
 and every other symbol is passed to [`RecordEntry`](@ref), which results in recording the
 field of the state with the symbol indicating the field of the solver to record.
@@ -952,6 +973,7 @@ function RecordActionFactory(s::AbstractManoptSolverState, symbol::Symbol)
     (symbol == :Iterate) && return RecordIterate(get_iterate(s))
     (symbol == :Iteration) && return RecordIteration()
     (symbol == :IterativeTime) && return RecordTime(; mode = :iterative)
+    (symbol == :ProximalParameter) && return RecordProximalParameter()
     (symbol == :Stepsize) && return RecordStepsize()
     (symbol == :Stop) && return RecordStoppingReason()
     (symbol == :Subsolver) && return RecordSubsolver()