Progress indicator not working on a table

Question

Consider the following code

gammaList = Table[gamma, {gamma, 1, 10^8, 1}];

Monitor[Table[{gamma}, {gamma, gammaList}], 
 Row[{ProgressIndicator[gamma, {gammaList[[1]], gammaList[[-1]]}], 
   gamma}, " "]]

As you can see, there is no progressbar displaying and I don't understand why. For me everything is correct here

How to fix in the most simple way my problem ?

Answer 1

To take some comments and put them into an answer, the reason this happens is auto-compilation. It's been extensively discussed on the site, but basically Mathematica will try to compile any call into Table that's large enough and with a simple enough function directly down to C before evaluating.

This means it's impervious to inspection by things like Monitor since it's not happening in the main evaluator loop. Consider this:

gammaList = Table[gamma, {gamma, 1, 10^2, 1}];
bigList = RandomReal[{}, {2000, 1000}];
Monitor[
  Table[
   bigList + gamma,
   {gamma, gammaList}], 
  Row[{ProgressIndicator[gamma, {gammaList[[1]], gammaList[[-1]]}], gamma}, 
   " "]
  ];

My old, slow computer can watch that churn. Now let's try bumping up the number of elements in gammaList and bumping down the bigList size:

gammaList = Table[gamma, {gamma, 1, 10^3, 1}];
bigList = RandomReal[{}, {1000, 1000}];

Now I just see this:

ProgressIndicator[gamma,{1,1000}]\[ThinSpace]gamma

Since gamma isn't in the main evaluator it can't be watched. A way around this is to use two calls into Table:

gammaList = Table[gamma, {gamma, 1, 10^3, 1}];
bigList = RandomReal[{}, {1000, 1000}];
chunkSize = 251;
numChunks = Ceiling[Length[gammaList]/chunkSize];
Monitor[
  Table[
   Table[
    bigList + gamma,
    {gamma, gammaList[[(chunk - 1)*chunkSize + 1 ;; UpTo[chunkSize*chunk]]]}
    ],
   {chunk, numChunks}
   ],
  Row[{ProgressIndicator[chunk, {1, numChunks}], chunk}, " "]
  ];

My computer complains vociferously about being asked to evaluate that, but you can watch it go.

Answer 2

A simple way to keep track of table iterators, I usually use, is:

Dynamic[ProgressIndicator[gamma/gammaMax]]

or

Dynamic[gamma]

Let us define the largest gamma value to be a bit smaller than 10^8 for the sake of example:

gammaMax=10^5;

Then, if you would like to actually see the increments being updated dynamically in the progress bar, you have to slow down the routine by, e.g., a Pause command:

gammaList = Table[Pause[0.00001]; gamma, {gamma, 1, gammaMax, 1}];

If you do not include a Pause, the Table is constructed so quickly, that the Dynamic routine has no chance to pick up on every individual step. Alternatively, if your actual Table components involve more complicated steps that naturally take a longer time to evaluate, then the Pause is not needed and you will be able to see increments dynamically as they come in.

As mentioned by b3m2a1, if the function in each element of Table is too simple, Mathematica may compile the table and make the iterator not accessible to the main window. In such a case the routine again is likely to run so fast that monitoring the iterator may be pointless. In any case where the Table construction involves more complicated input that is not auto-compiled, the above Dynamic will work as desired.