Introduction to Iteration Maps

This worksheet is intended to provide an introduction to Maple as well as to allow you to explore the behavior of iteration maps.

restart;

This command (restart) resets the Maple program so that it forgets any other commands. If you don't execute this command, then you sometimes find surprises in calculations coming from previous results that you don't realize Maple is using.

The following list of functions are three simple examples of iteration functions for population dynamics. The pound sign (#) at the beginning of a line is a way of hiding the command from Maple. Everything following a '#' is ignored (technically, it's callled a comment). Remove the '#' to select a function to use for iteration.

Second, note that the sequence ':=' is used to define f. The arrow '->' describes a function. The name on the left is the input value and the expression on the right is the output value. For example, the first equation would be written on paper as 'f(x) = ax'. Also, note that every operation must be explicitly written (multiplication, in particular).

# f := x->a*x; # geometric # f := x->K + a*(x-K); # shifted geometric # f := x->lambda*x*(M-x); # logistic

Each of the possible functions have parameters that need to be set before exploring this numerically. You should be sure to select parameters that match the equation you used above.

# a := 1.25; # geometric # a := 0.75; K := 200; # shifted geometric # lambda := 0.0125; M := 200; # logistic

Now that we have selected a method for iteration, we set up our iteration itself.

We need to know how many repeats we should ask the computer to compute (N).

We also need to tell the computer the first value (initial condition) (p[0]). We are creating a table of values that we call 'p'. To indicate which entry in the table we use (in other words, which generation of the population), we use brackets '[' and ']' around our index.

N:=20; p[0]:=10;

Now we ask the computer to do the iteration. We use a loop, where the computer repeats a task but on different index in the table each time.

In Maple, we use a for loop to let the index 't' increment through a sequence of values. Note that we use our variable N defined above as the last index to use in the loop.

The repeated task is surrounded by the key phrases do and end do. Note that we use the previous table entry to fill in the next table entry.

for t from 1 by 1 to N do p[t] := f(p[t-1]); end do;

If you want to look at the list as a sequence, use the seq command in Maple to extract information in the table.

seq(p[t], t=0..N);

We usually prefer graphical methods to visualize the data, so let's send this sequence to Maple's listplot command. Note that we used the seq command inside to create the sequence of data values. But we also needed to surround it with brackets '[ ]' so that the sequence is treated as a single object (an ordered list of numbers) instead of a long sequence of independent numbers (a sequence).

with(plots): listplot([ seq(p[t], t=0..N) ], style=POINT);

If you look at the above plot carefully, you'll notice that the first point is plotted at t=1, rather than t=0. Why?

Remember, the listplot command was simply sent an ordered list of values. It didn't know anything more, and so the x-axis is just showing the order in the list. To give more information, such as the true value of the index (which generation), then we need to pass two pieces of information about each point. Notice that the seq command now creates a sequence of ordered pairs [t, p[t]], which is then combined into a single list before being sent on to listplot.

listplot([ seq([t, p[t]], t=0..N) ], style=POINT, title="Population Size vs Generation", labels=["t", "p[t]"], labeldirections=[HORIZONTAL,VERTICAL]);

Notice that we added a title to the plot and labels for the axes. You can read about these and other options in the Maple help viewer under plot,options.

Another plot that we want to consider compares the size of one generation with a previous generation. Again, we use a listplot, but with a different order pair in the seq command:

k := 1; # Number of generations between population sizes. listplot([ seq([p[t-k], p[t]], t=k..N) ], style=POINT, title=cat("Compare generations with lag k=", k), labels=["p[t-k]", "p[t]"], labeldirections=[HORIZONTAL,VERTICAL]);