Here's a quick tutorial on using some features of Maple in support of your courses. More details can be had by using Maple's online help functions, and by consulting Maple manuals. This is by no means a comprehensive account of these aspects of Maple, and programming in Maple is not addressed at all.

There are a number of ways Maple can be invoked. If you are at a workstation,
the full graphical front end to Maple can be brought up by invoking Maple from
a terminal window by typing `xmaple` or `maple -x` at the
terminal window's prompt *machine_name*$. Bringing Maple up this way uses the
Java runtime environment which can be very slow. For a faster, lighter Maple
session, bring up graphical Maple environment by typing the command
`maple -cw` at the prompt in the command
window. The interface is different, but it retains all the functionality of
the Java version.

If you are connecting from a different site (for example, your home PC) to
`telnet.cs.uleth.ca`, or don't need or want the graphical front-end to
Maple, you can invoke Maple simply by typing `maple` at the prompt.

To quit from a graphical session (invoked as `xmaple` or
`maple -x` or `maple -cw`), go to the "File" menu and select the option "Exit". Wait a
few seconds before logging out, as it will take a few seconds for Maple to
clean up after itself before returning the prompt in the terminal window from
which you started Maple.

If you are running a text-only session (invoked by `maple`), simply
type `quit` at the Maple prompt. The command `quit` is one of the
few
exceptions to Maple's syntax of requiring either a semicolon or colon following
a command. Maple will then exit, print a brief summary of statistics concerning
your session, and return your machine's prompt.

Maple provides some very handy functions for dealing with linear algebra. Below is a Maple session illustrating some of the functionality of the linear algebra tools. Commentary is interspersed with the session. Maple also inserts blank lines to ease readability. These have been removed from the sample session.

nefarius$ maple |\^/| Maple V Release 5 (University of Lethbridge) ._|\| |/|_. Copyright (c) 1981-1997 by Waterloo Maple Inc. All rights \ MAPLE / reserved. Maple and Maple V are registered trademarks of <____ ____> Waterloo Maple Inc. | Type ? for help. > with(linalg); Warning, new definition for norm Warning, new definition for trace [BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp, QRdecomp, Wronskian, addcol, addrow, adj, adjoint, angle, augment, backsub, band, basis, bezout, blockmatrix, charmat, charpoly, cholesky, col, coldim, colspace, colspan, companion, concat, cond, copyinto, crossprod, curl, definite, delcols, delrows, det, diag, diverge, dotprod, eigenvals, eigenvalues, eigenvectors, eigenvects, entermatrix, equal, exponential, extend, ffgausselim, fibonacci, forwardsub, frobenius, gausselim, gaussjord, geneqns, genmatrix, grad, hadamard, hermite, hessian, hilbert, htranspose, ihermite, indexfunc, innerprod, intbasis, inverse, ismith, issimilar, iszero, jacobian, jordan, kernel, laplacian, leastsqrs, linsolve, matadd, matrix, minor, minpoly, mulcol, mulrow, multiply, norm, normalize, nullspace, orthog, permanent, pivot, potential, randmatrix, randvector, rank, ratform, row, rowdim, rowspace, rowspan, rref, scalarmul, singularvals, smith, stackmatrix, submatrix, subvector, sumbasis, swapcol, swaprow, sylvester, toeplitz, trace, transpose, vandermonde, vecpotent, vectdim, vector, wronskian]

If you didn't want the long list of components in the linear algebra package
appearing, then instead of typing `with(linalg);` with its trailing
semi-colon, you could just type `with(linalg):` (i.e., use a trailing
colon rather than a semicolon to suppress output).

To get help on any of these functions, type `?function-name` at the ">"
prompt. No trailing semicolon is required.

> ?cond linalg[cond] - condition number of a matrix Calling Sequence: cond(A) cond(A, normname) Parameters: A - a square matrix normname - (optional) matrix norm, must be one of: 1, 2, 'infinity', or 'frobenius'. Description: - The function cond computes the ``standard'' matrix condition number, defined as norm(A) * norm(inverse(A)). The matrix norm is the default employed by the linalg[norm] function, namely the infinity norm (maximum row sum). - More generally, cond(A, normname) computes norm(A, normname) * norm(inverse(A), normname). This is the same measure, but using the specified norm instead of the infinity norm. - The command with(linalg,cond) allows the use of the abbreviated form of this command.

