github.com/PDP-10.its
1
0
Fork 0
mirror of https://github.com/PDP-10/its.git synced 2026-02-26 17:03:20 +00:00
Code Issues Releases Wiki Activity

Add some macsyma documentation.

Browse Source 
Resolves #927.
This commit is contained in:
Eric Swenson
2018-07-15 20:35:38 -07:00
parent 82674a7555
commit 86b2d0e395
4 changed files with 569 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

262
doc/info/macsym.12 Executable file
View File

@@ -0,0 +1,262 @@
[-*-Text-*-]
This file gives introductory material about MACSYMA.
It replaces the full manual which is useless in this mode.

File: MACSYM, Node: Top, Up: (DIR), Next: Manual,
MACSYMA is a large symbolic algebraic manipulation program. It runs
only on the MC machine. It is invoked by :MACSYMA or :A (for short).
* Menu:
* Manual:: How to obtain published documentation for MACSYMA.
* Primer:: How to invoke the MACSYMA Primer.
* Syntax:: A brief introduction to MACSYMA syntax.
* Commands:: Some useful commands for on-line documentation.
* Demo:: How to run DEMO files.
* Save:: How to save your work.
* Helpme:: How to request help on-line with MACSYMA.
* Helpers:: People to communicate with for help.

File: MACSYM, Node: Manual, Previous: Top, Next: Primer, Up: Top
The current version of the MACSYMA Reference Manual is version 10,
January 1983.
The MACSYMA Reference Manual may be ordered from:
Publications
Laboratory for Computer Science
545 Technology Square
Cambridge, MA 02139
It costs $22.50. Prepayment or Purchase Order preferred. Checks or
money orders should be made payable to MIT Laboratory for Computer
Science.
The file MACDOC;UPDATE > contains updates to MACSYMA since the publication
of version 10. DESCRIBE(UPDATE); will list them briefly.

File: MACSYM, Node: Primer, Next: Syntax, Up: Top, Previous: Manual
You may start up an on-line tutorial for MACSYMA by typing
:TEACHMACSYMA
Or, if you have already started up a MACSYMA you may call the Primer
from inside it by giving the command
PRIMER();

File: MACSYM, Node: Syntax, Next: Commands, Up: Top, Previous: Primer,
Input to MACSYMA is done with a syntax somewhat like that of Fortran
or Algol. All input lines are terminated with a semi-colon (;).
Input lines are labeled consecutively starting with (C1), and then
(C2), (C3) etc. MACSYMA results are labeled from (D1) on. Thus (D1) is
the result of the computations performed by MACSYMA on the user's
input string (C1). These line numbers may be used to refer to
expressions.
2
For example: The expression X + 2 X + 1
would be typed in as: x^2+2*x+1;
Commands to MACSYMA take their arguments inside parentheses, e.g.
FACTOR(x^2+2*x+1);
Commands may be typed in upper or lower case. The symbol % may be used
to refer to the last expression MACSYMA computed. E.g.
(C1) (x+3)^5;
5
(D1) (X + 3)
(C2) expand(%);
5 4 3 2
(D2) X + 15 X + 90 X + 270 X + 405 X + 243
The Mathematical operators used by MACSYMA are:
! for Factorial,
^ or ** for Exponentiation,
* for Multiplication,
. for non-commutative multiplication (spaces must go on either
side of the dot)
/ for Division,
+ for Addition, and
- for Subtraction.
For more details see the SYNTAX section in the Primer.

