finish redesign.

Author: kellertuer

src/interface/interface.jl

@@ -43,7 +43,7 @@ By default this method continues to call [`solve!`](@ref).
 """
 function solve(p::Problem, a::Algorithm; kwargs...)
     s = initialize_state(p, a; kwargs...)
-    return solve!(p, a, s; kwargs...)
+    return solve!(s, p, a; kwargs...)
 end
 
 @doc """
@@ -70,4 +70,4 @@ function step! end
 Perform the current step of an [`Algorithm`](@ref) `a` solving [`Problem`](@ref) `p`
 modifying the algorithms [`State`](@ref) `s`.
 """
-step!(state::State, p::Problem, a::Algorithm)
+step!(s::State, p::Problem, a::Algorithm)

src/interface/state.jl

@@ -68,4 +68,4 @@ Return the [`StoppingCriterionState`](@ref) of the [`State`](@ref) `s`.
 
 The default assumes that the criterion is stored in `s.stopping_criterion_state`.
 """
-get_stopping_criterion(s::State) = s.stopping_criterion_state
+get_stopping_criterion_state(s::State) = s.stopping_criterion_state

src/stopping_criterion.jl

@@ -4,13 +4,14 @@
 An abstract type to represent a stopping criterion.
 
 A concrete [`StoppingCriterion`](@ref) `sc` should also implement a
-[`initialize(sc::StoppingCriterion)`](@ref) function to create its accompaying
+[`initialize_state(problem::Problem, algorithm::Algorithm, sc::StoppingCriterion; kwargs...)`](@ref) function to create its accompanying
 [`StoppingCriterionState`](@ref).
+as well as the corresponting mutating variant to reset such a [`StoppingCriterionState`](@ref).
+
 It should usually implement
 
 * `indicates_convergence(sc)` a boolean whether or not this stopping criterion would indicate
   that the algorithm has converged, if it indicates to stop.
-* `show(io::IO, scs)` for use in REPL and display within an [`Algorithm`](@ref).
 """
 abstract type StoppingCriterion end
 
@@ -98,7 +99,7 @@ A simple stopping criterion to stop after a maximal number of iterations.
 initialize the functor to indicate to stop after `maxIter` iterations.
 """
 struct StopAfterIteration <: StoppingCriterion
-     max_iterations::Int
+    max_iterations::Int
 end
 
 """
@@ -118,35 +119,44 @@ mutable struct DefaultStoppingCriterionState
     DefaultStoppingCriterionState() = new(-1)
 end
 
-initialize(::Problem, ::Algorithm, ::State, ::StopAfterIteration) = DefaultStoppingCriterionState()
-function initialize!(scs::DefaultStoppingCriterionState, ::Problem, ::Algorithm, ::State, ::StopAfterIteration)
-    scs.indicated_convergence_at = -1
+initialize_state(::Problem, ::Algorithm, ::StopAfterIteration; kwargs...) =
+    DefaultStoppingCriterionState()
+function initialize_state!(
+    scs::DefaultStoppingCriterionState,
+    ::Problem,
+    ::Algorithm,
+    ::StopAfterIteration;
+    kwargs...,
+)
+    scs.at_iteration = -1
     return scs
 end
 
-function (sc::DefaultStoppingCriterionState)(::Problem, ::Algorithm, s::State, sc::StopAfterIteration)
+function (scs::DefaultStoppingCriterionState)(
+    ::Problem,
+    ::Algorithm,
+    s::State,
+    sc::StopAfterIteration,
+)
     k = get_iteration(s)
-    (k == 0) && (sc.at_iteration = -1)
+    (k == 0) && (scs.at_iteration = -1)
     if k >= sc.max_iterations
-        sc.at_iteration = k
+        scs.at_iteration = k
         return true
     end
     return false
 end
-function get_reason(c::StopAfterIteration, scs::DefaultStoppingCriterionState)
-    if c.at_iteration >= c.max_iterations
-        return "At iteration $(c.at_iteration) the algorithm reached its maximal number of iterations ($(c.max_iterations)).\n"
+function get_reason(sc::StopAfterIteration, scs::DefaultStoppingCriterionState)
+    if scs.at_iteration >= sc.max_iterations
+        return "At iteration $(scs.at_iteration) the algorithm reached its maximal number of iterations ($(sc.max_iterations)).\n"
     end
     return ""
 end
 indicates_convergence(sc::StopAfterIteration) = false
-function get_summary(c::StopAfterIteration)
-    has_stopped = (c.at_iteration >= 0)
+function get_summary(sc::StopAfterIteration, scs::DefaultStoppingCriterionState)
+    has_stopped = (scs.at_iteration >= 0)
     s = has_stopped ? "reached" : "not reached"
-    return "Max Iteration $(c.max_iterations):\t$s"
-end
-function show(io::IO, c::StopAfterIteration)
-    return print(io, "StopAfterIteration($(c.max_iterations))\n    $(get_summary(c))")
+    return "Max Iteration $(sc.max_iterations):\t$s"
 end
 
 """
@@ -159,57 +169,86 @@ for example `Minute(15)`.
 # Fields
 
 * `threshold` stores the `Period` after which to stop
