Ralph Freese and David A. Stegenga

University of Hawaii at Manoa

In this course you will learn to use the computer mathematics program DERIVE. This program, along with others such as Maple and Mathematica, are very powerful tools for doing calculus. They are capable of doing exact computations with arbitrary precision. This means that you can work with numbers of any size or number of decimal places (most spreadsheets only use 10-20 significant digits). These programs can simplify mathematical expressions by canceling common factors and doing other algebraic operations. They can do symbolic calculus such as differentiation and integration, solve equations and factor polynomials. When possible these programs solve these problems exactly and when exact solutions do not exist, such as factoring high degree polynomials or integration of some non-polynomial expressions, then numerical methods are applied to obtain approximate results.

Probably the most important numerical technique is to graph and compare functions. This will be a key feature of the labs. Typically we will explore a topic by first graphing the functions involved and then trying to do symbolic calculus on them using the insight gained from the picture. If the problem is too difficult algebraically we then try numerical techniques to gain further insight into the problem. It is this combination of graphics, algebra and numerical approximation that we want to emphasize in these labs.

Calculus is a hard subject to learn because it involves many ideas such as slopes of curves, areas under graphs, finding maximums and minimums, analyzing dynamic behavior and so on. On the other hand, many computations involve algebraic manipulations, simplifying powers, dealing with basic trig expressions, solving equations and other techniques. Our goal is to help you understand calculus better by concentrating on the ideas and applications in the labs and let the computer do the algebra, simplifying and graphing.

Another important goal of the lab is to teach you a tool which can used from now on to help you understand advanced work, both in mathematics and in subjects which use mathematics. There are many features such as matrices and vector calculus which we will not discuss but can be learned later as you continue with your studies in mathematics, physics, engineering, economics or whatever. Any time you have a problem to analyze you can use the computer to more thoroughly explore the fundamental concepts of the problem, by looking at graphs and freeing you from tedious calculations.

This chapter contains a brief introduction on how to use DERIVE. We suggest you sit down at the computer and experiment as you look over the material. DERIVE is very easy to learn thanks to its system of menus. The few special things you need to remember are discussed below and can also be found using the help feature in DERIVE.

At any IBM-PC computer in the lab
start DERIVE by just typing `derive`. There will be several menu
items at the bottom of the screen. We will say more about these later.
The one that is highlighted is **A**uthor. Choose this either by
hitting the `Enter`

key or by typing `a` (or
`A` but uppercase doesn't matter to DERIVE on input so
don't bother). This allows you to enter a mathematical expression.

In this manual we use a typewriter like font, eg.,
`a(b + c)` to indicate something you might type in.
We use a sans serif
font for special keys on the keyboard like `Enter`

(the
return key) and `Tab`

.
DERIVE has easy to use menus described below. Each menu item has
one capital letter (usually, but not always, the first). You can
choose that menu item by pressing that letter. We denote this by
showing the capital letter in bold; for example, **S**implify or
so**L**ve.

After selecting **A**uthor, you enter a mathematical expression, i.e.,
you type it in and then press the `Enter`

key. You enter an
expression using the customary syntax: addition `+`-key,
subtraction `-`-key, division `/`-key, powers
`^`}-key and multiplication `*`-key (however;
multiplication does *not* require a `*`, i.e., `2x` is the same as `2*x`). DERIVE then displays it on the
screen in two-dimensional form with raised superscripts, displayed
fractions, and so forth. You should always check to make sure the
two-dimensional form agrees with what you thought you entered
(see **Editing** below to see how to correct typing errors).
Table 1 gives some examples.

Note from (3) and (4) and from (6) and (7) of Table 1 that
it is sometimes necessary to use parentheses. Also note in (8), that
to get the fraction you want, it is necessary to put parentheses around
the numerator and denominator. See what happens if you enter (8)
without the parentheses. Also try entering some expressions of your
own. (9) and (10) show you two ways to enter square roots.
(`Alt-`

`q` means hold down the `Alt`

-key and
press `q`.)

To get the symbol for infinity
, type `inf`. To get the symbol for the Greek letter , type `pi` or `Alt-`

