Always call callback (#1184)

* Always call callback

* Update callbacks.jl

Author: pkofod

docs/src/user/config.md

@@ -51,7 +51,7 @@ In addition to the solver, you can alter the behavior of the Optim package by us
 * `successive_f_tol`: Determines the number of times the objective is allowed to increase across iterations. Defaults to 1.
 * `iterations`: How many iterations will run before the algorithm gives up? Defaults to `1_000`.
 * `time_limit`: A soft upper limit on the total run time. Defaults to `NaN` (unlimited).
-* `callback`: A function to be called during tracing. The return value should be a boolean, where `true` will stop the `optimize` call early. The callback function is called every `show_every`th iteration. If `store_trace` is false, the argument to the callback is of the type  [`OptimizationState`](https://github.com/JuliaNLSolvers/Optim.jl/blob/a1035134ca1f3ebe855f1cde034e32683178225a/src/types.jl#L155), describing the state of the current iteration. If `store_trace` is true, the argument is a list of all the states from the first iteration to the current.
+* `callback`: A function to be called during tracing. The return value should be a boolean, where `true` will stop the `optimize` call early. The callback function is called every iteration. If `store_trace` is false, the argument to the callback is of the type  [`OptimizationState`](https://github.com/JuliaNLSolvers/Optim.jl/blob/a1035134ca1f3ebe855f1cde034e32683178225a/src/types.jl#L155), describing the state of the current iteration. If `store_trace` is true, the argument is a list of all the states from the first iteration to the current.
 
 !!! tip "Disabling a termination criterion"
     If the `x_abstol`, `x_reltol`, `f_abstol`, `f_reltol`, `g_tol`, or `time_limit` tolerances are set to `NaN` all comparisons will be false internally, and this fact can be used to turn off the check. For example, `x_reltol` defaults to `0`. This does not mean that the check is turned off it only means that we stop at exactly zero change. However, if we set it to `NaN` specifically, the check of the termination criterion is always false and as such we will never stop due to any value of the infinity norm of the vector of relative changes.

src/utilities/update.jl

@@ -20,7 +20,7 @@ function update!(
             flush(stdout)
         end
     end
-    if callback !== nothing && (iteration % show_every == 0)
+    if callback !== nothing
         if store_trace
             stopped = callback(tr)
         else

test/general/callbacks.jl

@@ -9,76 +9,70 @@
     d3 = TwiceDifferentiable(f, g!, h!, initial_x)
 
     for method in (NelderMead(), SimulatedAnnealing())
-        ot_run = false
+        ot_count = 0
         cb = tr -> begin
-            @test tr[end].iteration % 3 == 0
-            ot_run = true
+            ot_count += 1
             false
         end
         options = Optim.Options(callback = cb, show_every = 3, store_trace = true)
-        optimize(f, initial_x, method, options)
-        @test ot_run
+        res1 = optimize(f, initial_x, method, options)
+        @test ot_count == 1+res1.iterations
 
-        os_run = false
+        os_count_2 = 0
         cb = os -> begin
-            @test os.iteration % 3 == 0
-            os_run = true
+            os_count_2 += 1
             false
         end
         options = Optim.Options(callback = cb, show_every = 3)
-        optimize(f, initial_x, method, options)
-        @test os_run
+        res2 = optimize(f, initial_x, method, options)
+        @test os_count_2 == 1+res2.iterations
 
         # Test early stopping by callbacks
         options = Optim.Options(callback = x -> x.iteration == 5 ? true : false)
-        optimize(f, zeros(2), NelderMead(), options)
+        res3 = optimize(f, zeros(2), NelderMead(), options)
+        @test res3.iterations == 5
     end
 
-    for method in
-        (BFGS(), ConjugateGradient(), GradientDescent(), MomentumGradientDescent())
-        ot_run = false
+    for method in (BFGS(), ConjugateGradient(), GradientDescent(), MomentumGradientDescent())
+        ot_count = 0
         cb = tr -> begin
-            @test tr[end].iteration % 3 == 0
-            ot_run = true
+            ot_count += 1
             false
         end
         options = Optim.Options(callback = cb, show_every = 3, store_trace = true)
+        res1 = optimize(d2, initial_x, method, options)
+        @test ot_count == 1+res1.iterations
 
-        optimize(d2, initial_x, method, options)
-        @test ot_run
-
-        os_run = false
+        os_count = 0
         cb = os -> begin
-            @test os.iteration % 3 == 0
-            os_run = true
+            os_count += 1
             false
         end
         options = Optim.Options(callback = cb, show_every = 3)
-        optimize(d2, initial_x, method, options)
-        @test os_run
+        res2 = optimize(d2, initial_x, method, options)
+        @test os_count == 1+res2.iterations
     end
 
     for method in (Newton(),)
-        ot_run = false
+        ot_count = 0
         cb = tr -> begin
-            @test tr[end].iteration % 3 == 0
-            ot_run = true
+            ot_count += 1
             false
         end
         options = Optim.Options(callback = cb, show_every = 3, store_trace = true)
-        optimize(d3, initial_x, method, options)
-        @test ot_run
+        res1 = optimize(d3, initial_x, method, options)
+        @test ot_count == 1+res1.iterations
 
-        os_run = false
+        os_count = 0
         cb = os -> begin
-            @test os.iteration % 3 == 0
-            os_run = true
+            os_count += 1
             false
         end
         options = Optim.Options(callback = cb, show_every = 3)
-        optimize(d3, initial_x, method, options)
-        @test os_run
+        res2 = optimize(d3, initial_x, method, options)
+        @test os_count == 1+res2.iterations
     end
+
     res = optimize(x -> x^2, -5, 5, callback = _ -> true)
     @test res.iterations == 0
 end