In the newest release of Maple, a separate window opens displaying the help file information for this.

Manipulating matrices is very straightforward in Maple.

> A:=matrix(3,3,[4,1,0,1,4,1,0,1,4]); [4 1 0] [ ] A := [1 4 1] [ ] [0 1 4] > B := [2,1,3]; B := [2, 1, 3] > multiply(A,B); [9, 9, 13]

Maple is smart enought to know that the vector B must be interpreted as a column vector in this instance.

> X0 := [1,1,1]; X0 := [1, 1, 1] > L:=matrix(3,3,[0,0,0,1,0,0,0,1,0]); [0 0 0] [ ] L := [1 0 0] [ ] [0 1 0] > Dg:=matrix(3,3,[4,0,0,0,4,0,0,0,4]); [4 0 0] [ ] Dg := [0 4 0] [ ] [0 0 4] > U:=matrix(3,3,[0,1,0,0,0,1,0,0,0]); [0 1 0] [ ] U := [0 0 1] [ ] [0 0 0] > evalm(A); [4 1 0] [ ] [1 4 1] [ ] [0 1 4] > evalm(L+Dg+U); [4 1 0] [ ] [1 4 1] [ ] [0 1 4]

Doing matrix inverses? Notice this:

> evalm(1/Dg); [1/4 0 0 ] [ ] [ 0 1/4 0 ] [ ] [ 0 0 1/4] > evalm(X0); [1, 1, 1] > X1 := evalm((1/Dg)*(B - (L+U)*X0)); bytes used=1001056, alloc=720764, time=0.33 X1 := [1/4, -1/4, 1/2] > X2 := evalm((1/Dg)*(B - (L+U)*X1)); [ 13] X2 := [9/16, 1/16, --] [ 16] > X3 := evalm((1/Dg)*(B - (L+U)*X2)); [31 -3 47] X3 := [--, --, --] [64 32 64] > X4 := evalm((1/Dg)*(B - (L+U)*X3)); [67 -7 99 ] X4 := [---, ---, ---] [128 128 128] > X5 := evalm((1/Dg)*(B - (L+U)*X4)); [263 -19 391] X5 := [---, ---, ---] [512 256 512] > evalf(263/512); .5136718750 > evalf(-19/256); -.07421875000 > evalf(391/512); .7636718750

Maple will perform exact arithmetic. To render a fraction as a decimal
(or decimal approximation), the `evalf` function is used, as illustrated
above.

Maple can easily cope with row-reductions of matrices. With the matrix A
above, the reduced row-echelon form is obtainable with the `rref`
function:

> rref(A); [1 0 0] [ ] [0 1 0] [ ] [0 0 1]

Routine differentiation can be easily managed in Maple. For example, suppose
we have calculated that

is a solution to the differential equation

but want to check our solution. We can easily verify this using Maple's build-in ability to differentiate expressions.

First, let us assign a label *f* to our expression
for *y _{p}*,

> f:=exp(2*x)*((7/5)*cos(x)-(1/5)*sin(x)); f := exp(2 x) (7/5 cos(x) - 1/5 sin(x))

We need first and second derivatives of *f*, so
use the `diff` operator to compute them and save the results in
*df* and *ddf*, respectively:

> df:=diff(f,x); df := 2 exp(2 x) (7/5 cos(x) - 1/5 sin(x)) + exp(2 x) (-7/5 sin(x) - 1/5 cos(x)) > ddf:=diff(df,x); ddf := 4 exp(2 x) (7/5 cos(x) - 1/5 sin(x)) + 4 exp(2 x) (-7/5 sin(x) - 1/5 cos(x)) + exp(2 x) (-7/5 cos(x) + 1/5 sin(x))

With the first and second derivatives of *y _{p}*
in hand, we compute the left hand side of our differential equation:

> ddf-2*df +2*f; 2 exp(2 x) (7/5 cos(x) - 1/5 sin(x)) + 2 exp(2 x) (-7/5 sin(x) - 1/5 cos(x)) + exp(2 x) (-7/5 cos(x) + 1/5 sin(x))

There are some cancellations that can be performed here,
but we can get Maple to do that for us with the `simplify` command:

> simplify(%); exp(2 x) (cos(x) - 3 sin(x)) >

The percent symbol is Maple's shorthand for the output of the previous command.

Achieving this result validates our answer.