`p`. Euler's constant *e* is
displayed by DERIVE as ê. It is obtained by typing either
`Alt-`

`e` or `#e`. It is important to
distinguish this from just *e*, which DERIVE takes to just be some
constant like *a*. To get the functions *arctan(x)*, *arcsin(x)*,
etc., you type `atan x` and `asin x`.

The help feature can be used at any time to remind you how to type
these constants. Just select **H**elp and then select either
constants or functions. For now you can click to see the list of special constants in the Derive reference. The list of functions is very large and you
might want to avoid that in the beginning.

When you are `**A**uthoring' an expression, you can use the arrow
keys, `End`

-key and `Home`

-key to move forward and back.
The Delete key will delete characters. The `Insert`

-key toggles
between insert and overstrike mode. If you press the `F3`

-key,
the expression highlighted on the screen will be inserted; `F4`

will insert it with parentheses around it. You can use the up and down
arrows to change which expression is highlighted on the screen. The
help feature explains these techniques, just select **H**elp and then
choose **E** for edit. You can see this now by clicking edit. Try it.

The displayed expressions are numbered. You can refer to them as
`#n`. So, for example, with the expressions
in Table 1, you could
get *sin(x)/x²* by **A**uthoring `#5/#2`.

When you start DERIVE it is in a character mode. This means it
treats each single character as a variable, so if you type
`ax` DERIVE takes this to be *a* times *x*. This mode is what
is best for calculus. The exception to this are the functions
DERIVE knows about. If you type `xsinx`, DERIVE knows you
want *x sin(x)*. Actually on the screen you will see *x
SIN (x)*: DERIVE displays all variables in lower
case and all functions in upper case.

After you enter an expression, DERIVE displays it in two-dimensional
form, but does not simplify it. Thus, integrals are displayed with the
integral sign and derivatives are displayed using the usual notation.
To simplify (that is evaluate) it, choose **S**implify from the menu
by pressing the `s`-key. You can have the expression directly
evaluated by pressing `Ctrl-Enter`

instead of `Enter`

when you **A**uthor an expression. It is usually best not to bother
with this fast simplification technique since there is a tendency to
forget what was simplified when you look back at you work later.

DERIVE uses exact calculations. If you **A**uthor
`Alt-`

