Network Working Group A. Bhushan
Request for Comments: 578 N. Ryan
NIC: 19501 MIT-PTD (DMS)
October 1973
USING MIT-MATHLAB MACSYMA FROM MIT-DMS MUDDLE
An Experiment in Automated Resource Sharing
I. INTRODUCTION
This paper describes an experiment in non-trivial automated resource
sharing between dissimilar systems. The goal of the experiment was
to interface the MUDDLE system at MIT-DMS (Host 70.) to the MACSYMA
system at MIT-Mathlab (Host 198.), in such a manner that the MUDDLE-
user at MIT-DMS is not required to know anything about the ARPANET,
Mathlab, or even MACSYMA. In fact, the user need not be aware that
part of the computation is performed by MACSYMA on the Mathlab
computer.
This experiment differs from the MATHLAB-UCSB/OLS experiment (ref.
NWG/RFC 525, NIC 17161 "MIT-MATHLAB Meets UCSB-OLS" by Parrish and
Pickens) in several important respects. First, the use of the remote
network resource is *completely automated*. The human user does
nothing more than use a function in MUDDLE such as "INTEGRATE" which
requires the remote MACSYMA resource for computation. The program
performs all the required tasks of connecting to Mathlab, log in, and
using MACSYMA. (In the UCSB-OLS experiment, the user had to manually
connect to Mathlab, login, use MACSYMA, type the input in a form
suitable for MACSYMA, save the results in a file at Mathlab,
disconnect from Mathlab, start a retrieval job at UCSB to retrieve
the "saved" results, and finally submit the results to a local
program.) Second, the use of the remote resource is *completely
integrated* into the local MUDDLE system. The user can specify the
computations in a form that MUDDLE understands. The resource-sharing
program (whose existence the user need not be aware of) does the
translation from the MUDDLE "prefix" form to the MACSYMA "infix" form
on input, and vice-versa on output. This ability allows the MACSYMA
resources to be completely integrated into MUDDLE to the extent that
parts of the same computation can be performed by MACSYMA and others
by MUDDLE.
II. THE MACSYMA AND MUDDLE RESOURCES
Before proceeding to describe the resource sharing facility a
description of the two resources, MACSYMA and MUDDLE, is in order.
The MACSYMA system at Mathlab is a powerful resource for symbolic
manipulation of algebraic functions. It can, among other things,
Bhushan & Ryan [Page 1]
RFC 578 Using MIT-MATHLAB MACSYMA from MIT-DMS MUDDLE October 1973
perform symbolic integration and differentiation, expand series,
perform Laplace and inverse-Laplace transforms, solve equations and
systems of equations, and simplify rational functions. (A
description of MACSYMA's capabilities is given in "The MACSYMA Users'
Manual" available from the MIT-Mathlab group at Project MAC.)
The MUDDLE system provides a general-purpose environment suitable for
automatic programming, graphics, data management, "networking", and
mathematical computations. The MUDDLE language represents a powerful
extension of the list processing language LISP in the area of data
types such as strings, vectors, uniform vectors, and user definable
types. (MUDDLE is described in some detail in "The MUDDLE Primer"
(SYS.11.01) by Greg Pfister, available from the Programming
Technology Division at Project MAC.)
MUDDLE has extensive graphical and numerical computation facilities.
The user can display graphs on ARDS and IMLAC type consoles, and on
the Evans and Sutherland (E&S) display system. The MUDDLE console
graphics provide a facility to view graphical representation of
functions with overlay capability and automatic scaling that can be
controlled by the user. The E&S provides the user with a versatile
tool for studying the dynamic characteristics of graphs, curved
surfaces, and other three-dimensional objects. The combination of
MACSYMA, MUDDLE, and the E&S graphics capabilities represents a very
powerful resource for problem solving that is integrated and made
easily usable by the resource sharing facility.
III. THE AUTOMATED RESOURCE-SHARING FACILITY
The resource-sharing facility described herein uses the most easily
accessible communication path to MACSYMA, the TELNET connection to
the logger service on socket 1. No modifications were made to
MACSYMA, nor were any special programs created on the Mathlab
computer. The entire task of resource sharing is performed by
programs in MUDDLE. Let us say on the outset that we are not
advocating this mode of usage for automated resource sharing. A
resource-sharing protocol that allows convenient use of remote
resources via programs is a far more reliable and efficient way, but
that requires work on the part of server sites. The existing
protocols and systems FTP, RJE, RSEXEC, and the Datacomputer cater to
a limited subset of easily managed resources. We register here our
desire for uniformity (which alas is lacking) in the current systems,
and work along the direction of general-purpose resource sharing. In
the absence of a general resource-sharing protocol and a MACSYMA
server to go along with it at Mathlab, the TELNET connection is the
best a user can do.
Bhushan & Ryan [Page 2]
RFC 578 Using MIT-MATHLAB MACSYMA from MIT-DMS MUDDLE October 1973
The resource sharing facility comprises of several independent but
integrated parts. These are:
1) Connecting to Mathlab, login, and invoking MACSYMA.
2) Conversion of MUDDLE's prefix to MACSYMA's infix form.
3) Generation of MACSYMA input.
4) Interpreting MACSYMA's results including errors and comments.
5) MACSYMA infix to MUDDLE prefix conversion.
6) Plotting graphs for the functions.
7) Allowing human intervention if desired.
8) Disconnect from MACSYMA.
The user (assuming that he has loaded the necessary programs in
MUDDLE) to integrate the function "3*X" has only to type:
<INTEGRATE '<* .X 3>>$
where '$' represents the ASCII character <ESC> (or <ALT-MODE>).
MUDDLE will then return the following result:
</ <* 3 <^ .X 2>> 2>
Alternatively, if the user wishes to use the infix form, he can type:
<INTEGRATE "3*X">$
and the corresponding answer returned by MUDDLE would be
"3*X^2/2"
The following sequence of events takes place when integrate (or any
other function that uses MACSYMA) is used. If the user isn't already
communicating with a MACSYMA (the program keeps track of the
connection), a connection is established to MIT-Mathlab, the user is
logged in (automatically by program, using the user's
identification), and a MACSYMA is initiated. A prefix to infix
conversion is performed and the following input is sent to MACSYMA
(using the above example):
STRING (INTEGRATE (3*X,X));
The program then interprets MACSYMA's output recognizing error
responses and comments and extracts the result if no error is
encountered. The result which is in infix form is then converted to
the prefix form which is returned by the MUDDLE function INTEGRATE.
Bhushan & Ryan [Page 3]
RFC 578 Using MIT-MATHLAB MACSYMA from MIT-DMS MUDDLE October 1973
The INTEGRATE function takes an optional argument, the variable with
respect to which the integration is be performed. The syntax for the
function is:
<INTEGRATE {EXPR} ["{VAR}"]>
where EXPR is any expression of the type STRING or QUOTED FORM. The
optional argument (in square brackets) VAR must be of the type STRING
(enclosed by double-quotes). The syntax of other functions is:
<SIMPLIFY {EXPR}>
<DIFF {EXPR} ["{VAR}" "{TIMES}"]>
<EXPAND {EXPR} ["{MAXPOSEX}" "{MAXNEGEX}"]>
where TIMES is the number of times the EXPR is to be differentiated
and MAXPOSEX and MAXNEGEX control the maximum positive and negative
integer exponent to be used in expansion. The default value for VAR
is "X", for times is "1", and for MAXPOSEX and MAXNEGEX is "6" each.
The user can use the result returned by MUDDLE in any of his
computations, including drawing a graph. For example, typing:
<GRAPH <DIFF '<^ X. 3>> X -5 5>$
to MUDDLE will draw the graph "Y = 3*X^2" on the IMLAC or ARDS screen
with values of X from -5 to +5 (assuming the user has the graphics
package and the right IMLAC program loaded). The same graph would be
drawn if the user typed:
<GRAPH <IPARSE <DIFF "X^3">> X -5 5>$
where IPARSE is the MUDDLE function that converts infix to prefix
form. The corresponding function for prefix to infix conversion is
UNIPARSE.
The details of using the MACSYMA resource sharing facility may be
gathered from the annotated script of the example given in Section V
of this paper.
IV. CAPABILITIES AND LIMITATIONS
The program tries to be helpful to the user as much as possible. For
example, if for some reason the MIT-Mathlab computer is not
available, the MACSYMA service at the MIT-AI computer is procured.
It should be mentioned that though the program is fairly capable in
retrieving results, recognizing error messages, and separating
comments, its recognition is not fool-proof. The program only makes
Bhushan & Ryan [Page 4]
RFC 578 Using MIT-MATHLAB MACSYMA from MIT-DMS MUDDLE October 1973
an educated guess as to where the answer lies: it is not as clever as
a human user sitting at a console, who can filter out such messages
as "System going down" and communication from another user (console-
link) if they were to appear in the middle of the result. This
points to one of the pitfalls of using a facility via a program that
is basically designed for use by human users.
The program reliability can be marginally improved by asking MACSYMA
to print special characters before and after the results it sends
(but again this is not fool-proof). For example, the following input
to MACSYMA:
Block ([ans],
print (/(),
ans: diff (X^2,X),
print (string (ans))
print (/)),
return (ans));
will cause MACSYMA to generate the following output:
(
2*X
)
(D**) 2X
From the above output, the answer "2*X" can be easily extracted.
The resource sharing program does however recognize the so-called
"unintegratable" functions such as "EXP (X^2)" -- and gives the
correct error response. Normally, the user is in "TERSE" mode, and
does not see the interaction between MACSYMA and MUDDLE. To see the
interaction the user must enter "VERBOSE" mode by typing:
<VERBOSE>$
to MUDDLE. To return to "TERSE" mode the user types:
<TERSE>$
The user can also, if he is proficient in use of MACSYMA, communicate
directly with MACSYMA at any point by typing:
<TELCOM 1>$
Bhushan & Ryan [Page 5]
RFC 578 Using MIT-MATHLAB MACSYMA from MIT-DMS MUDDLE October 1973
to MUDDLE. The TELCOM feature may be useful if the user wishes to
see what is going on, or wants to examine the MACSYMA computations by
entering the LISP environment (typing <Control-G> to MACSYMA). To
return to MUDDLE and the automated environment, the user first
escapes to MUDDLE by typing <Control-E>, and then types:
<AUTO>$
to MUDDLE. If the user types "<ERRET 1>$" after escaping to MUDDLE
from "TELCOM" mode, he will be returned in direct communication with
MACSYMA. If the user discovers that his "MACSYMA" is hopelessly
confused or if he wishes to start a new version of MACSYMA, he must
type:
<DIS>$
to MUDDLE, which will disconnect him. Typing "<MACSYMA>$" or using
any of the functions that use MACSYMA will connect him to MACSYMA
again.
Currently, MUDDLE recognizes and takes action as described above
whenever differentiate, integrate, expand, simplify, and
integrate.simplify (integrate and simplify) functions are
encountered. But it is quite easy to generate programs for other
operations such as Laplace transforms and solving equations. The
prefix-to-infix conversion and vice-versa works for all mathematical
forms we have encountered so far in our short experiment.
An alternate way to utilize MACSYMA's capabilities would have been to
use it in the LISP environment by constructing a suitable interface
between LISP and MUDDLE. Such an approach would avoid the multiple
conversions from prefix to infix form and vice-versa, but other,
perhaps more difficult, conversions would be required.
V. EXAMPLE
The following scenario describes the use of the resource-sharing
facility. The facility is accessible in the MUDDLE system at MIT-
DMS. The interaction between MUDDLE and MACSYMA, normally not
visible to the user, is also shown here (in VERBOSE mode) so that the
reader may gain a better understanding of how the program operates.
It should be noted that the graphs will be plotted only if the user
has loaded the "graphics package" and is on an IMLAC or ARDS console.
We would also like to stress that this scenario is not intended to
demonstrate the full capabilities of MACSYMA, or of MUDDLE, but only
to illustrate the resource sharing facility.
SCENARIO FOR USING THE MUDDLE-MACSYMA FACILITY
Bhushan & Ryan [Page 6]
RFC 578 Using MIT-MATHLAB MACSYMA from MIT-DMS MUDDLE October 1973
(In the following scenario, user input is underlined and our comments
are preceded with a semicolon. <CR> represents a carriage return and
$ represents <ESC> or alt-mode. The user is assumed to be logged in
at MIT-DMS (Host 70). Note that the input should be typed exactly as
shown, as MUDDLE distinguishes between upper and lower case
characters. Please refer to "THE MUDDLE PRIMER" (SYS.11.01) by Greg
Pfister for a description of the MUDDLE system and to "MUDDLE CONSOLE
GRAPHICS USER GUIDE" (SYS.11.11) by Neal Ryan for a description of
the graphics package. Both documents are available from the
Programming Technology Division at Project MAC.)
[;]MUDDLE<CR> ; Get a MUDDLE, ';' is MONIT prompt.
----------
MUDDLE 42 IN OPERATION.
LISTENING-AT-LEVEL 1 PROCESS 1
<FLOAD "MUDDLE;MACSYM">$ ; Load the program from MUDDLE
------------------------ ; directory.
/METMUDGIN GOUT
GIN GOUT ; Harmless comments from MUDDLE.
"DONE"
<DIFF '<- <* .X <LOG .X>> .X>>$
-------------------------------
PLEASE BE PATIENT, MACSYMA LOADING MAY TAKE TIME
MACSYMA AT MIT-MATHLAB ; Comments from the program.
<LOG .X> ; The result is a MUDDLE form.
<INTEGRATE '<LOG .X>>$
----------------------
SIN FASL DSK MACSYM BEING LOADED
LOADING DONE ; Comments from MACSYMA.
SCHATC FASL DSK MACSYM BEING LOADED
LOADING DONE
<- <* .X <LOG .X>> .X> ; The answer again.
<SET A <INTEGRATE "X/(X^3+1)">>$; The input is in infix form.
--------------------------------
"LOG(X^2-X+1)/6+ATAN((2*X-1)/SQRT(3))/SQRT(3)-LOG(X+1)/3"
; The answer now is in infix form.
<SET B <DIFF .A>>$
------------------
"2/(3*((2*X-1)^2/3+1))+(2*X-1)/(6*(X^2-X+1))-1/(3*(X+1))"
<SIMPLIFY .B>$
--------------
"X/(X^3+1)" ; We get back the original expression.
<EXPAND '<^ <+ .X 2> 5>>$
-------------------------
<+ <+ <+ <+ <+ <^ .X 5> <* 10 <^ .X 4>>> <* 40 <^ .X 3>>>
<* 80 <^ .X 2>>> <* 80 .X>> 32>
<INTEGRATE '<EXP <^ .X 2>>>$
----------------------------
Bhushan & Ryan [Page 7]
RFC 578 Using MIT-MATHLAB MACSYMA from MIT-DMS MUDDLE October 1973
RISCH FASL DSK MACSYM BEING LOADED
LOADING DONE
*ERROR* ; Program recognizes that MACSYMA
CANT-INTEGRATE ; couldn't integrate.
LISTENING-AT-LEVEL 2 PROCESS 1
<ERRET>$ ; To get back to level 1.
--------
LISTENING-AT-LEVEL 1 PROCESS 1
<DIS>$ ; We disconnect here to show the verbose mode,
------ ; the program disconnects automatically on quitting.
"CONNECTIONS CLOSED NOW"
<VERBOSE>$
----------
"YOU WILL BE ABLE TO OBSERVE MUDDLE-MACSYMA INTERACTION NOW"
<DIFF '<^ .X 3>>$
-----------------
PLEASE BE PATIENT, MACSYMA LOADING MAY TAKE TIME
MIT MATHLAB PDP-10 STELNT.59
ML ITS.1. DDT.516.
10. USERS
:LOGIN 70GUEST ; The program uses User's SNAME (GUEST here).
:MACSYMA
THIS IS MACSYMA 226
SEE UPDATE > MACSYM; FOR CHANGES
FIX 226 DSK MACSYM BEING LOADED
LOADING DONE
(C1)
MACSYMA AT MIT-MATHLAB ; The program announces MACSYMA,
STRING (DIFF ((X^3),X,1)); ; and sends input in infix form.
(D1) 3*X^2
<* 3 <^ .X 2>> ; The output is in MUDDLE prefix form.
<INTEGRATE '</ .X <+ .X 1>>>$
-----------------------------
C2) STRING (INTEGRATE ((X/(X+1)),X));
SIN FASL DSK MACSYM BEING LOADED
LOADING DONE
SCHATC FASL DSK MACSYM BEING LOADED
LOADING DONE
(D2) X-LOG(X+1)
<- .X <LOG <+ .X 1>>> ; The output again.
<TERSE>$
--------
"OK" ; Back in TERSE mode now.
<FLOAD "MUDDLE;UGRF">$ ; To load graphics program
----------------------
IMLAC? (ANSWER Y OR N) Y ; for graphics on an IMLAC.
-
Bhushan & Ryan [Page 8]
RFC 578 Using MIT-MATHLAB MACSYMA from MIT-DMS MUDDLE October 1973
"DONE"
<GRAPH <SLT A '<^ <SIN .X> 2>> X -3 3>$
---------------------------------------
; To graph function sin(X)^2 (graph 1 on Figure 1).
<GRAPH <DIFF .A>>$
-------------------
; To graph diff of sin(X)^2 (see graph 2, Figure 1).
<GRAPH <INTEGRATE .A>>$
-----------------------
; To graph integral of sin(X)^2 (see graph 3, Figure 1).
<QUIT>$ ; To quit from program and MUDDLE.
-------
KILL
[;] ; semicolon prompt from MONIT.
Bhushan & Ryan [Page 9]
RFC 578 Using MIT-MATHLAB MACSYMA from MIT-DMS MUDDLE October 1973
FIG 1. GRAPH FOR SIN(X)^2, DIFF(SIN(X)^2), AND INTEGRATE(SIN(X)^2)
--+--2.0
|
|
| +++ (3)
| ++++
| ++
| +
| ++
ooo **** --+-- ooo ***+
o o** ** | o o** + **
o *o * | o *o + *
o * * | o * + *
o * o * | o * o *
* o * | * + o *
o ** ** |o ** ++ **
| * | o * | * ++ o | * (1) |
|-------**-------+-----------+++++o+++++-----------+-------**-------|
|-4.0 | o ++ | o | (2) |4.0
++ o| o
o + | o
o o | o o
+ o | o
+ o o | o o
+ o o | o o
+ ooo --+-- -1.0 ooo
++ |
+ |
++ |
++++ |
+++ |
|
|
--+-- -2.0
[ This RFC was put into machine readable form for entry ]
[ into the online RFC archives by Graeme Hewson 3/98 ]
Bhushan & Ryan [Page 10]
