From: edp@math.zko.dec.com (Eric Postpischil)
Subject: Info about Derive -- symbolic math package for HP-95
Reply-To: edp@math.zko.dec.com (Eric Postpischil)
Organization: Digital Equipment Corporation
Date: Tue, 5 May 1992 15:41:44 GMT
Status: OR

Here's some information I've written up about Derive, a symbolic math
package available on ROM for the HP-95.  I am appending the help file; it
gives an overview of what is in Derive.  One person commented that it does
not need a killer machine to do killer work -- I have found that to be true.
I am quite comfortable using it on the HP-95.  At times it pauses to do garbage
collection or memory expansion (including one time shortly after it is begun),
but in general it runs in reasonable time.  Perhaps my biggest gripe is that
display of long numbers or formulae is cumbersome; the user must scroll the
display, and one could lose track of one's place while copying down the
result.  The length of a display line is 36 characters, and each press of the
scroll key causes a 12-character shift, so three will bring up a new screen
-- except that at the end, the shift is less than 12, so you could lose your
place and have to match up the copied numbers with the displayed numbers. 
Still, this isn't a big problem, and one can always save long results in a
file for editing or printing outside of Derive.  I haven't encountered any
bugs yet.

I shouldn't have started with the gripes; the features well outweigh them.
I was quite amazed at several points in the manual; e.g., by the symbolic
matrix capabilities or by it reducing atan(2+sqrt(3)) to 5pi/12.  If there's
interest, I may try to load the demos and transfer to results to my
workstation for posting.

The main menu has a bunch of commands, which can be selecting using the
space bar and Enter or single letters:  Author, Build, Calculus, Declare,
Expand, Factor, Help, Jump, soLve, Manage, Options, Plot, Quit, Remove,
Simplify, Transfer, moVe, Window, and approXimate.

Author prompts you for a new formula.  The syntax is very flexible; you can
enter tanx for tan(x), but pdqx is taken to be p times d times q times x.
However, if you have a declared function "pd", pdqx is taken as pd(q) times x.
If pd is a declared variable, pdqx is pd times q times x.  That is when input
is in character mode and variables are presumed to be single letters unless
otherwise declared.  But you can change to word mode and use spaces and other
delimiters to distinguish multi-character variables without declaring them.
You can make input case sensitive or not.

Pressing the F3 or F4 key inserts a previous formula into the current line,
without or with enclosing parentheses.  The pointer can be moved up and down
the list of existing formulae (everything you have entered and the results of
commands you have executed) and into subexpressions easily, so you can pick out
parts of previous formulae to enter into a new one.