Plotting is best done in the X/Window invocation of Maple (start with
`maple -x` or `xmaple` or `maple -cw`).

A simple graph of this cubic polynomial will appear as output. Notice the
syntax of the `plot` command: the first argument is an expression in
an independent variable, followed by the range of the variable. By re-issuing
the `plot` command with different intervals, you can "zoom in" or "zoom
out" on the graph. Try the previous command with the intervals
`x=-1.5..1.5` and `x=-10..10` to see the effect for yourself.
The command `?plot` will provide you with additional information about
options to the `plot` command. Also, if you issue the `plot`
command in a Maple text window session, Maple will fashion a reasonable
facsimile of the graph using keyboard characters (an example of this follows).

A helpful timesaver in both the text-only and X/Windows forms of Maple is command recall. By using the "up arrow" key, you can recall a previous command and just edit that instead of re-typing the command. In the X/Windows form, the "up arrow" key will move the cursor up through previous lines in your session.

You can define functions in Maple as well for easy subsequent use. For example,

> f := x -> (x^2 + 3*x)/(x^4 + x + 1);

defines the rational function *f*(*x*) = (*x*^{2} + 3*x*)/(*x*^{4}
+ *x* + 1), and subsequent computations with this rational functional can be
done using *f(x)*:

> f := x -> (x^2 + 3*x)/(x^4 + x + 1); 2 x + 3 x f := x -> ---------- 4 x + x + 1 > f(1); 4/3 > evalf(f(1)); 1.333333333 > plot(f(x), x=-5..5); + AAAA + AA AAA 1+ A AAA + A AA +AA AAAA +A AAAAAAA ******-4************--2--+--+--+--+--*--+--+--+--+--2--+--+--+*****4******* AAAAA 0* AAA A+ AA A+ A A + A -1+ A AA + A A + A A + A A-2+ A AA + A A + A A + AAA + AA -3+

In an X/Windows session, the graph would be nicely drawn. You might find it interesting to try plotting functions that have singularities, to see how Maple copes with problem functions.

Maple can also handle functions that are piecewise defined. The appropriate
command to use is `piecewise`, and the syntax is

`piecewise(` 1st condition, 1st function, 2nd condition,
2nd function, etc., otherwise function`).`

So, if we wanted a function definition that was sin(x) for *x* < 1,
and then 2*x+1 for 1 <= x < 2, and then 1-x^3, we could code it up as

`g:=piecewise(x < 1, sin(x), 1 <= x and x< 2, 2*x+1, 1-x^3); `

Try graphing *g* using the `plot` command to see for yourself.
Try using the plotting option `discont=true` to rid your graph of
artifacts of the plotting process.

For the denominator in our rational function *f*, you might try to
see if it vanishes anywhere. Maple has built-in facilities for root-finding.
To search for an exact solution to an equation *p*(*x*) = 0, use
`solve()`. If this does not produce a solution in closed form, you can
look for a solution numerically with `fsolve`:

> solve(x^4 + x + 1 = 0, x); bytes used=1014064, alloc=851812, time=0.28 4 RootOf(_Z + _Z + 1)

This is Maple's way of stating that it was unable to obtain an exact solution. We can continue by searching for a numerical solution:

> fsolve(x^4 + x + 1 = 0);

In this case, no result is returned, so numerical methods failed to produce a solution to the equation. A slight modification of this problem will show you what to expect to see when solutions do exist:

> solve(x^4 + x + 1 = 4); 4 RootOf(_Z + _Z - 3) > fsolve(x^4 + x + 1 = 4); -1.452626879, 1.164035140

Maple can also plot implicitly defined functions. Issue the `with(plots)`
command to load an enhanced graphics library:

> with(plots); [animate, animate3d, animatecurve, changecoords, complexplot, complexplot3d, conformal, contourplot, contourplot3d, coordplot, coordplot3d, cylinderplot, densityplot, display, display3d, fieldplot, fieldplot3d, gradplot, gradplot3d, implicitplot, implicitplot3d, inequal, listcontplot, listcontplot3d, listdensityplot, listplot, listplot3d, loglogplot, logplot, matrixplot, odeplot, pareto, pointplot, pointplot3d, polarplot, polygonplot, polygonplot3d, polyhedra_supported, polyhedraplot, replot, rootlocus, semilogplot, setoptions, setoptions3d, spacecurve, sparsematrixplot, sphereplot, surfdata, textplot, textplot3d, tubeplot]

