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