The Build command lets you build previous formulae or parts thereof into a
new formula, using the operations +, -, *, /, ^, . (inner product), `
(transpose), =, ln, exp, sin, cos, and !.  Each formula is tagged with an
abbreviated description of its origin, so when the pointer is moved to a
formula you have entered, "User" appears in the lower left corner of the
screen.  Move to an expression build as the product of the formulae tagged
numbers 3 and 5 on your list, and "3*5" appears.  The result of simplifying
formula 6 is described as "Simp(6)".

Calculus lets you take a derivative, integral, limit, product, sum, or
Taylor sequence of a formula.  You can type these things in directly, but the
calculus command is an easy way to apply these things without remembering
the syntax.  Each option prompts you:  What formula to work on, what variable
to integrate or sum over, what limits, et cetera.  You can specify limits taken
from the left, right, or both, definite and indefinite integrals, products,
and sums (e.g., you can take the sum of i/2^i for i = 1 to n, or you can just
take the general sum, which returns a function analagous to the indefinite
integral).

Declare performs several functions.  You can declare a function; type in the
function name and an expression, and Derive makes it a known function.  You
can also type in a declaration with Author, which allows you more control over
the order of arguments.  Again, the syntax is flexible; if f(x,y) is declared
to be x^2+y^2, then f(3,4) is 25, but f(3) is 9+y^2 -- y is assumed to be
global.  You can declare a variable's value or its domain.  The former allows
you to make constants; the latter allows you to specify that a variable is
positive, nonnegative, real, complex, or in a real interval that you specify
with lower and upper limits (which can be infinite) and the operators < or <=.
The domain of a variable is used in various simplifications.  E.g., sqrt(x^2)
can simplify to x, abs(x), or sqrt(x^2) depending on whether its domain is
nonnegative, real, or complex.  You can also declare matrices and vectors.
This just tells Derive to prompt you for all the elements, so you can type
them more quickly than with the usual syntax.

Expand expands a formula; you can choose variables to be expanded on.

If given a symbolic formula, Factor tries to factor it.  You can specify the
amount of factoring:  trivial, square-free, rational, radical, or complex.  If
given a number, Factor finds its prime factors.

The Help is pretty flat; it's mostly a list of the available functions and
commands and pointers to their description in the manual.  You may need to
scroll through a lot of screens to find a function.  But other than that, the
Help isn't needed much; Derive is pretty simple to use.

Jump, moVe, and Remove let you manage the list of formulae.  You can delete
them, move them around, and move the pointer directly to them by tag number.

The soLve command can handle everything the HP-48 can plus cubics and quartics,
and I think it takes a good stab at other things.  For example, it can solve
quintics if it can factor the polynomial.  In approximate mode, it will use a
numerical method to approximate a solution.  You can also enter solve as a
function, which is useful in conjunction with the approximate command.  Derive
will also solve linear systems, including underspecified systems.

Most of the options in the Manage command give you a little control over
Derive's choices in symbolic manipulation.  You can specify the branches to be
used for complex functions.  (E.g., the cube root of -8 has three answers, -2
and two complex numbers.  One of the complex numbers is the principal branch.
You can tell Derive to use the principal branch, the real branch, or any one
that it finds convenient.)  You can specify whether exponential, logarithmic,
and trigonmetric functions (each class is specified individually) are to be
expanded or collected when attempting to simplify, or that Derive is to take
its own best guess.  You can specify a preference for sines or cosines or let
Derive choose.  Another function in the Manage command lets you substitute a
new expression everywhere a certain subexpression occurs in a formula.

Options lets you execute an MS-DOS command, specify the input mode as I
described earlier, turn the sound on or off, specify output notation and
precision, specify exact or approximate computations and the precision, and
specify input and output radices (from base 2 to base 36).  By default, Derive
does exact arithmetic.  Ask for 1000! and it will compute and display all
2568 digits in a minute.  Expressions involving square roots, exponentiation,
trigonmetric functions, et cetera are all handled exactly unless you request
otherwise.  If you specify approximate mode, then it will use rational
numbers to approximate.  I specified 5000 digits and asked it to approximate
pi; it took an hour to compute the result and save it in a file.

Derive does two- and three-dimensional plotting.  The plotting is powerful
and quite automated, but there is not a lot of user control.  E.g., in the
HP-48, you can specify the corners of the plot window or its center or its
scale, et cetera, whereas Derive is more limited.  In two dimensions, it is
smart enough to plot more points of a function in a region where the function
is curving sharply.  In three dimensions, it just takes a rectangular grid of
points, plots them, and draws the results, with hidden line removal (which I
think you can turn off).  Plotting is powerful, but Derive has a mind of its
own.

Simplify is a general, powerful command.  It tells Derive to go to town on a
formula.  Things like sin^2 x + cos^2 x become 1.  Oh, Derive displays
functions using drawn integrals, summations signs, raised exponents, et cetera,
but you enter them in a typed notation.  When you press F3 or F4 to enter
expressions into an author line, it enters the character version.  Simplifying
is pretty powerful, but sometimes you have to help it along by using the Manage
command to tell it which way to go with trigonmetric functions and such. 
Derive is much faster than the HP-48 at both simplification and displaying
the formulae.  You can also simplify in many cases by ending a command with
Control-Enter instead of just enter.  E.g., author an expression and press
Control-Enter, and the simplified result is presented.

The Transfer command lets you load and save formulae, merge existing files
with your current work, clear all declarations, and print results.  A number
of files are included with Derive that you can load.  There's also a Demo
option which loads a file, displaying and simplifying each expression for the
user to watch.  The included demonstrations are quite impressive.

The Window command lets you divide the screen into two or more windows.  This
is useful for having two streams of formulae or for plotting in one window
while the formulae are in another.  You can divide horizontally or vertically.
Two windows works reasonably well on the 95, and you might even get three,
but they are pretty small beyond that.

Finally, the approXimate command evaluates a single expression with approximate
mode temporarily turned on.  It's handy for things like numerical integration
or solving without changing the mode and having to change it back.  I used it
to count the number of digits in 1000! -- I authored log(1000!,10) and then
pressed X Enter.

I don't think Derive is designed for heavy statistics work.  [I wrote this
in response to a person who asked about statistics particularly.]  It does have
some minor things, like a standard deviation function.  And it has a function
that will fit a matrix of data to an arbitrary function, using least squares.
There's a file to load that defines functions like POISSON_DISTRIBUTION,
BINOMIAL_DISTRIBUTION, CHI_SQ, and some weird things I've never heard of
(POCHHAMMER, HYPERGEOMETRIC_DENSITY).  My eyes started glazing over in the
manual when it started discussing multidimensional derivatives in spaces with
arbitrary curvatures, so I'm not sure what else is in there.

Overall, I'm very happy with Derive; I recommend it.  One last thing; it
runs by itself, not with the System Manager.  If you boot with the card in
place, it will run first.  You can go into the System Manager from there, but
that uses about 2Kb of memory.  You can also go into Derive from the System
Manager, which leaves Derive with about 80Kb less memory.  I generally boot
without the card, then install the card.  That leaves Derive with less
memory when I invoke it from the System Manager, but it means all of memory
is available for the built-in applications.  If I should ever need more
memory for Derive, rebooting is easy.  However, there is one gotcha:  The
way Derive runs by itself, it leaves the serial port on, which drains your
batteries.  To fix this, put the following commands in a file called
C:\DERIVE.BAT:

	serctl/o
	cd c:\derive
	a:derive
	serctl/o
	a:ramcram b
	$sysmgr

By calling this DERIVE.BAT, the AUTOEXEC.BAT is tricked into running
C:DERIVE.BAT instead of A:DERIVE.EXE.  It turns off the serial port, sets
the default directory to C:\DERIVE (Any saves you do from Derive will go
there; loads will try there and A:\.), and runs the real A:DERIVE.EXE.
After Derive finishes, it turns off the serial port (it comes on again, and
you might leave the 95 sitting at the "Press any key to continue" message
with the power draining unless the port is turned off again), runs a program
that came with Derive that I am guessing about, and then tries to invoke the
System Manager.  If you have run Derive by rebooting, this changes the
behavior; exiting Derive goes directly into the System Manager instead of
prompting you for a choice.  If you have run Derive from the System Manager,
this last line is ignored.

If you have any questions, feel free to ask.


				-- edp



Derive Help Menu

E - line Editing commands
Editing
00000369	[This is just the raw help file, so it's got some internal
		controls in it.  Also, some of the lines are more than
		80 characters long.  -- edp]

F - Functions and constants
Functions
00001957

A - Algebra window commands
Algebra
00009807

2 - 2D-plot window commands
2D-plot
00013663

3 - 3D-plot window commands
3D-plot
00015477

U - Utility file functions
Utility
00017055

S - current State of system
State
00034494


Line Editing Commands (Section 2.4)

Special key commands:
  Backspace - delete char left of cursor
  Del - delete char at the cursor
  Enter - enter line of text
  Ctrl-Enter - enter & simplify line of text
  Esc - abort edit & return to menu
  Ins - toggle insert/overwrite modes
  F3 - insert highlighted expression
  F4 - insert highlighted expression in parentheses

Cursor movement commands:
  Ctrl-S - move left a character
  Ctrl-D - move right a character
  Ctrl-A - move left a word
  Ctrl-F - move right a word
  Ctrl-Q S - move to left end of line
  Ctrl-Q D - move to right end of line

Text deletion commands:
  Ctrl-H - delete char left of cursor (= Backspace)
  Ctrl-G - delete char at the cursor (= Del)
  Ctrl-T - delete word beginning at cursor
  Ctrl-Y - delete whole line
  Ctrl-Q Y - delete right end of line
  Ctrl-Q H - delete left end of line

Miscellaneous commands:
  Ctrl-M - enter line of text (= Enter)
  Ctrl-J - enter & simplify line of text (= Ctrl-Enter)
  Ctrl-[ - abort edit & return to menu (= Esc)
  Ctrl-V - toggle insert/overwrite modes (= Ins)
  Ctrl-U - insert previous line of text

Entering Greek letters, special contants & operators (type English
equivalent name or, on PC compatibles only, use Alt key):
  Alt-A  alpha	    Alt-M  mu
  Alt-B  beta	    Alt-P  pi
  Alt-G  GAMMA	    Alt-S  sigma
  Alt-D  delta	    Alt-T  tau
  Alt-N  epsilon    Alt-F  phi
  Alt-H  theta	    Alt-O  omega

  Alt-E  #e - base of natural logs
  Alt-I  #i - square root of -1
  Alt-Q  SQRT - square root operator


Functions, Constants, & Operators

  Derive can approximate &/or simplify the following functions,
constants & operators.	Given numeric arguments in approximate mode, they
are numerically approximated to the current precision.  Otherwise they
are algebraically simplified.	Many transformations are applied
automatically; some are applied only when requested by a Manage
command:

Constants:
  #e  Alt-E - base of natural logs
  #i  Alt-I - square root of -1
  pi  Alt-P - area of unit disk
  deg - radians per degree (=pi/180)
  inf - positive infinity

Operators (Section 3.1):
  +  plus
  -  minus or difference
  *  times
  /  quotient
  ^  exponentiation
  %  percent
  !  factorial

Relational operators (Section 4.13):
  =   equals
  /=  not equal
  <   less than
  <=  less than or equal
  >   greater than
  >=  greater than or equal

Solving relations (Section 4.14):
  SOLVE (u,x) - solve u=0 for x
  SOLVE (u=v,x) - solve u=v for x
  SOLVE (u<v,x) - solve u<v for x
  SOLVE (u=v,x,a,b) - solve u=v for x in [a,b], if in approximate mode
  SOLVE ([u1=v1,u2=v2,...], [x1,x2,...]) - solve system linear in x1, x2, ...

Exponential functions (Section 6.1):
  SQRT (z) - square root of z
  EXP (z) - #e raised to the power z

Logarithmic functions (Section 6.2):
  LN (z) - natural log of z
  LOG (z) - natural log of z
  LOG (z,w) - log of z to the base w

Trigonometric functions (Section 6.3):
  SIN (z*deg) - sine of z degrees
  SIN (z) - sine of z radians
  COS (z) - cosine of z radians
  TAN (z) - tangent of z radians
  COT (z) - cotangent of z radians
  SEC (z) - secant of z radians
  CSC (z) - cosecant of z radians

Inverse trigonometric functions (radians) (Section 6.4):
  ATAN (z) - angle whose tangent is z
  ATAN (y,x) - angle of the point (x,y)
  ACOT (z) - angle whose cotangent is z
  ACOT (x,y) - angle of the point (x,y)
  ASIN (z) - angle whose sine is z
  ASEC (z) - angle whose secant is z
  ACSC (z) - angle whose cosecant is z

Hyperbolic functions (Section 6.5):
  SINH (z) - hyperbolic sine of z
  COSH (z) - hyperbolic cosine of z
  TANH (z) - hyperbolic tangent of z
  COTH (z) - hyperbolic cotangent of z
  SECH (z) - hyperbolic secant of z
  CSCH (z) - hyperbolic cosecant of z

Inverse hyperbolic functions (Section 6.6):
  ASINH (z) - inverse hyperbolic sine of z
  ACOSH (z) - inverse hyperbolic cosine of z
  ATANH (z) - inverse hyperbolic tangent of z
  ACOTH (z) - inverse hyperbolic cotangent of z
  ASECH (z) - inverse hyperbolic secant of z
  ACSCH (z) - inverse hyperbolic cosecant of z

Piecewise continuous functions (Section 6.7):
  ABS (x) - absolute value of x
  SIGN (x) - sign of x
  MAX (x, y, ...) - maximum of arguments
  MIN (x, y, ...) - minimum of arguments
  STEP (x) - 1 if x>0, 0 if x<0
  CHI (a,x,b) - 1 if a<x<b, 0 if x<a or x>b
  NEXT_PRIME (n) - next prime larger than n

Complex variable functions (Section 6.8):
  ABS (z) - magnitude of z
  SIGN (z) - radial projection of z on unit circle
  RE (z) - real part of z
  IM (z) - imaginary part of z
  CONJ (z) - complex conjugate of z
  PHASE (z) - phase angle of z

Probability functions (Section 6.9):
  z! - z factorial
  GAMMA (z) - gamma function of z
  PERM (z,w) - permutations of z things taken w at a time
  COMB (z,w) - combinations of z things taken w at a time

Statistical functions (Section 6.10):
  AVERAGE (z1, ..., zn) - arithmetic mean (average)
  RMS (z1, ..., zn) - root mean square
  VAR (z1, ..., zn) - variance
  STDEV (z1, ..., zn) - standard deviation
  FIT (m) - least-squares fit to data matrix m

Error functions (Section 6.11):
  ERF (z) - error function
  ERF (z,w) - generalized error function
  ERFC (z) - complementary error function
  NORMAL (z,m,s) - normal distribution with mean m & standard deviation s

Financial functions (Section 6.12):
  PVAL (i, nper, pmt, fval, time) - present value of contract
  FVAL (i, nper, pmt, pval, time) - future value of contract
  PMT (i, nper, pval, fval, time) - periodic payment
  NPER (i, pmt, pval, fval, time) - number of payment periods
  RATE (nper, pmt, pval, fval, time, min, max) - periodic interest rate

Calculus functions (Sections in Chapter 7):
  7.1  LIM (u,x,a) - limit of u as x approaches a
  7.1  LIM (u,x,a,1) - limit of u as x approaches a from above
  7.1  LIM (u,x,a,-1) - limit of u as x approaches a from below
  7.2  DIF (u,x) - derivative of u wrt x
  7.2  DIF (u,x,n) - nth order derivative of u wrt x
  7.3  TAYLOR (u,x,a,n) - nth order Taylor approximation of u about x=a
  7.4  INT (u,x) - antiderivative of u wrt x
  7.4  DIF (u,x,-n) - nth-order antiderivative of u wrt x
  7.4  INT (u,x,a,b) - definite integral of u from x=a to b
  7.5  SUM (u,n) - antidifference of u wrt n
  7.5  SUM (u,n,k,m) - definite sum of u from n=k to m
  7.6  PRODUCT (u,n) - antiquotient of u wrt n
  7.6  PRODUCT (u,n,k,m) - definite product of u from n=k to m

Vector functions (Sections in Chapter 8):
  8.1  [x1, x2, ..., xn] - n-element vector
  8.2  VECTOR (u,k,n) - vector of u as k goes from 1 thru n in steps of 1
  8.2  VECTOR (u,k,m,n) - vector of u as k goes from m thru n in steps of 1
  8.2  VECTOR (u,k,m,n,s) - vector of u as k goes from m thru n in steps of s
  8.3  ELEMENT (v,n) - element n of vector v
  8.3  DIMENSION (v) - number of elements of vector
  8.3  ABS (v) - magnitude (length) of vector
  8.4  v . w   dot product of vectors (use a period)
  8.4  CROSS (v,w) - cross product

Matrix functions (Sections in Chapter 8):
  8.1  [[a, b], [c, d]] - 2x2 matrix
  8.2  IDENTITY_MATRIX (n) - nxn identity matrix
  8.3  ELEMENT (A,j,k) - element in row j & column k of matrix A
  8.4  A.B - dot product of matrices
  8.5  A` - transpose of A (On PC-9801 use Yen char)
  8.5  DET (A) - determinant of A
  8.5  TRACE (A) - trace of A (sum of diagonal elements)
  8.5  A^-1 - inverse of A
  8.6  ROW_REDUCE (A) - row echelon form of A
  8.6  ROW_REDUCE (A, B) - row echelon form of A augmented by B
  8.7  CHARPOLY (A, mu) - characteristic polynomial of A, using mu
  8.7  EIGENVALUES (A, mu) - eigenvalues of A

