How can an iterative algorithm be controlled dynamically?

Question

Suppose we need an iterative algorithm for mathematical optimisation. Each iteration takes a long and random time. After each iteration, a stopping condition is checked for the iterate x, based on some pre-defined parameter b. An example is "Stop if ||grad(x)|| < b", based on the objective's gradient at x.

Here's is an extremely simplified "algorithm" in pseudo-Scala

val f = (a: Dbl, b: Dbl) => { 
def go(x: Dbl): Dbl = if (x<b) x 
else go(bigComputation(x)) 
go(a)}

The actual algorithm could be recursive or have a while loop.

The user wants to update the stopping parameter b while the algorithm is running. (The reason could be to speed-up convergence or to improve solutions, if a good b is unknown beforehand.) The change is applied the sooner, the better - ideally, at the next iteration.

Q: What would a functional solution be? If such updating is against FP, what's the least bad non-FP design? (A small performance hit is fine, if the code is cleaner.)

There's a discussion of an FRP approach at http://sodium.nz/t/how-can-an-iterative-algorithm-be-controlled-dynamically-with-sodium/333/5, which doesn't fully solve it at the moment of writing.

Answer 1

I would simply pass a cancellation token into the function and have it check whether cancelation has been requested at each iteration.

However, this is obviously not a functional approach as the user would request the cancelation and thus inject state into the function.

Perhaps if you know the cancelation requirements in advance you can specify it as a function itself, (runningtime > 50,000) and get back to the functional paradigm

Answer 2

This would imply to pause the algorithm change the values check the coherency and validity of the values and then continue. The reason for pause is that the change does not happen in the middle of the iteration. The validity must be ensured lets say the value cannot be negative or something else.