Monitor only every $n$-th step in NDSolve

Question

I frequently use StepMonitor to keep an eye on NDSolve while it's working. Usually it does the job just fine. Recently however, I've been working with sets of coupled ODEs that take several hundred iterations to solve. The business of oversight then gets rather tedious as you get hundreds of lines of intermediate values.

Is there a way to keep the output manageable by telling StepMonitor to monitor only every $n$-th step?

---

Simple Example

Even an ODE as simple as

n = 1;
NDSolve[{y'[x] == y[x], y[0] == 1}, y, {x, 0, 5},
    StepMonitor :> Print[{n, x, y[x]}] n++] // Timing

results in 53 lines of intermediate results. What if I want, say, just 5 lines? Also, performing so many intermediate evaluations clearly introduces significant overhead. The above takes 0.002964 seconds to evaluate. By comparison, the same command without any monitoring,

NDSolve[{y'[x] == y[x], y[0] == 1}, y, {x, 0, 5}] // Timing

takes 0.00095 seconds, i.e. less than a third of the time.

Answer 1

If only you need to reduce the number of printed lines, this Prints once every 10 instances.

n = 1;
NDSolve[
  {y'[x] == y[x], y[0] == 1}
  , y
  , {x, 0, 5}
  , StepMonitor :> If[
    Mod[++n, 10] === 0
    , Echo[
     TemplateApply[StringTemplate["n:``, x:``, y:``", {n, x, y[x]}]]
     , "Monitor"]]
  ] // Timing

But the idea of filling the screen with updates seems sub-optimal. You could use a Dynamic update of a single line. To reduce the overhead, this limits the update to once per second.

AbsoluteTiming[
 DynamicModule[{n = 1, status},
  Dynamic[Refresh[Row@status, UpdateInterval -> 1]];
  sol = NDSolve[{y'[x] == y[x], y[0] == 1}, y, {x, 0, 5}, 
    StepMonitor :> (status = {n += 1, x, y[x]})];]]

Obviously you could combine the two solutions.

EDIT

All that said, after a better answer by @george2079 it seems the correct tool to use is Monitor.

Answer 2

if you just want a status monitor you can do like this:

Monitor[NDSolve[{y'[x] == x, y[0] == 1}, y, {x, 0, 5}, 
  StepMonitor :> (p = x; ++n)], {n, p}]

this prints every step but wont clutter your screen.

There is inevitably an overhead, but typically in a real case where you care about monitoring results it will be small compared to the function eval.

this is useful sometimes too:

p = 0; ProgressIndicator[Dynamic[p], {0, 5}]
NDSolve[{y'[x] == f[x], y[0] == 1}, y, {x, 0, 5}, 
 StepMonitor :> (p = x)]

Note if NDSolve needs to do recursion then the -x- val wont accurately reflect progress however.

Answer 3

As an alternative suggestion, I usually use Dynamic to monitor progress. It seems to add minimal overhead (beyond the overhead of StepMonitor). The use of InputForm lets one see small step sizes (how many digits are changed).

Dynamic@ InputForm@ foo
NDSolve[sys, y, {x, 0, 5}, StepMonitor :> (foo = x)]

---

Example from NDSolve returns solution with single point domain:

Here InputForm is not really needed or helpful since arbitrary precision numbers are used. Their digits are printed out to their precision by default.

time = 0; steps = 0;
Dynamic@Column@{time, steps}  (* monitor progress; it's educational *)

steps = 0;
{sol} = NDSolve[{Derivative[1][y][t] == (-2 E^(1/5 y[t]) + 1)/(-600 E^(1/5 y[t]) + 
       20338 + (2/10) t), y[101690] == 0}, y, {t, 0, 101690}, 
  MaxSteps -> 100000, WorkingPrecision -> 150, PrecisionGoal -> 8, 
  AccuracyGoal -> 8, StartingStepSize -> 0.001, 
  StepMonitor :> (time = t; steps++)]

Answer 4

Picking up on J.M.'s comment regarding adaptive step sizes, we can have StepMonitor only output a predetermined number of times while still keeping an eye on how many steps a given interval required:

runner = 1; counter = 0;
sol = NDSolve[{x'[t] == -Exp[x[t]], x[0] == 1}, x, {t, 0, 10}, 
  StepMonitor :> 
   counter++ If[t > runner, Print[{counter, t, x[t]}]; runner++]]
Plot[x[t] /. sol, {t, 0, 10}]

which gives

{50,1.03056,-0.335356}

{65,2.0474,-0.881814}

{74,3.01655,-1.21919}

{81,4.04807,-1.48522}

{87,5.19606,-1.71631}

{91,6.06848,-1.86196}

{95,7.22721,-2.0275}

{98,8.09626,-2.13584}

{101,9.25289,-2.26392}