File: MACSYM, Node: Commands, Next: Demo, Up: Top, Previous: Syntax,
MACSYMA itself provides some on-line help. Here are some useful commands
to get you started:
APROPOS(string); takes a character string as argument and looks at all
the MACSYMA names for ones with that string appearing anywhere within
them. Thus, APROPOS(EXP); will return a long list of all the flags
and functions which have EXP as part of their names, such as EXPAND,
EXP, EXPONENTIALIZE. Thus if you can only remember part of the name
of something you can use this command to find the rest of the name.
DESCRIBE(cmd); prints out information about "cmd", which may be any
MACSYMA command, switch or variable. Certain key words have also been
included, where they seem appropriate, thus DESCRIBE(TRIG); will print
out a list of the trig functions implemented in MACSYMA. See also
APROPOS(string) which allows you to locate command names even if you
aren't sure of the full name.
OPTIONS(); enters the OPTIONS interpreter which is a structured list
of MACSYMA commands. You type the number of the subject of interest,
followed by a ";" to see the list of commands available for that
subject. To move back up the list the command BACK; will go back up
one level, and TOP; will get you back to the original entry list.
EXIT; will quit out of OPTIONS. DESCRIBE may be called inside OPTIONS
on the commands listed, either by number or by name.
OPTIONS(command); will give the various commands and switches
associated with command.
EXAMPLE(command); will start up a demonstration of how command works
on some expressions. After each command line it will pause and wait
for a space to be typed, as in the DEMO command (type N to see the
DEMO command).

File: MACSYM, Node: Demo, Previous: Commands, Next: Save, Up: Top
There are two commands which are useful for finding out how MACSYMA
works on specific types of problems: DEMO and BATCH. BATCH is also
useful in programming. These two are essentially the same command,
except that the DEMO command pauses after each set of command/display
lines and waits for the user to indicate readiness for the next pair
by typing a space. Typing anything besides a space will terminate the
demonstration. (Note: on noisy phone lines, the phone line may type a
"rubout" (^? on some terminals) which terminates the demo. In this
case use the BATCH command to run demonstration files.)
DEMO(name1,name2,device,directory); starts up a demonstration.
To obtain a list of some interesting demonstrations, do
LISTFILES(DEMO); which will list the "DEMO" directory. To use the
DEMO command on a file from this directory, for instance, "BEGIN
DEMO", you proceed as follows: On the list printed out by
LISTFILES(DEMO); you will see the line:
[BEGIN, DEMO, DSK, DEMO] 5/2/81 L=335 chars.
The four words inside the square brackets are what you place inside
the parentheses as arguments to the DEMO command, e.g.
DEMO(BEGIN,DEMO,DSK,DEMO);
The remaining information on the line is the creation date of the file and
its length.
To run this demonstration using the BATCH command, you would type:
BATCH(BEGIN,DEMO,DSK,DEMO);

File: MACSYM, Node: Save, Previous: Demo, Next: Helpme, Up: Top
There are several ways to store a MACSYMA calculation or partial
results on disk to return to at a later date:
SAVE([optional file spec],arg1, arg2,...,argi) saves quantities
described by its arguments on disk and keeps them in core also. The
optional file spec is in the form NAME1,NAME2,DSK,DIRECTORY and is
enclosed in square brackets, e.g. [JAMU,FUNCS,DSK,USERS2]. If you
omit the file spec, MACSYMA will select a file name for you consisting
of the first three letters of your login name followed by a digit (the
lowest digit which will give a unique file name). The second file
name will be a number. The arg's are the expressions to be SAVEd.
ALL is the simplest, but note that saving ALL will save the entire
contents of your MACSYMA, which in the case of a large computation may
result in a file which is too large to be reloaded. VALUES,
FUNCTIONS, or any other items on the INFOLISTS may be SAVEd, as may
functions and variables by name. C and D lines may also be saved, but
it is better to give them explicit names, which may be done in the
command line, e.g. SAVE(RES1=D15); Files saved with SAVE should be
reloaded with LOADFILE.
FASSAVE(args) is similar to SAVE but produces a FASL file in which
the sharing of subexpressions which are shared in core is preserved in
the file created. Hence, expressions which have common subexpressions
will consume less space when loaded back from a file created by
FASSAVE rather than by SAVE. Files created with FASSAVE are reloaded
using LOADFILE, just as files created with SAVE.
LOADFILE(fn1, fn2, DSK, directory) loads a file as designated by its
arguments. This function may be used to bring back quantities that
were stored from a prior MACSYMA session by use of the SAVE or STORE
functions.
STORE(args) same as SAVE but doesn't retain quantities in core.
RESTORE(file-specification) reinitializes all quantities filed away
by a use of the SAVE or STORE functions, in a prior MACSYMA session,
from the file given by file-specification without bringing them into
core.

