[Date Index] [Thread Index] [Author Index]

The simple command x=0;Dynamic[x=x+1]

• To: mathgroup at smc.vnet.net
• Subject: [mg124787] The simple command x=0;Dynamic[x=x+1]
• From: Fred Simons <f.h.simons at tue.nl>
• Date: Tue, 7 Feb 2012 04:00:15 -0500 (EST)
• Delivered-to: l-mathgroup@mail-archive0.wolfram.com

For a long time I thought that the result of the command x=0; 
Dynamic[x=x+1] was easy to explain: at each update the value of x 
changes, so it will be updated again, and so on, so we see a fastly 
increasing counter. Now I start realizing that it is not that trivial. 
At least there are some features that puzzle me and I hope someone can 
come up with an explanation.

The first line of the next commands creates something like a clock. The 
second line gives the command that I am trying to understand. It shows 
that the value of x increases with a speed of about 600 per second (on 
my computer, this is system dependent!), instead of the speed of about 
20 that I would expect, since updating takes place at about that rate. 
Why is it so fast? We are not reading an infinite loop (I think); when x 
has a value, execution of the command x=x+1 is not a problem.

n=0;Dynamic[n=n+1, TrackedSymbols->{}, UpdateInterval->1]
x=0; Dynamic[x=x+1]

Remove the above output and have a look at the following, where we have 
two identical constructions, with different variables. The speed now 
slows down to about 400 per second.

n=0;Dynamic[n=n+1, TrackedSymbols->{}, UpdateInterval->1]
x=0; Dynamic[x=x+1, SynchronousUpdating->True]
y=0; Dynamic[y=y+1, SynchronousUpdating->True]

Again remove the output. In the next commands we set one of the two 
dynamics to queued updating. The effect is remarkable. It slows down the 
synchronized dynamics to a speed of about 100 per second. Moreover, for 
some or other reason the synchronized dynamics seems to be exactly twice 
as fast as the queued one, with a speed of 50 per second.

n=0; Dynamic[n=n+1, TrackedSymbols->{}, UpdateInterval->1]
x=0; Dynamic[x=x+1, SynchronousUpdating->True]
y=0; Dynamic[y=y+1, SynchronousUpdating->False]

Finally, when both are queued, the speed of both decreases to about 30 
per second:

n=0; Dynamic[n=n+1, TrackedSymbols->{}, UpdateInterval->1]
x=0; Dynamic[x=x+1, SynchronousUpdating->False]
y=0; Dynamic[y=y+1, SynchronousUpdating->False]

But in all cases, the speed is higher than the refresh rate. Very likely 
I overlook something simple, but at the moment I have only a very vague 
idea what could be going on here.

All comment on this behaviour is highly appreciated.

Many thanks in advance and kind regards,

Fred Simons
Eindhoven University of Technology