You should spend some time browsing this rich set of tools. For now, suppose
we want a plot of the ellipse *x*^{2} + 2(*y* - 1)^{2} = 4.
The `implicitplot` function is the appropriate tool to use for this task:

> implicitplot(x^2+2*(y-1)^2 = 4, x=-4..4, y=-4..4);

Maple obligingly supplies a graph. `implicitplot` can be very
helpful when drawing the isoclines for a differential equation.

Plotting of parametrically defined curves can also be done. For example,
to plot the plane curve *x* = 1 + 3*t*^{2},
*y* = *t*^{3} -2*t*, first ensure you have the graphical
front end of Maple running (by invoking either `xmaple` or
`maple -x` or `maple -cw` from the Unix command line), and then define the functions
*f* and *g* by the Maple commands

`
> f:=t->1+3*t^2;
> g:=t->t^3-2*t;
`
Maple responds by pretty-printing these function definitions. To plot the
curves with

>plot([f(t),g(t),t=-2..2]);

Plotting polar curves produces no great difficulties. To plot a curve
expressing *r* as a function of an angle, first define *r* as a
function of the angle, and then plot the Cartesian equations as above.

For example, to plot the ellipse given by *r* = 1/(2 + cos(theta)),
we define *r* by `r:=theta->1/(2+cos(theta))` to which Maple responds
by pretty-printing the function definition, and then issue the plot command
`
> plot([r(theta)*cos(theta), r(theta)*sin(theta),
> theta=0..2*Pi], scaling=constrained);
`

Notice that `Pi` is a built-in constant for Maple. The corresponding
figure produced will indeed be that of an ellipse, though if you omit the option
`scaling=constrained` from the plot command, what you'll see will be more
like a circle due to Maple's default action of scaling axes to fill out the
command window.

A more interesting polar curve is a three-leaved rose, given by *r* =
cos(3*theta). If plotted as for the previous example with, say,
`r1:=theta->cos(3*theta)` used to define *r* as a function of theta,
then the full curve is traced out, of course, with theta varying from 0 to
2*Pi. You can analyse the curve using smaller intervals for theta, though.
Using the interval from 0 to Pi will trace out the full curve, and if you
restrict theta further, say to [0, Pi/2], using the command
`plot([r1(theta)*cos(theta), r1(theta)*sin(theta), theta=0..Pi/2])`, the
figure at the right results.

To plot parametric curves in space requires the use of the `plots`
package, so make sure you have loaded the package into your active Maple session
by typing `with(plots):` into the command window in Maple if you haven't
already done so.

Let us plot the parametric space curve *x* = *t*, *y* =
*t*^{2}, *z* = *t*^{3} with *t* ranging over
the interval [0, 3].

We could define functions for each of the coordinates *x*, *y* and
*z* as we did for our first parametric curve in the plane, but this one is
simple enough to do directly. Issue the command
`spacecurve([t,t^2,t^3], t=0..3, axes=frame,labels=[x,y,z]);`
in the Maple command window. Maple produces the figure at the right, which
sadly is not very helpful.

The options in the `spacecurve` command provide axes and labels for
the coordinate axes and can be modified or omitted as you see fit.

Notice that when you move the mouse pointer over the figure, the pointer changes into a curved arrow. If you click and hold the right mouse button while the curved pointer is visible, as the pointer moves the figure itself will rotate. This allows you to view the curve from a number of different points, and gives you a better sense of the three-dimensional character of the plot than would otherwise be the case for a fixed, static, image.

The image at the right is one of the many possible views that result when rotating the image, and the labelling of the coordinate axes is a great help in determining the view you are getting of the curve.

Multiple curves can be plotted on the same graph. To illustrate this, we take
as an example the first order PDE used to illustrate the method of characteristics
found in the text by Carrier and Pearson: the PDE is

To plot several of these characteristic curves (starting from the non-characteristic
curve at *t* = 0), we define them first by

`
x:=(t,s) -> s/(1-s*t);
y:=(t,s) -> t^2/2+1-s;
y:=(t,s) -> t;
`

which Maple dutifully pretty-prints. The plotting is accomplished by

[x(t,0.15),y(t,0.15),u(t,0.15), t=0..6.55],

[x(t,0.2),y(t,0.2),u(t,0.2), t=0..4.9],