File: MACSYM, Node: Helpme, Next: Helpers, Up: Top, Previous: Save,
In MACSYMA there are a number of commands which will allow you to
communicate with the Mathlab Group or other MACSYMA Users:
SEND("message"); - will send your message to some MACSYMA
system programmer who is logged in at that
time. Note that message must begin and end
with double quotes.
SEND(username,"message"); - sends the message to a specified user.
Expressions may be included by referring to them, outside double
quotes, e.g.
SEND("I am trying to integrate",D3,"but it runs out of core.");
MAIL("message"); - will send mail to MACSYMA. This may be used
to report problems or bugs.
MAIL(username,"message"); - will send mail to a specific user.
Expressions may be included outside double quotes, as with SEND.
BUG("message"); - similar to mail, sends a message to MACSYMA
Mail. This may be used for reporting bugs or
suspected bugs in MACSYMA. Expressions may be
included by referring to them, outside double
quotes as with SEND and MAIL.

File: MACSYM, Node: Helpers, Up: Top, Previous: Helpme,
To get help with problems in MACSYMA or with the system, these people
are useful to communicate with:
Login name Full name Phone # Room #
----------------------------------------------------------------
JPG Golden, Jeffrey (617)253-5891 832
ELLEN Golden, Ellen " " -5891 832
RWK Kerns, Bob " " -5217 835
KMP Pitman, Kent " " -7838 352
GJC Carrette, George " " -5887 833
U. S. Mail Address:
Laboratory for Computer Science
Room <number>
545 Technology Square
Cambridge, MA 02139
The WHO(); command will print out a list of people currently logged in.


12
doc/macdoc/new.manual Executable file
View File

@@ -0,0 +1,12 @@
Version 10 of the MACSYMA Manual is now available. It may be
ordered from
Publications
MIT Laboratory for Computer Science
545 Technology Square
Cambridge, MA 02139
It costs $22.50 and prepayment or official purchase order is preferred.
Checks, money orders, or Purchase Orders should be made out to:
MIT Laboratory for Computer Science

142
doc/macdoc/update.10 Executable file
View File

@@ -0,0 +1,142 @@
JPG@MIT-MC 05/10/85 14:26:34-EST To: INFO-MACSYM
If you are interested in using new code which handles the differentiation
of unknown functions in MACSYMA, please read MC:JPG;NDIFF USAGE .
Comments to JPG.

JGA@MIT-MC 10/20/84 11:25 Re.: divided differences
To: INFO-MACSYM
I put a divided difference function in SHARE2;DIVDIF .

RWG@SPA-NIMBUS 01/07/84 21:23 PST Re.: new Share USAGE files
SHARE1;SPANGL USAGE for simplifying trigfun(rational*%PI).
SHARE2;SQDNST USAGE for denesting SQRTs of surds.

JPG@MIT-MC 12/17/83 11:44 To: INFO-MACSYM
An EULERPOLY(v,n) function has been written by ASB.
It generates the nth Euler polynomial in the variable v.

ELLEN@MIT-MC 08/13/83 16:11 To: INFO-MACSYM Re.: Updates to MACSYMA
A new entry has been added to DESCRIBE. DESCRIBE(UPDATE); will print
out a summary of the changes to MACSYMA since the most recent version
of the Manual was printed. (In this case, since January 1983.)

JPG@MIT-MC 06/17/83 03:59 EDT To: INFO-MACSYM
Macsyma 304 has just been created in the newly released Lisp 2138.