`q 8`, 8 will be displayed. If you **S**implify this, you get 22. If you want to see a decimal
approximation, choose the appro**X**imate menu item by pressing the
`x`-key. See Figure 1 for several examples.
Notice that the number of places can be changed by choosing
**O**ptions/**P**recision and changing **D**igits by pressing the
`Tab`

-key and entering a number.

An important problem is to find all solutions to the equation *f*(*x*)=0.
If *f*(*x*) is a quadratic polynomial such as , then this
can be done using the quadratic formula or by factoring. In DERIVE
we choose **F**actor after highlighting the above expression, press
the *Enter*-key and ignore the other options for now. The result
is that *f*(*x*) = (*x*+1)(*x*-2). This means that the roots of *f*(*x*) are
*x*=-1, 2, i.e., these are the only solutions to *f*(*x*)=0. We can also
do this in DERIVE by choosing **S**olve with the quadratic expression
highlighted. The quadratic formula is used to solve for the roots so
it is possible the answer will involve square roots (and even complex
solution, e.g., has no *real* roots but it does have two
complex ones, namely, *x = ± i*,
).

If *f*(*x*) is not a quadratic polynomial then DERIVE may not be able to
factor it; nevertheless, it may be able to solve the equation *f*(*x*)=0.
As an example, *sin x = 0* has infinitely many solution where
*m* is any integer. If we use DERIVE to solve this equation it gives
the 3 solutions corresponding to *m*=-1,0,1 (these are the principle
solutions and all others are obtained by adding or subtracting multiples
of ).

Finally, the simple equation
cannot be solved exactly
in DERIVE although it is obvious that *x*=0 is one solution and by
viewing the graph we see another one with . In order to
approximate this solution we need to choose **O**ption/**P**recision
and then set Mode to Approximate (by pressing the `a`-key).
Then, when we choose **S**olve we are asked for a range of *x*'s
(initially it is the interval [-10,10]). Since we have (at least) 2
solutions we should restrict the interval to say [.5,1] which seems
reasonable based on the graphical evidence. The result is that DERIVE
gives the solution *x*=.876626. We will discuss how this computation
is done later in Chapter 5.

If you have an expression like
and you want to
evaluate this with *x=3* or if you solved an equation *f(x)=0* and want to substitute in that value of *x*, you **A**uthor the expression
and then choose **M**anage/**S**ubstitute. This will ask you for
the expression. It will guess the highlighted expression, which is
usually what you want so you can just hit return in this case. It
then gives the name of a variable occurring in the expression. In
this example *x* is the only variable. You then type over *x* with
the value you want to substitute, in this case *3*. You can then
**S**implify or appro**X**imate. You do not have to substitute a
number for *x*; you can substitute another expression.

This menu item
is very important for us. After pressing the `c`-key, you get a
submenu with
**D**ifferentiate,
**I**ntegrate,
**L**imit,
**P**roduct,
**S**um,
**T**aylor and
**V**ector.
After you have **A**uthored an expression, you can differentiate
it by choosing **C**alculus, then choosing **D**ifferentiate.
It will ask you
what expression you want to differentiate and with respect to which
variable and how many times to differentiate,
but it usually guesses right so you can just hit `Enter`

three times.

To integrate an expression, first **A**uthor it, then choose **C**alculus, then **I**ntegrate. It will ask you what expression to
integrate; it will guess you want to integrate the highlighted
expression. It will then ask you what variable you what to integrate
over; again it will probably guess right. Then it will ask for the
limits of integration. If you want an indefinite integral, just press
`Enter`

. For a definite integral type in the lower limit, then
use the `Tab`

-key to move to the upper limit field and enter it.
See Figure 1 for several examples using **D**ifferentiate and **I**ntegrate on the **C**alculus menu.

Figure 1. Using the **C**alculus menu.

The options **C**alculus/**L**imits is similar to the above. To solve

you must enter the expression, then choose **L**imits from the **C**alculus menu. You must tell DERIVE the variable (which is *x*) and
the limit point which is *-1* since *x-1*. Then **S**implify to
get the answer. In a similar manner DERIVE does summation and
product problems. Special notations are used; namely,

See Figure 2 for some examples. Note that in Figure 2

Let us discuss the summation notation which may be new to you. If are numbers then

The symbol on the left, , is read as ``the sum of
as *i* runs from 1 to *n*.''
Often is a formula involving *i*. So

You can do this computation in DERIVE using the **S**um option on the
**C**alculus menu. Just **A**uthor `i^2` then choose
**C**alculus, then **S**um. Follow the menu and let *i* start at 0
and end at 5. **S**implify to get 55. As an interesting aside,
edit the above sum and have DERIVE **S**implify
to get the formula:

This formula is used in many calculus texts to evaluate certain Riemann sums.

Figure 2. Examples of **L**imits, **P**roducts and **S**ums

The option **C**alculus/**T**aylor will be explained later in
Chapter 10.

Expression/Action | Type: | Menu: | ||

e |
Alt-e or #e |
|||

Alt-p or pi |
||||

, | inf, -inf | |||

The square sign: | alt-q | |||

, | ln x , log(b, x) | |||

Inverse trigonometric functions | asin x, atan x, etc. | |||

dif(f(x), x) | Calc/Diff | |||

dif(f(x), x, n) | Calc/Diff | |||

int(f(x), x) | Calc/Int | |||

int(f(x), x, a, b) | Calc/Int | |||

Simplify an expression | s | Simplify | ||

Approximate | x | Approximate | ||

Cancel a menu choice | Esc-key |
|||

Move around in a menu | Tab-key |
|||

Change highlighted expression | up, down arrow keys | |||

Insert highlighted expression | F3 ,
F4 with ( )'s |

Supposed you wanted to graph the function *x sin x*. You would first
**A**uthor this and then choose **P**lot. You then get the submenu:
**B**eside, **U**nder, **O**verlay. You will usually want **B**eside. After choosing this (by pressing the `b`--key or
pressing the `Enter`

key), you are asked for the column. You can
press `Enter`

to get column 40. This will split the screen into
two windows: an Algebra window on the left and a Plotting window on the
right. These windows each have a number in their upper left
hand corner. You
can tell which window you are in by which number is highlighted. You
can switch windows by pressing the `F1`

-key or choosing
**A**lgebra when you are in the plot window or choosing **P**lot from the
algebra window.

After you have created the plot window, you are in that window. You
need to choose **P**lot from that window to actually do the
plotting. This will plot the expression highlighted in the algebra
window. You can plot several functions in the same plot window.
Move to the algebra window, use the up and down arrows to highlight
the expression you want to plot, switch to the plot window (by
pressing `F1`

or choosing **P**lot), and then choose **P**lot from
the plot window. Now both expressions will be graphed. You can plot
as many as you want this way. The plot window also has a **D**elete option for removing some or all of the expressions to be
plotted.

When you plot, there is a small crosshair in the plot window,
initially at the *(1,1)* position. You can move it around using the
arrow keys. The coordinates of the position of the cross are give
at the bottom of the screen. This is useful for such things as
finding the coordinates of a maximum or a minimum, or where two
graphs meet. The **C**enter option will redraw the graph so that
the cross is in the center of the window. You can use the **Z**oom
option to move in or out.

We mentioned above how to plot any number of graphs simultaneously by
repeatedly switching between the algebra window and the graphics
window. Another technique for plotting three or more functions is to
plot a vector of functions. This just means **A**uthoring a
collection of functions, separated by commas and surrounded by
brackets.
For example, **P**lotting the expression `[x, x^2,
x^3]` will graph the three functions: *x*, *x²*, and *x³*. In
order to plot a collection of individual points one enters the points
as a matrix, for example **A**uthoring the expression
`[[0,0], [1,1], [2,0]]` and then **P**lotting it will graph
the 3 points: *(0,0)*, *(1,1)* and *(2,1)*. In the graphics window
choose **O**ption}/**S**tate then press the `Tab`

key
followed by **C**onnected. Then choosing **P**lot again will
graph the 3 points above but also draw the line segment between them.
See the Figure 4 where each of these techniques is
demonstrated. The color of a plot is controlled by choosing
**O**ption/**C**olor/**P**lot and then making sections
on the menu.

Click 2D-Plot to see a summary of these of these commands or choose **2D-Plotting** for the online Help menu.

Figure 5. Using **P**lot for graphics

The main tools for manipulating the view of your graph are:

- Use
**Z**oom to zoom in or out on either the*x*or*y*-axis or both. You can also use*F9*to zoom in and*F10*to zoom out. You can choose**S**cale to control the scale exactly. - Use
**C**enter to reposition the view so that the crosshair is in the center. -
**R**ange can be used to control the range. By changing the four numbers,**L**eft,**R**ight,**B**ottom, and**T**op, you can control where the view window is. You can either type in the values you want or use the arrow keys to visually change a range box on the screen. - Choose
**S**cale/**A**uto get auto-scaling mode. In this mode DERIVE chooses a good*y*-scaling to fit your graph for you. - You can get the crosshair to follow along the curve (it
changes to a small square when it does this) by choosing
**O**ption/**S**tate and choosing**Y**es in the**T**race field. If you have more than one graph, the up and down arrows will change which graph the cursor is on. - For some graphs you might need more accuracy in the plotting
to see what is going on, for example
*x SIN(1/x)*.**O**ptions/**A**ccuracy controls this. - One easy way go back to the default coordinates in a plot
window is to choose
**W**indow/**D**esignate/**2**d-plot.

Effect: | Type: | Menu: |

Switch windows | F1 |
Algebra or Plot |

Zoom in, zoom out | F9, F10 |
Zoom |

Move Crosshair | 4 arrow keys | Move |

Move crosshair quickly |
Ctrl- , Ctrl- , PgUp,
PgDn |
Move |

Center on crosshair | c | Center |

change the scale | s | Scale |

If you **A**uthor `f(x)`, DERIVE will put *f x* on the
screen because it thinks both *x* and *f* are variables. If you wish to
define *f(x)=x² + 2x + 1* for example, you could **A**uthor
`f(x) := x^2 + 2x + 1`, or you could choose **D**eclare
from the main menu at the bottom, then choose **F**unction, and then
fill in the information asked for. See Figure 4.

Figure 4. Examples of **D**eclare, **S**implify and **A**pproX

Constant are treated just like functions except there are no
arguments. In order to set *a = 2* for example you type `a
:= 2 pi`. Then, whenever you simplify an expression containing *a*,
each occurrence is replaced with *2*. In many problems you find
it useful to have constant names with more than one letter or symbol,
which is the default in DERIVE. For example variables with names like
`x1`, `y2`, etc. will be used frequently as our names like
``gravity". This can be done by changing to *word* input mode by
choosing **O**ptions/**I**nput/**W**ord. In this mode variables can
have several letters but when in word input mode you have to be more
careful with spaces: to get you should enter `a x^2`,
not `ax^2` (otherwise will be treated as
a variable). DERIVE indicates multiplication with a centered dot. So
on the screen you should see , not .

An interesting function defining technique is provided by the
factorials. For *n = 1, 2, ...*
we define *n*-factorial,
denoted by *n*!, as

and for completeness we define 0! = 1. These numbers are important in
many formulas, e.g., the binomial theorem. One observes the important
*recursive* relationship *n*! = *n* (*n*-1)! which gives the value of
*n*! in terms of the previous one (*n*-1)!. Thus, since 5! = 120 we
see immediately that 6!= 720 without multiplying all 6 numbers together.

In DERIVE we can recursively define a function `F(n)`
satisfying *F*(*n*)=*n*! by simply typing

`F(n) := IF(n=0, 1, n F(n-1))`

!

We will give several other examples of this technique in the text.

In calculus functions are typically described by giving a formula
like but another technique is to describe the values
restricted to certain intervals or with different formulas on different
ranges of *x*-values. As an example, consider the function

which defines a unique value *f*(*x*) for each value of *x*. The problem
is how do we define such a function using DERIVE?

One basic technique is to use the logical `IF` statement.
The syntax is `IF(test, true, false)`. For example, if we enter
and simplify `IF(1 < 2, 0, 1)` we get 0
whereas `IF(1 = 2, 0, 1)` simplifies to 1.
Now our function above is entered as:

`f(x):= IF(x < 1, 2x + 1, IF(x <= 2, x^2, 4))`

Notice how we use nested `IF` statements to deal with the three
conditions and that with four conditions even more nesting would be
required. Now once *f*(*x*) has been defined we can make computations such
as **S**implifying `F(1)` (should get 1), computing limits such
as the right-hand limit (should get *x²* =x^2 evaluated
at *x*=1) or definite integrals using appro**X** to simplify. We can
also plot *f*(*x*) in the usual manner described in the previous section.

Notice from Figure 0.5 that the function *y*=*f*(*x*) is continuous
at all . At *x*=1, both left and right limits exist but they
are not equal so the graph has a jump discontinuity.

As the number of table entries increases we are forced into using nested
`IF` statements and the formulas become quite difficult to read
and understand. An alternate approach is to use the DERIVE function
`CHI(a,x,b)` which is simply

Then except for *x* = 1 our function *f*(*x*) above satisfies:

`F(x):=(2x+1) CHI(-inf,x,1) + x^2 CHI(1,x,2) + 4 CHI(2,x,inf)`

Vectors are quite useful in DERIVE, even for calculus.
The next section shows how they are used in plotting.
To enter the 3 element vector with entries *a*, *b*, and *c*,
**A**uthor `[a, b, c]`. It is important to note the square
brackets which are used in DERIVE for vectors; commas are used to
separate the elements.

DERIVE also provides a useful function for constructing vectors.
The `vector` function is
a good way to make lists and tables in DERIVE.
For example, if you **A**uthor `vector(n^2, n, 1, 3)`,
it will **S**implify to `[1, 4, 9]`.
The form of the `vector` function is `vector(u,i,k,m)` where
`u` is an expression containing `i`. This will
produce the vector *[u(k),u(k+1),...,u(m)]*. You can also use
the **C**alculus/**V**ector menu option to create a vector. So,
for example, to obtain the same vector as before, you **A**uthor
`n^2` and highlight this. Now choose
**C**alculus/**V**ector and setting `Variable: n` (not
`x`), `Start: 1` and `End: 3`.

A table (or matrix) can be produced by making a vector with vector
entries. If we modify the previous example slightly by replacing the
expression `n^2` with `[n, n^2]` and then repeating
the above we get `[[1, 1], [2, 4], [3, 9]]` which displays as a
table with the first column containing the value of the index *n* and
the second column containing the value of the expression *n²*. This
is a good technique for studying patterns in data. See
Figure 6 for some examples. Click VECTOR for more information on this function.

Figure 6. Using the **C**alculus/**V**ector command

We have already seen two important applications of vectors in Section 0.10; namely,

- Plotting a vector of 3 or more functions plots each of these functions in order.
- Plotting a vector of 2-vectors will plot the individual points , .

We will have other application that will require us to refer to the
individual expression inside of a vector. This is done with the DERIVE
`SUB` function (which is short for *subscript*). Thus, for
example, `[a,b,c] SUB 2` simplifies to the second element *b*.
DERIVE will display this as which explains the name.
For a matrix or vector of vectors then double subscripting is used so
that, for example, if

then **A**uthoring `y SUB 2 SUB 1` will be displayed
as and simplify to 3 (because it's on row 2 and column 1).

You can save your expressions to a floppy
disk or the hard drive H: and come back later to continue
working on them. To
do this, put a floppy in say the A: drive and, from the algebra
window, choose **T**ransfer, then choose **S**ave,
then **D**erive and then enter a file name
such as A:LAB5 or A:LAB5.MTH or H:LAB5 for the hard drive.
If you don't type the
extension .MTH; DERIVE will add it anyway. Later, you
can reenter these expressions by starting DERIVE and
choosing
**T**ransfer, then
**L**oad, then
**D**erive, and then entering the file name A:LAB5
or A:LAB5.MTH. If you forget the name of your files just type
either A: or H: and press the *F1*-key to select from a listing
of your files.

During the course of your session with the computer you will make lots
of typing and mathematical mistakes. Before saving your work to a file or
before printing and turning your lab in for grading you should erase the
unneed entries and clean up the file. You do this with the **R**emove
and the mo**V**e commands. You should practice these commands on some
scratch work to make certain you understand them. There is also
an **U**nremove command for correcting mistakes. One way to use the
mo**V**e command is to write comments in the file and placing them
before computation. Many of the *.MTH files that we wrote for this lab
manual use this technique. To do it, just **A**uthor a line of text
enclosed in double quotes, for example, `"Now substitute x=0."`.

You can print all the expressions in the algebra window (even the ones
you can't see) or you can do a screen dump which will print the whole
screen including your graphs.
If you are working at home, be sure you to first
configure your printer (this is not necessary in the Bilger labs). Choose **T**ransfer, then **P**rint, then **O**ption. You will probably want to
choose **S**ome for the range, **E**xtended for the character set and
**D**otmatrix for the printer. The next menu you can ignore unless
you want sideways printout (**L**andscape), just press
*Enter*. Now choose **P**rinter, then choose either **E**xpressions (to print the expressions), or **S**creen or **W**indow.
Printing the screen or window is quite slow, so only do it when you
want to include a graph.

Usually you just want to print a graph. To print just a window with
a graph in it, make that its the current window, and then press
*Shift-F9*. Typically, students turn in the labs by hand
writing most of the exercise answers and then including some graphs
using this method. Another technique for longer labs is to make a file
as discussed above and then printing the file. Some combination of hand
writing and printouts should be the most efficient.

You can obtain on-line help by choosing **H**elp. This help feature
provides information on all DERIVE functions and symbols. Suppose that
you want to know how to enter the second derivative of a functions *f*(*x*)
by typing. For example, maybe this expression is to be used as part of
another function. There are three techniques for learning how to do this.

The first method is to use the menus with **C**alculus/**D**ifferentiate
to enter the second derivative by typing 2 after the Order entry.
Then, press **A**uthor followed by the pull-down key *F3* which
will enter DERIVE's way of typing the expression, in this case it's
`DIF(g(x),x,2)`. The second method is to use the online help,
either by choosing **H**elp on the main menu or pressing *F1* while
authoring an expression. On then, selects *F* (for functions) and
then by pressing *Enter* several times one finds the appropriate
page of explanations.

The third method is use our Web page, see the index
at the top of this file,
which also is linked to DERIVE's online help file. The advantage of
this last method is that the relevant page, once found, can be
kept available for further consultation. One just flips between
the DERIVE window and the help window by pressing
the *Alt-Tab* or *Alt-Esc* keys on your PC.

We have included a few quick reference tables with common keys used
for entering things like , and Euler's
constant *e*. Table 0.2
gives a summary
of commands that can be issued from the Algebra window and
Table 0.3 gives a summary
of useful commands that can be used in the Plot window.

Here are a few common mistakes that everyone
makes, including the authors, every once in a while. It just takes
practice and discipline to avoid these problems, although, it is human
nature to blame the computer for *your own* mistakes. Fortunately,
the computer never takes insults personally and it *never* takes revenge
by creating sticky keys, erasing files, locking up, or anything else like
that ... or does it?

- I tried to
**P**lot the line*ax*+*b*and instead I got an error message about ``too many variables". What did I do wrong? You must define*a*,*b*to have numerical values, otherwise DERIVE treats your function as*f*(*a*,*b*,*x*) which it can not plot. - I tried to
**P**lot the family of parabolas and instead I got a picture of some surface. What did I do wrong? Same problem as above, except now DERIVE is plotting a surface*z*=*f*(*x*,*c*). You probably want to enter a vector of functions such asand`VECTOR(x^2 + c, c, 0, 4)`**P**lot this vector of 5 functions: , , , , and . - I entered the expression correctly, but when I
substituted
*x*=9 and simplified I got . What happened? You took the square root of a negative number which is not allowed when you are working with the real number system. DERIVE treats this as a computation with complex numbers and uses the complex number*i*(where ). - I so
**L**ved for the 3 roots of the cubic and I got*x*=2 which I guessed from the graph but the other two solutions were and . Where do these last two come from? If you**F**actor the cubic instead of using so**L**ve you would get . The complex solutions come from that quadratic term. In calculus, we just ignore those complex solutions. For example, in approximate mode (use the**O**ption/**P**recision menu) solving the above cubic will give only real solutions. - I differentiated and I got , what's wrong?
Nothing, DERIVE is treating the letter
*e*as an ordinary symbol like*a*or*b*. You probably wanted Euler's constant*e*which is entered with*Alt-e*or*#e*. - I tried to
**A**uthor the inverse tangent function`arctan x`and I got instead. What's wrong? DERIVE recognized the`tan x`part but treated the other symbols as individual constants. Use`atan x`. - I entered the vector by typing
`[v1,v2,v3]`and I got instead. What happened? You must use*word input mode*in order that`v1`is treated as a single variable. To do this choose**O**ption/**I**nput and select Word mode. - I tried to
**A**uthored`x^n`and I got a syntax error! How was this possible? The problem here is that either*x*or*n*is previously defined as a function. For example, maybe or maybe is defined in the file on Newton approximation. You can check on this by scrolling up to find the definition or else if you are sure that neither definition is needed you can select**T**ransfer/**C**lear and then choose**F**unctions. This will clear*all*function definitions. If instead, you know the problem is that*x*(*t*) is defined and you want to erase just that definition, then**A**uthor`x:=`. - I entered and simplified and I got
`SIN([2 ])`instead, what happened? You**A**uthor`sin[2pi]`instead of`sin(2pi)`. DERIVE treats square brackets not as parenthesis but as a device for defining*vectors*, see Section 0.13. - I tried to show that , instead DERIVE returns a question mark indicating that it can't do this problem. What's wrong? Same as above, check your parenthesis. This last example is a little tricky because DERIVE uses square brackets to display some expressions, when in fact, those expressions must be entered with parenthesis.