How can I make Plot show the plot while it's computing it?

Question

Normally, Plot acts like a black box and only gives you the requested plot once it has finished computing it.

However it can be useful, other than interesting, to see the unfinished plot in the act of being built. For example to get an immediate, rough idea of how a function behaves, without having to wait for the whole detailed graph to be computed.

How can I make Plot (or some other function) act like this?

---

I can simulate a similar behaviour using some loop which increases step by step the MaxRecursion option and shows each result, but this would require a lot more computational time because at each new value of MaxRecursion Plot would recompute all the previous recursions.

I can also make a "progressive plot" generating the list of point with something like

out={};Do[AppendTo[out,{x,x^2}],{x,0,10,0.1}];
Dynamic@ListPlot[out]

but this is no good either because I can't efficiently use recursion steps like Plot does and it gets slower and slower at increasing x values, probably because of the AppendTo creating a larger and larger list.

I looked around at options like EvaluationMonitor and StepMonitor but I didn't manage to understand how to use them for this purpose.

Answer 1

Here is a only slightly different approach. As I think it probably isn't essential in that case to actually see every single point appearing on its own it might be much more efficient and user friendly to just update at a given period without the actual code having to wait for the update to finish. I have also added some option handling:

SetAttributes[dynamicPlot, HoldAll]

Options[dynamicPlot] = Join[Options[Plot], Options[Dynamic]];

dynamicPlot[f_, {x_Symbol, x0_Real, x1_Real}, 
  opts : OptionsPattern[]] := Module[{
   bag = Internal`Bag[]
   },
  PrintTemporary[
   Dynamic[ListPlot[Sort@Internal`BagPart[bag, All],
     Evaluate[Sequence @@ FilterRules[{opts}, Options[ListPlot]]]
     ], Evaluate[Sequence @@ FilterRules[{opts}, Options[Dynamic]]], 
    UpdateInterval -> 0.5
    ]
   ];
  Plot[f[x], {x, x0, x1},
   EvaluationMonitor :> (Internal`StuffBag[bag, {x, f[x]}]),
   Evaluate[Sequence @@ FilterRules[{opts}, Options[Plot]]]
   ]
]    

you can then call it like e.g.:

dynamicPlot[NIntegrate[Sin[t] Exp[-t] t^8, {t, 0, #}] &, {x, 0., 20.},
 MaxRecursion -> 4, PlotRange -> All, UpdateInterval -> 0.1
]  

it seems to be stable on my machine, but I don't exactly understand how it is different from your code in that respect, I use trigger variables as in your code often and that alone seems to not be a problem.

It is probably also worth noting that the bag local variable in that case is colored red by the frontend as it seems to escape the Module. It is not entirely clear to me when an expression printed with PrintTemporary will be deleted and what that means for the local bag. It seems that the last instance of that variable survives but will be cleaned by the garbage collection at the next possibility so there is never more than one of them floating around...

Answer 2

Thanks to the links and tips provided by Mr.Wizard I found the answer I was looking for, with a combination of EvaluationMonitor and the undocumented Bag functionality.

Two problems with the code I found:

1. For some reason updating the Bag object doesn't trigger the evaluation of a Dynamic expression containing it. I had to add another variable which changing value triggers the update of the plot.
2. The code is not stable. For some reason, more often than not it crashes the Kernel. I have no idea whatsoever why it does this.

Here is an example code:

Dynamic[a;
 ListPlot[Sort@Internal`BagPart[bag, All], Joined -> True, 
  ImageSize -> Large, PlotRange -> {{0, 100}, {0, 0.2}}]
 ]

bag = Internal`Bag[]; a = False;
integral[x_] := Abs@NIntegrate[Exp[I x (t + t^2)], {t, 0, 1}];
Plot[
 integral[x],
 {x, 0, 100},
 DisplayFunction -> (Null &),
 EvaluationMonitor :> (Internal`StuffBag[bag, {x, integral[x]}]; 
   a = ! a),
 MaxRecursion -> 4
 ]

I would have liked to have it all in a nicely callable function, but I don't know (yet) how to make the Dynamic@ListPlot show before the rest of the code is executed.

Here is a short sample of how it works:

EDIT:

Here is a cleaner solution, inspired by the other answer (this is the function used to generate the above gif):

SetAttributes[dynamicPlot, HoldAll]
Options[dynamicPlot] = Join[Options[Plot], Options[Dynamic]];
dynamicPlot[f_, {x_Symbol, x0_, x1_}, opts : OptionsPattern[]] :=
  Module[{bag = Internal`Bag[]},
    PrintTemporary @ Dynamic[
      ListPlot[
        Sort @ Internal`BagPart[bag, All],
        Evaluate[Sequence @@ FilterRules[{opts}, Options[ListPlot]]]
      ],
      Evaluate[Sequence @@ FilterRules[{opts}, Options[Dynamic]]],
      UpdateInterval -> 0.01
    ];
    Plot[f, {x, x0, x1},
      EvaluationMonitor :> (Internal`StuffBag[bag, {x, f}]),
      Evaluate[Sequence @@ FilterRules[{opts}, Options[Plot]]]
    ]
  ];

Answer 3

FWIW You can actually do this very simply with AppendTo:

a = {};
Monitor[Plot[y = Sqrt[x] Cos[1/x^(3/2)], {x, 0, 2},
  EvaluationMonitor :> (Pause[.01] ; AppendTo[a, {x, y}])], 
  ListPlot[a]]

I suppose if the function eval is so slow that you want to do this in the first place, you might not care about the performance hit associated with AppendTo.

I don't know if that might avoid the stability issue.