LPH@MIT-MC 05/12/83 17:59 EDT To: INFO-MACSYM
A set of rules for performing simplifications on inequalities is
available in SHARE1;INEQ FASL, and DEMO and USAGE files are provided.
Send comments and bugs to LPH@MIT-MC.

GCOOK@MIT-MC 05/03/83 19:50 To: INFO-MACSYM
[1] A new function for generating FORTRAN:
The file DSK:SHARE1;CFORTR FASL contains the function CRAY_FORTRAN and
some other related functions (see the description file). CRAY_FORTRAN
generates FORTRAN suitable for the CRAY compilers.
A demo is available in DSK:SHARE1;CFORTR DEMO.
The function is described in DSK:SHARE1;CFORTR USAGE.
[2] A code sequence optimization function:
The file DSK:SHARE1;SEQOPT FASL contains the function SEQUENCE_OPTIMIZE, a
function which optimizes a MACSYMA expression or code sequence (list of
MACSYMA equations). It knows slightly more about optimization than OPTIMIZE.
A demo is available in DSK:SHARE1;SEQOPT DEMO.
The function is described in DSK:SHARE1;SEQOPT USAGE.
[3] A function which replaces constant subexpressions with new constants:
The file DSK:SHARE1;RDUCON FASL contains the function REDUCE_CONSTS, a
function which replaces constant subexpressions by newly-generated constant
atoms, and maintains a list of definitions of those atoms.
A demo is available in DSK:SHARE1;RDUCON DEMO.
The function is described in DSK:SHARE1;RDUCON USAGE.
[4] A new factoring function:
The file DSK:SHARE1;SCIFAC FASL contains the function GCFAC, a new
factoring function which is capable of doing some "scientific" factoring.
A demo is available in DSK:SHARE1;SCIFAC DEMO.
The function is described in DSK:SHARE1;SCIFAC USAGE.

ASB@MIT-MC 01/27/83 12:26 EST To: INFO-MACSYM
SHARE1;ATRIG1 FASL contains several additional simplification rules for
inverse trig functions.
A brief description can be found in SHARE1;ATRIG1 USAGE.
LOAD(ATRIG1) to use the rules.

ASB@MIT-MC 01/15/83 13:02-EST To: INFO-MACSYM
There is a new function RNCOMBINE which is similar to COMBINE, but
unlike COMBINE it collects terms whose denominators may differ by
numerical factors. A more complete description is in SHARE1;RNCOMB USAGE
and a demo in SHARE1;RNCOMB DEMO.
LCM, a function that finds the Least Common Multiple of a set of
expressions, has been added to SHARE;FUNCTS >. A brief description is in
SHARE;FUNCTS USAGE, and a line for LCM has been added to SHARE;FUNCTS DEMO.

JPG@MIT-MC 01/12/83 06:31-EST To: INFO-MACSYM
MACSYMA 303 has just been created.

GJC@MIT-MC 05/06/80 1816-EDT To: INFO-MACSYMA-TRANSLATION
The 4 argument version of ROMBERG, e.g.
F(A):=(MODEDECLARE(A,FLOAT),ROMBERG(SIN(A*X)*(X^2-A*X+1),X,0,%PI));
now compiles well, actually better than the three argument version.
In this example F(3.3) takes 2.1 seconds to calculate uncompiled
but only 0.022 seconds compiled. Using a separate function for
SIN(A*X)*(X^2-A*X+1), and compiling it, gives a timing of 0.032 seconds.
P.S. the 4 argument version of INTERPOLATE works also.

GJC@MIT-MC 03/09/80 0612-EST To: INFO-MACSYM
There is a version of CFFK's famous INTERPOLATE function on the NUMER
directory. The changes are that it now takes a macsyma (untranslated)
function as a functional argument in the 3 argument case. And a call
to it can be used in compiled code without loss of variable scoping.
These changes will also be made soon to PLOT2 and ROMBERG. If any users
have always wanted to write a function that took arguments in the neat
way that these functions do I can show you the package I used to convert
INTERPOLATE. A demo, NUMER;INTPOL DEMO highlights these changes.

