I have been playing with the animate command, and have recently encountered a situation in which I need a vertical line (it will move from side to side, but remain vertical). Because there is no function of x that can give me this, I am forced to use a command. I have found the command line([a,b],[a,b]), which is used to draw a line segment, in the package plottools, but this did not appear to work with animations. How do I make a vertical line in an animation?

Most of my animations also contain more than 1 function. I do know about the option color=, but unlike the plot command, animate will only let you put one color there. I ﬁnd it hard to believe that you must make everything the same color. Is there a way to use multiple colors like you do with the plot command?

Note: I use Maple V Release 5 Student Version

About your questions concerning animations. 1) You want to plot your vertical lines as parametric curves. 2) You can generate several animations with the curves plotted in diﬀerent colors, then show them together using the display command from the plots package. Here’s a simple example showing both things:

with(plots): L1:=animate([t,u,u=0..1],t=-2..2,color=blue): L2:=animate([2-t,u,u=0..1],t=-2..2,color=red): display({L1,L2});

Using the "display" command with the argument "insequence= true" is a much more ﬂexible way to produce animations. The "animate" command only works with functions. Any plot whatsoever can be animated with the "insequence" option, including plots containing text.

The vertical line x=a can be expressed as a function in polar coordinates as
`r = a*sec(theta)`

. You can then use the range of theta to control the height of the
line segment. You can include the argument `"coords= polar"`

to the animate
command.

There are many other ways to draw a line segment. You could use a parametric plot:

plot([a, t, t= c..d])

will plot a vertical line segment from `[a,c] to [a,d]`

. But this is using an elephant gun to
swat a ﬂy.

Other ways to draw the line segment from [a,b] to [c,d]:

plot( [[a,b],[c,d]] ) pointplot ( [[a,b],[c,d]], connect= true)

and my favorite (because it will avoid some function call overhead if you are putting many line segments in one display):

display(CURVES([[a,b],[c,d]]))

Note the capital letters.

Putting it all together, the following command will produce an animation of `n+1`

vertical line
segments moving through the color spectrum:

display([seq(CURVES( [[k/n,0],[k/n,1]], COLOR(HUE,k/n)), k= 0..n)] ,thickness= 9, view= [0..1,0..1], insequence= true)

Using n=100, this command executes in 0.41 seconds on my SPARCstation 4, not a particularly fast computer; whereas doing the equivalent thing with the plot command takes over 5 secs; with line, 0.7 secs; and with pointplot, 1.27 secs.

There are many good examples of using the "insequence" option in `_Calculus the Maple Way_`

by Robert B Israel. In particular, note that each frame of the animation can itself be a
complex structure created with the display command.

If anyone wants them, I will email them worksheets with animations of:

1. the osculating circle rolling along a 2D or 3D curve

2. Newton’s method for functions of a single real variable. This one uses text in the animation to print

a. the equation of the tangent line at each iteration

b. the x-intercept at each iteration

c. context-sensitive advice on how improve the approximation.

To get a vertical line x=a, you could use a parametric representation, e.g. `[a, t, t=0..1]`

.

Try the following:

f:= t -> 1-t^2: p1:=plot(f,-1..1,color=blue): p2:=animate([a,t*f(a),t=0..1],a=-1..1,color=red): display(p1,p2);

Here’s a little ’dirty’ procedure which does the trick.

restart; with(plots): pl:=proc(xa,ya,xe,ye,xstep,ystep,xytimes) local i,j; PLOT(ANIMATE(seq([CURVES([seq([evalf(xa+(i-1)*(xe-xa)+(j-1)*xstep), evalf(ya+(i-1)*(ye-ya)+(j-1)*ystep)],i=1..2)]) ],j=1..xytimes))) end:

Short description:

The procedure pl produces a plot structure. The parameters are: xa,ya - (coordinates of the beginning point of the line) xe,xe - (coordinates of the ending point of the line) xstep - difference between the x coordinates of the actual point and next point to be drawn ystep - difference between the y coordinates of the actual point and next point to be drawn xytimes - how many animation frames Example: > gp:=pl(-.25,-1.5,.25,-1,Pi/6,5/12,6): > display({gp},view=[-.25..3.55,-3..3]);

Displaying several animation in one window:

E.g. create normal animation via:

> fp:=animate(sin(x)*t*cos(x),x=0..Pi,t=1..5,frames=6,color=blue): > display({gp,fp},color=green); | your color question

Look at the above examples how to manage it, should be obvious.

Add. Info: The outer color deﬁnition used in ’display’ is overwritten temporary in ’fp’.

Further and more detailed info in the manuals and help pages, e.g.
`?plot[structure], ?plot[options]`

, ...

I use the plot command with a list of coordinates (two in this example). Try as an example:

with(plots): display([ seq( plot([[x,0],[x,1]]) ,x=1..100) ],insequence=true);

It plots a unit verticle line at various x positions.

You can use display of the plots package with `insequence=true`

. Create a plot structure for
each frame and specify the color you want in each frame.

The following will produce an animation with four frames. In the ﬁrst frame we have the line x=1 in blue. In the second one x=1.5 is green, etc.

a[1]:=plot([[1,0],[1,1]],x=0..2,color=blue): a[2]:=plot([[1.5,0],[1.5,1]],x=0..2,color=green): a[3]:=plot([[1.75,0],[1.75,1]],x=0..2,color=red): a[4]:=plot([[0.1,0],[0.1,1]],x=0..2,color=yellow): s:=seq(a[i],i=1..4): plots[display](s,insequence=true);

In the work above all of the vertical lines have the same height. If you want to vary the height using a function and you’d like the function to be displayed as well, then the following will do it.

h will give the height over interval [a,b]

> h:=x->x^2+1; > a:=-1;b:=2;

there will be 26 frames

> n:=25;

the color of each vertical line is randomly determined

g:=(h,a,b,i)->plot([[a+i*((b-a)/n),0],[a+i*((b-a)/n),h(a+i*((b-a)/n))]], a..b,color=COLOR(RGB,rand()/10^12, rand()/10^12, rand()/10^12)): c:=plot(h,a..b,color=black): for j from 0 to 25 do p[ j ]:=plots[display]({g(h,a,b, j),c}): od: s0:=seq(p[ j ], j=0..25): plots[display](s0,insequence=true);

If I understand your request, it is possible to create what you want using the display command from the plots package. The following sequence of commands illustrates the general idea by drawing the vertical height of a function at 21 uniformly spaced points in the interval [-1,1].

> restart; > with( plots ): > > f := x -> x^2+1; 2 f := x -> x + 1 > P := plot( f, -1..1, color=BLUE ): > P2 := seq( display( P, plot( [[x,0],[x,f(x)]] ) ), x=[i/10 $ i=-10..10] ): > display( P2, insequence=true );

I hope you can modify this for your needs,