Differential vector calculus (Section 8.9):
  GRAD (expn) - gradient of expn depending on x, y & z
  GRAD (expn,v) - gradient of expn depending on variables in vector v
  GRAD (expn,A) - gradient of expn in coordinate system A
  DIV (v,A) - divergence of vector v
  LAPLACIAN (expn,A) - divergence of the gradient of expn
  CURL (v,A) - curl of vector v

Integral vector calculus (Section 8.10):
  POTENTIAL (v) - scalar potential of a vector
  POTENTIAL (v,w) - potential of a vector with starting coordinates w
  POTENTIAL (v,w,A) - potential of a vector in coordinate system A
  VECTOR_POTENTIAL(v,w,A) - vector potential of a vector

Programming functions and operators (Sections in Chapter 10):
  10.1	ITERATES (u,x,x0) - returns the vector [x0,u(x0),u(u(x0)),...]
until a term is repeated
  10.1	ITERATES (u,x,x0,n) - returns the first n+1 elements of the
vector [x0,u(x0),u(u(x0)),...]
  10.2	ITERATE (u,x,x0) - returns the first repeated element of the
sequence x0, u(x0), u(u(x0)), ...
  10.2	ITERATE (u,x,x0,n) - returns the n+1th element of the sequence
x0, u(x0), u(u(x0)), ...

  10.3	IF (r,t,f) - if relation r is true, return expression t; if it is
