longer argument names

Author: lkdvos

src/interface/algorithm.jl

@@ -19,6 +19,7 @@ e.g. as accessors
 The following methods should be implemented for an [`Algorithm`](@ref)
 
 * [`get_stopping_criterion`](@ref) to return the algorithms stopping criterion.
+
 ## Example
 
 For a [gradient descent](https://en.wikipedia.org/wiki/Gradient_descent) algorithm
@@ -27,10 +28,10 @@ the algorithm would specify which step size selection to use.
 abstract type Algorithm end
 
 """
-    get_stopping_criterion(a::Algorithm)
+    get_stopping_criterion(algorithm::Algorithm)
 
-Return the [`StoppingCriterion`](@ref) of the [`Algorithm`](@ref) `a`.
+Return the [`StoppingCriterion`](@ref) of the [`Algorithm`](@ref).
 
-The default assumes that the criterion is stored in `s.stopping_criterion_state`.
+The default assumes that the criterion is stored in `algorithm.stopping_criterion`.
 """
-get_stopping_criterion(a::Algorithm) = a.stopping_criterion
+get_stopping_criterion(algorithm::Algorithm) = algorithm.stopping_criterion

src/interface/state.jl

@@ -24,48 +24,48 @@ their accessors.
 
 The following methods should be implemented for a state
 
-* [`get_iteration`](@ref)`(s)` to return the current iteration number
-* [`increment!](@ref)`(s)`
+* [`get_iteration`](@ref)`(state)` to return the current iteration number
+* [`increment!](@ref)`(state)`
 * [`get_stopping_criterion_state`](@ref) return the [`StoppingCriterionState`](@ref)
 * [`get_iterate`](@ref) return the current iterate ``x^{(k)}``.
 """
 abstract type State end
 
 """
-    get_iterate(s::State)
+    get_iterate(state::State)
 
-Return the current iterate ``x^{(k)}`` of a [`State`](@ref) `s`
+Return the current iterate ``x^{(k)}`` of a [`State`](@ref).
 
-The default assumes that the current iteration is stored in `s.iterate`.
+The default assumes that the current iterate is stored in `state.iterate`.
 """
-get_iterate(s::State) = s.iterate
+get_iterate(state::State) = state.iterate
 
 """
-    get_iteration(s::State)
+    get_iteration(state::State)
 
-Return the current iteration a [`State`](@ref) `s` either is currently performing or was last performed
+Return the current iteration a [`State`](@ref) either is currently performing or was last performed
 
-The default assumes that the current iteration is stored in `s.iteration`.
+The default assumes that the current iteration is stored in `state.iteration`.
 """
-get_iteration(s::State) = s.iteration
+get_iteration(state::State) = state.iteration
 
 """
-    increment!(s::State)
+    increment!(state::State)
 
-Return the current iteration a [`State`](@ref) `s` either is currently performing or was last performed
+Increment the current iteration a [`State`](@ref) either is currently performing or was last performed
 
-The default assumes that the current iteration is stored in `s.iteration`.
+The default assumes that the current iteration is stored in `state.iteration`.
 """
-function increment!(s::State)
-    s.iteration += 1
+function increment!(state::State)
+    state.iteration += 1
     return s
 end
 
 """
-    get_stopping_criterion_state(s::State)
+    get_stopping_criterion_state(state::State)
 
-Return the [`StoppingCriterionState`](@ref) of the [`State`](@ref) `s`.
+Return the [`StoppingCriterionState`](@ref) of the given [`State`](@ref).
 
-The default assumes that the criterion is stored in `s.stopping_criterion_state`.
+The default assumes that the criterion is stored in `state.stopping_criterion_state`.
 """
-get_stopping_criterion_state(s::State) = s.stopping_criterion_state
+get_stopping_criterion_state(state::State) = state.stopping_criterion_state

src/stopping_criterion.jl

@@ -202,24 +202,24 @@ mutable struct GroupStoppingCriterionState{TCriteriaStates<:Tuple} <: StoppingCr
 end
 
 function initialize_state(
-    p::Problem,
-    a::Algorithm,
+    problem::Problem,
+    algorithm::Algorithm,
     sc::Union{StopWhenAll,StopWhenAny};
     kwargs...,
 )
     return GroupStoppingCriterionState([
-        initialize_state(p, a, sc_i; kwargs) for sc_i in sc.criteria
+        initialize_state(problem, algorithm, sc_i; kwargs) for sc_i in sc.criteria
     ])
 end
 function initialize_state!(
     scs::GroupStoppingCriterionState,
-    p::Problem,
-    a::Algorithm,
+    problem::Problem,
+    algorithm::Algorithm,
     sc::Union{StopWhenAll,StopWhenAny};
     kwargs...,
 )
     for (scs_i, sc_i) in zip(scs.criteria_states, sc.criteria)
-        initialize_state!(scs_i, p, a, sc_i; kwargs...)
+        initialize_state!(scs_i, problem, algorithm, sc_i; kwargs...)
     end
     scs.at_iteration = -1
     return scs
@@ -259,29 +259,29 @@ function Base.summary(io::IO, sc::StopWhenAll, scs::GroupStoppingCriterionState)
 end
 # Meta functors
 function (scs::GroupStoppingCriterionState)(
-    p::Problem,
-    a::Algorithm,
-    s::State,
+    problem::Problem,
+    algorithm::Algorithm,
+    state::State,
     sc::StopWhenAll,
 )
-    k = get_iteration(s)
+    k = get_iteration(state)
     (k == 0) && (scs.at_iteration = -1) # reset on init
-    if all(st -> st[2](p, a, s, st[1]), zip(sc.criteria, scs.criteria_states))
+    if all(st -> st[2](problem, algorithm, state, st[1]), zip(sc.criteria, scs.criteria_states))
         scs.at_iteration = k
         return true
     end
     return false
 end
 
 function (scs::GroupStoppingCriterionState)(
-    p::Problem,
-    a::Algorithm,
-    s::State,
+    problem::Problem,
+    algorithm::Algorithm,
+    state::State,
     sc::StopWhenAny,
 )
-    k = get_iteration(s)
+    k = get_iteration(state)
     (k == 0) && (c.at_iteration = -1) # reset on init
-    if any(st -> st[2](p, a, s, st[1]), zip(sc.criteria, scs.criteria_states))
+    if any(st -> st[2](problem, algorithm, state, st[1]), zip(sc.criteria, scs.criteria_states))
         c.at_iteration = k
         return true
     end
@@ -344,10 +344,10 @@ end
 function (scs::DefaultStoppingCriterionState)(
     ::Problem,
     ::Algorithm,
-    s::State,
+    state::State,
     sc::StopAfterIteration,
 )
-    k = get_iteration(s)
+    k = get_iteration(state)
     (k == 0) && (scs.at_iteration = -1)
     if k >= sc.max_iterations
         scs.at_iteration = k
@@ -434,8 +434,8 @@ function initialize_state!(
     return scs
 end
 
-function (scs::StopAfterTimePeriodState)(::Problem, ::Algorithm, s::State, sc::StopAfter)
-    k = get_iteration(s)
+function (scs::StopAfterTimePeriodState)(::Problem, ::Algorithm, state::State, sc::StopAfter)
+    k = get_iteration(state)
     if value(scs.start) == 0 || k <= 0 # (re)start timer
         scs.at_iteration = -1
         scs.start = Nanosecond(time_ns())