[x(t,0.3),y(t,0.3),u(t,0.3), t=0..3.25],

[x(t,0.4),y(t,0.4),u(t,0.4), t=0..2.4],

[x(t,0.5),y(t,0.5),u(t,0.5), t=0..1.85],

[x(t,0.6),y(t,0.6),u(t,0.6), t=0..1.55],

[x(t,0.7),y(t,0.7),u(t,0.7), t=0..1.33],

[x(t,0.8),y(t,0.8),u(t,0.8), t=0..1.15],

[x(t,0.9),y(t,0.9),u(t,0.9), t=0..1.02]},

axes=frame,labels=[x,y,u]);

which results in the graph (three views are shown)

If you haven't yet done so, start up Maple with the graphical front-end by
either typing `xmaple` or `maple -x` or `maple -cw` into a command window, and
load the graphics library by typing, in the Maple command window, the statement

> with(plots):

We'll explore some possibilities for plotting surfaces in this section. Remember that Maple commands must always be terminated by semicolons, even if the examples shown here don't always reflect this fact.

First, here's how to plot a simple surface given as a function of two
variables. We'll use the example of *g*(*x*,*y*) = *xy*,
which has a saddle surface (hyperbolic paraboloid) as its graph. To start, define
the function *g* by issuing the command

> g:=(x,y)->x*y;

Maple will respond by nicely printing your function definition for you. To
generate a plot requires the specification of ranges of *x* and *y*
values. Type

> plot3d(g(x,y),x=-3..3,y=-3..3);

into the command window to generate the graph of *g* with *x* and
*y* each ranging over the interval [-3,3]. This will produce the plot
seen at the right. If you move your mouse pointer over the graph in the Maple
window, the cursor will change into a curved arrow, and if you click and hold
the left mouse button and slowly move the curved cursor around, you'll see
the plotted image rotate. By playing with the rotations this way, you'll be
able to get a sense of how the surface fits into space.

This plot of the saddle surface was done using simple defaults in the plot3d
command. To gain some idea of the range of options possible with the plot3d
command, type the command `?plot3d,options` into the Maple command
window. A new window (the help window) will pop open with a description of the
plot3d command, along with examples and options. Close the help window and type
the command

> plot3d(g(x,y),x=-5..5,y=-5..5,style=patchnogrid);

into the command window and Maple will produce a new saddle surface plot,
without grid lines. The plot at the right is what you should expect (here, the
figure has been rotated to more clearly show the saddle). `plot3d` has a
sizeable number of options, and it is well worth the time to experiment with
different options and parameter values.

The `plots` library of functions can also do plotting of surfaces
defined implicitly. For example, to plot the plane with equation 4*x* -
2*y* + *z* = 8, you could issue the command

> implicitplot3d(4*x - 2*y + z = 8, x=-3..3,y=-3..3,z=-3..3);

and Maple would respond by generating a plot of that portion of the plane found in the rectangular box [-3,3]×[-3,3]×[-3,3]. With a little more sophistication, multiple plots of surfaces can be incorporated into the same graphic. For example, to simultaneously plot a plane and sphere in the same figure, issue the commands

> plane:=4*x-2*y+z=8; > sphere:=x^2+y^2+z^2=9;

This symbolically labels the equations defining each of a plane and a sphere
for subsequent, easier reference. If you issue
`implicitplot3d(plane, x=-3..3, y=-3..3, z=-3..3)` and
`implicitplot3d(sphere, x=-3..3, y=-3..3, z=-3..3)`
commands, then you will generate separate plots of the plane and the sphere, as
illustrated above at right. To incorporate both surfaces in the same plot,
though, issue the single command
`implicitplot3d({plane,sphere}, x=-3..3, y=-3..3, z=-3..3)`
and Maple will produce the figure at right (this time presented full size from
the Maple session used to generate these graphics).