false, return expression f
  10.3	IF (r,t,f,u) - if relation r is true, return expression t; if it
is false, return expression f; if truth unknown, return u
  10.5	IF (r AND s,t,f) - if relation r is false, return expression f;
otherwise return IF(s,t,f)
  10.5	IF (r OR s,t,f) - if relation r is true, return expression t;
otherwise return IF(s,t,f)
  10.5	IF (NOT r,t,f) - if relation r is false, return expression t; if
it is false, return expression f


Algebra Window Command Menu

  To issue a menu option command, press Space bar until desired command
is highlighted, then press Enter key.  Alternatively, type the letter
that is capitalized in the desired command.

  The following gives the section in the Derive Manual that describes
each command menu option.

  3.1  Author - enter new expression
  3.5  Build - combine expressions

       Calculus
  7.2	 Differentiate - differentiate expression
  7.4	 Integrate - integrate expression
  7.1	 Limit - find limit of an expression
  7.6	 Product - find closed form product
  7.5	 Sum - find closed form sum
  7.3	 Taylor - find Taylor approximation

       Declare
  4.12	 Function - define function
	 Variable
  4.10	   Domain - declare variable's domain
  4.11	   Value - declare variable's value
  8.1	 Matrix - declare a matrix
  8.1	 vectoR - declare a vector

  4.4  Expand - expand (sub)expression
  4.6  Factor - factor (sub)expression

  2.5  Help   get on-line help on:
  2.4	 Editing - line editing commands
  6.	 Functions - functions & constants
  2.2	 Algebra - algebra window commands
  5.2	 2D-plot - 2D-plot window commands
  5.6	 3D-plot - 3D-plot window commands
  9.	 Utility - utility file functions
  2.11	 State - current state of system
  2.5	 Return - return to Derive

  3.3  Jump - highlight expression
  4.14 soLve - solve equation, relation or vector of linear equations

      Manage
  4.5	 Branch - principal vs real roots
  6.1	 Exponential - exponential transformations
  6.2	 Logarithm - logarithmic transformations
  4.3	 Ordering - variable ordering
  4.8	 Substitute - substitute for variables or a subexpression
  6.3	 Trigonometry - trigonometric transformations

       Options
	 Color
  5.1	   Menu - set menu, message & status line colors
  5.1	   Work - set expression area colors
  5.1	 Display - set display mode
  2.7	 Execute - execute DOS command
  4.1	 Input - set variable name & case-sensitive input modes
  2.3	 Mute - mute audible error beeps
  3.9	 Notation - set numeric notation style
  3.8	 Precision - set arithmetic precision mode
  3.11	 Radix - set input & output radix bases

  5.2  Plot - plot (sub)expression
  2.6  Quit - quit Derive
  3.7  Remove - remove expressions
  3.2  Simplify - simplify (sub)expression

       Transfer
	 Load
  2.9	   Derive - load expressions from MTH file
  2.11	   State - load state from INI file
  2.9	   Utility - load definitions from MTH file
	 Save
  2.8	   Derive - save expressions in MTH file
  2.8	   Basic - save expressions in BAS file
  2.8	   Fortran - save expressions in FOR file
  2.8	   Pascal - save expressions in PAS file
  2.8	   Options - select save range and file linelength
  2.11	   State - save current state in INI file

  2.9	 Merge - merge expressions from MTH file
  2.9	 Clear - clear expressions from window
  2.9	 Demo - run demonstration in DMO file
	 Print
  2.10	   Printer - print expressions to printer
  2.10	   File - print expressions to file
  2.10	   Layout - set page size & margins
  2.10	   Options - set height, range & character set

  3.6  moVe - move expressions

       Window
  5.7	 Close - close window
  5.7	 Designate - designate window's type
  5.7	 Flip - flip overlaid windows (= F2 key)
  5.7	 Goto - go to given window
  5.7	 Next - go to next window (= F1 key)
  5.7	 Open - open window
  5.7	 Previous - go to previous window
	 Split - split window
  5.7	   Horizontal - horizontally
  5.7	   Vertical - vertically

  3.10 approX - approximate (sub)expression

Algebra window function key commands:
  F1 - go to next window
  F2 - flip overlaid windows
  F3 - insert highlighted expression
  F4 - insert highlighted expression in parentheses
  F5 - switch to previous display mode


2D-plot Window Command Menu

  To issue a menu option command, press Space bar until desired command
is highlighted, then press Enter key.  Alternatively, type the letter
that is capitalized in desired command.

  The following gives the section in the Derive Manual that describes