-* `start` stores the starting time when the algorithm is started, that is a call with `i=0`.
-* `time` stores the elapsed time
-* `at_iteration` indicates at which iteration (including `i=0`) the stopping criterion
-  was fulfilled and is `-1` while it is not fulfilled.
 
 # Constructor
 
     StopAfter(t)
 
 initialize the stopping criterion to a `Period t` to stop after.
 """
-mutable struct StopAfter <: StoppingCriterion
+struct StopAfter <: StoppingCriterion
     threshold::Period
-    start::Nanosecond
-    time::Nanosecond
-    at_iteration::Int
     function StopAfter(t::Period)
-        return if value(t) < 0
+        if value(t) < 0
             error("You must provide a positive time period")
         else
-            new(t, Nanosecond(0), Nanosecond(0), -1)
+            s = new(t)
         end
+        return s
     end
 end
-function (sc::StopAfter)(::Problem, ::Algorithm, s::State)
+
+@doc """
+    StopAfterTimePeriodState <: StoppingCriterionState
+
+A state for stopping criteria that are based on time measurements,
+for example [`StopAfter`](@ref).
+
+* `start` stores the starting time when the algorithm is started, that is a call with `i=0`.
+* `time` stores the elapsed time
+* `at_iteration` indicates at which iteration (including `i=0`) the stopping criterion
+  was fulfilled and is `-1` while it is not fulfilled.
+
+"""
+mutable struct StopAfterTimePeriodState <: StoppingCriterionState
+    start::Nanosecond
+    time::Nanosecond
+    at_iteration::Int
+    function StopAfterTimePeriodState()
+        return new(Nanosecond(0), Nanosecond(0), -1)
+    end
+end
+
+initialize_state(::Problem, ::Algorithm, ::StopAfter; kwargs...) =
+    StopAfterTimePeriodState()
+
+function initialize_state!(
+    scs::DefaultStoppingCriterionState,
+    ::Problem,
+    ::Algorithm,
+    ::StopAfter;
+    kwargs...,
+)
+    scs.start = Nanosecond(0)
+    scs.time = Nanosecond(0)
+    scs.at_iteration = -1
+    return scs
+end
+
+function (scs::StopAfterTimePeriodState)(::Problem, ::Algorithm, s::State, sc::StopAfter)
     k = get_iteration(s)
-    if value(sc.start) == 0 || k <= 0 # (re)start timer
-        sc.at_iteration = -1
-        sc.start = Nanosecond(time_ns())
-        sc.time = Nanosecond(0)
+    if value(scs.start) == 0 || k <= 0 # (re)start timer
+        scs.at_iteration = -1
+        scs.start = Nanosecond(time_ns())
+        scs.time = Nanosecond(0)
     else
-        sc.time = Nanosecond(time_ns()) - sc.start
-        if k > 0 && (sc.time > Nanosecond(sc.threshold))
-            sc.at_iteration = k
+        scs.time = Nanosecond(time_ns()) - scs.start
+        if k > 0 && (scs.time > Nanosecond(sc.threshold))
+            scs.at_iteration = k
             return true
         end
     end
     return false
 end
-function get_reason(sc::StopAfter)
-    if (c.at_iteration >= 0)
-        return "After iteration $(sc.at_iteration) the algorithm ran for $(floor(c.time, typeof(c.threshold))) (threshold: $(c.threshold)).\n"
+function get_reason(sc::StopAfter, scs::StopAfterTimePeriodState)
+    if (scs.at_iteration >= 0)
+        return "After iteration $(scs.at_iteration) the algorithm ran for $(floor(scs.time, typeof(sc.threshold))) (threshold: $(sc.threshold)).\n"
     end
     return ""
 end
-function get_summary(c::StopAfter)
-    has_stopped = (c.at_iteration >= 0)
+function get_summary(sc::StopAfter, scs::StopAfterTimePeriodState)
+    has_stopped = (scs.at_iteration >= 0)
     s = has_stopped ? "reached" : "not reached"
-    return "stopped after $(c.threshold):\t$s"
-end
-indicates_convergence(c::StopAfter) = false
-function show(io::IO, sc::StopAfter)
-    return print(io, "StopAfter($(repr(sc.threshold)))\n    $(get_summary(sc))")
+    return "stopped after $(sc.threshold):\t$s"
 end
+indicates_convergence(sc::StopAfter) = false

test/newton.jl

@@ -20,18 +20,29 @@ end
 mutable struct NewtonState{S} <: State
     iteration::Int
     iterate::Float64
-    stopping_criterion::S
+    stopping_criterion_state::S
 end
 
 # Implementing the algorithm
 # --------------------------
-function initialize_state(::RootFindingProblem, algorithm::NewtonMethod)
-    return NewtonState(0, 1.0, algorithm.stopping_criterion) # hardcode initial guess to 1.0
+function initialize_state(problem::RootFindingProblem, algorithm::NewtonMethod)
+    scs = initialize_state(problem, algorithm, algorithm.stopping_criterion)
+    return NewtonState(0, 1.0, scs) # hardcode initial guess to 1.0
 end
-function initialize_state!(::RootFindingProblem, algorithm::NewtonMethod, state::NewtonState)
+function initialize_state!(
+    state::NewtonState,
+    problem::RootFindingProblem,
+    algorithm::NewtonMethod,
+)
     state.iteration = 0
     state.iterate = 1.0
-    state.stopping_criterion = algorithm.stopping_criterion
+    initialize_state!(
+        state.stopping_criterion_state,
+        problem,
+        algorithm,
+        algorithm.stopping_criterion,
+    )
+    return state
 end
 
 function step!(problem::RootFindingProblem, ::NewtonMethod, state::NewtonState)