Mike,

I woke up remembering that there was an example in the documentation highlighting the way that Animate interacts with normal evaluation order that is worth studying.

Animate[Plot[
  Evaluate[{Sin[x], Normal[Series[Sin[x], {x, 0, n}]]}], {x, -10, 10},
   PlotRange -> 3], {n, 1, 20, 2}, 
 AnimationDirection -> ForwardBackward, AnimationRunning -> False]

Note that if you remove the Evaluate, it errors because when Animate evaluates its expression, it sets n to be a value and evaluates the Plot, however, Plot will set a value for x everywhere in the term

{Sin[x], Normal[Series[Sin[x], {x, 0, n}]]}

which is a problem because Series needs to have a variable, not a number where 'x' appears. So the evaluation must be controlled so that n is first given a value, then the Series[] is evaluated, and only then can x take on values in the Plot[]. Animate handles the assignment of n but the Evaluate[] causes the Series to be evaluated out of order -- it comes first before Plot[] sets a value for x. You can edit the example and see the errors and see why it breaks.

To be a bit more clear, the Evaluate really only needs to be around the Series[] because this is the part that has evaluation order issues.

Animate[Plot[{Sin[x], 
   Evaluate[Normal[Series[Sin[x], {x, 0, n}]]]}, {x, -10, 10}, 
  PlotRange -> 3], {n, 1, 20, 2}, 
 AnimationDirection -> ForwardBackward, AnimationRunning -> False]

(Also note that even without the Animate, the Evaluate[] is necessary because the error arises because of the Plot[]. The animate makes it conceptually harder because it adds another variable, n, to the evaluation order issue.)

Your original term

Graphics[gList, PlotRange -> {{-5, 5}, {-4, 4}}]

has a similar problem -- if you evaluate that Graphics[] expression, it errors because the variable tis not yet defined.

I hope this helps.

Regards,

Neil

Mike,

Evaluation order and scoping is a difficult area of Mathematica. It takes considerable experimenting to understand it. I do not have a good reference but I believe there are some threads in the forum that talk about references. Generally the tutorials in the documentation are good. This scoping is especially hard when you use Manipulate, Animate, and Dynamic.

The problem with your formulation is that you used functions to create a list of expressions and then wanted to use that list as a function inside a dynamic construct. This gets complicated. For example,

In[46]:= aa = Expand[(x + 5)^3]

Out[46]= 125 + 75 x + 15 x^2 + x^3

In[47]:= bb[x_] := aa

In[48]:= bb[g]

Out[48]= 125 + 75 x + 15 x^2 + x^3

Note that bb failed to have the proper definition. This is analogous to what you are doing. One way to fix it is to force aa to evaluate immediately.

In[49]:= bb[x_] := Evaluate[aa]

In[50]:= bb[g]

Out[50]= 125 + 75 g + 15 g^2 + g^3

You have a similar problem with gList -- it is an expression in t but you want to substitute in values for t as if it were a function (similar to what I did above). My suggestion would be change your approach and construct circle piecewise functions so that they are functions of t and then they will behave as you expect.

circ[y_, r_][t_] := Circle[{f1[t], y}, r]

gList = Table[circ[0, i], {i, 1, 2}]

{circ[0, 1], circ[0, 2]}

I made a function circ that returns a function of time. Now gList is a list of functions -- not expressions. I can apply each of these to a time and they will produce a circle at that instant in time.

Animate[Graphics[Through[gList[tp]], 
  PlotRange -> {{-5, 5}, {-4, 4}}], {tp, 0, 10}, AnimationRate -> .5]

The function Through just applies each function in my list, gList, to the argument [tp]. Essentially giving you {c1[tp], c2[tp], ... cn[tp]} where c1, c2, ... are circle functions of only time. Now this behaves as you expect. Its a list of functions that animate without having to worry about scoping of variables.

You could also do this with Map instead of Through if it is more clear:

Animate[Graphics[Map[#[tp] &, gList], 
  PlotRange -> {{-5, 5}, {-4, 4}}], {tp, 0, 10}, AnimationRate -> .5]

I hope this helps (and did not make things worse!)).

Regards,

Neil

Mike,

The problem is twofold. First gList needs to be evaluated because Animate is HoldAll. Secondly, gList has a variable t that is locally scoped and has no value when it is evaluated -- you need it to be filled in by the animate. These situations can be addressed with the function "With[]". Do the following:

Animate[Graphics[With[{t = tp}, Evaluate[gList]], 
  PlotRange -> {{-5, 5}, {-4, 4}}], {tp, 0, 10}, AnimationRate -> .5]

Regards,

Neil