Notice that the different surfaces being simultaneously plotted in the one
`implicitplot3d` are enclosed in curly braces {...} and separated by
commas. The same idea can be used without resorting to individually labelling
each constituent equation. For example, if we wished to plot the three level
surfaces *f*(*x*,*y*,*z*) = -1,
*f*(*x*,*y*,*z*) = 0 and
*f*(*x*,*y*,*z*) = 1
for the function *f*(*x*,*y*,*z*) = *x*^{2}
- *y*^{2} + *z*^{2}, then first define the function
in the command window by typing `f:=(x,y,z)->x^2-y^2+z^2` and then issue
the command `implicitplot3d({f(x,y,z)=-1, f(x,y,z)=0, f(x,y,z)=1}, x=-1.2..1.2,
y=-1.2..1.2, z=-1.2..1.2)` to produce the striking figure at the right (or above,
depending on your browser and the width you've selected for the window).
As before, if you use the mouse to rotate the surfaces, additional insight can
be had into how these surfaces are placed in space (in this case, a hyperboloid
of one sheet wraps around a cone through the origin which in turn has each nappe
containing one component of an hyperboloid of two sheets).

Maple can also plot parametrised surfaces. For example, for the surface
with chart (or patch)

where

The result is shown below.

Happy plotting!

The `plots` library contains other specialised tools for plotting.
Here, we just mention the use of the gradient plotting function `gradplot`.

If you have not done so, load the `plots` library into Maple by typing
the command `with(plots);` into the command window. Then try the command

gradplot(x^3*y^2/(x^2+y^2),x=-2..2,y=-2..2);

Maple responds by generating a plot of the gradient vector field associated
with the function (in this case, the function is
*x*^{3}*y*^{2}/(*x*^{2}
+ *y*^{2})):

Some additional insight into this vector field can be seen by plotting the
function and viewing it from several angles. Use the command

plot3d(x^3*y^2/(x^2+y^2),x=-2..2,y=-2..2,axes=BOXED);and view it from several different angles to try to reconcile the gradient field plot with the surface plot you see.

Maple has a library of functions for use in manipulating differential
equations, `DEtools`. Load this now:

> with(DEtools); [DEnormal, DEplot, DEplot3d, DEplot_polygon, DFactor, Dchangevar, GCRD, LCLM, PDEchangecoords, RiemannPsols, abelsol, adjoint, autonomous, bernoullisol, buildsol, buildsym, canoni, chinisol, clairautsol, constcoeffsols, convertAlg, convertsys, dalembertsol, de2diffop, dfieldplot, diffop2de, eigenring, endomorphism_charpoly, equinv, eta_k, eulersols, exactsol, expsols, exterior_power, formal_sol, gen_exp, generate_ic, genhomosol, hamilton_eqs, indicialeq, infgen, integrate_sols, intfactor, kovacicsols, leftdivision, liesol, line_int, linearsol, matrixDE, matrix_riccati, moser_reduce, mult, newton_polygon, odeadvisor, odepde, parametricsol, phaseportrait, poincare, polysols, ratsols, reduceOrder, regular_parts, regularsp, riccati_system, riccatisol, rightdivision, separablesol, super_reduce, symgen, symmetric_power, symmetric_product, symtest, transinv, translate, untranslate, varparam, zoom]

The command `DEplot` is especially useful in the early part of the
study of differential equations.

For example, to build a direction field for the DE *dy*/*dx* = *x*^{2} - *y*^{2}
over a grid in the *x*-direction from -4 to 4, and in the *y*-direction
from -3 to 3, enter:

> de := D(y)(x) = x^2 - y(x)^2; 2 2 de := D(y)(x) = x - y(x) > DEplot(de,y(x),x=-4..4, y=-3..3, arrows=THIN,scaling=constrained);

The first line of input is the statement of the differential equation in
Maple terms, with *y*'s dependence on *x* explicitly stated. The
derivative is expressed as `D(y)(x)`. The entire DE has been labelled
as `de` so that we don't have to re-type in subsequent commands.

The `DEplot` command is shown with a number of options (use
`?DEplot` to see more), and with an X/Windows Maple session running,
you will obtain an attractive plot of the direction field for this DE.

A slight change to this `DEplot` command will also graph solutions
to initial value problems (IVPs). Instead of the `DEplot` we used above,
issue the command:

Maple will produce a direction field plot again over the same grid in the
*xy*-plane, but now with a curve superimposed on the grid which shows
the solution to the IVP with initial data *y*(-2) = 0.

`DEplot` can be used with coupled systems of differential equations in
much the same fashion. Suppose we want to analyse the system (a competition
model)

(

The system can be described by the Maple definition

To plot the direction field with solution curves issuing, at *t* = 0,
from points (*N*_{1}, *N*_{1}) = (2,1), (6,1), (6,6)
and (1,7), we would use `DEplot` in the form

> DEplot(de2, [N1(t),N2(t)], t=0..5, > {[N1(0)=2,N2(0)=1],[N1(0)=6,N2(0)=1], > [N1(0)=6,N2(0)=6],[N1(0)=1,N2(0)=7]}, > N1=0..8, N2=0..8);

Maple then obligingly produces the figure displayed at the right (it will squawk, however, about variable names).

From the
illustration produced, we can clearly see the equilibrium point "attracting"
solutions issuing from different parts of the
*N*_{1}*N*_{2}-plane. The equilibrium point, by the
way, is readily found to be (10/3, 10/3), and the lines in the first quadrant
for which either (*d*/*dt*)*N*_{1} = 0 or
(*d*/*dt*)*N*_{2} = 0 are easily determined as

*N*_{2} = 10 - 2*N*_{1}

and

*N*_{2} = 5 - *N*_{1}/2,

respectively.

If we alter our last DEplot command to

> DEplot(de2, [N1(t),N2(t)], t=0..5, > {[N1(0)=2,N2(0)=1],[N1(0)=6,N2(0)=1], > [N1(0)=6,N2(0)=6],[N1(0)=7,N2(0)=1]}, > N1=0..8, N2=0..8,scene=[t,N1]);(i.e., we add the parameter "scene=[t,N1]" at the end of the command) then instead of producing the direction field plot we had obtained before, we now get plots of

Maple can also exactly solve limited classes of DEs (and produce numerical
solutions, if desired). For example, to solve the second order DE *y*'' - *y*'
- 2*y* = *x*, you could issue the commands:

> eq := (D@@2)(y)(x)-D(y)(x)-2*y(x)=x; (2) eq := (D )(y)(x) - D(y)(x) - 2 y(x) = x > dsolve(eq, y(x)); bytes used=5215952, alloc=2358864, time=2.53 y(x) = 1/4 - 1/2 x + _C1 exp(2 x) + _C2 exp(-x)

The `dsolve` command is the relevant tool here. In the definition of
the DE (which here is labelled "eq"), you can see how to express a second-order
derivative. In the solution Maple was able to furnish, you'll notice the
expression of two arbitrary constants `_C1` and `_C2`. This is
what we would expect to happen in the solution of a second order equation. For
`dsolve` output in solving a first-order equation, we would anticipate
the presence of a single arbitrary constant in the general solution.

Maple can be a useful tool for exploring properties of sequences and series.
To illustrate, let us look at a *p*-series with *p* = 2. Define the sequence
{1/*n*^{2}} by

Maple responds by pretty-printing the definition of the sequence. To see the first ten terms of this sequence, use the sequence command

Plotting is a little more involved. First, we generate a list of the
sequence elements we want to plot:

Of course, you could call the list of ordered pairs (

The result is a graph like that below.

If you consult Maple's Help on the plot command, you will see other options available to you. The first range in the plot command,

Maple can also do limits. We know that 1/*n*^{2} goes to 0
as *n* tends to infinity; so does Maple:

Maple responds by pretty-printing the limit. To get a value, next type

The percent sign is Maple shorthand for the output of the previous command. In this case, you should see Maple correctly answer "0" for the value of the limit.

To sum elements of a sequence, type

Maple pretty-prints the sum and to see the value of this partial sum, issue the command

Maple responds with the exact value of the sum, expressed as a fraction. To obtain a decimal approximation of this fraction, next issue the command

This tells Maple to use the machine's floating point arithmetic to compute the fraction, calculator style. Occasionally, Maple is also able to sum an infinite series. For the sum of the full

Maple again pretty-prints the series, and to see if Maple can calculate a value for the sum of the series, try

In this case, Maple can evaluate the sum of the series, and responds with a pretty-printed exact value. To obtain a decimal approximation to this, again issue the command

If Maple cannot evaluate a series, it won't and will let you know.
Sometimes, Maple can determine if a series diverges, too. For example, define
the terms in the harmonic series by

As usual, Maple pretty-prints the function definition. Then try summing the harmonic series:

Maple pretty-prints the series, but now if you issue the command

What does Maple do if a series' divergence or convergence can't be determined?
Try this exercise: define the sequence of alternating 1s and (-1)s by

Then trying summing it:

As expected, the series is pretty-printed. What results now if you issue the command

You can use the `Limit` command to aid you in applying convergence tests.
For example, to apply the ratio test to the series of terms given by

try using the

followed by