GJC@MIT-MC 01/12/80 0035-EST To: INFO-MACSYM
NUMER;BATCH FASL has some functions in it that may be useful to users
who run MACSYMA while not being logged in. Such things as checking
the status of a disowned running macsyma without stopping it.
See the file NUMER;BATCH INFO.

JPG@MIT-MC 08/07/79 0716-EDT To: INFO-MACSYM, SPECIAL-FUNCTIONS
To aid in the introduction of polylogarithms, etc., when DIFF(F[N](X),X);
is done and F has a GRADEF defined for it, then DIFF(F(N,X),X); is
attempted. As an example, a GRADEF for the Bessel function %J[N](X)
has been set up, so e.g. RATSIMP(DIFF(%J[2](X),X,2)); may be done.
(The fact that this is implemented in terms of DIFF(%J(N,X),X) is
somewhat hidden here.) (Compare with the example given in the manual on
p.72. (Please note that the "RATSIMP" used there should be in line (C5),
not (C4).)) At this time, setting up the GRADEF via GRADEF(F[N](X),...);
cannot be done. The syntax GRADEF(F(N,X),...); must be used.

GJC@MIT-MC 08/05/79 2134-EDT To: INFO-MACSYM
See the "SUPER WINNING EXAMPLE" in the documentation for the macsyma
COMPILE command for turning expressions derived with macsyma into
floating point function definitions that you will then use in GRAPH2,
RUNGEKUTTA, ROMBERG, or whatever.

