Finish the last gradient processors.

Author: kellertuer

src/plans/first_order_plan.jl

@@ -1042,6 +1042,11 @@ mutable struct PreconditionedDirectionRule{
     } <: DirectionUpdateRule
     preconditioner::F
     direction::D
+    function PreconditionedDirectionRule(;
+            preconditioner::F, direction::D, evaluation::E
+        ) where {E <: AbstractEvaluationType, D <: DirectionUpdateRule, F}
+        return new{E, D, F}(preconditioner, direction)
+    end
 end
 function PreconditionedDirectionRule(
         M::AbstractManifold,
@@ -1050,7 +1055,7 @@ function PreconditionedDirectionRule(
         evaluation::E = AllocatingEvaluation(),
     ) where {E <: AbstractEvaluationType, F}
     dir = _produce_type(direction, M)
-    return PreconditionedDirectionRule{E, typeof(dir), F}(preconditioner, dir)
+    return PreconditionedDirectionRule(; preconditioner = preconditioner, direction = direction, evaluation = evaluation)
 end
 function (pg::PreconditionedDirectionRule{AllocatingEvaluation})(
         mp::AbstractManoptProblem, s::AbstractGradientSolverState, k
@@ -1072,6 +1077,22 @@ function (pg::PreconditionedDirectionRule{InplaceEvaluation})(
     pg.preconditioner(M, dir, p, dir)
     return step, dir
 end
+function Base.show(io::IO, pg::PreconditionedDirectionRule{E}) where {E <: AbstractEvaluationType}
+    print(io, "PreconditionedDirectionRule(; direction = ", pg.direction, ", preconditioner = ", pg.preconditioner, ", ", _to_kw(E))
+    return print(io, ")")
+end
+function status_summary(pg::PreconditionedDirectionRule; context::Symbol = :default)
+    (context === :short) && return repr(pg)
+    (context === :inline) && return "A preconditioner gradient processor"
+    return """
+    Preconditioned Direction Rule
+
+    ## Parameters
+    preconditioner: $(_MANOPT_INDENT)$(nr.μ)
+    ## Direction Rule
+    $(_in_str(status_summary(pg.direction; context = context); indent = 1, headers = 1))
+    """
+end
 
 """
     PreconditionedDirection(preconditioner; kwargs...)

src/solvers/alternating_gradient_descent.jl

@@ -27,7 +27,13 @@ function AlternatingGradientRule(
     ) where {T}
     return AlternatingGradientRule{T}(X)
 end
-
+function Base.show(io::IO, ag::AlternatingGradientRule)
+    return print(io, "AlternatingGradientRule($(ag.X)")
+end
+function status_summary(ag::AlternatingGradientRule; context::Symbol = :default)
+    (context === :short) && return repr(ag)
+    return "A alternating gradient processor"
+end
 """
     AlternatingGradientDescentState <: AbstractGradientDescentSolverState
 

src/solvers/stochastic_gradient_descent.jl

@@ -141,7 +141,6 @@ function StochasticGradientRule(
     ) where {T}
     return StochasticGradientRule{T}(X)
 end
-
 function (sg::StochasticGradientRule)(
         apm::AbstractManoptProblem, sgds::StochasticGradientDescentState, k
     )
@@ -151,7 +150,13 @@ function (sg::StochasticGradientRule)(
     j = sgds.order_type == :Random ? rand(1:length(sgds.order)) : sgds.order[sgds.k]
     return sgds.stepsize(apm, sgds, k), get_gradient!(apm, sg.X, sgds.p, j)
 end
-
+function Base.show(io::IO, sg::StochasticGradientRule)
+    return print(io, "StochasticGradientRule($(sg.X)")
+end
+function status_summary(sg::StochasticGradientRule; context::Symbol = :default)
+    (context === :short) && return repr(sg)
+    return "A stochastic gradient processor"
+end
 @doc """
     StochasticGradient(; kwargs...)
     StochasticGradient(M::AbstractManifold; kwargs...)