each 2D-plot window's command menu option.

  5.2  Algebra - switch to Algebra window
  5.2  Center - center window over cross

       Delete	delete from plot list:
  5.3	 All - all expressions
  5.3	 Butlast - all but the last expression
  5.3	 First - first expression
  5.3	 Last - last expression

  2.5  Help - (same as Algebra window's Help command)
  5.2  Move - move cross to coordinates

       Options
  5.4	 Accuracy - set plot accuracy
	 Color
  5.3	   Auto - turn off auto color change
  5.2	   Plot - set plot & axes colors
  5.1	   Menu - set menu, message & status line colors
  5.1	   Work - set plot area background color
  5.1	 Display - set display mode
  2.7	 Execute - execute DOS command
  2.3	 Mute - mute audible error beeps
  3.9	 Notation - set numeric notation style
  3.8	 Precision - set arithmetic precision mode
  3.11	 Radix - set input & output radix bases
  5.5	 State - select coordinates, line segments, & dot size

  5.2  Plot - plot highlighted expression
  2.6  Quit - quit Derive
  5.2  Scale - set plot scale
  5.2  Ticks - set aspect ratio

  5.7  Window - (same as Algebra window's Window command)
  5.2  Zoom - zoom (adjust) plot scale in or out

2D-plot window function key commands:
  F1 - go to next window
  F2 - flip overlaid windows
  F5 - switch to previous display mode
  F7 - zoom y-axis in
  F8 - zoom y-axis out
  Shift-F7 - zoom x-axis in
  Shift-F8 - zoom x-axis out
  F9 - zoom both axes in
  F10 - zoom both axes out


3D-plot Window Command Menu

  To issue a menu option command, press Space bar until desired command
is highlighted, then press Enter key.  Alternatively, type the letter
that is capitalized in desired command.

  The following gives the section in the Derive Manual that describes
each 3D-plot window's command menu option.

  5.2  Algebra - switch to Algebra window
  5.8  Center - set coordinates of box center
  5.8  Eye - set coordinates of viewer's eye
  5.8  Focal - set coordinates of focal point
  5.8  Grids - set number of grid panels
  5.8  Hide - control display of hidden lines
  5.8  Length - set box side lengths

       Options
  5.8	 Axes - control axes display
	 Color
  5.8	   Plot - set top, bottom & axes colors
  5.1	   Menu - set menu, message & status line colors
  5.1	   Work - set plot area background color
  5.1	 Display - set display mode
  2.7	 Execute - execute DOS command
  2.3	 Mute - mute error beeps
  3.9	 Notation - set numeric notation style
  3.8	 Precision - set arithmetic precision mode
  3.11	 Radix - set input & output bases

  5.8  Plot - plot highlighted expression
  2.6  Quit - quit Derive
  5.7  Window - (same as Algebra window's Window command)
  5.8  Zoom - zoom box side lengths in or out

3D-plot window function key commands:
  F1 - go to next window
  F2 - flip overlaid windows
  F5 - switch to previous display mode
  F7 - zoom y-axis in
  F8 - zoom y-axis out
  Shift-F7 - zoom x-axis in
  Shift-F8 - zoom x-axis out
  F9 - zoom both axes in
  F10 - zoom both axes out


Utility File Functions (Chapter 9)

[Note:  These functions are in files that must be loaded into Derive before
use.  -- edp]

9.1  SOLVE.MTH - Solving Nonlinear Systems:  Simplify using approX
command.  Use complex x0 for complex solutions.
  NEWTONS (u,x,x0,n) := n iterations of Newton's method for vector
u(x)=0
  FIXED_POINT (g,x,x0,n) := n iterations of vector x=g(x), starting @
x=x0

9.2  VECTOR.MTH - Additional Vector & Matrix Functions.  If v & w are
vectors & A & B are matrices:
  i_ := [1, 0, 0]: unit vector for x-axis
  j_ := [0, 1, 0]
  k_ := [0, 0, 1]
  OUTER (v,w) := outer product of v & w
  KRONECKER (i,j) := Kronecker delta function
  APPEND_VECTORS (v,w) := append v & w
  DELETE_ELEMENT (v,k) := delete element k from v
  MINOR (A,i,j) := delete row i & column j from A
  REVERSE_VECTOR (v) := reverse order of elements
  SWAP_ELEMENTS (v,i,j) := interchange elements i & j of v
  SCALE_ELEMENT (v,i,s) := multiply element i of v by s
  SUBTRACT_ELEMENTS (v,i,j) := subtract element j from element i of v

  FORCE0 (A,i,j,p) := force element i,j of A to 0 using pivot row p
  PIVOT (A,i,j) := force column j below row i to 0 by pivoting
  MATPROD (A,B,i,j) := element i,j of the dot product of A & B
  COFACTOR (A,i,j) := numerator of element i,j of A inverse
  ADJOINT (A) := adjoint of square matrix A
  EXACT_EIGENVECTOR (A,mu) := eigenvector of A < 4x4 for eigenvalue mu
  APPROX_EIGENVECTOR (A,mu) := approximate eigenvector of A: Use approX command
  JACOBIAN (u,v) := Jacobian for vector x=u(c), curvilinear coord c & Cart. x
  COVARIANT_METRIC_TENSOR (A) := covariant metric tensor of Jacobian matrix A
  GEOMETRY_MATRIX (c,G) := geometry matrix of curv coord c & metric tensor G
  cylindrical := geometry matrix for cylindrical coordinates r, theta, z
  spherical := geometry matrix for spherical coordinates r, theta, phi

9.3  NUMERIC.MTH - Numeric Derivatives, etc:  Use approX command.
  DIF_NUM (y,x,x0,h) := 1st derivative of y wrt x at x0 using step size h
  DIF2_NUM (y,x,x0,h) := 2nd derivative of y wrt x
  SMOOTH_VECTOR (v) := smoothed copy of vector v
  SMOOTH_COLUMN (A,j) := matrix A with column j smoothed
  DIF_DATA (A) := 1st derivative of 2-column numeric data matrix A
  DIF2_DATA (A) := 2nd derivative of A
  INT_DATA (A) := antiderivative of A

9.4  DIF_APPS.MTH - Applications of Differentiation
  CURVATURE (y,x) := curvature of y(x)
  CENTER_OF_CURVATURE (y,x) := center of curvature of y(x)
  TANGENT (y,x,x0) := line tangent to y(x) at x=x0
  PERPENDICULAR (y,x,x0) := line perpendicular to y(x) at x=x0
  OSCULATING_CIRCLE (y,x,theta) := circle osculating y(x), in terms of theta

  PARA_DIF (v,t,n) := nth derivative of v wrt t, where v=[x(t),y(t)]
  PARA_CURVATURE (v,t) := curvature of v
  PARA_CENTER_OF_CURVATURE (v,t) := center of curvature of v
  PARA_TANGENT (v,t,t0,x) := line tangent to v at t=t0, in terms of x
  PARA_PERPENDICULAR (v,t,t0,x) := line perpendicular to v at t=t0
  PARA_OSCULATING_CIRCLE (v,t,t0,phi) := circle osculating v, in terms of phi

  POLAR_DIF (r,theta,n) := nth derivative of r(theta), in terms of theta
  POLAR_CURVATURE (r,theta) := curvature of r
  POLAR_CENTER_OF_CURVATURE (r,theta) := center of curvature of r
  POLAR_TANGENT(r,theta,theta0,x):=line tangent to r@ theta=theta in terms of x
  POLAR_PERPENDICULAR(r,theta,theta0,x):=line perpendicular to r@ theta=theta0
  POLAR_OSCULATING_CIRCLE(r,theta,theta0,phi):=osculating circle in
terms of phi

  IMP_DIF (u,x,y,n) := implicit derivative DIF(y,x,n) for u(x,y)=0
  IMP_CURVATURE (u,x,y) := curvature of implicit curve u=0
  IMP_CENTER_OF_CURVATURE (u,x,y) := center of curvature of u=0
  IMP_TANGENT (u,x,y,x0,y0) := line tangent to u=0 at x=x0 & y=y0
  IMP_PERPENDICULAR (u,x,y,x0,y0) := line perpendicular to u=0 at x0 & y0
  IMP_OSCULATING_CIRCLE (u,x,y,x0,y0,phi) := osculating circle in terms of phi

  TANGENT_PLANE (u,v,v0) := plane tangent to u(x,y,z)=0 @ [x,y,z]=v=v0
  NORMAL_LINE (u,v,v0,t) := line normal to u=0 at v=v0, using parameter t

9.5  INT_APPS.MTH - Applications of Integration
  FOURIER (y,t,t1,t2,n) := nth-harmonic Fourier series of y(t) from t=t1 to t2
  LAPLACE (y,t,s) := Laplace transform of y(t) for transform domain
variable s.  s must be declared sufficiently large for the integral to
converge.
  To find the inverse Laplace transform, use the Expand command to find
the partial fraction expansion, then lookup the inverse in a table.

  ARC_LENGTH (y,x,x1,x2) := arc length of y(x) from x=x1 to x2
  ARC_LENGTH (y,x,x1,x2,mu) := integral of mu(x) along arc y(x) from x=x1 to x2
  POLAR_ARC_LENGTH (r,th,th1,th2) := arc length of polar r(th) from th1 to th2
  POLAR_ARC_LENGTH (r,th,th1,th2,mu) := integral of mu(th) along arc r
  PARA_ARC_LENGTH (v,t,t1,t2) := arc length of vector v(t) from t=t1 to t2
  PARA_ARC_LENGTH (v,t,t1,t2,mu) := integral of mu(t) along v

  AREA (x,x1,x2,y,y1,y2) := area of region x=x1 to x2 & y=y1(x) to y2(x)
  AREA (x,x1,x2,y,y1,y2,mu) := integral of mu(x,y) over region
  AREA_CENTROID (x,x1,x2,y,y1,y2) := areal centroid of region
  AREA_CENTROID (x,x1,x2,y,y1,y2,mu) := centroid of density mu(x,y) over region
  AREA_INERTIA (x,x1,x2,y,y1,y2) := areal inertia tensor of region
  AREA_INERTIA (x,x1,x2,y,y1,y2,mu) := inertia tensor of density mu(x,y)
  POLAR_AREA (r,r1,r2,th,th1,th2) := area of th=th1 to th2 & r=r1(th) to r2(th)
  POLAR_AREA (r,r1,r2,th,th1,th2,mu) := integral of mu(th) over region
  SURFACE_AREA (z,x,x1,x2,y,y1,y2) := area of surface z(x,y)
  SURFACE_AREA (z,x,x1,x2,y,y1,y2,mu) := integral of mu(x,y) over surface z

  VOLUME(x,x1,x2,y,y1,y2,z,z1,z2):=volume y=y1(x) to y2(x), z=z1(x,y) to
z2(x,y)
  VOLUME (x,x1,x2,y,y1,y2,z,z1,z2,mu) := integral of mu(x,y,z) over
region
  VOLUME_CENTROID (x,x1,x2,y,y1,y2,z,z1,z2) := volumetric centroid of
region
  VOLUME_CENTROID (x,x1,x2,y,y1,y2,z,z1,z2,mu) := centroid of density
mu(x,y,z)
  VOLUME_INERTIA (x,x1,x2,y,y1,y2,z,z1,z2) := volumetric inertia tensor
  VOLUME_INERTIA (x,x1,x2,y,y1,y2,z,z1,z2,mu) := inertia tensor of
mu(x,y,z)
  SPHERICAL_VOLUME(r,r1,r2,th,th1,th2,phi,phi1,phi2):=volume in
spherical coord.  r=r1 to r2, th=th1(r) to th2(r), phi=phi1(r,th) to
phi2(r,th)
  SPHERICAL_VOLUME (r,r1,r2,th,th1,th2,phi,phi1,phi2,mu) := integral of
mu
  CYLINDRICAL_VOLUME(r,r1,r2,th,th1,th2,z,z1,z2) := volume in
cylindrical coord.  z=z1 to z2, th=th1(z) to th2(z), r=r1(th,z) to
r2(th,z)
  CYLINDRICAL_VOLUME (r,r1,r2,th,th1,th2,z,z1,z2,mu) := integral of mu

  AREA_OF_REVOLUTION (y,x,x1,x2) := area of y(x) revolved about x-axis
  VOLUMEY_OF_REVOLUTION (y,x,x1,x2) := volume of y(x) revolved about y-axis
  AREAY_OF_REVOLUTION (y,x,x1,x2) := area of y(x) revolved about y-axis

9.6  ODE1.MTH - First-order Ordinary Differential Equations (y=y0 at x=x0)
  SEPARABLE (p,q,x,y,x0,y0) := solves y'=p(x)q(y)
  LINEAR1 (p,q,x,y,x0,y0) := solves y'+p(x)y=q(x)
  BERNOULLI (p,q,k,x,y,x0,y0) := solves y'+p(x)y=q(x)y^k
  FUN_LIN_CCF (r,p,q,k,x,y,x0,y0) := solves y'=r(p*x+q*y+k) with p,q,k constant
  LIN_FRAC (r,a,b,c,p,q,k,x,y,x0,y0) := solves y'=r((ax+by+c)/(px+qy+k))
  CLAIRAUT (p,q,x,y,v,c1) := solves p(x*v-y)=q(v) where v represents y'

  HOMOGENEOUS (r,x,y,x0,y0) := solves y'=r(x,y) if HOMOGENEOUS_TEST
(r,x,y) is free of x
  EXACT (p,q,x,y,x0,y0) := solves p(x,y)+q(x,y)y'=0 if EXACT_TEST
(p,q,x,y) is 0
  FREE_OF_INDEPENDENT (p,q,x,y,x0,y0) := solves p(x,y)+q(x,y)y'=0 if
FREE_OF_INDEPENDENT_TEST (p,q,x,y) is free of x
  FREE_OF_DEPENDENT (p,q,x,y,x0,y0) := solves p(x,y)+q(x,y)y'=0 if
FREE_OF_DEPENDENT_TEST (p,q,x,y) is free of y
  GEN_HOM (r,x,y,x0,y0) := solves y'=r(x,y) if GEN_HOM_TEST (r,x,y) is
free of x & y
  ALMOST_LIN (r,b,p,q,x,y,x0,y0) := solves r(x,y)y'+p(x)b(y)=q(x) if
ALMOST_LIN_TEST (r,b,y) is free of y

  MONOMIAL_TEST (p,q,x,y) is an integrating factor if of the form x^m*y^n
  USE_INTEG_FCTR (mu,p,q,x,y,x0,y0) := solves p+qy'=0 if mu is an integ fctr

9.7  ODE2.MTH - Second-order Ordinary Differential Equations
  LIN2_POS (p,q,r,x) := solves y"+p(x)y'+q(x)y=r(x) if LIN2_TEST (p,q,x)
is free of x & positive
  LIN2_NEG (p,q,r,x) := solves y"+p(x)y'+q(x)y=r(x) if LIN2_TEST (p,q,x)
is free of x & negative
  LIN2_0 (p,q,r,x) := solves y"+p(x)y'+q(x)y=r(x) if LIN2_TEST (p,q,x)
is 0

    If LIN2_TEST (p,q,x) is not free of x then:
  LIN2A_POS (p,q,r,x) := solves y"+p(x)y'+q(x)y=r(x) if LIN2A_TEST
(p,q,x) is free of x & positive
  LIN2A_NEG (p,q,r,x) := solves y"+p(x)y'+q(x)y=r(x) if LIN2A_TEST
(p,q,x) is free of x & negative
  LIN2A_0 (p,q,r,x) := solves y"+p(x)y'+q(x)y=r(x) if LIN2A_TEST (p,q,x)
is 0

  IMPOSE_BV2 (x,y,x0,y0,x2,y2,c1,c2) := c1 & c2 in y(x) so y(x0)=y0 & y(x2)=y2
  IMPOSE_IV2 (x,y,x0,y0,v0,c1,c2) := c1 & c2 in y(x) so y=y0 & y'=v0 @ x=x0

  AUTONOMOUS_CONSERVATIVE(q,x,y,x0,y0,v0):=solves y"=q(y), y=y0 & y'=v0 @ x=x0
  LIOUVILLE (p,q,x,y,c1,c2) := solves y"+p(x)y'+q(y)(y')^2=0
  AUTONOMOUS (r,v) := dv/dy, given y"=r(y,v), reducing to sequence of 2 1st ord
  EXACT2 (p,q,x,y,v,c2) reduces the order of p(x,y,v)y"+q(x,y,v)=0 with
v=y' if EXACT2_TEST (p,q,x,y,v) is [0,0]

9.8  ODE_APPR.MTH - Approximately Solving ODEs
Solving individual equations y'=r(x) with y(x0)=y0
  DIRECTION_FIELD(r,x,x0,xm,m,y,y0,yn,n): grid (x0,y0) to (xm,yn), approX, Plot
  TAY_ODE1 (r,x,y,x0,y0,n) := nth order Taylor series solution.
  PICARD (r,p,x,y,x0,y0) := improved approximation, given approximation p(x)
  EULER(r,x,y,x0,y0,h,n) := [[x0,y0],...,[xn,yn]] with step size h: use approX

Solving systems of equations:  vector y'=r(x), with y(x0) = vector y0
  TAY_ODES (r,x,y,x0,y0,n) := nth order Taylor series solution
  PICARD(r,p,x,y,x0,y0):=improved approximation, given approximation
vector p(x)
  RK (r,v,v0,h,n) := [[x0, y0(x0), ... ym(x0)], ... [xn, y0(xn), ...
ym(xn)]] classic Runge-Kutta with step h.	Use approX
  EXTRACT_2_COLUMNS (A,j,k) := columns j & k from A for plots of RK
results

9.9  RECUREQN.MTH - Solving Recurrence Equations
  LIN1_DIFFERENCE (p,q,x,x0,y0) := solves y(x+1)=p(x)y(x)+q(x), y(x0)=y0
  RECURRENCE1 (r,x,y,x0,y0,n) := n steps of y(x+1)=r(x,y(x)), y(x0)=y0
  GEOMETRIC1 (k,p,q,x,x0,y0) := solves y(k*x)=p(x)y(x)+q(x), y(x0)=y0
  CLAIRAUT_DIF (p,q,d,x,y) := solves p(y-xd)=q(d), d represents y(x+1)-y(x)
  LIN2_CCF_DISC (p,q) := discriminant d for y(x+2)+p*y(x+1)+q*y(x)=r(x)
    LIN2_CCF_POS (p,q,r,x) := solves y(x+2)+p*y(x+1)+q*y(x)=r(x) if d>0
    LIN2_CCF_NEG (p,q,r,x) := solves y(x+2)+p*y(x+1)+q*y(x)=r(x) if d<0
    LIN2_CCF_0 (p,q,r,x)   := solves y(x+2)+p*y(x+1)+q*y(x)=r(x) if d=0
  IMPOSE_BV2 (x,y,x0,y0,x2,y2,c1,c2) := c1 & c2 in y(x) so y(x0)=y0 & y(x2)=y2

9.10  APPROX.MTH - Pade Rational Approximation
  PADE(y,x,x0,n,d):=approx y(x) near x=x0, n=numr deg, d=denr deg, n=d or d-1

9.11  EXP_INT.MTH - Exponential, Log, Sine, & Cosine Integrals:  use approX
  euler_gamma := Euler's constant to 25 significant digits
  EI(x,m):=m terms of series for exponential integral
INT(#e^-t/t,t,-x,inf), x>0
  LI(x,m):=m terms of series for logarithmic integral INT(1/LN t,t,0,x),
x>1
  EN (n,z) := nth exponential integral INT(exp(-zt)/t^n,t,1,inf),
RE(z)>0, n>=0
  EN_ASYMP (n,z,m) := m+1 terms of asymptotic series for EN(n,z), |z|
large
  E1(z,m) := m terms of series for exponential integral E1(z)=EN(1,z)
  SI(z) := sine integral INT(SIN(t)/t,t,0,z)
  CI(z) := cosine integral INT(COS(t)/t,t,0,z), |phase z| < pi

9.12  PROBABIL.MTH - Additional Probability Functions:	use approX
  POCHHAMMER (a,x) := Pochhammer symbol (a)x = GAMMA(a+x)/GAMMA(a)
  PSI (z) := DIF(GAMMA(z),z)/GAMMA(z), |phase z| < pi/2
  POLYGAMMA (n,z,m) := m+1 terms of series for DIF(PSI(z),z,n), z/=0,-1,-2,...
  INCOMPLETE_GAMMA (z,w) := P(z,w)=INT(#e^-t*t^(z-1),t,0,w)/GAMMA(z), RE(z)>0
  INCOMPLETE_GAMMA_SERIES (z,w,m) := m+1 terms of series for above
  BETA (z,w) := beta function B(z,w)=GAMMA(z)*GAMMA(w)/GAMMA(z+w)
  INCOMPLETE_BETA (x,z,w) := Bx(z,w) = INT(t^(z-1)*(1-t)^(w-1),t,0,x)
  POISSON_DENSITY (k,t) := Poisson probability density #e^-t*t^k/k!
  POISSON_DISTRIBUTION (k,t) := SUM (#e^-t*t^j/j!,j,0,k)
  BINOMIAL_DENSITY (k,n,p) := COMB(n,k)*p^k*(1-p)^(n-k)
  BINOMIAL_DISTRIBUTION (k,n,p) := SUM (COMB(n,j)*p^j*(1-p)^(n-j),j,0,MIN(k,n))
  HYPERGEOMETRIC_DENSITY (k,n,p) := COMB(m,k)*COMB(j-m,n-k)/COMB(j,n)
  HYPERGEOMETRIC_DISTRIBUTION (k,n,p) := cumulative hypergeometric distribution
  STUDENT (t,v) := student's cumulative probability distribution A(t|v)
  F_DISTRIBUTION (f,v1,v2) := the F cumulative distribution P(f|v1,v2)
  CHI_SQ (u,v) := Chi-square distribution P(u|v), u = Chi^2

9.13  FRESNEL.MTH - Fresnel Integrals:	use approX
  FRESNEL_SIN (z) := Fresnel sine integral S(z)=INT(SIN(pi*t^2/2),t,0,z)
  FRESNEL_SIN_SERIES (z) := m+1 terms of series for above
  FRESNEL_COS (z) := Fresnel cosine integral C(z)=INT(COS(pi*t^2/2),t,0,z)
  FRESNEL_COS_SERIES (z) := m+1 terms of series for above

9.14  BESSEL.MTH - Bessel & Airy Functions:  use approX
  BESSEL_J (n,z) := Bessel function of 1st kind Jn(z), n rational
  BESSEL_J_ASYMP (n,z) := 1 term of asymptotic series for above for large |z|
  BESSEL_Y (n,z) := Bessel function of second kind Yn(z), n fractional
  BESSEL_Y_SERIES (n,z,m) := m+1 terms of series for above
  BESSEL_Y_ASYMP (n,z) := 1 term of asymptotic series for above for large |z|
  SPHERICAL_BESSEL_J(n,z) := closed-form spherical Bessel fcn of 1st kind,jn(z)
  SPHERICAL_BESSEL_Y(n,z) := closed-form spherical Bessel fcn of 2nd kind,yn(z)
  AI_SERIES (z) := m+1 terms of series for Airy function Ai(z)
  BI_SERIES (z) := m+1 terms of series for Airy function Bi(z)

9.15  HYPERGEO.MTH - Hypergeometric Functions: use approX
  KUMMER (a,b,z) := Kummer's confluent hypergeometric function M(a,b,z)
  KUMMER_SERIES (a,b,z,m) := m+1 terms of series for M(a,b,z)
  HYPERGEOMETRIC (a,b,c,z) := Gauss hypergeometric function F(a,b;c;z)
  HYPERGEOMETRIC (a,b,c,z,m) := m+1 terms of series for F(a,b;c;z)

9.16  ELLIPTIC.MTH - Elliptic Integrals:  use approX
  ELLIPTIC_F (phi,m) := elliptic integral of 1st kind F(phi\m)
  ELLIPTIC_E (phi,m) := elliptic integral of 2nd kind E(phi\m)
  ELLIPTIC_PI (phi,m,n) := elliptic integral of 3rd kind II(n;phi\m)

9.17  ORTH_POL.MTH - Orthogonal Polynomials
  CHEBYCHEV_T (n,x) := nth Chebychev polynomial of 1st kind Tn(x)
  CHEBYCHEV_U (n,x) := nth Chebychev polynomial of 2nd kind Un(x)
  LEGENDRE_P (n,x) := nth Legendre polynomial Pn(x)
  ASSOCIATED_LEGENDRE_P (n,m,x) := nth associated Legendre polynomial Pn^m(x)
  HERMITE_H (n,x) := nth Hermite polynomial Hn(x)
  HERMITE_HE (n,x) := nth associated Hermite polynomial HEn(x)
  WEBER_D (n,x) := Weber's nth parabolic cylinder function Dn(x)
  GENERALIZED_LAGUERRE(n,a,x):=nth generalized Laguerre polynomial
Ln^a(x).  Use a=0 for ordinary Laguerre polynomials
  JACOBI_P (n,a,b,x) := nth Jacobi polynomial Pn^(a,b)(x)
  GEGENBAUER_C (n,a,x) := nth Gegenbauer ultraspherical polynomial
Cn^a(x)

9.18  ZETA.MTH - Zeta, Polylogarithm, & Dilogarithm Functions:	use approX
  ZETA (s,m) := m+1 terms of series for Riemann zeta function SUM(k^-s,k,1,inf)
  HURWITZ_ZETA (s,a,m) := m+1 terms of series for SUM((k+a)^-s,k,0,inf)
  POLYLOG (n,z,m) := m terms of series for Jonquire's polylogarithm Lin(z)
  LERCH_PHI (z,s,a,m) := m terms of series for Lerch transcendent Phi(z,s,a)
  DILOG (x) := dilogarithm function INT(LN(t)/(t-1),t,1,x)

9.19  GRAPHICS.MTH - Space Curves, Parametric Surfaces & Complex Values
Isometric projections for 2D Plot:  Use Options State Rectangular Connected
  axes := 3D coordinate axes
  ISOMETRIC (v) := matrix for space curve v = [x(t),y(t),z(t)]: Plot
  ROTATE_X (phi) := matrix A so that A . [x,y,z] rotates angle phi about x axis
  ROTATE_Y (phi) := matrix A so that A . [x,y,z] rotates angle phi about y axis
  ROTATE_Z (phi) := matrix A so that A . [x,y,z] rotates angle phi about y axis
  ISOMETRICS (v,s,s0,sm,m,t,t0,tn,n):=matrix for surface
[x(s,t),y(s,t),z(s,t)]  s=s0...sm, t=t0...tn: approX then Plot
  CYLINDER (r,theta,z) := eg. of v for ISOMETRICS (v,theta,...,z,...)
  SPHERE (r,theta,phi) := eg. of v for ISOMETRICS (v,theta,...,phi,...)
  TORUS (r,theta,phi) := eg. of v for ISOMETRICS (v,theta,...,phi,...)
  CONE (phi,theta,z) := eg. of v for ISOMETRICS (v,theta,...,z,...)

2D Plots of complex-expression w(z) where z = x + #i y = r #e^(#i theta)
    Use approX and Options State Rectangular Connected
  RAYS (w,z,z00,zmn,m,n):= matrix of w vectors for z = x0 + #i y0 ... xm + #i y
  HORIZONTALS (w,z,z00,zmn,m,n) := w-plane map of rectangular z-plane grid
  ARCS (w,z,r0,rm,m,th0,thm,n) := w-plane map of polar z-plane grid
r=r0...rm, theta=th0...thn

9.20  MISC.MTH - Miscellaneous Utilities
  MOD (a,b) := a modulo b (the nonnegative remainder of a/b)
  FLOOR (a,b) := greatest integer <= a/b
  RATIO_TEST (t,n) := if > 1, SUM(t,n,a,inf) converges; < 1, sum diverges
  LIM2 (u,x,y,x0,y0) := limit of u as [x,y] -> [x0,y0] along slope of @1
  LEFT_RIEMANN (u,x,a,b,n) := left Riemann sum for INT(u,x,a,b), n rectangles
  INVERSE (y,x) := inverse of y(x) with respect to x
  INT_PARTS (u,dv,x) := integrate by parts INT (u*dv,x)
  INT_SUBST (y, x, g) := simplify INT(y,x) using substitution x->g(x)
  PROVE_SUM (t,k,a,n,s) := [0,0] if SUM(t,k,a,n)=s
  NTH_PRIME (n) := nth prime number
  POLY_COEFF (u,x,n) := coefficient of x^n term in polynomial u(x)
  POLY_DEGREE (u,x) := degree of polynomial u(x)


System Control Settings

[Beyond this, the help file contains text into which the current settings
are inserted.  I've omitted this.  -- edp]