Replace get_ with getproperty

Author: lkdvos

src/interface/algorithm.jl

@@ -7,31 +7,16 @@ A concrete algorithm contains all static parameters that characterise the algori
 Together with a [`Problem`](@ref) an `Algorithm` subtype should be able to initialize
 or reset a [`State`](@ref).
 
-## Usual fields
+## Properties
 
-Usually this should include the following. If you use this naming scheme, default functions
-e.g. as accessors
+Algorithms can contain any number of properties that are needed to define the algorithm,
+but should additionally contain the following properties to interact with the stopping criteria.
 
-* `stopping_criterion` a [`StoppingCriterion`](@ref)
-
-## Methods
-
-The following methods should be implemented for an [`Algorithm`](@ref)
-
-* [`get_stopping_criterion`](@ref) to return the algorithms stopping criterion.
+* `stopping_criterion::StoppingCriterion`
 
 ## Example
 
 For a [gradient descent](https://en.wikipedia.org/wiki/Gradient_descent) algorithm
 the algorithm would specify which step size selection to use.
 """
 abstract type Algorithm end
-
-"""
-    get_stopping_criterion(algorithm::Algorithm)
-
-Return the [`StoppingCriterion`](@ref) of the [`Algorithm`](@ref).
-
-The default assumes that the criterion is stored in `algorithm.stopping_criterion`.
-"""
-get_stopping_criterion(algorithm::Algorithm) = algorithm.stopping_criterion

src/interface/problem.jl

@@ -5,6 +5,7 @@ An abstract type to represent a problem to be solved with all its static propert
 not change during an algorithm run.
 
 ## Example
+
 For a [gradient descent](https://en.wikipedia.org/wiki/Gradient_descent) algorithm the problem consists of
 
 * a `cost` function ``f: C → ℝ``

src/interface/state.jl

@@ -6,49 +6,24 @@ An abstract type to represent the state an iterative algorithm is in.
 The state consists of any information that describes the current step the algorithm is in
 and keeps all information needed from one step to the next.
 
-## Usual fields
+## Properties
 
-Usually this should include the following. If you use this naming scheme, default functions
-e.g. as accessors
+In order to interact with the stopping criteria, the state should contain the following properties,
+and provide corresponding `getproperty` and `setproperty!` methods.
 
 * `iteration` – the current iteration step ``k`` that is is currently performed or was last performed
 * `stopping_criterion_state` – a [`StoppingCriterionState`](@ref) that indicates whether an [`Algorithm`](@ref)
   will stop after this iteration or has stopped.
 * `iterate` the current iterate ``x^{(k)}```.
 
-These variable names given in this list are the defaults for which the accessors are implemented,
-such that if your concrete `MyState <: State` follows this convention, you do not have to reimplement
-their accessors.
-
 ## Methods
 
 The following methods should be implemented for a state
 
-* [`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(state::State)
-
-Return the current iterate ``x^{(k)}`` of a [`State`](@ref).
-
-The default assumes that the current iterate is stored in `state.iterate`.
-"""
-get_iterate(state::State) = state.iterate
-
-"""
-    get_iteration(state::State)
-
-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 `state.iteration`.
-"""
-get_iteration(state::State) = state.iteration
-
 """
     increment!(state::State)
 
@@ -60,12 +35,3 @@ function increment!(state::State)
     state.iteration += 1
     return state
 end
-
-"""
-    get_stopping_criterion_state(state::State)
-
-Return the [`StoppingCriterionState`](@ref) of the given [`State`](@ref).
-
-The default assumes that the criterion is stored in `state.stopping_criterion_state`.
-"""
-get_stopping_criterion_state(state::State) = state.stopping_criterion_state

src/stopping_criterion.jl

@@ -90,8 +90,8 @@ function is_finished(problem::Problem, algorithm::Algorithm, state::State)
         problem,
         algorithm,
         state,
-        get_stopping_criterion(algorithm),
-        get_stopping_criterion_state(state),
+        algorithm.stopping_criterion,
+        state.stopping_criterion_state,
     )
 end
 
@@ -104,8 +104,8 @@ function is_finished!(problem::Problem, algorithm::Algorithm, state::State)
         problem,
         algorithm,
         state,
-        get_stopping_criterion(algorithm),
-        get_stopping_criterion_state(state),
+        algorithm.stopping_criterion,
+        state.stopping_criterion_state,
     )
 end
 
@@ -303,7 +303,7 @@ function is_finished(
     stop_when_all::StopWhenAll,
     stopping_criterion_states::GroupStoppingCriterionState,
 )
-    k = get_iteration(state)
+    k = state.iteration
     (k == 0) && (stopping_criterion_states.at_iteration = -1) # reset on init
     if all(
         st -> is_finished(problem, algorithm, state, st[1], st[2]),
@@ -320,7 +320,7 @@ function is_finished!(
     stop_when_all::StopWhenAll,
     stopping_criterion_states::GroupStoppingCriterionState,
 )
-    k = get_iteration(state)
+    k = state.iteration
     (k == 0) && (stopping_criterion_states.at_iteration = -1) # reset on init
     if all(
         st -> is_finished!(problem, algorithm, state, st[1], st[2]),
@@ -339,7 +339,7 @@ function is_finished(
     stop_when_any::StopWhenAny,
     stopping_criterion_states::GroupStoppingCriterionState,
 )
-    k = get_iteration(state)
+    k = state.iteration
     (k == 0) && (stopping_criterion_states.at_iteration = -1) # reset on init
     if any(
         st -> is_finished(problem, algorithm, state, st[1], st[2]),
@@ -356,7 +356,7 @@ function is_finished!(
     stop_when_any::StopWhenAny,
     stopping_criterion_states::GroupStoppingCriterionState,
 )
-    k = get_iteration(state)
+    k = state.iteration
     (k == 0) && (stopping_criterion_states.at_iteration = -1) # reset on init
     if all(
         st -> is_finished!(problem, algorithm, state, st[1], st[2]),
@@ -460,7 +460,7 @@ function is_finished(
     stop_after_iteration::StopAfterIteration,
     stopping_criterion_state::DefaultStoppingCriterionState,
 )
-    return get_iteration(state) >= stop_after_iteration.max_iterations
+    return state.iteration >= stop_after_iteration.max_iterations
 end
 function is_finished!(
     ::Problem,
@@ -469,7 +469,7 @@ function is_finished!(
     stop_after_iteration::StopAfterIteration,
     stopping_criterion_state::DefaultStoppingCriterionState,
 )
-    k = get_iteration(state)
+    k = state.iteration
     (k == 0) && (stopping_criterion_state.at_iteration = -1)
     if k >= stop_after_iteration.max_iterations
         stopping_criterion_state.at_iteration = k
@@ -570,7 +570,7 @@ function is_finished(
     stop_after::StopAfter,
     stop_after_state::StopAfterTimePeriodState,
 )
-    k = get_iteration(state)
+    k = state.iteration
     # Just check whether the (last recorded) time is beyond the threshold
     return (k > 0 && (stop_after_state.time > Nanosecond(stop_after.threshold)))
 end
@@ -581,7 +581,7 @@ function is_finished!(
     stop_after::StopAfter,
     stop_after_state::StopAfterTimePeriodState,
 )
-    k = get_iteration(state)
+    k = state.iteration
     if value(stop_after_state.start) == 0 || k <= 0 # (re)start timer
         stop_after_state.at_iteration = -1
         stop_after_state.start = Nanosecond(time_ns())