GJC@MIT-MC 08/04/79 0147-EDT To: INFO-MACSYM
To see an example of fast numerical methods in macsyma, do
DEMO(RGKTEST,MAC,GJC); . It shows the usage of the compiler from macsyma,
and two ways of calculating (GRAPH2'ing) the solution of a differential
equation, formal and RUNGEKUTTA.

GJC@MIT-MC 07/26/79 02:56:58 To: INFO-MACSYM
A program RUNGEKUTTA(F,X,Y,D) that is fairly winning
when used in conjunction with GRAPH2 (X,Y, and D are arrays),
resides as NUMER;RUNGE FASL. Documentation is in the file RUNGE USAGE .
(*** For updated note on RUNGE_KUTTA, see this file, note of 06/07/81. ***)

GJC@MIT-MC 07/08/79 15:47:02 To: INFO-MACSYM
I have just added to the share2 directory functions that I have been
using for a while that are both fast and convenient when working with
declared floating point arrays and translated functions. There are
functions for tabulating and mapping over declared arrays, a Gaussian
quadrature formula, a simpson's rule for functions and one for arrays.
If you tend to use PLOT2 and ROMBERG on the same functions, then these
can save you a lot of time. Please see the file SHARE2;NUMRCL INFO if
you are interested.


153
doc/macdoc/update.11 Executable file
View File

@@ -0,0 +1,153 @@
NCS@MIT-MC.ARPA 06/26/85 14:58:24-EDT To: INFO-MACSYM
There are new additions to the EIGEN package. Try load(eigen); while in
MACSYMA. This was written by Nicholas Strauss (NCS@MC).
Further documentation in SHARE; EIGEN DEMO and SHARE; EIGEN USAGE.
Abstract: One addition allows automatic finding of eigenvalues over
finite fields. Merely set MODULUS to desired integer and type
EIGENVALUES(MAT). Also, there is a command JORDANFORM which automatically
returns the jordanform matrix over Complex or Finite Field. These are not
intended for large matrices, nor zero-equivalent ambiguous matrices.

JPG@MIT-MC 05/10/85 14:26:34-EST To: INFO-MACSYM
If you are interested in using new code which handles the differentiation
of unknown functions in MACSYMA, please read MC:JPG;NDIFF USAGE .
Comments to JPG.

JGA@MIT-MC 10/20/84 11:25 Re.: divided differences
To: INFO-MACSYM
I put a divided difference function in SHARE2;DIVDIF .

RWG@SPA-NIMBUS 01/07/84 21:23 PST Re.: new Share USAGE files
SHARE1;SPANGL USAGE for simplifying trigfun(rational*%PI).
SHARE2;SQDNST USAGE for denesting SQRTs of surds.

JPG@MIT-MC 12/17/83 11:44 To: INFO-MACSYM
An EULERPOLY(v,n) function has been written by ASB.
It generates the nth Euler polynomial in the variable v.

ELLEN@MIT-MC 08/13/83 16:11 To: INFO-MACSYM Re.: Updates to MACSYMA
A new entry has been added to DESCRIBE. DESCRIBE(UPDATE); will print
out a summary of the changes to MACSYMA since the most recent version
of the Manual was printed. (In this case, since January 1983.)

JPG@MIT-MC 06/17/83 03:59 EDT To: INFO-MACSYM
Macsyma 304 has just been created in the newly released Lisp 2138.

LPH@MIT-MC 05/12/83 17:59 EDT To: INFO-MACSYM
A set of rules for performing simplifications on inequalities is
available in SHARE1;INEQ FASL, and DEMO and USAGE files are provided.
Send comments and bugs to LPH@MIT-MC.

GCOOK@MIT-MC 05/03/83 19:50 To: INFO-MACSYM
[1] A new function for generating FORTRAN:
The file DSK:SHARE1;CFORTR FASL contains the function CRAY_FORTRAN and
some other related functions (see the description file). CRAY_FORTRAN
generates FORTRAN suitable for the CRAY compilers.
A demo is available in DSK:SHARE1;CFORTR DEMO.
The function is described in DSK:SHARE1;CFORTR USAGE.
[2] A code sequence optimization function:
The file DSK:SHARE1;SEQOPT FASL contains the function SEQUENCE_OPTIMIZE, a
function which optimizes a MACSYMA expression or code sequence (list of
MACSYMA equations). It knows slightly more about optimization than OPTIMIZE.
A demo is available in DSK:SHARE1;SEQOPT DEMO.
The function is described in DSK:SHARE1;SEQOPT USAGE.
[3] A function which replaces constant subexpressions with new constants:
The file DSK:SHARE1;RDUCON FASL contains the function REDUCE_CONSTS, a
function which replaces constant subexpressions by newly-generated constant
atoms, and maintains a list of definitions of those atoms.
A demo is available in DSK:SHARE1;RDUCON DEMO.
The function is described in DSK:SHARE1;RDUCON USAGE.
[4] A new factoring function:
The file DSK:SHARE1;SCIFAC FASL contains the function GCFAC, a new
factoring function which is capable of doing some "scientific" factoring.
A demo is available in DSK:SHARE1;SCIFAC DEMO.
The function is described in DSK:SHARE1;SCIFAC USAGE.

ASB@MIT-MC 01/27/83 12:26 EST To: INFO-MACSYM
SHARE1;ATRIG1 FASL contains several additional simplification rules for
inverse trig functions.
A brief description can be found in SHARE1;ATRIG1 USAGE.
LOAD(ATRIG1) to use the rules.

ASB@MIT-MC 01/15/83 13:02-EST To: INFO-MACSYM
There is a new function RNCOMBINE which is similar to COMBINE, but
unlike COMBINE it collects terms whose denominators may differ by
numerical factors. A more complete description is in SHARE1;RNCOMB USAGE
and a demo in SHARE1;RNCOMB DEMO.
LCM, a function that finds the Least Common Multiple of a set of
expressions, has been added to SHARE;FUNCTS >. A brief description is in
SHARE;FUNCTS USAGE, and a line for LCM has been added to SHARE;FUNCTS DEMO.

JPG@MIT-MC 01/12/83 06:31-EST To: INFO-MACSYM
MACSYMA 303 has just been created.

GJC@MIT-MC 05/06/80 1816-EDT To: INFO-MACSYMA-TRANSLATION
The 4 argument version of ROMBERG, e.g.
F(A):=(MODEDECLARE(A,FLOAT),ROMBERG(SIN(A*X)*(X^2-A*X+1),X,0,%PI));
now compiles well, actually better than the three argument version.
In this example F(3.3) takes 2.1 seconds to calculate uncompiled
but only 0.022 seconds compiled. Using a separate function for
SIN(A*X)*(X^2-A*X+1), and compiling it, gives a timing of 0.032 seconds.
P.S. the 4 argument version of INTERPOLATE works also.

GJC@MIT-MC 03/09/80 0612-EST To: INFO-MACSYM
There is a version of CFFK's famous INTERPOLATE function on the NUMER
directory. The changes are that it now takes a macsyma (untranslated)
function as a functional argument in the 3 argument case. And a call
to it can be used in compiled code without loss of variable scoping.
These changes will also be made soon to PLOT2 and ROMBERG. If any users
have always wanted to write a function that took arguments in the neat
way that these functions do I can show you the package I used to convert
INTERPOLATE. A demo, NUMER;INTPOL DEMO highlights these changes.

GJC@MIT-MC 01/12/80 0035-EST To: INFO-MACSYM
NUMER;BATCH FASL has some functions in it that may be useful to users
who run MACSYMA while not being logged in. Such things as checking
the status of a disowned running macsyma without stopping it.
See the file NUMER;BATCH INFO.

JPG@MIT-MC 08/07/79 0716-EDT To: INFO-MACSYM, SPECIAL-FUNCTIONS
To aid in the introduction of polylogarithms, etc., when DIFF(F[N](X),X);
is done and F has a GRADEF defined for it, then DIFF(F(N,X),X); is
attempted. As an example, a GRADEF for the Bessel function %J[N](X)
has been set up, so e.g. RATSIMP(DIFF(%J[2](X),X,2)); may be done.
(The fact that this is implemented in terms of DIFF(%J(N,X),X) is
somewhat hidden here.) (Compare with the example given in the manual on
p.72. (Please note that the "RATSIMP" used there should be in line (C5),
not (C4).)) At this time, setting up the GRADEF via GRADEF(F[N](X),...);
cannot be done. The syntax GRADEF(F(N,X),...); must be used.

GJC@MIT-MC 08/05/79 2134-EDT To: INFO-MACSYM
See the "SUPER WINNING EXAMPLE" in the documentation for the macsyma
COMPILE command for turning expressions derived with macsyma into
floating point function definitions that you will then use in GRAPH2,
RUNGEKUTTA, ROMBERG, or whatever.

GJC@MIT-MC 08/04/79 0147-EDT To: INFO-MACSYM
To see an example of fast numerical methods in macsyma, do
DEMO(RGKTEST,MAC,GJC); . It shows the usage of the compiler from macsyma,
and two ways of calculating (GRAPH2'ing) the solution of a differential
equation, formal and RUNGEKUTTA.

GJC@MIT-MC 07/26/79 02:56:58 To: INFO-MACSYM
A program RUNGEKUTTA(F,X,Y,D) that is fairly winning
when used in conjunction with GRAPH2 (X,Y, and D are arrays),
resides as NUMER;RUNGE FASL. Documentation is in the file RUNGE USAGE .
(*** For updated note on RUNGE_KUTTA, see this file, note of 06/07/81. ***)

GJC@MIT-MC 07/08/79 15:47:02 To: INFO-MACSYM
I have just added to the share2 directory functions that I have been
using for a while that are both fast and convenient when working with
declared floating point arrays and translated functions. There are
functions for tabulating and mapping over declared arrays, a Gaussian
quadrature formula, a simpson's rule for functions and one for arrays.
If you tend to use PLOT2 and ROMBERG on the same functions, then these
can save you a lot of time. Please see the file SHARE2;NUMRCL INFO if
you are interested.