├── cffk
    └── cpoly.lisp.64
├── das
    └── mstuff.lisp.21
├── ellen
    └── option.lisp.88
├── emaxim
    ├── edbuf.lisp.39
    ├── edctl.lisp.22
    ├── edexp.lisp.174
    ├── edlm.lisp.20
    └── edmac.lisp.106
├── jim
    ├── askp.lisp.85
    ├── limit.lisp.273
    └── tlimit.lisp.47
├── jm
    ├── risch.lisp.434
    ├── simp.lisp.834
    ├── sin.lisp.200
    ├── sinint.lisp.140
    └── zero.lisp.23
├── jpg
    ├── comm.lisp.395
    ├── comm2.lisp.56
    ├── dskfn.lisp.169
    ├── mlisp.lisp.613
    └── suprv.lisp.619
├── libmax
    ├── defcal.lisp.12
    ├── defopt.lisp.8
    ├── displm.lisp.10
    ├── maxmac.lisp.198
    ├── mdefun.lisp.57
    ├── mforma.lisp.99
    ├── mopers.lisp.48
    ├── mrgmac.lisp.21
    ├── numerm.lisp.12
    ├── procs.lisp.16
    ├── strmac.lisp.4
    ├── transm.lisp.127
    └── transq.lisp.83
├── lmmax
    ├── array.lisp.11
    ├── bessel.lisp.24
    ├── compat.lisp.75
    ├── ellipt.lisp.23
    ├── iffun.lisp.24
    ├── let.qfasl.1
    ├── lmsup.lisp.90
    ├── misc.lisp.51
    ├── mormac.lisp.3
    ├── mudoc.lisp.14
    ├── patch-1.directory.1
    ├── patch.directory.1
    ├── plot.lisp.61
    ├── plot3d.lisp.21
    ├── plotll.lisp.62
    ├── pltwin.lisp.27
    ├── scrc-sysdef.lisp.1
    └── scrc-sysdef.lisp.2
├── lmmaxq
    ├── algfac.qfasl.1
    ├── algsys.qfasl.1
    ├── array.qfasl.1
    ├── askp.qfasl.1
    ├── asum.qfasl.1
    ├── bessel.qfasl.1
    ├── buildq.qfasl.1
    ├── combin.qfasl.2
    ├── comm.qfasl.2
    ├── comm2.qfasl.3
    ├── compar.qfasl.2
    ├── compat.qfasl.1
    ├── cpoly.qfasl.1
    ├── csimp.qfasl.1
    ├── csimp2.qfasl.1
    ├── db.qfasl.1
    ├── defcal.qfasl.1
    ├── defint.qfasl.1
    ├── defopt.qfasl.1
    ├── displa.qfasl.2
    ├── displm.qfasl.1
    ├── dskfn.qfasl.3
    ├── edbuf.qfasl.1
    ├── edctl.qfasl.1
    ├── edexp.qfasl.1
    ├── edlm.qfasl.1
    ├── edmac.qfasl.1
    ├── ellipt.qfasl.1
    ├── factor.qfasl.1
    ├── float.qfasl.1
    ├── fortra.qfasl.1
    ├── grind.qfasl.1
    ├── hayat.qfasl.1
    ├── homog.qfasl.1
    ├── iffun.qfasl.1
    ├── inmis.qfasl.1
    ├── irinte.qfasl.2
    ├── laplac.qfasl.1
    ├── ldisp.qfasl.1
    ├── lesfac.qfasl.1
    ├── limit.qfasl.1
    ├── linnew.qfasl.1
    ├── lmsup.qfasl.2
    ├── logarc.qfasl.1
    ├── macros.qfasl.1
    ├── mat.qfasl.1
    ├── matcom.qfasl.1
    ├── matrix.qfasl.3
    ├── matrun.qfasl.2
    ├── maxmac.qfasl.2
    ├── mdot.qfasl.2
    ├── merror.qfasl.1
    ├── mforma.qfasl.1
    ├── mformt.qfasl.1
    ├── mhayat.qfasl.1
    ├── misc.qfasl.1
    ├── mlisp.qfasl.3
    ├── mload.qfasl.1
    ├── mmacro.qfasl.1
    ├── mopers.qfasl.1
    ├── mormac.qfasl.1
    ├── mrgmac.qfasl.1
    ├── mstuff.qfasl.1
    ├── mutils.qfasl.1
    ├── nalgfa.qfasl.1
    ├── newdet.qfasl.1
    ├── newinv.qfasl.1
    ├── nforma.qfasl.1
    ├── nisimp.qfasl.1
    ├── nparse.qfasl.1
    ├── nrat4.qfasl.1
    ├── numer.qfasl.1
    ├── numerm.qfasl.1
    ├── numth.qfasl.1
    ├── opers.qfasl.1
    ├── optim.qfasl.2
    ├── option.qfasl.1
    ├── outmis.qfasl.1
    ├── pade.qfasl.1
    ├── plot.qfasl.2
    ├── plot3d.qfasl.1
    ├── plotll.qfasl.2
    ├── pltwin.qfasl.1
    ├── polyrz.qfasl.1
    ├── procs.qfasl.1
    ├── psolve.qfasl.1
    ├── rat3a.qfasl.1
    ├── rat3b.qfasl.1
    ├── rat3c.qfasl.1
    ├── rat3d.qfasl.1
    ├── rat3e.qfasl.2
    ├── ratmac.qfasl.1
    ├── ratout.qfasl.1
    ├── residu.qfasl.1
    ├── result.qfasl.1
    ├── risch.qfasl.1
    ├── rpart.qfasl.2
    ├── runtim.qfasl.1
    ├── schatc.qfasl.1
    ├── scs.qfasl.1
    ├── series.qfasl.1
    ├── simp.qfasl.2
    ├── sin.qfasl.2
    ├── sinint.qfasl.1
    ├── solve.qfasl.1
    ├── specfn.qfasl.1
    ├── spgcd.qfasl.1
    ├── sprdet.qfasl.1
    ├── strmac.qfasl.1
    ├── sublis.qfasl.1
    ├── sumcon.qfasl.1
    ├── suprv.qfasl.2
    ├── system.qfasl.1
    ├── tlimit.qfasl.1
    ├── trgred.qfasl.1
    ├── trigi.qfasl.1
    ├── trigo.qfasl.1
    ├── ufact.qfasl.1
    ├── utils.qfasl.1
    └── zero.qfasl.1
├── lmmaxr
    ├── acall.qfasl.1
    ├── evalw.qfasl.1
    ├── fcall.qfasl.1
    ├── intpol.qfasl.1
    ├── mdefun.qfasl.1
    ├── mudoc.qfasl.1
    ├── rombrg.qfasl.1
    ├── trans1.qfasl.1
    ├── trans2.qfasl.1
    ├── trans3.qfasl.1
    ├── trans4.qfasl.1
    ├── trans5.qfasl.1
    ├── transf.qfasl.1
    ├── transl.qfasl.1
    ├── transm.qfasl.1
    ├── transq.qfasl.2
    ├── transs.qfasl.1
    ├── trdata.qfasl.1
    ├── trmode.qfasl.1
    ├── troper.qfasl.1
    ├── trpred.qfasl.1
    ├── trprop.qfasl.1
    └── trutil.qfasl.1
├── macrak
    ├── logarc.lisp.27
    └── rpart.lisp.263
├── maxdoc
    ├── lmdcls.lisp.1
    └── lmdcls.qfasl.2
├── maxii
    ├── nparse.lisp.158
    └── system.lisp.43
├── maxsrc
    ├── inmis.lisp.98
    ├── intpol.lisp.13
    ├── irinte.lisp.54
    ├── laplac.lisp.202
    ├── ldisp.lisp.43
    ├── mdot.lisp.94
    ├── merror.lisp.47
    ├── mformt.lisp.27
    ├── mload.lisp.121
    ├── mutils.lisp.11
    ├── numer.lisp.17
    ├── opers.lisp.75
    ├── outmis.lisp.309
    ├── rombrg.lisp.43
    ├── runtim.lisp.19
    ├── sublis.lisp.11
    ├── sumcon.lisp.18
    └── utils.lisp.26
├── mrg
    ├── compar.lisp.857
    ├── db.lisp.1145
    ├── displa.lisp.769
    ├── fortra.lisp.64
    ├── grind.lisp.150
    ├── nforma.lisp.15
    ├── optim.lisp.14
    ├── scs.lisp.60
    ├── trigi.lisp.343
    └── trigo.lisp.330
├── paulw
    ├── algfac.lisp.45
    ├── csimp.lisp.299
    ├── csimp2.lisp.63
    ├── defint.lisp.658
    ├── linnew.lisp.27
    ├── mat.lisp.286
    ├── matrix.lisp.320
    ├── newinv.lisp.89
    ├── residu.lisp.105
    └── sprdet.lisp.60
├── rat
    ├── algsys.lisp.149
    ├── factor.lisp.472
    ├── float.lisp.321
    ├── hayat.lisp.396
    ├── homog.lisp.39
    ├── lesfac.lisp.147
    ├── matcom.lisp.98
    ├── matrun.lisp.80
    ├── mhayat.lisp.61
    ├── nalgfa.lisp.67
    ├── newdet.lisp.12
    ├── nisimp.lisp.81
    ├── nrat4.lisp.265
    ├── pade.lisp.42
    ├── polyrz.lisp.93
    ├── psolve.lisp.19
    ├── rat3a.lisp.258
    ├── rat3b.lisp.95
    ├── rat3c.lisp.302
    ├── rat3d.lisp.264
    ├── rat3e.lisp.546
    ├── ratmac.lisp.30
    ├── ratout.lisp.64
    ├── result.lisp.30
    ├── solve.lisp.401
    ├── spgcd.lisp.110
    └── ufact.lisp.32
├── reh
    ├── buildq.lisp.9
    └── mmacro.lisp.50
├── rz
    ├── asum.lisp.271
    ├── combin.lisp.152
    ├── macros.lisp.47
    ├── numth.lisp.47
    ├── schatc.lisp.54
    ├── series.lisp.133
    └── trgred.lisp.88
├── transl
    ├── acall.lisp.68
    ├── evalw.lisp.11
    ├── fcall.lisp.40
    ├── trans1.lisp.107
    ├── trans2.lisp.39
    ├── trans3.lisp.47
    ├── trans4.lisp.27
    ├── trans5.lisp.26
    ├── transf.lisp.11
    ├── transl.lisp.1157
    ├── transs.lisp.79
    ├── trdata.lisp.67
    ├── trmode.lisp.69
    ├── troper.lisp.15
    ├── trpred.lisp.6
    ├── trprop.lisp.1
    └── trutil.lisp.22
└── wgd
    └── specfn.lisp.96


/das/mstuff.lisp.21:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1981 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module mstuff)
 6 | 
 7 | (DECLARE (SPLITFILE MSORT) (FIXNUM N))
 8 | 
 9 | (DEFMFUN $SORT N
10 |   (IF (OR (= N 0) (> N 2)) (MERROR "SORT takes 1 or 2 arguments."))
11 |   (LET ((LLIST (ARG 1)) COMPARFUN BFUN)
12 |        (IF (NOT ($LISTP LLIST))
13 | 	   (MERROR "The first argument to SORT must be a list:~%~M" LLIST))
14 |        (SETQ LLIST (APPEND (CDR LLIST) NIL)
15 | 	     COMPARFUN 
16 | 	     (MFUNCTION1 (SETQ BFUN (IF (= N 2) (GETOPR (ARG 2)) 'LESSTHAN))))
17 |        (IF (MEMQ BFUN '(LESSTHAN GREAT))
18 | 	   (SETQ LLIST (MAPCAR #'RATDISREP LLIST)))
19 |        (CONS '(MLIST SIMP) (SORT LLIST COMPARFUN))))
20 | 
21 | (DEFUN MFUNCTION1 (FUN)
22 |   `(LAMBDA (X Y) (MEVALP `((,',FUN) ((MQUOTE) ,X) ((MQUOTE) ,Y)))))
23 | 
24 | (DEFUN LESSTHAN (A B) (GREAT B A))
25 | 
26 | (DECLARE (SPLITFILE MAKEL))
27 | 
28 | (DEFMSPEC $MAKELIST (X) (SETQ X (CDR X))
29 |    (PROG (N FORM ARG A B LV D)
30 |       (SETQ N (LENGTH X))
31 |       (IF (OR (< N 3) (> N 4))
32 | 	  (MERROR "MAKELIST takes 3 or 4 arguments."))
33 |       (SETQ FORM (CAR X)
34 | 	    ARG (CADR X)
35 | 	    A (MEVAL (CADDR X))
36 | 	    LV (COND ((= N 3) 
37 | 		      (IF ($LISTP A)
38 | 			  (MAPCAR #'(LAMBDA (U) (LIST '(MQUOTE) U)) (CDR A))
39 | 			  (MERROR "
40 | If 3 arguments are given to MAKELIST,
41 | the 3rd argument should evaluate to a list:~%~M" A)))
42 | 		     (T
43 | 		      (SETQ B (MEVAL (CADDDR X)))
44 | 		      (IF (OR (NOT (EQ (TYPEP (SETQ D (SUB* B A))) 'FIXNUM))
45 | 			      (< D -1))
46 | 			  (MERROR "
47 | If 4 arguments are given to MAKELIST, the difference of the 3rd
48 | and 4th arguments should evaluate to a non-negative integer:~%~M" D)
49 | 			  (INTERVAL A B)))))
50 |       (RETURN 
51 | 	 (DO ((LV LV (CDR LV)) (ANS))
52 | 	     ((NULL LV) (CONS '(MLIST SIMP) (NREVERSE ANS)))
53 | 	     (SETQ ANS (CONS (MEVAL `(($EV)
54 | 				      ,@(LIST (LIST '(MQUOTE) FORM)
55 | 					  (LIST '(MEQUAL SIMP) 
56 | 						ARG 
57 | 						(CAR LV)))))
58 | 			     ANS))))))
59 | 
60 | (DEFUN INTERVAL (I J)
61 |    (DO ((NN I (ADD2 1 NN)) (M 0 (1+ M)) (K (SUB* J I)) (ANS))
62 |        ((> M K) (NREVERSE ANS))
63 |        (SETQ ANS (CONS NN ANS))))
64 | 
65 | (DEFMFUN $SUBLIST (A F)
66 |   (IF ($LISTP A)
67 |       (DO ((A (CDR A) (CDR A)) (X))
68 | 	  ((NULL A) (CONS '(MLIST SIMP) (NREVERSE X)))
69 | 	  (IF (MEVALP (LIST (NCONS F) (CAR A)))
70 | 	      (SETQ X (CONS (CAR A) X))))
71 |       (MERROR "The first argument to SUBLIST must be a list:~%~M" A)))
72 | 
73 | ; Undeclarations for the file:
74 | (DECLARE (NOTYPE N))
75 | 


--------------------------------------------------------------------------------
/jim/tlimit.lisp.47:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1980 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module tlimit)
 6 | (load-macsyma-macros rzmac)
 7 | 
 8 | ;; TOP LEVEL FUNCTION(S): $TLIMIT $TLDEFINT
 9 | 
10 | (DECLARE (GENPREFIX TL)
11 | 	 (*LEXPR $LIMIT)
12 | 	 (SPECIAL $TLIMSWITCH TAYLORED EXP VAR VAL LL UL
13 | 		  SILENT-TAYLOR-FLAG)) 
14 | 
15 | (DEFMFUN $TLIMIT NARGS 
16 |        ((LAMBDA ($TLIMSWITCH) (APPLY '$LIMIT (LISTIFY NARGS))) T)) 
17 | 
18 | (DEFMFUN $TLDEFINT (EXP VAR LL UL) 
19 |        ((LAMBDA ($TLIMSWITCH) ($LDEFINT EXP VAR LL UL)) T))
20 | 
21 | (DEFUN TLIMP (EXP) ; TO BE EXPANDED TO BE SMARTER (MAYBE)
22 |        T) 
23 | 
24 | (DEFUN TAYLIM (E *I*) 
25 |   (PROG (EX)
26 | 	(SETQ EX (*CATCH 'TAYLOR-CATCH
27 | 			 (let ((SILENT-TAYLOR-FLAG t))
28 | 			   ($TAYLOR E VAR (RIDOFAB VAL) 1.))))
29 | 	(OR EX (RETURN (COND ((EQ *I* T) (LIMIT1 E VAR VAL))
30 | 			     ((EQ *I* 'THINK) (COND ((MEMQ (CAAR EXP)
31 | 							   '(MTIMES MEXPT))
32 | 						     (LIMIT1 E VAR VAL))
33 | 						    (T (SIMPLIMIT E VAR VAL))))
34 | 			     (T (SIMPLIMIT E VAR VAL)))))
35 | 	(RETURN
36 | 	 (let ((TAYLORED t))
37 | 	   (LIMIT
38 | 	    (SIMPLIFY
39 | 	     ($logcontract ($RATDISREP ex)))
40 | 	    ;;(COND ((EQ (CADR EX) 'PS)
41 | 	    ;;       (CONS (CAR EX)
42 | 	    ;;             (LIST 'PS (THIRD EX) (FOURTH EX)
43 | 	    ;;                   (FIFTH EX))))
44 | 	    ;;      (t (EX)))
45 | 	    VAR
46 | 	    VAL
47 | 	    'THINK)))))
48 | 
49 | (DECLARE (UNSPECIAL TAYLORED EXP VAR VAL LL UL)) 
50 | 


--------------------------------------------------------------------------------
/jm/zero.lisp.23:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1982 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module zero)
 6 | 
 7 | (DECLARE (SPECIAL S VAR EXP V1 V R1 R2 $NUMER $LISTCONSTVARS VARLIST GENVAR)
 8 | 	 (*LEXPR $RAT))
 9 | 
10 | (DEFMFUN $ZEROEQUIV (EXP VAR)
11 |        (PROG (R S V VARLIST GENVAR)
12 | 	     (SETQ EXP (SPECREPCHECK EXP))
13 | 	     (SETQ R (LET ($LISTCONSTVARS) ($LISTOFVARS EXP)))
14 | 	     (IF (AND (CDR R) (OR (CDDR R) (NOT (ALIKE1 (CADR R) VAR))))
15 | 		 (RETURN '$DONTKNOW))
16 | 	     (SETQ EXP ($EXPONENTIALIZE EXP))
17 | 	     (SETQ R (SDIFF EXP VAR))
18 | 	     (IF (ISINOP R '%DERIVATIVE) (RETURN '$DONTKNOW))
19 | 	     ($RAT R)
20 | 	     (SETQ R ($RAT EXP))
21 | 	     (SETQ S (CAR R))
22 | 	     (SETQ V (RATNUMERATOR (CDR R)))
23 | 	     (RETURN (ZEROEQUIV1 V))))
24 | 
25 | (DEFUN ZEROEQUIV1 (V)
26 |        (PROG (V1 V2 COEFF DEG)
27 | 	     (IF (ATOM V) (RETURN (EQUAL V 0)))
28 |    COEFFLOOP (IF (NULL (CDR V)) (RETURN T))
29 |              (SETQ DEG (CADR V))
30 | 	     (IF (EQUAL DEG 0) (RETURN (ZEROEQUIV1 (CADDR V))))
31 | 	     (SETQ COEFF (CADDR V))
32 | 	     (WHEN (ZEROEQUIV1 COEFF)
33 | 		   (SETQ V (CONS (CAR V) (CDDDR V)))
34 | 		   (GO COEFFLOOP))
35 | 	     (SETQ V1 ($RAT (SDIFF (RATDISREP (CONS S (CONS V (CADDR V))))
36 | 				   VAR)))
37 | 	     (SETQ V2 (CADR ($RAT (RATDISREP V1))))
38 | 	     (IF (EQUAL (PDEGREE V2 (CAR V)) (CADR V))
39 | 		 (RETURN (ZEROEQUIV2 V)))
40 | 	     (IF (LESSP (PDEGREE V2 (CAR V)) (CADR V))
41 | 		 (RETURN (IF (ZEROEQUIV1 V2) (ZEROEQUIV2 V))))
42 | 	     (RETURN '$DONTKNOW)))
43 | 
44 | (DEFUN ZEROEQUIV2 (V)
45 |        (PROG (R R1 R2)
46 | 	     (SETQ R (SIN (TIMES 0.001 (RANDOM 1000.))))
47 | 	     (SETQ V (SUBSTITUTE R VAR (RATDISREP (CONS S (CONS V 1)))))
48 | 	     (SETQ V (MEVAL '(($EV) V $NUMER)))
49 | 	     (COND ((AND (NUMBERP V) (LESSP (ABS V) (TIMES R 0.01)))
50 | 		    (RETURN T))
51 | 		   ((NUMBERP V) (RETURN NIL)))
52 | 	     (IF (AND (FREE V '$%I) (NOT (ISINOP V '%LOG)))
53 | 		 (RETURN '$DONTKNOW))
54 | 	     (SETQ R1 ($REALPART V))
55 | 	     (SETQ R1 (MEVAL '(($EV) R1 $NUMER)))
56 | 	     (IF (NOT (NUMBERP R1)) (RETURN '$DONTKNOW))
57 | 	     (SETQ R2 ($IMAGPART V))
58 | 	     (SETQ R2 (MEVAL '(($EV) R2 $NUMER)))
59 | 	     (IF (NOT (NUMBERP R2)) (RETURN '$DONTKNOW))
60 | 	     (COND ((AND (LESSP (ABS R1) (TIMES R 0.01))
61 | 			 (LESSP (ABS R2) (TIMES R 0.01)))
62 | 		    (RETURN T))
63 | 		   (T (RETURN NIL)))))
64 | 


--------------------------------------------------------------------------------
/libmax/defopt.lisp.8:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1980 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module defopt macro)
 6 | 
 7 | ;; For defining optimizers which run on various systems.
 8 | ;; Q: What is an optimizer?
 9 | ;; A: A transformation which takes place in the compiler.
10 | 
11 | ;; ***==> Right now, DEFOPT is used just like you would a DEFMACRO <==***
12 | ;; (defopt <name> <arlist> <body-boo>)
13 | 
14 | ;; PDP-10 Maclisp:
15 | ;; SOURCE-TRANS property is a list of functions (F[1] F[2] ... F[n]).
16 | ;; F[k] is funcalled on the <FORM>, it returns (VALUES <NEW-FORM> <FLAG>).
17 | ;; If <FLAG> = NIL then compiler procedes to F[k+1]
18 | ;; If <FLAG> = T then compiler calls starts again with F[1].
19 | 
20 | ;; LispMachine Lisp:
21 | ;; COMPILER:OPTIMIZERS property is a list of functions as in PDP-10 Maclisp.
22 | ;; F[k] returns <NEW-FORM>. Stop condition is (EQ <FORM> <NEW-FORM>).
23 | 
24 | ;; VAX NIL (with compiler "H"):
25 | ;; SOURCE-CODE-REWRITE property is a function, returns NIL if no rewrite,
26 | ;; else returns NCONS of result to recursively call compiler on.
27 | 
28 | ;; Multics Maclisp:
29 | ;; ???
30 | ;; Franz Lisp:
31 | ;; ???
32 | 
33 | ;; General note:
34 | ;; Having a list of optimizers with stop condition doesn't provide
35 | ;; any increase in power over having a single property. For example,
36 | ;; only two functions in LISPM lisp have more than one optimizer, and
37 | ;; no maclisp functions do. It just isn't very usefull or efficient
38 | ;; to use such a crude mechanism. What one really wants is to be able
39 | ;; to define a set of production rules in a simple pattern match
40 | ;; language. The optimizer for NTH is a case in point:
41 | ;; (NTH 0 X) => (CAR X)
42 | ;; (NTH 1 X) => (CADR X)
43 | ;; ...
44 | ;; This is defined on the LISPM as a single compiler:optimizers with
45 | ;; a hand-compiled pattern matcher.
46 | 
47 | #+LISPM
48 | (progn 'compile
49 | (defmacro defopt-internal (name . other)
50 |   `(defun (,name opt) . ,other))
51 | (defun opt-driver (form)
52 |   (funcall (get (car form) 'opt) form))
53 | (defmacro defopt (name . other)
54 |   `(progn 'compile
55 | 	  ,(si:defmacro1 (cons name other) 'defopt-internal)
56 | 	  (defprop ,name (opt-driver) compiler:optimizers))))
57 | #+PDP10
58 | (progn 'compile
59 | (defun opt-driver (form)
60 |   (values (apply (get (car form) 'opt)
61 | 		 (cdr form))
62 | 	  t))
63 | ;; pdp10 maclisp has argument destructuring available in
64 | ;; vanilla defun.
65 | (defmacro defopt (name . other)
66 |   `(progn 'compile
67 | 	  (defun (,name opt) . ,other)
68 | 	  (defprop ,name (opt-driver) source-trans)))
69 | )
70 | #+NIL
71 | (progn 'compile
72 | (defun opt-driver (form)
73 |   (ncons (apply (get (car form) 'opt) (cdr form))))
74 | (defmacro defopt (name argl . other)
75 |   `(progn 'compile
76 | 	  (defun (,name opt) ,argl . ,other)
77 | 	  (defprop ,name opt-driver source-code-rewrite)))
78 | )
79 | #+(or Multics Franz)
80 | (defmacro defopt (name argl . other)
81 |   `(defmacro ,name ,argl . ,other))
82 | 
83 | 


--------------------------------------------------------------------------------
/libmax/numerm.lisp.12:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1980 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module numerm macro)
 6 | 
 7 | ;;; Macros for interface of lisp numerical routines to macsyma,
 8 | ;;; for use with the functions in Maxsrc;Numer.
 9 | 
10 | (defmacro make-array$ (&rest l)
11 |   #+Maclisp
12 |   `(*array nil 'flonum ,@l)
13 |   #+LISPM
14 |   `(make-array (list ,@l) ':type 'art-q)
15 |   )
16 | 
17 | 
18 | (defmacro make-array% (&rest l)
19 |   #+Maclisp
20 |   `(*array nil 'fixnum ,@l)
21 |   #+Lispm
22 |   `(make-array (list ,@l) ':type 'art-q)
23 |   )
24 | 
25 | (defmacro aref$ (&rest l)
26 |   #+Maclisp
27 |   `(arraycall flonum ,@l)
28 |   #+Lispm
29 |   `(aref ,@l)
30 |   )
31 | 
32 | (defmacro aref% (&rest l)
33 |   #+Maclisp
34 |   `(arraycall fixnum ,@l)
35 |   #+Lispm
36 |   `(aref ,@l)
37 |   )
38 | 
39 | (defmacro free-array% (a)
40 |   #+Maclisp
41 |   `(*rearray ,a)
42 |   #+Lispm
43 |   ;; not useful to call return-array unless it is at end of area.
44 |   ;; programs do better to save arrays as a resource, this works
45 |   ;; in maclisp too.
46 |   a
47 |   )
48 | (defmacro free-array$ (a)
49 |   #+maclisp
50 |   `(*rearray ,a)
51 |   #+Lispm
52 |   a
53 |   )
54 | 
55 | (DEFMACRO DEFBINDTRAMP$ (NARGS)
56 |   (LET ((BIND-TRAMP$ (SYMBOLCONC 'BIND-TRAMP NARGS '$))
57 | 	(TRAMP$ (SYMBOLCONC 'TRAMP NARGS '$)))
58 |     `(PROGN 'COMPILE
59 | 	    (IF (FBOUNDP 'SPECIAL) (SPECIAL ,TRAMP$))
60 | 	    (DEFMACRO ,BIND-TRAMP$ (F G &REST BODY)
61 | 	      `(LET ((,',TRAMP$))
62 | 		 (LET ((,F (MAKE-TRAMP$ ,G ,',NARGS)))
63 | 		   ,@BODY))))))
64 | 
65 | (DEFBINDTRAMP$ 1)
66 | (DEFBINDTRAMP$ 2)
67 | (DEFBINDTRAMP$ 3)
68 | 
69 | (defmacro fcall$ (&rest l)
70 |   #+Maclisp
71 |   `(subrcall flonum ,@l)
72 |   #+Lispm
73 |   `(funcall ,@l)
74 |   )
75 | 
76 | ;; Central location for some important declarations.
77 | #+Maclisp
78 | (IF (FBOUNDP 'FLONUM)
79 |     (FLONUM (GCALL1$ NIL NIL)
80 | 	    (GCALL2$ NIL NIL NIL)
81 | 	    (MTO-FLOAT NIL)
82 | 	    ))
83 | 
84 | 
85 | 


--------------------------------------------------------------------------------
/libmax/procs.lisp.16:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1980 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module procs macro)
 6 | 
 7 | ;;; Fast dispatching off the property list with SUBRCALL.
 8 | ;;; MARCH 1980. -GJC
 9 | 
10 | ;;; The advantages:
11 | ;;; [1] (SUBRCALL NIL (GET (CAR FORM) 'FOO) FORM) is fast! (PUSHJ P @ 0 P)
12 | ;;; [2] Creates no extra symbols of the kind |NAME FOO|.
13 | ;;; The problems with using SUBRCALL:
14 | ;;; [1] Only have subrs in compiled code.
15 | ;;; [2] System-dependant.
16 | ;;; [3] Fixed number of arguments.
17 | 
18 | ;;; This macro package fixes problems [1] and [2]. 
19 | ;;; Number [3] isn't a problem for the parsers, translators and tree-walkers
20 | ;;; in macsyma.
21 | 
22 | (defun verify-as-subr-argument-list (property l n)
23 |   (if (or (memq '&rest l)
24 | 	  (memq '&optional l))
25 |       (error (list "bad argument list for a" property "property.") l)
26 |       (let ((length (- (length l)
27 | 		       (length (memq '&aux l)))))
28 | 	(if (eq n '*)
29 | 	    (if (< length 6.)
30 | 		length
31 | 		(error (list "argument list too long for a" property "property.") l))
32 | 	    (if (= n length)
33 | 		length
34 | 		(error (list "argument list for a" property "property must be"
35 | 			     n "long.")
36 | 		       l))))))
37 | 
38 | 
39 | (defun a-def-property (name argl body property n)
40 |   (verify-as-subr-argument-list property argl n)
41 |   (cond ((status feature pdp10)
42 | 	 (cond ((memq compiler-state '(maklap compile))
43 | 		`(defun (,name nil ,property) ,argl . ,body))
44 | 	       ('else
45 | 		(let ((f (symbolconc name '- property)))
46 | 		  `(progn (defprop ,name ,(make-jcall n f) ,property)
47 | 			  (defun ,f ,argl . ,body))))))
48 | 	('else
49 | 	 `(defun (,name ,property) ,argl . ,body))))
50 | 	 
51 | (defmacro def-def-property (name sample-arglist)
52 |   
53 |   `(defmacro ,(symbolconc 'def- name '-property) (name argl . body)
54 |      (a-def-property name argl body ',name 
55 | 		     ',(verify-as-subr-argument-list 'def-def-property
56 | 						       sample-arglist
57 | 						       '*))))
58 | 
59 | #+PDP10
60 | (progn 'compile
61 | (defun make-jcall (number-of-arguments name-to-call)
62 |   (boole 7 13._27.
63 | 	 (lsh number-of-arguments 23.)
64 | 	 (maknum name-to-call)))
65 | ;; SUBRCALL does argument checking in the interpreter, so
66 | ;; the FIXNUM's won't pass as subr-pointers.
67 | ;; The following code must be compiled in order to run interpreted code
68 | ;; which uses SUBR-CALL and DEF-DEF-PROPERTY.
69 | (defun subr-call-0 (f)          (subrcall nil f))
70 | (defun subr-call-1 (f a)        (subrcall nil f a))
71 | (defun subr-call-2 (f a b)      (subrcall nil f a b))
72 | (defun subr-call-3 (f a b c)    (subrcall nil f a b c))
73 | (defun subr-call-4 (f a b c d)  (subrcall nil f a b c d))
74 | (defun subr-call-5 (f a b c d e)(subrcall nil f a b c d e))
75 | (DEFMACRO SUBR-CALL (F &REST L)
76 |   (IF (MEMQ COMPILER-STATE '(MAKLAP COMPILE))
77 |       `(SUBRCALL NIL ,F ,@L)
78 |       `(,(cdr (assoc (length l)
79 | 			       '((0 . subrcall-0)
80 | 				 (1 . subrcall-1)
81 | 				 (2 . subrcall-2)
82 | 				 (3 . subrcall-3)
83 | 				 (4 . subrcall-4)
84 | 				 (5 . subrcall-5))))
85 | 		  ,f ,@l)))
86 | )
87 | 
88 | #-PDP10
89 | (DEFMACRO SUBR-CALL (F &REST L) `(FUNCALL ,F ,@L))


--------------------------------------------------------------------------------
/lmmax/array.lisp.11:
--------------------------------------------------------------------------------
 1 | ;;;; -*- Mode:Lisp; Package:Macsyma; -*-
 2 | 
 3 | (defun $listarray (ary)
 4 |  `((mlist) .
 5 |       ,(cond ((mget ary 'hashar)
 6 | 	      (mapcar (function (lambda (subs) ($arrayapply ary subs)))
 7 | 		      (cdddr (apply '$arrayinfo (list ary)))))
 8 | 	     ((mget ary 'array) (listarray (mget ary 'array)))
 9 | 	     (t (displa ary)
10 | 		(error "arg to listarray must be an array")))))
11 | 
12 | (defun $fillarray (ary1 ary2)
13 |   ((lambda (ary)
14 |        (setq ary (cond ((mget ary1 'array))
15 | 		       (t (displa ary1)
16 | 			  (error "first arg to fillarray must be a declared array"))))
17 |        (fillarray ary
18 | 		  (cond (($listp ary2) (cdr ary2))
19 | 			((mget ary2 'array))
20 | 			(t (displa ary2)
21 | 			   (error
22 | 			    "second arg to fillarray must be an array or list"))))
23 |        ary1)
24 |    nil))
25 | 
26 | (defun $rearray fexpr (l)
27 |        (cond ((> (length l) 6.) (displa l) (error "too many args to rearray"))
28 | 	     ((< (length l) 2.) (displa l) (error "too few args to rearray")))
29 |        ((lambda (ary)
30 | 		(setq l (cdr l)
31 | 		      l (mapcar (function
32 | 				 (lambda (x)
33 | 					 (setq x (meval x))
34 | 					 (cond ((not (fixp x))
35 | 						(displa x)
36 | 						(error
37 | 						 "non integer dimension to rearray")))
38 | 					 (1+ x)))
39 | 				l))
40 | 		(apply '*rearray (cons ary (cons (car (arraydims ary)) l))))
41 | 	(cond ((mget (car l) 'array))
42 | 	      (t (displa (car l))
43 | 		 (error "first arg to rearray must be a declared array")))))
44 | 
45 | (defun $arrayapply (ary subs) (meval ($arraymake ary subs)))
46 | 


--------------------------------------------------------------------------------
/lmmax/compat.lisp.75:
--------------------------------------------------------------------------------
 1 | ;; -*- Mode: Lisp; Package: Macsyma -*-
 2 | 
 3 | ;; Maclisp compatibility definitions for the Lisp Machine.  This file
 4 | ;; is for Lisp differences only.  No knowledge of Macsyma should be
 5 | ;; contained in this file.
 6 | 
 7 | ;; Couldn't this copy to some static area?
 8 | (DEFMACRO PURCOPY (X) X)
 9 | 
10 | (DEFMACRO CHARPOS (IGNORE) '(CDR (CURSORPOS)))
11 | (DEFMACRO SLEEP (SECONDS) `(PROCESS-SLEEP (FIX (* ,SECONDS 60.))))
12 | 
13 | (DEFUN LINEL (&OPTIONAL STREAM)
14 |   (FUNCALL (SI:DECODE-PRINT-ARG STREAM) ':SIZE-IN-CHARACTERS))
15 | 
16 | ;; Perhaps this should do something.
17 | (DEFMACRO NOINTERRUPT (IGNORE) NIL)
18 | 
19 | (DEFMACRO FIXNUM-IDENTITY (X) X)
20 | (DEFMACRO FLONUM-IDENTITY (X) X)
21 | 
22 | ;; Keep the compiler quiet.
23 | ;; Use GET-PNAME or FORMAT instead of EXPLODE, EXPLODEN, EXPLODEC.
24 | ;; Use AREF instead of GETCHAR and GETCHARN.
25 | ;; Use MAKE-SYMBOL instead of MAKNAM.
26 | ;; Use INTERN instead of IMPLODE.
27 | ;; Use STRING-LESSP instead of ALPHALESSP.
28 | 
29 | (REMPROP 'EXPLODE       'COMPILER:STYLE-CHECKER)
30 | (REMPROP 'EXPLODEC      'COMPILER:STYLE-CHECKER)
31 | (REMPROP 'EXPLODEN      'COMPILER:STYLE-CHECKER)
32 | (REMPROP 'ALPHALESSP    'COMPILER:STYLE-CHECKER)
33 | (REMPROP 'GETCHARN      'COMPILER:STYLE-CHECKER)
34 | (REMPROP 'GETCHAR       'COMPILER:STYLE-CHECKER)
35 | (REMPROP 'IMPLODE       'COMPILER:STYLE-CHECKER)
36 | (REMPROP 'MAKNAM        'COMPILER:STYLE-CHECKER)
37 | 
38 | (DEFMACRO WHEN (PRED &BODY BODY)
39 |   `(COND (,PRED . ,BODY)))
40 | 
41 | (DEFMACRO UNLESS (PRED &BODY BODY)
42 |   `(COND ((NOT ,PRED) . ,BODY)))
43 | 
44 | (DEFMACRO SFA-CALL (STREAM OPERATION ARG)
45 |   `(FUNCALL ,STREAM (READ-FROM-STRING (STRING-APPEND #/: ,OPERATION)) ,ARG))
46 | 
47 | ;; Things that appear within DECLARE bodies.
48 | 
49 | ;; Why doesn't this work?
50 | ;; Because of the brain-damaged way the lispm compiler is written. -gjc
51 | ;; (PUTPROP 'DECLARE '(DECLARE-OPTIMIZER) 'COMPILER:OPTIMIZERS)
52 | ;;
53 | ;; (DEFUN DECLARE-OPTIMIZER (DECLARE-FORM &AUX (RETURN-FORM NIL))
54 | ;;   (DO ((L (REVERSE (CDR DECLARE-FORM)) (CDR L)))
55 | ;;       ((NULL L))
56 | ;;     (IF (NOT (MEMQ (CAAR L)
57 | ;; 		   '(FIXNUM FLONUM NOTYPE MACROS ARRAY* GENPREFIX
58 | ;; 			    CLOSED MUZZLED MAPEX SPLITFILE)))
59 | ;; 	(PUSH (CAR L) RETURN-FORM)))
60 | ;;   (IF RETURN-FORM (CONS 'DECLARE RETURN-FORM) NIL))
61 | 
62 | ;; These are in global, so avoid redefinition warning by using FDEFINE
63 | ;; rather than DEFUN.
64 | (FDEFINE 'FLONUM #'(LAMBDA (&QUOTE &REST IGNORE) NIL))
65 | (FDEFINE 'ARGS	 #'(LAMBDA (&QUOTE &REST IGNORE) NIL))
66 | 
67 | (DEFUN MACROS	     (&QUOTE &REST IGNORE) NIL)
68 | (DEFUN CLOSED	     (&QUOTE &REST IGNORE) NIL)
69 | (DEFUN NOTYPE	     (&QUOTE &REST IGNORE) NIL)
70 | (DEFUN ARRAY*	     (&QUOTE &REST IGNORE) NIL)
71 | (DEFUN GENPREFIX     (&QUOTE &REST IGNORE) NIL)
72 | (DEFUN MUZZLED	     (&QUOTE &REST IGNORE) NIL)
73 | (DEFUN MAPEX	     (&QUOTE &REST IGNORE) NIL)
74 | (DEFUN SPLITFILE     (&QUOTE &REST IGNORE) NIL)
75 | (DEFUN EXPR-HASH     (&QUOTE &REST IGNORE) NIL)
76 | 
77 | ;; Run time stuff
78 | 
79 | (DEFUN SYMBOLCONC (&REST SYMS)
80 |   (INTERN (APPLY #'STRING-APPEND
81 | 		 (MAPCAR #'(LAMBDA (SYM)
82 | 			     (COND ((FLOATP SYM)
83 | 				    (FORMAT NIL "~S" SYM))
84 | 				   ((FIXP SYM)
85 | 				    (FORMAT NIL "~D" SYM))
86 | 				   (T SYM)))
87 | 			 SYMS))))
88 | 
89 | (DEFUN QUOTED-ARGS (&QUOTE &REST L)
90 |   (MAPCAR #'(LAMBDA (X) (PUTPROP X '((1005 (FEF-ARG-OPT FEF-QT-QT))) 'ARGDESC))
91 | 	  L))
92 | 


--------------------------------------------------------------------------------
/lmmax/ellipt.lisp.23:
--------------------------------------------------------------------------------
 1 | ;;;; -*- Mode:Lisp; Package:Macsyma; -*-
 2 | 
 3 | ;;; Copied From CFFK
 4 | 
 5 | ; Amplitude for Jacobian Elliptic functions. See A+S 16.4
 6 | 
 7 | (defun $am1 (u m1)
 8 |    (if (or (< m1 0.0) (> m1 1.0)) (error "Modulus of AM must lie in 0<m<1"))
 9 |    (phi u (if (= m1 0.0) 1.e-300 (sqrt m1)) (sqrt (- 1.0 m1)) 1.0))
10 | 
11 | (defun $am (u m) ($am1 u (- 1.0 m)))
12 | 
13 | (defun phi (u b ca a)
14 |    (if (not (> (* ca a) 1.e-8)) (* a u)
15 |        (let ((phi (phi (FSC u 1) (sqrt (* a b)) (setq ca (// (* 0.5 (- a b))
16 | 							     (setq a (* 0.5 (+ a b)))))
17 | 		       a)))
18 | 	    (* 0.5 (+ phi (asin (* ca (sin phi))))))))
19 | 
20 | (defun $sn (u m) (sin ($am u m)))
21 | 
22 | (defun $cn (u m) (cos ($am u m)))
23 | 
24 | (defun $dn (u m) (sqrt (- 1.0 (* m (^ ($sn u m) 2)))))
25 | 
26 | ; ref Abramowitz and Stegun eqs 17.3.34 and 36
27 | (defun $elliptk1 (m1)
28 |    (if (or (not (> m1 0.0)) (> m1 1.0)) (error "Arg. out of range for ELLIPTK"))
29 |    (+ (+ (* m1 (+ (* m1 (+ (* m1 (+ (* m1 0.01451196212)
30 | 				    0.03742563713))
31 | 			   0.03590092383))
32 | 		  0.09666344259))
33 | 	 1.38629436112)
34 |       (* (+ (* m1 (+ (* m1 (+ (* m1 (+ (* m1 0.00441787012)
35 | 				       0.03328355346))
36 | 			      0.06880248576))
37 | 		     0.12498593597))
38 | 	    0.5)
39 | 	 (log (// m1)))))
40 | 
41 | (defun $elliptk (m) ($elliptk1 (- 1.0 m)))
42 | 
43 | (defun $ellipte1 (m1)
44 |        (if (or (< m1 0.0) (> m1 1.0)) (error "Arg. out of range for ELLIPTE"))
45 |        (+ (+ (* m1 (+ (* m1 (+ (* m1 (+ (* m1 0.01736506451)
46 | 					0.04757383546))
47 | 			       0.06260601220))
48 | 		      0.44325141463))
49 | 	     1.0)
50 | 	  (* (* m1 (+ (* m1 (+ (* m1 (+ (* m1 0.00526449639)
51 | 					0.04069697526))
52 | 			       0.09200180037))
53 | 		      0.24998368310))
54 | 	     (log (if (= m1 0.0) 1.0 (// m1))))))
55 | 
56 | (defun $ellipte (m) ($ellipte1 (- 1.0 m)))
57 | 
58 | ;AGM method for ELLIPTK1.  Approx. 4 times longer than above method.
59 | ; maybe a bit more accurate.
60 | (comment
61 | (defun $k1 (m)
62 |        (do ((a 1.0 (* 0.5 (+ a b)))
63 | 	    (b (if (= m 0.0) 1.e-300 (sqrt m)) (sqrt (* a b))))
64 | 	   ((not (> a b)) (// #,(atan 1.0 0.0) a)))))
65 | 
66 | ; attempt at incomplete ell fun of first kind.  Srewed by ATAN not taking
67 | ;  right branch.  Not clear how to fix.
68 | (comment
69 | (defun $f1 (phi m1)
70 |        (do ((n 0 (1- n))
71 | 	    (a 1.0 (* 0.5 (+ a b)))
72 | 	    (b (if (= m1 0.0) 1.e-300 (sqrt m1)) (sqrt (* a b))))
73 | 	   ((not (> a b)) (fsc (// phi a) n))
74 | 	   (setq phi (+ phi (atan (* (// b a) (sin phi))
75 | 				   (* (// b a) (cos phi))))))))
76 | 
77 | 


--------------------------------------------------------------------------------
/lmmax/iffun.lisp.24:
--------------------------------------------------------------------------------
  1 | ;;; -*- mode:lisp; package:macsyma -*-
  2 | 
  3 | ;;;transformation funtions - part of the PLOT package
  4 | 
  5 | (declare (special logbas cosang sinang))
  6 | 
  7 | (setq logbas (log 10.0))
  8 | 
  9 | (defun $clog (xf) (// (cond ((= 0.0 xf) -90.0) (t (log (abs xf)))) logbas))
 10 | 
 11 | (defun $polarx (xf yf) (* yf (cos xf)))
 12 | 
 13 | (defun $polary (xf yf) (* yf (sin xf)))
 14 | 
 15 | (defun $reflect (xf) (- xf))
 16 | 
 17 | (defun $ytox (xf yf) yf)
 18 | 
 19 | (defun $xtoy (xf yf) xf)
 20 | 
 21 | (defun $ztoy (xf yf zf) zf)
 22 | 
 23 | (defun $ztox (xf yf zf) zf)
 24 | 
 25 | (declare (special cosang sinang))
 26 | 
 27 | (defun $initrotate (ang) (setq cosang (cos ang) sinang (sin ang)) nil)
 28 | 
 29 | ($initrotate (atan 1. 0.))
 30 | 
 31 | (defun $rotatex (xf yf) (- (* xf cosang) (* yf sinang)))
 32 | 
 33 | (defun $rotatey (xf yf) (+ (* xf sinang) (* yf cosang)))
 34 | 
 35 | (declare (special ex ey ez cosal cosbe cosga singa2 x0 z0))
 36 | 
 37 | (defun $initperspec (xf yf zf xf1 yf1 zf1)
 38 |        ((lambda (ax ay az dx dy dz d r)
 39 | 		(setq ax xf ay yf az zf ex xf1 ey yf1 ez zf1
 40 | 		      dx (- xf xf1) dy (- yf yf1) dz (- zf zf1)
 41 | 		      d (sqrt (+ (* dx dx) (* dy dy) (* dz dz)))
 42 | 		      cosal (// dx d) cosbe (// dy d) cosga (// dz d)
 43 | 		      singa2 (- 1.0 (* cosga cosga))
 44 | 		      x0 (// ex ey) z0 (// ez ey)
 45 | 		      r (// (sqrt (- 1.0 (* cosga cosga)))))
 46 | 		nil)
 47 | 	0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0))
 48 | 
 49 | (comment 
 50 | (defun $p3dx (xf yf zf)
 51 |        ((lambda (q)
 52 | 		(* (- (* (+ ex (* q (- xf ex)) (- ax)) cosbe)
 53 | 			(* (+ ey (* q (- yf ey)) (- ay)) cosal))
 54 | 		    r))
 55 | 	(// d (+ (* (- xf ex) cosal) (* (- yf ey) cosbe) (* (- zf ez) cosga)))))
 56 | 
 57 | (defun $p3dy (xf yf zf)
 58 |        ((lambda (q)
 59 | 		(* (+ ez (* q (- zf ez)) (- az)) r))
 60 | 	(// d (+ (* (- xf ex) cosal) (* (- yf ey) cosbe) (* (- zf ez) cosga)))))
 61 | )  ;;end of comment
 62 | 
 63 | (defun $p3dx (xf yf zf)
 64 |        (setq xf (- xf ex) yf (- yf ey))
 65 |        (// (- (* xf cosbe) (* yf cosal))
 66 | 	    (+ (* xf cosal) (* yf cosbe) (* (- zf ez) cosga))))
 67 | 
 68 | (defun $p3dy (xf yf zf)
 69 |        (setq zf (- zf ez))
 70 |        (// zf (+ (* (- xf ex) cosal) (* (- yf ey) cosbe) (* zf cosga))))
 71 | 
 72 | (defun $p3dxr (xf yf zf) (- ($p3dx xf yf zf)))
 73 | 
 74 | (fset '$p3dyr #'$p3dy)
 75 | 
 76 | (defun $howclose3d (xf yf zf)
 77 |        (setq xf (- xf ex) yf (- yf ey) zf (- zf ez))
 78 |        (sqrt (+ (* xf xf) (* yf yf) (* zf zf))))
 79 | 
 80 | (defun $np3dx (xf yf) (- (* cosbe xf) (* cosal yf)))
 81 | 
 82 | (defun $np3dy (xf yf zf)
 83 |        (- (* singa2 zf) (* cosga (+ (* cosbe yf) (* cosal xf)))))
 84 | 
 85 | (defun $np3dxr (xf yf) (- ($np3dx xf yf)))
 86 | 
 87 | (fset '$np3dyr #'$np3dy)
 88 | 
 89 | (defun $howclosenp3d (xf yf zf) (+ (* xf cosal) (* yf cosbe) (* zf cosga)))
 90 | 
 91 | (defun $old3dx (xf yf) (// (- xf ex) (- yf ey)))
 92 | (defun $old3dy (xf yf zf) (// (- zf ez) cosbe (- yf ey)))
 93 | (defun $old3dxr (xf yf) (- ($old3dx xf yf)))
 94 | 
 95 | (fset '$old3dyr #'$old3dy)
 96 | 
 97 | (fset '$howcloseold3d #'$howclose3d)
 98 | 
 99 | (defun $oldnp3dx (xf yf) (* cosbe (- xf (* yf x0))))
100 | (defun $oldnp3dy (xf yf zf) (- zf (* yf z0)))
101 | (defun $oldnp3dxr (xf yf) (- ($oldnp3dx xf yf)))
102 | 
103 | (fset '$oldnp3dyr #'$oldnp3dy)
104 | 
105 | (defun $howcloseoldnp3d (xf yf zf) (* cosbe (+ (* x0 xf) yf (* z0 zf))))
106 | 


--------------------------------------------------------------------------------
/lmmax/let.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATAD,kmp,Lisp Machine Twenty-twoZuFNF,pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElAIDB0,DSKDB0lLISPM2DB0,LETDB0pB l
UNSPECIFICDB0FpB.,
PACKAGEpB ,SYSTEM-INTERNALS1D
SPECIALC
LET-MACRO-VALS1D
REMPROPDB0LETDB0SOURCE-FILE-NAME1DBIDB0LET*DB0BL1DCDEFMACRO-SET-INDENTATION-FOR-ZWEIDB0BJDB0F
BJK%_*@F:@BJ@FA@@@@{BF1CERRORR-- wrong number of args to a macro.@LISTRDCPAIRSC&BODYBODY@CFERRORR,Garbage found in LET pattern: ~S@CLET-MACRO-GET-VARSRCNCONCRC
LET-MACRO-HAIRRCLIST*RCLAMBDA@
REVERSERCPROGNDDp,
COMPILER,
ARG-MAPD
D
C
*MACROARG*DpBql
LOCAL-MAPDD
BdD
BfD
BdD
VARSD
TEMD
ARGLISTBdBeBf%T:U8$	`
2 | $e)'@w))Aw@%Bw6$BXB'yX%$BgB'C%v:Cw%$v:vC%Dw
3 |  B1CeCwD%CuX  B1B%*:dAeAwBBZYC8 $ CeAe dvA	
XA$A%vD@CMACROBOBJBjK#@F@Bj@F@@@@BF1BhR,Garbage found in LET pattern: ~S@BjD
DBsDD

PATTERND
B}
X
X%yX%$e%$v:v%
%v	)


--------------------------------------------------------------------------------
/lmmax/misc.lisp.51:
--------------------------------------------------------------------------------
 1 | ;; -*- Mode: Lisp; Package: Macsyma -*-
 2 | 
 3 | ;;  Maclisp compatibility package for the Lisp Machine -- run time
 4 | 
 5 | ;;  This function should really bash the array or use an invisible pointer
 6 | ;;  to be compatible with maclisp.  ARRAY-SYMBOL can be either an array object
 7 | ;;  or a symbol.  This only works for one dimensional arrays right now.
 8 | ;;  IGNORE is normally the type, but Maclisp only has ART-Q arrays.
 9 | ;;  *REARRAY of one arg is supposed to return the array.
10 | ;;  Rewrite at some point to use ADJUST-ARRAY-SIZE.
11 | 
12 | (DEFUN *REARRAY (ARRAY-SYMBOL &OPTIONAL IGNORE &REST DIMS)
13 |   (CHECK-ARG ARRAY-SYMBOL
14 | 	     (OR (SYMBOLP ARRAY-SYMBOL) (ARRAYP ARRAY-SYMBOL))
15 | 	     "a symbol or an array")
16 |   (COND ((NULL DIMS))
17 | 	((NULL (CDR DIMS))
18 | 	 (LET ((OLD-ARRAY (IF (SYMBOLP ARRAY-SYMBOL)
19 | 			      (FSYMEVAL ARRAY-SYMBOL) ARRAY-SYMBOL))
20 | 	       (NEW-ARRAY (MAKE-ARRAY NIL 'ART-Q (CAR DIMS)))
21 | 	       (MIN-ARRAY-LENGTH))
22 | 	   (SETQ MIN-ARRAY-LENGTH (MIN (ARRAY-DIMENSION-N 1 OLD-ARRAY)
23 | 				       (ARRAY-DIMENSION-N 1 NEW-ARRAY)))
24 | 	   (DO I 0 (1+ I) (= I MIN-ARRAY-LENGTH)
25 | 	       (ASET (AREF OLD-ARRAY I) NEW-ARRAY I))
26 | 	   (IF (SYMBOLP ARRAY-SYMBOL) (FSET ARRAY-SYMBOL NEW-ARRAY))
27 | 	   NEW-ARRAY))
28 | 	(T (FERROR NIL "Can't handle *REARRAY with more than one dimension"))))
29 | 
30 | (DEFUN RUNTIME NIL (TIME))
31 | 
32 | 


--------------------------------------------------------------------------------
/lmmax/mormac.lisp.3:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1980 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | ;; more macros for LISPM compatibility.
 6 | 
 7 | ;; Needed at read time, by e.g. JPG;SUPRV.  There should be a better
 8 | ;; way of setting this up for #+.
 9 | (SSTATUS FEATURE MAXII)
10 | 
11 | (DEFMACRO MACSYMA-MODULE (MODULE &REST OPTIONS)
12 |   (IF (NULL OPTIONS)
13 |       (PUSH 'RUNTIME OPTIONS))
14 |   `(DEFPROP ,MODULE ,OPTIONS MACSYMA-MODULE))
15 | 
16 | 
17 | (macsyma-module mormac macro)
18 | 
19 | 


--------------------------------------------------------------------------------
/lmmax/patch-1.directory.1:
--------------------------------------------------------------------------------
1 | ;;; -*- Mode: Lisp; Package: User; Base: 10.; Patch-File: T -*-
2 | ;;; Patch directory for Macsyma version 1
3 | ;;; Written 5/22/82 23:54:07 by HIC,
4 | ;;; while running on Collie from band 2
5 | ;;; with System 210.51, ZMail 45.2, LMFS 26.14, Tape 9.4, Canon 14.1, microcode 896, site configuration 10.
6 | 
7 | (EXPERIMENTAL
8 |  ((0 "Macsyma Loaded" "HIC")
9 |   ))


--------------------------------------------------------------------------------
/lmmax/patch.directory.1:
--------------------------------------------------------------------------------
1 | ;;; Written 5/22/82 23:54:04 by HIC,
2 | ;;; while running on Collie from band 2
3 | ;;; with System 210.51, ZMail 45.2, LMFS 26.14, Tape 9.4, Canon 14.1, microcode 896, site configuration 10.
4 | 
5 | 
6 | ("Macsyma" 1.) 


--------------------------------------------------------------------------------
/lmmaxq/array.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteenc}FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLMMAXDB0lARRAYDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLMMAXDB0lARRAYDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMAC
$LISTARRAYK9"@F%@BR@FA@@@@|D
CMLIST@MGETRCHASHAR@C
$ARRAYINFO@
$ARRAYAPPLYRCARRAY@C
LISTARRAYRCDISPLARCERRORRlarg to listarray must be an arrayDDp,
COMPILER,
ARG-MAPD
D
ARYDpBdl
LOCAL-MAPDD
pBdl
MAP-RESULTD
pBd,
MAP-TEMPNILD
SUBS$%d8@7	 e/:BwAw
2 | A%B'Cw
3 |  %Cet:AWXBBtY@%
4 | %d8 `%d
5 | e dvOyBRC
$FILLARRAYK
6 | )@F@


--------------------------------------------------------------------------------
/lmmaxq/askp.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenR5FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,JIMDB0,ASKPDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,JIMDB0,ASKPDB0B:DB0FUpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPASKPD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALCLIMITP
INTEGER-INFO
$ASKINTEGERK3	"@F"@B^@@@@~~|*LEXPR-ARGLIST*F @@Fe
WNA-ERRRB^@
ASK-INTEGERRARGR
$INTEGER@DC$EVEN$ODDBk@IMPROPER-ARG-ERRD
Dp,
COMPILERl
LOCAL-MAPDD
BeD
CN$T:AwA%5XA%U8	
2 | dA%8 e
3 | d e$8 e`e e
4 | dOyB^BiK
5 | ,$@F@Bi@F@@@@
SRATSIMPRCSUBLISRDD@Z**D@*Z*@FREER$%PI@$%I@
RATNUMPR$NO@Bk@
ASK-INTEGERPR
ASK-EVODD
DpBp,
ARG-MAPDD
CXD

EVEN-ODD `$ew	%
6 | d8	%d8e
8
7 | 
%t8e%
eOBiBKL(@F0@B@F@@@@~EVODR
INTEGERPR$YES@
$NUMBERPRB
8 | @
ASK-PROPRBl@even@odd@Cnumber@
ASK-DECLARERBm@


--------------------------------------------------------------------------------
/lmmaxq/buildq.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen+#FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,REHDB0lBUILDQDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,REHDB0lBUILDQDB0B:DB0F	pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCBUILDQD

RUNTIMEC
MACSYMA-MODULE1DBR
$BUILDQC
SIMPBUILDQC
OPERATORS1DBR
%BUILDQBZB[BZK@F
2 | @BZ@FC@@@@DBYSIMPD
Dp,
COMPILER,
ARG-MAPDD
CXD

*IGNORE*D
C
SIMP-FLAGS$)vOuBZDpB ,
PROPERTYBY
MFEXPR*K@F@By@FA@@@@CMERRORR,BUILDQ takes 2 args:~%~M@D
BY@
MBUILDQD
DBkD
D
FORM	8
3 | 8$$%vz	'kO	ByBK=@F&@B@F@`@@|
VARLISTC$LISTPRBRlFirst arg to BUILDQ not a list: ~M@C
MBUILDQ-SUBSTRCMEVALRCMSETQ@lIllegal form in variable list--BUILDQ: ~MDDBkDD
BD
C
EXPRES


--------------------------------------------------------------------------------
/lmmaxq/compat.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteensFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLMMAXDB0lCOMPATDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLMMAXDB0lCOMPATDB0B:DB0FKpB.,
PACKAGEpB.,
MACSYMA
PURCOPYK	@F@BR@FA@@@@CERRORRplSI,-- wrong number of args to a macro.@LISTRD
CXDDp,
COMPILER,
ARG-MAPD
D
pBZl
*MACROARG*DpB`l
LOCAL-MAPD
D
B^D
ARGLISTB^%T:UX%T:58$`	$e)'@w@D@CMACROBpOrBR
CHARPOSK	@F@Bs@FA@@@@BYRB\@B]RD
CIGNORE@DCDRD
C
CURSORPOSDDBbD
D
BdDBiD
D
BzDBmBz%T:UX%T:58$`	$e)'@w
2 | D@BqBO	BsCSLEEPK( @F@B
3 | @FA@@@@BYRB\@B]RD

SECONDS@C
PROCESS-SLEEP@FIX@CLIST*RC*@D
F<DDBbD
D
BdDBiD
D
BDBmB%T:UX%T:58$`	$e)'@w
4 | $`$`
5 | $@%dD@BqB!O"B
6 | CLINELK	
7 | @F@B#@F
@@@@pBZ,DECODE-PRINT-ARGRpB lSIZE-IN-CHARACTERSD
DBbD
D
CSTREAM e
dO3B#
NOINTERRUPTK	@F@B4@FA@@@@BYRB\@B]RD
BzDDBbD
D
BdDBiD
D
BzDBmBz%T:UX%T:58$`	$e)'@wD@BqBDOEB4FIXNUM-IDENTITYK	@F@BF@FA@@@@BYRB\@B]RD
B^DDBbD
D
BdDBiD
D
B^DBmB^%T:UX%T:58$`	$e)'@w@D@BqBVOWBFFLONUM-IDENTITYK	@F@BX@FA@@@@BYRB\@B]RD
B^DDBbD
D
BdDBiD
D
B^DBmB^%T:UX%T:58$`	$e)'@w@D@BqBhOiBX1D
REMPROPDB0
EXPLODEDB0pB`l
STYLE-CHECKER1DBjDB0
EXPLODECDB0Bn1DBjDB0
EXPLODENDB0Bn1DBjDB0C
ALPHALESSPDB0Bn1DBjDB0
GETCHARNDB0Bn1DBjDB0
GETCHARDB0Bn1DBjDB0
IMPLODEDB0Bn1DBjDB0CMAKNAMDB0Bn1DpBZlDEFMACRO-SET-INDENTATION-FOR-ZWEIDB0WHENDB0F



--------------------------------------------------------------------------------
/lmmaxq/csimp.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenU$FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lPAULWDB0lCSIMPDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lPAULWDB0lCSIMPDB0B:DB0F+
pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCCSIMPD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALRSN*
$FACTLIM$EXPONENTIALIZEVAR
VARLISTCGENVAR
$%EMODEC
$RATPRINTNN*DN*
$ERREXP
SQRT3/2
SQRT2/2
-SQRT2/2
-SQRT3/2C
$DEMOIVRE
ERRORSWCISLINPC
$KEEPFLOAT
$RATFACNILNpBiBpNpBZBpNp
$NOINTEGRATEFNrC
$LHOSPITALLIMBpNp
$TLIMSWITCHBpNpC
$LIMSUBSTBpNp
$ABCONVTESTBpNpC
COMPLEX-LIMITBpNp
PLOGABSCTNy
$INTANALYSIS1DplSIl
DEFCONST-1%P%IDB0DD
CMTIMES$%I$%PI1DB}C
FOURTH%PIDB0DD
BDDRATSIMPF
FB1DB}
HALF%PIDB0DD
BDDB	B
 2 | F
FB1DB}%PI2DB0DD
BFB1DB}
HALF%PI3DB0DD
BDDB	B
 3 | FFB1DB}C
$SUMSPLITFACTBy1DB}C
$GAMMALIM@B1DCMAP2CDB0DCLAMBDADCACBD
PUTPROPB7B8DB0
$INVERSEDB:B8B7DB0B;DB0D%SINC%ASIN%COSC%ACOS%TANC%ATAN%COTC%ACOT%SECC%ASEC%CSCC%ACSCC%SINHC%ASINHC%COSHC%ACOSHC%TANHC%ATANHC%COTHC%ACOTHC%SECHC%ASECHC%CSCHC%ACSCHBiK
 4 | 	@F@Bi@FA@P@@~B\CMEXPT@$%E@
DEMOIVRER
RECUR-APPLYRBiDDp,
COMPILER,
ARG-MAPD
D
EXPDpBhl
LOCAL-MAPDD
B\D
NEXP
X1t	8+t8	 %+zAw
8A
 5 | $eOwBiBfK1&@F"@Bf@FA@@@@B\1CMERRORR,Demoivre and Exponentialize may not both be true@
ISLINEARRB
@CMUL2*RCPOWER*RBe@CADD2*RLISTRD
BD@D
BBD
DBjD
D
CL8d	 %
 6 | dw%x'%;b:
 7 | x 
 8 | $i` $g`
 9 | $`$gO
BfB
K	@F@B
@F@@@@Bk1CSDIFFRCFREEOFRC
SUBSTITUTEDDBjDD
BkD
VAR1DBpD
D
B7
%V %
e@w
%@e8@%	 %
%evO
B
C
$PARTITIONK"X(@F6@B 
@F@@@@{C
MRATCHECKRCGETOPRRC$LISTPRFREERB
RDCMLISTB
10 | @
NREVERSERCMPLUSPRD
B@
MTIMESPRB~R,~M is an incorrect arg to PARTITION@C
PARTITIONDDBjDD
CED
B
DBpDD
CKD
B
D
CL1D
CL2D
CX ew 
e
we 8)Aw AgDw	D%
e8D%B%v:BwD%C%v:CwAAmY
11 | $$ Bev:$ Cevz
12 | e8$)v:w@	e8%@w$e %
%@ew
13 | $'iOD
B 
B2
K N@F.@B2
@FC@@@@}D
CMPLUS@D
B@CALIKE1RB@B*
RC
SIMPLIFYARB-
DDBjDD
BkD
B
D
B8
DBpDD
CCONSTD
CVARBLD
COP%8$
$Bw%
eX1	tX%%v
14 | '
e8'@%v:@w'A%v:AwX@X%
15 | @	X@' B% @ev:
eAX%
16 | A	XA' B% Aev:
evSO^
B2
1DCMAKNAMD
EXPLODEDB0FOONe
B]CNUMDENK
17 | -&@F @Bf
@FA@P@@B^QBbqBcqB]1B
RCNEWVARRFMTR
RATREP*RBO
RPDISRC
RATDENOMINATORR
RATNUMERATORDDBjD
D
B3
DBpD
D
B^
18 |  	dv eWe
19 |  e)w  `eev  `eev`Oz
Bf
Bn
K1{2@FJ@Bn
@FA@P@@BbCMNUMPRBd@C$SIGNR$NEG@B
RD
C
MQUOTIENT@F@
@Bn
RCTIMESKRB0
R
SRATSIMPRD
B@NEGRBK
@CSPEXPRCMAPCARR
DELSIMPDDBjD
D
BkDBpD
D
Bb
Xe
81tR8%+z8	 %+z
20 | t8$%%+:
21 | t8`k	` q k`
22 | $%+z%+X q k%+z %+zVe8j8	 j
23 | t8$%` q k*
24 | t8$,vz`d0t8`(k1t: $iv g $ivO
Bn
B


--------------------------------------------------------------------------------
/lmmaxq/defcal.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLIBMAXDB0lDEFCALDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLIBMAXDB0lDEFCALDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCDEFCALD
CMACROC
MACSYMA-MODULECHECK-SUBR-ARGLK&@F@BY@FA@@@@F@C&REST@C
&OPTIONAL@C&RESTV@C&QUOTE@CERRORRlCan't DEF-PROPL-CALL with non-subr arglistD
Dp,
COMPILER,
ARG-MAPD
D
CL%T:4X$%X$%X	$%X
 2 | $%8$eOoBY1DplSI,
DEFVAR-1
USE-SUBRCALLNILC
DEF-PROPL-CALLK1TYb@F@Bw@FA@@@@zBs1F@BeRpBp,-- wrong number of args to a macro.@LISTRDNAMED@COPBjC
DEFAULT-ACTION&AUXDTEMPD
CGENSYMDCSUBR?DCIFBsDB
DC
SYMBOLCONCBDB0C-SUBRBt@BRB
 3 | RB@BYRCPROGN@DB0
COMPILE@
DEFMACRO@DEF-@C-EQUIV@DBCEQUIV@pBp,
XR-BQ-LIST*@DB0
PUTPROP@DpBpl
XR-BQ-LISTDB0B0B@DB"DB0
FUNCTIONB@B0@C-PROPL@-FUN@D@
OP-NAMEOP-LBODY@CLIST*RDB0CDEFUN@pBpl
XR-BQ-CONS@B*@DB+B,@B/@C-CALL@LET@AND@
SYMBOLP@GETL@B@NULL@CEQ@CAR@
SUBRCALL@CADR@
FUNCALLDDBiD
D
pBpl
*MACROARG*DpBgl
LOCAL-MAPDD
BD
BD
BjD
BD
BD
BD
ARGLISTBBBBB
 4 | B%T:TX%T:48	$
 5 | `$e)'@w))''Aw))')Bw)))'Cw"Dw8
 6 |  
 7 | `@%d
%EwE8Be
 8 | $$
 9 |  $
10 |  $@%d$
11 | `$$$$
12 | `$
13 | `
14 | `$@e
15 |  $
16 |  @%d%
17 | `$
18 | `$@%E%vz
19 |  $
20 |  $@%d$`$$
21 |   $!$
22 | `$@%E%vz"d
23 | `#$
24 |  @%$dA%B%v:
25 | `%$
26 |  
27 | `D%
28 | `&$
29 |  '$Ae
30 | `($A%
31 | `$@%E%vz
32 | `)$
33 |  *$DeC%E8
34 | `)$
35 |  +$
36 |  ,$De
37 | `$Eg -$%
38 |  .$DeA%Be`/$
39 |  .$DeA%Be`/$
40 |  .$DeA%BeD@BTBQORBwMAKE-PARSER-FUN-DEFKB$@F*@BS


--------------------------------------------------------------------------------
/lmmaxq/defopt.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenTFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLIBMAXDB0lDEFOPTDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLIBMAXDB0lDEFOPTDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCDEFOPTD
CMACROC
MACSYMA-MODULEDEFOPT-INTERNALK$@F@BY@FA@@@@~CERRORRplSI,-- wrong number of args to a macro.@LISTRD@NAMECOTHER@CLIST*RCDEFUN@D



--------------------------------------------------------------------------------
/lmmaxq/displm.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATAD,GJClSetterK|FPF
pB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLIBMAXDB0lDISPLMDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLIBMAXDB0lDISPLMDB0B:DB0F
2 | pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCDISPLMD
CMACROC
MACSYMA-MODULE1DCMAP-EVAL-FOR-DECLARATIONSDB0DD$
SPECIALC^WC^RC
SMART-TTYC
RUBOUT-TTY
SCROLLPCLINELC
TTYHEIGHTCWIDTHCHEIGHTCDEPTHCMAXHTCMAXDPCLEVELSIZELOPROPCBREAKCRIGHTBKPTCBKPTWDCBKPTHTCBKPTDPC
BKPTLEVEL
BKPTOUTCLINESCOLDROWCOLDCOL
DISPLAY-FILEIN-P
MOREMSGC
MOREFLUSH
MORE-^WCMRATP
$ALIASESC
ALIASLISTDCFIXNUMBbBcBdBeBfBgBhBlBnBoBpBqBrB`
TYHEIGHTBtBuDCNOTYPEDTYO*BD
SETCURSORPOSBBDC*EXPR+TYOB
MTERPRI
FORCE-OUTPUTC
LINEAR-DISPLAC
TTYINTSONC
TTYINTSOFF
MORE-FUNCGETOPLBPRBP
NFORMATC
FULLSTRIP1C
MAKSTRINGC$LISTPDBCDISPLAC
DIMENSION
CHECKRATC
CHECKBREAKDC*LEXPR$BOXC$DIFF
$EXPAND
$FACTORC
$INTEGRATEC
$MULTTHRU
$RATSIMPCTABLENK@F@B*@FA@@@@CERRORRplSI,-- wrong number of args to a macro.@LISTRFDDp,
COMPILER,
ARG-MAPD
D
pB2l
*MACROARG*D

ARGLIST%T:58$`%e	D@BTBBOCB*C
MAKE-LINEARRAYK
3 | "@F@BD@FA@@@@B1RB4@B5RD
Bh@CLIST*RC
MAKE-ARRAY@DDB0pB ,TYPEDB0CART-QDDB9D
D
B;DpB7l
LOCAL-MAPD
D
BhDB?Bh%T:UX%T:58$`	$e+@w
4 | $@%dD@BTB^O_BDC
SET-LINEARRAYK&@F@B`@FA@@@@~F@B1RB4@B5RDCICX@ASET@C
LINEARRAYDDB9D
D
B;DBXDD
BhD
BiDB?BhBi%T:TX%T:48$	`
5 | $e+@w%+:Aw	$A%$@eD@BTBvOwB`BlK
6 | 
7 | !@F@Bl@FA@@@@B1RB4@B5RD
CJ@AREF@BlDD


--------------------------------------------------------------------------------
/lmmaxq/edlm.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen,FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lEMAXIMDB0,EDLMDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lEMAXIMDB0,EDLMDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPEDLMD

RUNTIMEC
MACSYMA-MODULE1DplSI,
DEFVAR-1CIDEL-CHARS-AVAILABLE?CT1DB[CIDEL-LINES-AVAILABLE?B]1DB[C12-BIT-KBD-AVAILABLE?B]1DB[COVERSTRIKE-AVAILABLE?B]1DB[
$BOXCHARl&1D
SPECIALC
TTYHEIGHTCMINIBUFFER-HEIGHTMINIBUFFER-VPOSC
MODE-LINE-VPOS1DB[BoF
ED-PROLOGUEK	 @F@Bw@@@@BqqEXPR-AREA-HEIGHTqBoqBpq
TERMINAL-IOqBnqCLINEL1pB lSIZE-IN-CHARACTERS
2 | $%~
3 | dvv$RS	v$RSv	$V:VOBw
ED-EPILOGUEK
@F@B@@@@OB
TV-BEEPK

4 | @F	@B@@@@B1BEEPdOBMINIBUFFER-CLEARK	@F@B@@@@Bp1C
CURSORPOSRCE$edOBEXPR-AREA-CLEARK
5 | @F@B@@@@@Bq1BRCLD
Dp,
COMPILERl
LOCAL-MAPD
D
VPOS%@w@%ed@U@%w9O/BMINIBUFFER-PRINTK	@F@B0@@@@~~|*LEXPR-ARGLIST*F @@FeCFORMAT@
LISTIFYD
DB)DD
B7D
ARGS$T:Aw	$
%
6 |  Aev:OBB0DCTL-CLEAR-LINESK


--------------------------------------------------------------------------------
/lmmaxq/edmac.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteend,FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lEMAXIMDB0lEDMACDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lEMAXIMDB0lEDMACDB0B:DB0FjpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCEDMACD
CMACROC
MACSYMA-MODULE1DBRC
REGION-BOXED?D@C
EXPRESSIONBYplSIl
DEFSTRUCT-SLOTD
NAMED-SUBSTDBYDp,SYS,FUNCTION-PARENTBZC
DEFSTRUCTD
BZDAREFBZF
2 | OlBY1DBR
REVEAL-DEPTHD@BZBmB^DBaDBmDBdBZBeBhDBiBZF	OuBm1DBRCEXPRESSION-HEIGHTD@BZBvB^DBaDBvDBdBZBeBhDBiBZFO~Bv1DBREXPRESSION-LABELD@BZBB^DBaDBDBdBZBeBhDBiBZFOB1DBR
OPERANDD@BZBB^DBaDBDBdBZBeBhDBiBZFOB1DBR
OPERATORD@BZBB^DBaDBDBdBZBeBhDBiBZFOB1DBRC
REGION-LENGTHD@BZBB^DBaDBDBdBZBeBhDBiBZFO"B1DBR
SAVE-PDLD@BZB#B^DBaDB#DBdBZBeBhDBiBZFO+B#1DBRCREGIOND@BZB,B^DBaDB,DBdBZBeBhDBiBZFO4B,1DBRC
DISPLAYEDD@BZB5B^DBaDB5DBdBZBeBhDBiBZF
O=B51DBRBODYD@BZB>B^DBaDB>DBdBZBeBhDBiBZOFB>1DBRMAKE-EXPRESSIONBZpB\l
DEFSTRUCT-NAME1D
FDEFINEDB0BGDB0D@BTpB\,DEFSTRUCT-EXPAND-CONS-MACROCT1DBRALTER-EXPRESSIONBZBI1DBLDB0BUDB0D@BTpB\,DEFSTRUCT-EXPAND-ALTER-MACROBR1DBRBZDpB\,ONECARRAYpB\,DEFSTRUCT-DONT-DISPLACEDDB>NILpB\,%%DEFSTRUCT-EMPTY%%pB\lNOTYPEBeB>DB5F
BeBgBiBeB5DB,FBeBgBiBeB,DB#FBeBeBiBeB#DBFBeF
BiBeBDBFBeBeBiBeBDBFBeBeBiBeBDBFBeBgBiBeBDBvFBeBgBiBeBvDBmF	BeBiBeBmDBYF
3 | BeBeBiBeBYBeD
D
BGBeBeFBeBZBeDEVAL
COMPILELOADBUBeBRBeBepB\lDEFSTRUCT-DESCRIPTION1DpB\,RECORD-SOURCE-FILE-NAMEDB0BZDB0BeBZ1DBR
BUFFER-MODED@CBUFFERB
B^DBaDB
DBdB
BeD
B
DBiB
FO
B
1DBRCCURRENT-EXP-DISTANCE-FROM-TOPD@B
B 
B^DBaDB 
DBdB
BeB
DBiB
FO(
B 
1DBR
CURRENT-EXPD@B
B)
B^DBaDB)
DBdB
BeB
DBiB
FO1
B)
1DBREXPRESSION-LISTD@B
B2
B^DBaDB2
DBdB
BeB
DBiB
F
O:
B2
1DBR
BUFFER-NAMED@B
B;
B^DBaDB;
DBdB
BeB
DBiB
OC
B;
1DBR
MAKE-BUFFERB
BI1DBLDB0BD
DB0BPBR1DBR
ALTER-BUFFERB
BI1DBLDB0BK
DB0B[BR1DBRB
DB`BaBcDDB;
BeBgBiBeB;
DB2
F
BeBeBiBeB2
DB)
FBeBeBiBeB)
DB 
FBeBiBeB 
DB
FBeDB0C
ExpressionBiBeB
BeD
D
BD
BeBeFBeB
BeB	
BK
BeBRBeBeB
1DB
DB0B
B
B
CDEFCOMK"N>D@Fp@Bj
@FA@@@@vNAME1F@CERRORRpB\,-- wrong number of args to a macro.@LISTRDBq

OPTION-LISTC
DOCUMENTATIONC&RESTB>@
ITERATE@
DISCARD@
ARGUMENT@PASS@DISCARD-ARGUMENT@C
CHARACTER@
READ-KEY@C
&OPTIONAL@CPROGN@D
MINIBUFFER-CLEAR@CLIST*RDC
READ-LINEREAD-EXPRESSION@lUnknown defcom option@
NREVERSERDB0B
@
PUTPROP@B0@D
DB0ED-DOCUMENTATION@D
DB


--------------------------------------------------------------------------------
/lmmaxq/ellipt.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen;FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLMMAXDB0lELLIPTDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLMMAXDB0lELLIPTDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA$AM1K&@F@BR@F@@@@G@G
@@CERRORR,Modulus of AM must lie in 0<m<1@PHIRG8U@SQRTD
Dp,
COMPILER,
ARG-MAPDD
CUD
CM1
%TX
%48	d
2 | %
%8$ 
e $
SedOjBR$AMK	@F@Bk@F@@@@BRRG
@D
DBbDD
BcD
CM%$
SeOyBkB]K6@F"@B]@F
@@@@GffU	;@B]RFSCRB_RG@@ASINRSINDDBbDD
BcD
CBD
CCAD
CADpB`l
LOCAL-MAPD
D
B]%s4X%s  %e	 %
se
3 | $%
Ss
4 | $%
3sWWe@w
5 | $@% % @ese3sOB]$SNK	
6 | @F@B@F@@@@BRBkD
DBbDD
BcD
Bt`


--------------------------------------------------------------------------------
/lmmaxq/fortra.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen
}FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,MRGDB0lFORTRADB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,MRGDB0lFORTRADB0B:DB0F@pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCFORTRAD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALCLBCRBC
$LOADPRINT1/2-1/21DplSIl
DEFCONST-1
$FORTSPACESNIL1DBc
$FORTINDENT1DBcC
$FORTFLOATBeDpB ,
PROPERTY
$FORTRAN
MFEXPR*K;"@F&@Bs@FA@@@@C
FEXPRCHECKR
STRMEVALRCMSETQPRLISTRD
CMEQUAL@CMEVALR
$MATRIXPR
$FORTMXRB~@C
FORTRAN-PRINTDDp,
COMPILER,
ARG-MAPD
D
CLDpBl
LOCAL-MAPD
D
CVALUE ew e@we8	 
2 | $+`e@w%y8@e8
3 | %@e@8@1t8@+y8@%+z8
4 | @+@%+z@eOBs1DBRCMEXPTDF*F*CDISSYMBK44	h@Fh@B@B@L@@||zBZQB[QBdqBhqSTANDARD-OUTPUT1@F@B A
F2@@F(@F2@@F)@Fe@Fe
FORTSCANRF@F@
PUTPROPRB@
MSIZE-INFIX@CGRIND@CMMINUS@Fd@LBP@CMSETQ@D
F=@CSTRSYM@
MSTRINGRC
MSZ-MEXPT@
REMPROPRD
F:@F0@F@
PRINT-SPACESRF@TYORF @F\@FH@F@CTERPRIRF1@F@F	@C$DONEDDBDD
CXD
CSTREAMDBDD
BZD
B[D
CCD
CCOLUMN ew$$/
%$$d$$d$$ d! eWe$"$d#$d$


--------------------------------------------------------------------------------
/lmmaxq/homog.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0lHOMOGDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0lHOMOGDB0B:DB0F'pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCHOMOGD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALC*HVARC*HMATC
ADDVARDEGK	@F@B^@FC@@@@}DDp,
COMPILER,
ARG-MAPDD
CND
CLD
CLTDpBel
LOCAL-MAPDD
pBel
MAP-RESULTNILD
CX
%@w@%Aw	A'Bw%B%v:%v:wAAuYO{B^
PTERMVECK@F@B|@FA@@@@
LTERMVECRSORTRC
LISTOVARSRC
POINTERGPD
DBgD
D
CP%  e	deOB|BK<@F$@B@FC@@@@~LISTRCNZEROSRBRB^RBDDBgDD
BD
CVLD
CCOEF?DBqDD
BD
Bl
X8e
e	X`
%T:8e
e
'g8	%
2 |  %
)ee)@w@-	 @'
3 |  @+
)eAeAw%@w@sYAO!BC
HLINSOLVEK~
 @F@B"@FA@@@@kCMAPCARRC-@CARRAYR
TFGELI1RCERRORR
Inconsistant@CSIGNPRCG@
*REARRAYDDBgD
D
MATDBqDD
BsD
pBe,
MAP-TEMPBuD
BvD
BhD
CMD
ARRD

NDEPVARD
B2D
CMLD
CID
BjD
CJD
DETD
CVARORDD
GCDD
BLD
BED
VECLD
ANSD
BE%T:V:'T:@7)BwAwA%B'Cw $'Cet:AWXBBsY@%HwGwFwEwDw E
EE%D%r;U:%E3eFwH%%JwIwI'%LwKwK'F%J%L%NKLUKwY%F%J%L%NIJUIiY	 F%D%E%UzHwH8
4 | dD%H'T:SGwD%U:JwG%U:Lw%F%J%L%NLUL%E5w9JUJ%E5o9G%U:F!%e;MwJwM%F%J%J%NJUJ%E5w9
5 | DFa%e8%JwG%U:Lw	F!J%Leo:F%


--------------------------------------------------------------------------------
/lmmaxq/iffun.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen:FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLMMAXDB0lIFFUNDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLMMAXDB0lIFFUNDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
SPECIALCLOGBASCCOSANGCSINANG1DLOGGPN[BSC$CLOGK@F@B\@FA@@@@BS1G@G&@BXD
Dp,
COMPILER,
ARG-MAPD
D
CXF$8$	 %{OmB\
$POLARXK@F@Bn@F@@@@COSD
DBgDD
BhD
CYF
% esO|Bn
$POLARYK@F@B}@F@@@@SIND
DBgDD
BhD
Bw
% esO
2 | B}
$REFLECTK
	@F@B@FA@@@@D
DBgD
D
Bh%oOBC$YTOXK
	@F@B@F@@@@D
DBgDD
BhD
Bw
O#BC$XTOYK
	@F@B$@F@@@@D
DBgDD
BhD
BwO0B$C$ZTOYK
	@F@B1@FC@@@@D
DBgDD
BhD
BwD
CZFO?B1C$ZTOXK
	@F@B@@FC@@@@D
DBgDD
BhD
BwD
B:OMB@1DBRBTBU
$INITROTATEK@F@BP@FA@@@@BUqBT1BuRBD
DBgD
D
ANG ev	 evO\BP1DBPDATANF

$ROTATEXK	@F@Bc@F@@@@BUqBT1D
DBgDD
BhD
Bw%r
%rSOoBc
$ROTATEYK	@F@Bp@F@@@@BTqBU1D
DBgDD
BhD
Bw%r
%r3O|Bp1D
3 | BRCEXCEYCEZCCOSALCCOSBECCOSGACSINGA2CX0CZ0
$INITPERSPECK'a&@F:@B
@F
@@@@xB
qB
qB
qB
qB

qB
qBqB~qB}1G@SQRTRG
@DDBgDD
BhD
BwD
B:D
XF1D
YF1D
ZF1DpBel
LOCAL-MAPDD
CAXD
CAYD
CAZD
CDXD
CDYD
CDZD
CDD
CR$@w$Aw$Bw$Cw$Dw$Ew$Fw$Gw%@w
%Aw%Bw%v%
4 | v%v%SCw
%SDw%SEw C%CsD%Ds3E%Es3eFwC%FvD%F
5 | vE%F	v$	$	rSv$
6 | v$
7 | v% $	$	rS


--------------------------------------------------------------------------------
/lmmaxq/inmis.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteenl4FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lINMISDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lINMISDB0B:DB0FbpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCINMISD

RUNTIMEC
MACSYMA-MODULE1DplSIl
DEFCONST-1C
$LISTCONSTVARSNIL1D
SPECIALC
LISTOFVARSB]N]
$COMBINEFLAGB]N]
$POLYFACTOR
$UNKNOWNK
2 | @F@Bf@FA@@@@F@
UNKNOWNRC
MRATCHECKD
Dp,
COMPILER,
ARG-MAPD
D
CF$.;%``eOxBfBnK
3 | )@F@Bn@FA@@@@
MAPATOMR
MQAPPLY@
SPECSIMP@C
OPERATORS@MAPCRBnD
DBrD
D
Bs eb:x1t8%1:$PX%
%81	$PX%
%8
4 | $iO


--------------------------------------------------------------------------------
/lmmaxq/ldisp.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen(3FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lLDISPDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lLDISPDB0B:DB0F+pB.,
PACKAGEpB.,
MACSYMA1D
SPECIALCLINEAR-DISPLAY-BREAK-TABLE
FORTRANPC
LINEAR-DISPLAKB$@F*@BW@FA@@@@BT1CTERPRIRCMLABLE@CPRIN1RLISTR
STRIPDOLLARRTYORF @C
LINEAR-DISPLA1RC
CURSORPOSRCMTEXTDDp,
COMPILER,
ARG-MAPD
D
CXDpBhl
LOCAL-MAPD
D
Bk)81t88	
2 | ``k
3 | d%+:"i1


--------------------------------------------------------------------------------
/lmmaxq/lesfac.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteenn'FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0lLESFACDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0lLESFACDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCLESFACD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALC
*FNEWVARSW
FACLISTRESCPOLY*
NEWSYM2K
 2 | %@F@B`@F@@@@
VARLISTqCGENVAR1CGENSYMR
PUTPROPRCDISREP@
UNHACKEDDDp,
COMPILER,
ARG-MAPDD
CPD
CEDpBml
LOCAL-MAPD
D
CG"@w	@%
%
 3 | d@%&{:V:Z@%$v:v
%$v:v	@%%d@O}B`C
GETUNHACKK	@F
 4 | @B~@FA@@@@Bl@PGETD
DBoD
D
GEN%$P:eOB~CGETDISK
 5 | "@F@B@FA@@@@CERRORRplSI,-- wrong number of args to a macro.@LISTRD
CX@CLIST*RGET@D
DB0BkDDBoD
D
pBl
*MACROARG*DBwD
D
BD
ARGLISTB%T:UX%T:58$`	$e)'@w
 6 | $@%dD@CMACROB)O+BCCONS1K
 7 | "@F@B,@FA@@@@BRB@BRD
B@BRCONS@D
F
DDBoD
D
BDBwD
D
BDB&B%T:UX%T:58$`	$e)'@w
 8 | $@%dD@B*B?O@B,
FRPOLY?K@F	@BA@FA@@@@D
DBoD
D
CR%)OMBA
SETCALLK
 9 | @F@BN@FA@@@@CSUBLISRBRCFNCALL@CA@CB@DCPROG1DCARDSETQBWBVDB[BXDCCADDRBWBWDCADRBWD
DBoD
D
CL $)v:	$%+:v:
10 | $%7:vzdD@B*BiOjBN
PQUOCOFK	@F@Bk@F@@@@C
TESTDIVIDERBDDBoDD
BpD
CQDBwD
D
CQQ %
e@w@8
%@%e%%
eO}BkCPOLYSTK	@F@B~@FA@@@@BRB~D
DBoD
D
BWXe'+v: %+zvO	
B~CCDINFK
11 | *@F@B
12 | 
@FC@@@@BRCSUBSTRCD1D
DBoDD
BWD
BXD
BOTH8
X%%
e %%et:w8 %%
e

%t:
w %
%e'
gO
B
13 | 
B
KD@F(@B
@FC@@@@CPTIMESRCPEXPTRBRB
RC
POINTERGPD
DBoDD
BWD
BXD
B
8

X1
1u!8  q8%*:
%*:3%*:%%6:W8
%
%6:W
%.:
we	`%
%e
14 | 1
q8	%.:
%e	%
%.:eO*
B
CLMAKEK
15 | &@F@B+
@F@@@@Bl@B+
RBD
DBoDD
BpD
BdX%
%v'$P8%+:'+v:
%vz %+:
e
w
% '+
gWO7
B+
CLMAKE2K	%@F@B8
@F@@@@}B+
RB~DDBoDD
BpD
BdDBwDD
pBml
MAP-RESULTNILD
B %
e
w
)@w@%AwA'BwB% BgWAAwY
'u
8
	
%
'%v:WOK
B8
CPMAKEK
16 | %@F@BL
@FA@@@@BL
RB!
RCCEXPTRBD
DBoD
D
Bd
X%/8i1k8 1o`i	 1/e`iOX
BL

FACMGCDK?@F%@BY
@FA@@@@|
FPGCDCORBRB!
R
NREVERSEDDBoD
D
CPLDBwDD
BdD
ANSD
GCDD
CL2)'Bw@w) B%@gBwB'u8%%vAX BkAwB+uXA%CwC% B+CgWCCxY@)B%+:A%v:B'Bw%Aw%@w@UYB%	 AevOp
BY
B`
K9@F$@B`
@F@H@@~
$RATFAC
PGCDCOFACTSRBRC
PTIMESCHKRB+
RCMAPCARRBL
@CLGCD1DDBoDD
BpD
BtDBwDD
Bw
D
GCDL8
X%
e	  %
eW'%+:
w+w%
17 |  %ew
18 |  
%e
w $
19 | `)
iAWg	 'Ak	`
'A%+zO
B`
B{
KeX@Fs@B{
@F@@@@pB~R
PIRREDPRBkRBx
RBrR
MAKPRODGRBDDBoDD
BWD
BXDBwD


--------------------------------------------------------------------------------
/lmmaxq/logarc.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen}%FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMACRAKDB0lLOGARCDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMACRAKDB0lLOGARCDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCLOGARCD

RUNTIMEC
MACSYMA-MODULE
$LOGARCK&@F@BY@FA@@@@ARCPRBSRBYRC$ATAN2@C%ATAN@DIVR
RECUR-APPLYD
Dp,
COMPILER,
ARG-MAPD
D
EXP
Xq81`k1	t8
2 | $``+%+z$eOmBYBSK"<D@F^@BS@F@@@@DC%ACOSBbC%ASINHC%ATANH@DBtC%ASIN@MUL2RDDCMTIMESSIMPF@
$%I@CSIMPLNRLISTRD
%LOG@ADD2RB@ROOTRNEGRCPOWERRDBbC%ACOT@DDB{B|DDRATB|F
FB@BcRMORPRPORMRDBuC%ACOSH@DBvC%ACOTH@DDBB|F
F@F@
@DC%ASECC%ACSCC%ASECHC%ACSCH@BSR
$INVERSE@C


--------------------------------------------------------------------------------
/lmmaxq/macros.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen8FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lRZDB0lMACROSDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lRZDB0lMACROSDB0B:DB0F/pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCRZMACD
CMACROC
MACSYMA-MODULECREPEATK7"@F$@BY@FA@@@@}F@CERRORRplSI,-- wrong number of args to a macro.@LISTRD@CINDEXCLIMITBODY@CLIST*RCDO@C1+@NOT@C<DDp,
COMPILER,
ARG-MAPD
D
pBbl
*MACROARG*DpBol
LOCAL-MAPDD
BfD
BgD
BhD@
ARGLISTBfBgBh%T:T8$	`
 2 | $e)'@w))'Aw)))Bw$	 	`@%%	`
 3 | $@e	 	`$	`$@%AeBeD@BTB
OBYCLOGORK
 4 | @F
 5 | @B@FA@@@@BjRCBOOLE@FDDBqD
D
BsDBxD
D
CFROBSD@B~B)@w$$@eD@BTBOBC
ADD-TO-SETK:(@F'@B@FA@@@@SET1F@BaRBd@BeRDBFROB@CLAMBDA@D
TEMP@COR@MEMQ@B#@SETQ@CONSDDBqD
D
BsDBxD
D
B DB~BB %T:TX%T:48	$
 6 | `$e)'V))'@w
 7 | 
 8 |  $
 9 | $
10 | `$
11 |  $$d
12 | `$$
13 | `$$d@eD@BTB1O2BC
COMPILINGK
14 | @F@B3@FA@@@@BaRBd@BeDDBqD
D
BsD
B~%T:58$`%e
D@BTB?O@B3C*BIND*KJ@F+@BA@FA@@@@yCNCONCRBeRBk@C<-@CRETURNDDBqD
D
CLDBxDD

BINDINGSD
BhD
pBol
MAP-RESULTD
pBo,
MAP-TEMPNILD
CQD
CX+-Aw@w $B7@%DwCwC%D'EwEX Ee	E+	t8 E'E%+z
E%t:CWXDDiYB%eBwB7A%DwCwC%D%FwF	X
15 | $F%v:
F't:CWXDDpYB%eD@BTB`OaBAC
DISPLACE2K.@F@Bb@FA@@@@}F@BaRBd@BeRDFORM
NEW-CAR
NEW-CDR@CRPLACA@CRPLACDDDBqD
D
BsDBxDD
BjD
BkD
BlDB~BjBkBl%T:TX%T:48$	`
16 | $e)'@w))'Aw)))'Bw	$	 $@%BeAeD@BTBzO{BbC
NEGATE-IFK6 @F#@B|@FA@@@@}F@BaRBd@BeRDC
PREDICATECVALUE&AUXDB#D
CGENSYM@B
RLET@COND@NEGDDBqD
D
BsDBxDD
B
D
B
D
B#DB~B
B
B
B	
%T:TX%T:48$	`
17 | $e)'@w))'Aw"Bw	$	 	`B%@e	`
18 | $	 B%	`$Ae	`
%AeD@BTB
O
B|CEITHERK
19 | -@F@B
@FA@@@@}F@BaRBd@BeRDCWHICHCFIRSTCSECOND@B
DDBqD
D
BsDBxDD
B"
D
B#
D
B$
DB~B"
B#
B$
%T:TX%T:48$	`
20 | $e)'@w))'Aw)))'Bw	$	 @%Ae	`BeD@BTB0
O1
B
C
SET-EITHERKF @F+@B2
@FA@@@@{F@BaRBd@BeRDC
FIRST-VARC
SECOND-VARCSWITCHB
B
DB#D
B
@B
RB
@B
@B'DDBqD
D
BsDBxDD
B:
D
B;
D
B<
D
B
D
B#DB~B:
B;
B<
B
B
B>
%T:TX%T:48$	`
21 | $e)'@w))'Aw)))'Bw))))'Cw"Dw	$	 	`D%Ce	`
22 | $	 B%	`$@%De	`
%	`$A%DeD@BTBL
OM
B2
C\*K@F@BN
@FA@@@@C
REMAINDERDDBqD
D
BsDBxD
D
BKDB~C&RESTBK)@w$@%vD@BTB_
O`
BN
CM+K@F@Ba
@FA@@@@ADD*DDBqD
D
BsDBxD
D
BhD@B~Bh)@w$@%vD@BTBq
Or
Ba
CM*K@F@Bs
@FA@@@@MUL*DDBqD
D
BsDBxD
D
BhD@B~Bh)@w$@%vD@BTB
O
Bs
M1+K


--------------------------------------------------------------------------------
/lmmaxq/matrun.qfasl.2:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATAD,HIC,
SCRC-COLLIEx~HFRF3pB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTE,
MACSYMADB0pB l
UNSPECIFICDB0,RATDB0lMATRUNDB0B4DB0B4pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0lFDB0B4DB0,
>MACSYMA>RATDB0B8DB0,LISPDB0FPpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMATRUND

RUNTIMEC
MACSYMA-MODULE1D
SPECIALC*EXPRC
*RULELISTC$RULES
$FACTORFLAG$MAXAPPLYHEIGHTC
$MAXAPPLYDEPTH1DplSIl
DEFCONST-1B^F'1DBcB]F'DpB ,
PROPERTYC
$DISPRULE
MFEXPR*K@F@Bn@FA@@@@B[1C
DISPRULE1R$ALL@
CONSRULED
Dp,
COMPILER,
ARG-MAPD
D
CL	8e'tX	ghOBnBuK
 2 | @F@Bu@FA@@@@C$LDISPRBwRC$DONEDDBzD
D
B{DpBxl
LOCAL-MAPD
D
B{%@w`@g@@zYOBuBwK@F@Bw@FA@@@@MGETRC$RULE@LISTRDCMSETQSIMP@DCMARROWB@CMERRORR,~:M not a user ruleDDBzD
D
CXDB
 3 | D
D
RULE %d@w@8	$%
 4 | $@)vz$eO,Bw
$REMRULEK3"@F"@B-@F@@@@CGETOPRRBv@C
REMOVERULERCGETOPRBR
OLDRULES@B!Rl~:@M has no rules@
MPUTPROPR
RULENUMDDBzDD
COPD
B'DB
 5 | D
D
CRULES ew
%tX%
e	e
 6 |  %d@wX
 7 | $e@8@	X%%d	e%@g@qOEB-B5K2
:@FO@B5@F@@@@|B[1BRB7@CMEMBERRB!R,~:M - no such rule.@C
SIMPARGS1@DCLAMBDADCACBCCD
SIMPARGSBPBR@DEXPRSUBR@
PUTPROPRBW@
REVERSERCSUBSTRC
MAKUNBOUNDR
MREMPROPRB@C
$RULETYPE@CRULEOF@
REMPROPRDELQRC
OPERATORS@B9DDBzDD
B;D
B'DB
 8 | DD
B7D
OLDD

OTHRULENAMED

OTHRULE %d@w
8	 
%@e@wX
 9 | $
e@)@WX@$Bw
10 | $Cw@'Bw@'$Q:+Cw
%C%d	 
%``%d)AwA
11 | 8A' B%
%A'$Pzd
%~8
e
%d
%d
%d
%d
%$e
%B%d%$P:
u8%B%d% 
%`%ddOrB5CFINDBEK
12 | "@F@Bs@FA@@@@D@F
@D@F
@CMEXPTD
DBzD
D
CE%u
8%u
8X%%v1t8+%+:v%%vO
Bs
FINDFUNK
13 | ,@F@B
@FC@@@@
MATCHERRRDCMPLUSCMTIMES@B[D
DBzDD
B

D
CPD
BR81
u
881uX%$8 iw
X8%(:
u
8sO
B
C
FINDEXPONK#T@F1@B
@FC@@@@CMEXPTPRCALIKE1RDB
B
@B[R
MEMALIKERB
@B
DDBzDD
CE1D
CBASE*D
BRDB
14 | D
D
B

%@w@e8
%@k8@%+@8@1u8%$8	 @i@w
@@8@g8
%@%*z8@%6r8%$8%1u8
15 | 
%e
16 | X%
eX
8%
1u
8%t8
`O0
B

FINDBASEK
17 | $U@F1@B1
@FC@@@@B
@B
RB!
RB"
RDB
B
@B[D
DBzDD
B

D
CEXPOND
BR
%u	8%t8%uX
%u
8
%k8
%l8%u
8e8	
%%+z
881uX%
18 | $8 iw
X
%k8
%m
8g8	
%%6z8%*jO@
B1
CPART+K7.@FN@BA
@FC@@@@{B[RCNTHKDRR
NREVERSERC
$RATEXPANDRCMPLUSPRB
RDBSETQ@B!RlTwo or more pattern variables TRUE@MSETRFz@CMATCH@CMCALLR


--------------------------------------------------------------------------------
/lmmaxq/mdot.qfasl.2:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATAD,HIC,
SCRC-COLLIEx2HFRF3pB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTE,
MACSYMADB0pB l
UNSPECIFICDB0lMAXSRCDB0,MDOTDB0B4DB0B4pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0lFDB0B4DB0,>MACSYMA>MAXSRCDB0B8DB0,LISPDB0F^pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPMDOTD

RUNTIMEC
MACSYMA-MODULE1DplSIl
DEFCONST-1C
$DOTCONSTRULESCT1DBZC
$DOT0SIMPB\1DBZ
$DOT0NSCSIMPB\1DBZC
$DOT1SIMPB\1DBZ
$DOTSCRULESNIL1DBZ
$DOTDISTRIBBi1DBZ
$DOTEXPTSIMPB\1DBZC
$DOTASSOCB\1DBZ
$DOALLMXOPSB\1DBZC
$DOMXMXOPSB\1DBZC
$DOSCMXOPSBi1DBZ
$DOMXNCTIMESBi1DBZC
$SCALARMATRIXPB\1DBZC
$DOTIDENTF
1DBZC
$ASSUMESCALARB\1D
SPECIALC$EXPOPC$EXPONSIGN
SIMPNCTK%`eJ@F@B@FC@@@@xBrqBoqBqBlqB1C
SIMPCHECKRCNCMULNRCOMMUTATIVE-PRODUCTPRMUL2RCPRODUCT-WITH-INNER-SCALARPRCPARTITION-PRODUCTRC
OUTER-CONSTANTRCMPLUSPRADDNRCNCMUL2RCMATRIX-MATRIX-PRODUCTPRCTIMEXRCSCALAR-MATRIX-PRODUCTPRC
SIMPLIFYARC
OUTERMAP1R
MNCTIMES@C
SIMPNCT-ALIKERCSIMPNCT-MERGE-FACTORSRC
MNCTIMESPRCAPPENDRCSIMPNCT-MERGE-PRODUCTRCSIMPNCT-ANTISYM-CHECKRCEQTESTRLISTRD
B'DDp,
COMPILER,
ARG-MAPDD
EXPD
C
VESTIGIALD
C
SIMP-FLAGDpB1l
LOCAL-MAPDD
CCHECKD

FIRST-FACTORD
C
REMAINDERD
P-PD
pB1l
MAP-RESULTD
pB1,
MAP-TEMPBiD
CX% +e%/8 -e %+:eBwAw@w	
X
 2 | 
 3 | 
XA
 4 | A%Be8A%BeAe8 AeCwC'C)BeBe8 BeCwC'A%CiAe8	X$YXD7A)FwEw
 5 | E%F'Gw G%Bet:EWXFFtYD%
eBe8	X$YXDwD7B)FwEw
 6 | E%F'Gw A%Get:EWXFFtYD%
eA%Be8A%BeA%BeXB%Ae8 $A%Be
eA%Be88A%BeAe
 7 | 88 A)Be8BiB%tz
eBe888 A%Biwe88 )@e!%@eBe88 A%B)v:@e!" #$A%Be@eOQBBK
 8 | 
 9 | @F@B@F@@@@CSIMPNCT-SC-OR-CONST-PR
SIMPNCT-ONEPRC
ZERO-PRODUCTPD
DB3DD
B@D
BB e 
e
10 |  e
11 |  
e %
e
%eO`BBXK	@F@BX@FA@@@@CSIMPNCT-CONSTANTPRCSIMPNCT-ASSUMESCALARPD
DB3D
D
TERM eeOnBXBgK@F@Bg@FA@@@@B[1CMNUMPRC
$CONSTANTPR
$NONSCALARPD
DB3D
D
Bi$x e ex	 ebO|BgBhK@F@Bh@FA@@@@BqBh1SCALAR-OR-CONSTANT-PR$ALLD
DB3D
D
Bi$x%$	${O	
BhBYK	@F@BY@FA@@@@Be1CONEP1D
DB3D
D
Bi$xeO
BYBZK@F@BZ@F@@@@BbqB_1CZEROP1RBwD
DB3DD

ONE-TERMD
C
OTHER-TERM ex$x$	 
ebO$
BZBK
12 | @F@B@FA@@@@BhqB[1
MTIMESPRBXDDB3D



--------------------------------------------------------------------------------
/lmmaxq/merror.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen  FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lMERRORDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lMERRORDB0B:DB0F/pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMERRORD

RUNTIMEC
MACSYMA-MODULE1DplSIl
DEFCONST-1C$ERRORDB0DDCMLISTSIMPC
&No error.1DB[C
$ERRORMSGDB0CTB\K	
2 | @F@B\@@@@@BSR
FSTRINGCDDp,
COMPILERl
LOCAL-MAPD
D
CLDC
DOCUMENTATIONlSignals a Macsyma user error.$ @eO|B\1DB[
$ERROR_SIZEF
3 | C
ERROR-SIZEK	!@F@B
@FA@@@@~B}1B
DDpBq,
ARG-MAPD
D
EXPDBsDD
BtD
CN
X)%Aw@w	@)A% @g3U:Aw%@w@8A%4r9AOB
BSK@F@BS@A@@@@B\qBe1CHECK-OUT-OF-CORE-STRINGRCLIST*RD
B]@BeRCERRORDDB	D
D
CSTRINGDBsD
D
Bt ew	 
4 | $%@eV
8eO'BS1DBRBSBfpB l
ERROR-REPORTER1DB[
$ERROR_SYMSDB0DD
B]
$ERREXP1
$ERREXP2
$ERREXP3DpB ,
PROPERTYB,CASSIGNK
5 |  @F@B8@F@@@@C$LISTPRBSR,The variable ~M being set to ~M which is not a list of symbols.DDB	DD
VARD
VALDBsD
D
Bt
e8
)@w@'yX@@xY
X$%
eOKB8


--------------------------------------------------------------------------------
/lmmaxq/mformt.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenB FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lMFORMTDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lMFORMTDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMFORMTD

RUNTIMEC
MACSYMA-MODULEC
DEF-MFORMAT-OPK
2 | "@F@BY@FA@@@@~CERRORRplSI,-- wrong number of args to a macro.@LISTRDCHARC&RESTBODY@CLIST*R+DEF-MFORMAT-OP@DDp,
COMPILER,
ARG-MAPD
D
pBal
*MACROARG*DpBll
LOCAL-MAPDD
BeD
BgD
ARGLISTBeBfBg%T:U8$`	$e)'@w))Aw
3 | $$@%AeD@CMACROB}OBYDEF-MFORMAT-VARK.@F@B@FA@@@@}F@B`RBc@BdRDVARVALINIT@+DEF-MFORMAT-VAR@BkDDBnD
D
BpDBuDD
BD
B	D
B
4 | DBzBB	B
5 | %T:TX%T:48$	`
6 | $e)'@w))'Aw)))'Bw	$$@%A%BeD@B~BOB
MFORMAT-LOOPK
7 | @F
8 | @B@FA@@@@BiRC
+MFORMAT-LOOP@BkDDBnD
D
BpDBuD
D

ENDCODEDBzBfB$)@w$$@eD@B~B*O+BC:-FLAGC@-FLAGC
PARAMETER
PARAMETER-PTEXTC
TEXT-TEMP
DISPLA-P
PRE-%-P
POST-%-PCHECK-OUT-OF-CORE-STRINGK
	@F@B5@FA@@@@D
DBnD
D
CSTRINGOAB5C
PUSH-TEXT-TEMPK@F@BB@FA@@@@B`RBc@BdRDCIFB1DSETQB0DCONSDBKDB0D

TEXT-STRINGD
NREVERSEB1B0B1NILDDBnD
D
BpD
Bz%T:58$`%e	D@B~B[O\BB
OUTPUT-TEXTK@F@B]@FA@@@@B`RBc@BdRDCPROGND
BBD
OUTPUT-TEXT*CSTREAMB0B2B3B4D	BJB0BSB2BSB3BSB4BSDDBnD
D
BpD
Bz%T:58$`%e	D@B~BpOqB]C
MFORMAT-%&C
MFORMA


--------------------------------------------------------------------------------
/lmmaxq/misc.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen_ FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLMMAXDB0,MISCDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLMMAXDB0,MISCDB0B:DB0F3pB.,
PACKAGEpB.,
MACSYMA
*REARRAYK#X$@F5@BR@B@@@@{CCERRORRpB ,WRONG-TYPE-ARGUMENT@,The argument ~2G~A was ~1G~S, 


--------------------------------------------------------------------------------
/lmmaxq/mload.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATAD,rhb,
SpanielOLFPFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lMLOADDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lMLOADDB0B:DB0FypB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMLOADD

RUNTIMEC
MACSYMA-MODULE1D
SPECIAL
$FILE_SEARCH
$FILE_TYPES
$LISTP_CHECKK
 2 | @F@B^@F@@@@C$LISTPRCMERRORRlThe variable ~:M being set to a non-LISTP object:~%~MDDp,
COMPILER,
ARG-MAPDD
VARD
VALDC
DOCUMENTATIONlGives an error message including its first argument if its second
 3 |   argument is not a LIST 
e$%
eOuB^1DBRBZB^CASSIGN1DBRB[B^BvBZKX	8@F:@BZ@C@H@@{|{CLQBZqB[1@F@F@@B[A
Fe@Fe@Fe@Fe@@Fe$FILENAME_MERGERBeRBfR,3'rd arg to FILE_SEARCH not a list.~%~M@CPROBEFRCTO-MACSYMA-NAMESTRINGRD
CMLIST@
NREVERSER,Could not find file which matches ~MDDBjDD
CXD
CLISTPD
B
DpBhl
LOCAL-MAPDD

MERGE-SPECSD
CPROBEDD
CFOUNDD
CU ewd8$d"(v:@w!$ @gCwV `%C%fAw8
8 AeB%v:Bw
kY8Ae@@]Y
8$ Bev$eO&BZ1DBYC
$LOADPRINTC
LOAD-AND-TELLK	
 4 | @F@B*@FA@@@@B'1
LOADFILED
DBjD
D

FILENAME%
%dO7B*B
 5 | K

 6 | @F	@B
 7 | @FA@@@@pB+l
PARSE-PATHNAMED
DBjD
D
BeODB
 8 | MACSYMA-NAMESTRINGPK	
 9 | @F@BE@FA@@@@plSI,
TYPEP-FLAVORRpB+,
PATHNAMED
DBjD
D
B%dOUBECERRSET-NAMESTRINGK@F@BV@FA@P@@CERRSETQplEHl
ERRSET-STATUSqpB^,ERRSET-PRINT-MSG1F%@pB^,
ERRSET-CATCH@LISTRB?DDBjD
D
BDBD
D
B]
%V6	$.;
10 | $``eOnBVB
11 | K	 @F@B
12 | @@@@@~}|F @F2@,@FepB+,MERGE-PATHNAME-DEFAULTSRCMACSYMA-NAMESTRING-SUBRB
13 | D
DBDD
C
FILE-SPECSD
CFD
CJ@%T:Bw	
14 |   B%V:@%{AeAwBuB%Yt9AeO
B
15 | B{K+@F@B{@FA@@@@~BERC
FULLSTRIP1RBeRC
FULLSTRIPRBfRlBad file spec:~%~M@BVRlBad file spec: ~:MDDBjD
D

USER-OBJECTDBDD
C
SYSTEM-OBJECTD
C
NAMESTRING-TRYe
8X e	e8	 i
16 |  $e@w @eAwA
8A
17 | 
18 | $eO
B{
OPEN-OUT-DSKK


--------------------------------------------------------------------------------
/lmmaxq/mmacro.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen#FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,REHDB0lMMACRODB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,REHDB0lMMACRODB0B:DB0F2pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMMACROD

RUNTIMEC
MACSYMA-MODULE1D
SPECIAL
$MACROSC
$FUNCTIONSC
$TRANSRUNC
$TRANSLATE1DplSIl
DEFCONST-1$MACROEXPANSIONNILC
COPY1CONSK'@F@Bg@FA@@@@NAME1CERRORRpB`,-- wrong number of args to a macro.@LISTRD
Bn@CONS@CAR@CDRDDp,
COMPILER,
ARG-MAPD
D
pB`l
*MACROARG*D
ARGLISTBn%T:UX%T:58$	`
2 | $e)'V	$	 $d	`
3 | $dD@CMACROBOBgDpB ,
PROPERTYC
MDEFMACRO
MFEXPR*K@F@B	@FA@@@@CMERRORR,Wrong number of args to ::= ~%~M@D
B@C
MDEFMACRO1D
DByD
D
FORM	8%/8$$%vz	'kOB	BK$1H@FU@B@F@H@@|BnQB]qBZqB[1CARRAY@MOPPR
$VERBIFYRD$ALLC$%$%%
MQAPPLY@BR,Illegal macro definition: ~M@
MREDEF-CHECKRC
MDEFPARAMRC
MDEFLISTPRlIllegal parameter in macro definition: ~M@
REMOVE1RCMEXPR@
MPUTPROPR
MLEXPRP@ARGSRBn@DBtBdDCLENGTHB1@REMOVE-TRANSL-FUN-PROPSR
ADD2LNCRBrR
MDEFINE1RBS@CTRANSLATE-AND-EVAL-MACSYMA-EXPRESSIONRD
B@DBSIMPDDByDD
FUND
BODYDpBwl
LOCAL-MAPDD
BnD
B1D
CAD
B08X
4 | $/
5 | X qVeX$
6 | $8$e$1uX'$W)AwdA%BwBg
7 | XBe8B'k8
%Cw$BgBBmY$t:$
%	$
eC8$
%dDdd dA%v:d$ A%
ed8


--------------------------------------------------------------------------------
/lmmaxq/mopers.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen4FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLIBMAXDB0lMOPERSDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLIBMAXDB0lMOPERSDB0B:DB0F0pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMOPERSD
CMACROC
MACSYMA-MODULE1DLOAD-MACSYMA-MACROSCDEFOPT1DCLOAD-MACSYMA-MACROS-AT-RUNTIMEDB0BZC=0K
 2 | "@F@Ba@FA@@@@CERRORRplSI,-- wrong number of args to a macro.@LISTRD
CX@CLIST*RCEQUAL@D
DDp,
COMPILER,
ARG-MAPD
D
pBil
*MACROARG*DpBsl
LOCAL-MAPD
D
BmD
ARGLISTBm%T:UX%T:58$`	$e)'@w
 3 | $@%dD@BTBOBaC=1K
 4 | "@F@B@FA@@@@BhRBk@BlRD
Bm@BoRBp@D
F
DDBuD
D
BwDB|D
D
BmDBBm%T:UX%T:58$`	$e)'@w
 5 | $@%dD@BTBOBDpB ,
PROPERTYADDOPTK@F@B@FA@@@@ADD2@BoRADDN@Bl@D
CTDDBuD
D
BwDB|D
D
CTERMSDBC&RESTB+)@w@%T:8$@%v$	$@%v:
 6 | dO2B1DBRBD
C
OPT-DRIVERpBsl
OPTIMIZERSDBADD*BK@F@B:@FA@@@@CADD2*@BoRB%@Bl@D
NILDDBuD
D
BwDB|D
D
B+DBB/B+)@w@%T:8$@%v$	$@%v:
 7 | dOLB:1DBRB9B4B6DBMULBK$@F@BP@FA@@@@MUL2@F@MUL3@BoRMULN@Bl@D
B&DDBuD
D
BwDB|D
D

FACTORSDBB/B_)@w@%T:8$@%v@%T:8$@%v	
 8 | $$@%v:dOeBP1DBRBOB4B6DBMUL*BK@F@Bi@FA@@@@CMUL2*@BoRBZ@Bl@D
BBDDBuD
D
BwDB|D
D
B_DBB/B_)@w@%T:8$@%v$	$@%v:
 9 | dOzBi1DBRBhB4B6INVK
10 | "@F@B}@FA@@@@BhRBk@BlRD
Bm@BoRCPOWER@D
F@
DDBuD
D
BwDB|D
D
BmDBBm%T:UX%T:58$`	$e)'@w
11 | $@%dD@BTB
O
B}INV*K
12 | "@F@B
@FA@@@@BhRBk@BlRD
Bm@BoRCPOWER*@D
F@
DDBuD
D
BwDB|D
D
BmDBBm%T:UX%T:58$`	$e)'@w
13 | $@%dD@BTB%
O&
B
CNCMULK@F@B'
@FA@@@@CNCMUL2@BoRCNCMULN@Bl@D
B&DDBuD
D
BwDB|D
D
B_DBB/B_)@w@%T:8$@%v$	$@%v:
14 | dD@BTB9
O:
B'
TAKEK@$@F)@B;
@FA@@@@}BhRBk@BlRD
OPERATORB/ARGS&AUXC
SIMPLIFIER@B0@DD@C%ATANC
SIMP-%ATAND@%TANC
SIMP-%TAND@%LOGCSIMPLND@MABS
SIMPABSD@%SINC
SIMP-%SIND@%COSC
SIMP-%COSD@C$ATAN2C
SIMPATAN2@BoRBl@DF
B&@C
SIMPLIFYA@D
B&DDBuD
D
BwDB|DD
BB
D
BC
D
BE
DBBB
B/BC
BD
BE
%T:U8$`	$e)'@w))Aw@%c:b:	x@'
15 | $;x@%):$R:)BwB8B% 
16 | $@%Aed$ 
17 | $@%AedD@BTBk
Ol
B;
CMIN%IK


--------------------------------------------------------------------------------
/lmmaxq/mormac.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteendFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLMMAXDB0lMORMACDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLMMAXDB0lMORMACDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
SSTATUS
FEATURECMA


--------------------------------------------------------------------------------
/lmmaxq/mstuff.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenIFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,DASDB0lMSTUFFDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,DASDB0lMSTUFFDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMSTUFFD

RUNTIMEC
MACSYMA-MODULEC$SORTKO	6@F5@BY@@@@}{|*LEXPR-ARGLIST*F @@Fe@Fe@Fe@FeCMERRORR,SORT takes 1 or 2 arguments.@ARGRC$LISTPRlThe first argument to SORT must be a list:~%~M@CAPPENDRC
MFUNCTION1RCGETOPRR
LESSTHAN@DBnCGREAT@CMAPCARRC
RATDISREPRDCMLISTSIMP@SORTD
Dp,
COMPILERl
LOCAL-MAPDD
B`D
CND
CLLISTD
C
COMPARFUND
BFUN$T:AwA%XA%58
2 | d eBwBeX$Be B)eBw A%8 `e
$DWeCwD%$8 $BeBw$ B%CevOBYBlK@F@Bl@FA@@@@LISTRCLAMBDA@DCXCY@CMEVALP@CLIST*RplSIl
XR-BQ-LIST@B0@DDBDB0D
CMQUOTEBDBDB0D
BBD
DpBw,
ARG-MAPD
D
FUN$$`	$
3 | `$ $`e
4 | dO&BlBnK@F
5 | @Bn@F@@@@BoD
DB DD
CAD
C


--------------------------------------------------------------------------------
/lmmaxq/mutils.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteeng FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lMUTILSDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lMUTILSDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMUTILSD

RUNTIMEC
MACSYMA-


--------------------------------------------------------------------------------
/lmmaxq/newdet.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen)wFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0lNEWDETDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0lNEWDETDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCNEWDETD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALCVLIST
VARLISTCGENVARARYP
$NEWDETK;	"@F&@B`@@@@~}|*LEXPR-ARGLIST*F @@Fe@FeARGRCMERRORR,Wrong arg to NEWDET: ~M@
$MATRIXPRlWrong number of args to NEWDET@BSD
Dp,
COMPILERl
LOCAL-MAPDD
BgD
CND
CA$T:AwA%8
 2 |  e[X$
 3 | `e
 4 |  eBw
 5 |  eAwA%8
 6 | 
 7 |  eBWe8
 8 |  e)T:AwdB%A%eO{B`C
$PERMANENTK;	"@F&@B|@@@@~}|BgF @@Fe@FeBkRBlRlWrong arg to PERM: ~M@BnR,Wrong number of args to PERM@BSD
DBrDD
BgD
BtD
Bv$T:AwA%8
 9 |  e[X$
10 | `e
11 |  eBw
12 |  eAwA%8
13 | 
14 |  eBWe8
15 |  e)T:AwdB%A%
eOB|BSK(P
P@F<@BS@FC@@@@rBZQSIGNQB]qB\qB[1F2@BlRlArray too big 


--------------------------------------------------------------------------------
/lmmaxq/newinv.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenwFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lPAULWDB0lNEWINVDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lPAULWDB0lNEWINVDB0B:DB0FYpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCNEWINVD

RUNTIMEC
MACSYMA-MODULE1D	
SPECIALC*NONZ*CDETL**R0MUL*
$SPARSEC*DET**RR*CAXCMULTBKK	)@F@Bd@FC@P@@}Ba
RATTIMESDDp,
COMPILER,
ARG-MAPDD
CLD
BaD
CMDpBll
LOCAL-MAPDD
CED
CJD
CI%U:Aw'@w%Bw @% B%Ae
e B%Ae_BUB%5r9AUA%%s5f9`O
Bd
CTIMEMTK
2 | @F@B@F@@@@CNCONCRLISTR
TIMESROWDDBnDD
CXD
CYDBwD
D
CC

X@ @%``%
g@w
tOBCSTORAK;	*@F(@B@
@`@@{{|BaF@@@@@F0@F2@@F0@F0@F0C
RATREDUCERPTRRPTCDDBnDD
BaD
BrD
CEID
CRDBwDD
DETD
B|D
BzD
CROD
MAT
X'DwD1@wD%BwDs9AUD'CwDCv9BU C1@e A%
%B3e_%  Ae`Be_CkO?BCPRODHKKO"@F0@B@@F
@@@@@uB`QB\QB[qBa1BRCAPPENDRB
3 | R
NREVERSERB	RBMHKDDBnDD
CRID
CDD
B0D
BrDBwDD
B.D
BxD
B`D
B\D
CCOD
pBll
MAP-RESULTD
pBl,
MAP-TEMPNILB^D
BD
B%v%@w@+X
4 | 	$% D%`
ee
'$v:


--------------------------------------------------------------------------------
/lmmaxq/nforma.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen3FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,MRGDB0lNFORMADB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,MRGDB0lNFORMADB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCNFORMAD

RUNTIMEC
MACSYMA-MODULE1D
SPECIAL1/2-1/2
DISPLAYPC
ALIASLISTIN-P1DplSIl
DEFCONST-1C
$POWERDISPNIL1DBcC
$PFEFORMATBe1DBc
$%EDISPFLAGBe1DBcC
$EXPTDISPFLAGCT1DBcC
$SQRTDISPFLAGBo1DBc$NEGSUMDISPFLAGBoBeNeB^
NFORMATK8<@FV@Bx@FA@@@@B]qB\qB^1LISTRD
CMMINUS@C$TRUE@C$FALSE@CASSQRRRAT@D
B@C
MMACROEXPANDED@BxRCMPLUS@C
FORM-MPLUSRCMTIMES@
FORM-MTIMESRCMEXPT@C
FORM-MEXPTRMRAT@C
FORM-MRATRCMPOIS@C
$OUTOFPOISR
BIGFLOATD
Dp,
COMPILER,
ARG-MAPD
D
FORM X%k8%m8	
2 | $%oz
%u8
8
X
8$x
3 |  %d'
$1u8+m8	
4 | $	`$+o:%+z$)v$1u8%+z
X$1u8e$1u8e$1u8e$1u8e$1u8`e$1u8+m8	
5 | $	`'+o:%+z')vOBxB	K!U&@F4@B	@FA@@@@~BuqBd1CMAPCARRBxRCTRUNC@DBB#@D
B@
RATSIMP@SIMP@
NREVERSERCCF@
MMMINUSPDDBD
D
BDpBl
LOCAL-MAPDD
ARGSD
B# 	$i@w
6 | $/;Aw


--------------------------------------------------------------------------------
/lmmaxq/numer.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen';FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lNUMERDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lNUMERDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCNUMERD

RUNTIMEC
MACSYMA-MODULECCOMPATIBLE-ARRAY-TYPE?K'@F@BY@FA@@@@~F@CERRORRplSI,-- wrong number of args to a macro.@LISTRDTYPEC
TYPE-LIST@CLIST*RCEQ@D
DB0CART-QDDp,
COMPILER,
ARG-MAPD
D
pBbl
*MACROARG*DpBnl
LOCAL-MAPDD
BfD
BgD
ARGLISTBfBg%T:TX%T:48$	`
 2 | $e)'@w))'Aw$@%
 3 | dD@CMACROBO
BYC
GET-ARRAYK1y.@FH@B@C@@@@{CTYPEPRD
CARRAY@D
CSYMBOL@B
 4 | @CMERRORRlNot a lisp array:~%~M@BRC
ARRAY-TYPERBk@,~:M is not an array of type: ~:M@D
CMLIST@
ARRAY-#-DIMSRl~:M does not have ~:M dimensions.@C*@CARRAY-DIMENSION-NR,~:M does not have dimension ~:M equal to ~:MDDBpDD
CXD
CKINDSD
C#-DIMSDBwDD
C
DIMENSIONSD
pBbl
*SELECTQ-ITEM*D
CAD
CJD
CLDC
DOCUMENTATIONlGet-Array is fairly general.
 5 |   Examples:
 6 |   (get-array ar '(flonum) 2 3 5) makes sure ar is a flonum array
 7 |   with 2 dimensions, of 3 and 5.
 8 |   (get-array ar '(fixnum) 1) gets a 1 dimensional fixnum array.
#X eAwA%$
8A%$8%	$P:%|;x	$ %{;x%;
 9 | $e
10 | $eX eBw
11 |  Bet
8B
12 | $%$
%vz@
13 | X %
eBw Be
8B
14 | $%e %
%eBw%@%DwCwD'tXD' C%BeX
15 | $%C%DgCUDDnYBO2B1D
SPECIALC%E-VALC
MTO-FLOATK
16 | @F@B7@FA@@@@C$NUMERqC$FLOATqB41C
SSIMPLIFYARCSUBSTR$%ED
DBpD
D
B%k8%
17 | 
%V
%V	 
18 | `$$e
(OGB71DpBb,
DEFVAR-1
TRAMP$-ALISTNILC
DEFTRAMP$K0~<@FN@BN@FA@@@@vBaRBd@BeRD
CNARGS@C
SYMBOLCONCRCTRAMP@C$@$-F@$-M@CGENSYMRCPROGN@DB0
COMPILE@BiRPUSH@B0@D
BJ@
DEFMVAR@D
,Contains the object to jump to if needed@CDEFUN@CFLOAT@
FUNCALL@CMAPPLY@BeDDBpD
D
BrDBwD
19 | D
BUD
CTRAMP$D

TRAMP$-FD

TRAMP$-MD
B*D
pBnl
MAP-RESULTD
pBn,
MAP-TEMPBKD
CIGNORED

ARG-LISTDB|BU%T:UX%T:58$`	$e)'@w
20 |  $@%d
21 |  $@%
22 | d
23 |  $@%d%%@%;DwCwBwAwE7D%GwFwF%G'Hw"t:FWXGGvYE%Iw$$ $ $`@%A%B%Ced $A%d $B%I%`$`$A%Ie`$C%I%`$`$A%$I%v:`$AeD@BB
O
BN1DCONSDB0DF

TRAMP1$C
TRAMP1$-FC
TRAMP1$-MBJN
BJ1DpBbl
DEFCONST-1B
BcB
K@F
24 | @B
@FA@@@@B
1D
DBpD
BK e(O
B
B
K@F@B
@FA@@@@B
1BhRBeRB
D
DBpD
BK $ e	d(O$
B
1DB
DB0DF
TRAMP2$C
TRAMP2$-FC
TRAMP2$-MBJN,
BJ1DB
B&
BcB'
K@F
25 | @B'
@F


--------------------------------------------------------------------------------
/lmmaxq/numerm.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenRFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLIBMAXDB0lNUMERMDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLIBMAXDB0lNUMERMDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCNUMERMD
CMACROC
MACSYMA-MODULE
MAKE-ARRAY$K@F@BY@FA@@@@CLIST*RC
MAKE-ARRAY@LIST@DDB0pB ,TYPEDB0CART-QDDp,
COMPILER,
ARG-MAPD
D
plSIl
*MACROARG*DpBil
LOCAL-MAPD
D
CLD
ARGLISTC&RESTBt)@w$$@%v:	dD@BTB|O}BY
MAKE-ARRAY%K@F@B~@FA@@@@B`RBa@Bb@DDB0BdDB0BfDDBkD
D
BnDBsD
D
BtDBxByBt)@w$$@%v:	dD@BTBOB~CAREF$K@F@B@FA@@@@AREFDDBkD
D
BnDBsD
D
BtDBxByBt)@w$@%vD@BTB"O#BCAREF%K@F@B$@FA@@@@BDDBkD
D
BnDBsD
D
BtDBxByBt)@w$@%vD@BTB3O4B$
FREE-ARRAY%K	@F@B5@FA@@@@CERRORRpBl,-- wrong number of args to a macro.@BbRD
CADDBkD
D
BnDBsD
D
B?DBxB?%T:UX%T:58$`	$e)'@w@D@BTBIOJB5
FREE-ARRAY$K	@F@BK@FA@@@@B<RB>@BbRD
B?DDBkD
D
BnDBsD
D
B?DBxB?%T:UX%T:58$`	$e)'@w@D@BTB[O\BKC
DEFBINDTRAMP$K _>@F?@B]@FA@


--------------------------------------------------------------------------------
/lmmaxq/numth.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen
 2 | 
FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lRZDB0lNUMTHDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lRZDB0lNUMTHDB0B:DB0F/pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCNUMTHD

RUNTIMEC
MACSYMA-MODULE1D
SPECIAL
PRIMECHANNELC
$INTFACLIM1DplSIl
DEFCONST-1C
$MAXPRIMEfw1DCORDCBOUNDPDB0BZDSETQBZNILCOPEN-PRIMECHANNELK
 3 | @F
 4 | @Bn@@@@BZ1OPENRlmc:maxdmp;ptable >@DREADCFIXNUMpB l
BYTE-SIZEF	 $	dVO}BnCPRIMEK	@F@B~@FA@@@@Ba1C
INPUT-WORDD
Dp,
COMPILER,
ARG-MAPD
D
CN%UX%4
8eOB~
BYTE-INK
 5 | "@F@B@FA@@@@CERRORRpB^,-- wrong number of args to a macro.@LISTRD
FILE@CLIST*R
FUNCALL@D
DB0TYIDDBD
D
pB^l
*MACROARG*DpBl
LOCAL-MAPD
D
BD
ARGLISTB%T:UX%T:58$`	$e)'@w
 6 | $@%dD@CMACROB.O0BBK$@F@B@FA@@@@BZ1pB ,
SET-POINTER@F@B@FI@F	@FID
DBD
D
B	$$%V:se 	d
 7 | $ 	d$ 	d$ 	dN:N:NOABC$PRIMEK	 @F@BB@FA@@@@BZ1BnRF@B~RBRD
BB@CCLOSED
DBD
D
B	%C:8	 e
 8 |  $e
 9 |  $edOPBB
$DIVSUMK!Z	0@F9@BQ@@@@|z{*LEXPR-ARGLIST*QB[1F @@Fe@Fe@@Fe@Fe@Fe@FeF@CMERRORR,To many arguments to DIVSUM@ARGR
CFACTORWRCDIVSUMRBRD
BQD
DB'DD
BXD
B	D
CKD
B	D
CLD
CA$T:AwA%TXdA%8% e eCwBw6B%[&8C%[#8C%;CwB%u8C%
8C%
8 Ce%EwDwD-E%D+U:sEw%DwDvYE CeBe$C%BeOsBQBeK@F@Be@F@@@@~DDBDD
BlD
BiDB'DD
ANSD
TEMP%@w'uX'
%;AwA%+U:;V:A%V:@s@w5lY@O
Be
$TOTIENTK5@F @B
@FA@@@@~B[1BdRBRD
B
DDBD
D
B	DB'DD

FACTORSD
CTOTAL%[#8%;w%U
8%u
86 e%Aw@w
10 | @-A%@'V:s@'@+V:;sAw%@w@qYA	$eO
B
1DBYC*INCL
MODULUSB[1DBFFN 
B
1DANDDCNCONCB
B
DB0
NOPRINT
RTZERL2K
11 | @F@B(
@FA@@@@F@
HAIPARTRF@DDBD
D
B	DB'D
D
B	%Y
8%@w@%@w @%dYxY@O9
B(
CIMODPK:$@F&@B:
@FA@@@@~B
1C
REMAINDERRF@F@F@CIMODP1RF@F@F@CJACOBIRF@
DDBD
D
CPDB'DD
CID
CJ %du
X %	d
12 | t8%e %d
13 | t8$e


--------------------------------------------------------------------------------
/lmmaxq/opers.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lOPERSDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lOPERSDB0B:DB0FKpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCOPERSD

RUNTIMEC
MACSYMA-MODULEADD2K
2 | @F@BY@F@@@@C
SIMPLIFYARLISTRD
CMPLUSD
Dp,
COMPILER,
ARG-MAPDD
CXD
CY%u
8

%u
8 $%
e
eOnBYCADD2*K
3 | 	@F@Bo@F@@@@B`RBaRD
BbD
DBfDD
BgD
Bi%u8
%e
%u8%e $%
eeO|BoADDNK	@F
4 | @B}@F@@@@B`RD
BbD
DBfDD
CTERMSD
C
SIMP-FLAG
X$%v:
eOB}1D
SPECIAL
$NEGDISTRIBNEGK@F@B@FA@@@@B1B`RBaRD
CMTIMES@F@
D
DBfD
D
Bg%k8%o
%V 	$
5 | $e
eOBSUBK	@F@B @F@@@@BRBYD
DBfDD
BgD
Bi
%u
8%u8
e%`
eO,B SUB*K@F@B-@F@@@@BYRB`RMUL2RF@
D
DBfDD
BgD
Bi %e`	$`
%eO;B-B4K
6 | @F@B4@F@@@@B`RBaRD
BD
DBfDD
BgD
Bi%u
8

%u
8 $%
e
eOHB4CMUL2*K
7 | 	@F@BI@F@@@@B`RBaRD
BD
DBfDD
BgD
Bi%u8
%e
%u8%e $%
eeOVBIMUL3K
8 | %@F@BW@FC@@@@B4RB`R


--------------------------------------------------------------------------------
/lmmaxq/optim.qfasl.2:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATAD,DLA,
SCRC-BASSETg/0FRFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTE,
MACSYMADB0pB l
UNSPECIFICDB0,MRGDB0lOPTIMDB0B4DB0B4pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0lMCDB0,DSKDB0,MRGDB0lOPTIMDB0B4DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCOPTIMD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALVARSCSETQSC
OPTIMCOUNTCXVARS1DC
UNSPECIALARGS1DCARRAYCSUBEXPCTF@1DplSIl
DEFCONST-1
$OPTIMPREFIXDB0C$%1DBlC
$OPTIMWARNBfC
$OPTIMIZEKY6@F:@Bu@FA@@@@BrqBZqB[qB\qB]1
$LISTOFVARSRC
FILLARRAYRBe@D
NIL@
COLLAPSER
OPFORMATRCCOMEXPRBSRCMPROG@C$LISTPR
NREVERSERCNCONCRCLIST*RDBSIMP@D
CMLISTDDp,
COMPILER,
ARG-MAPD
D
CX0DpBl
LOCAL-MAPD
D
CX$V66	6
2 | 6	 e)
3 | v
4 | $d ``e@w@
X@@e @e@wX%@1t8@k	8@%-8 @%$vz@w  d@m@w $$ dv:@e
5 | $dOBuB
K8$@F%@B
@FA@@@@Br1
SPECREPPRB
RC
SPECDISREPRC
MSPECFUNPRCMTELLR,	OPTIMIZE has met up with a special form - ~
6 | 			     answer may be wrong.@CMEXPT@
OPMEXPTRCMAPCARRCALIKEDDBD
D
BDBD
D

NEWARGS
Xe8	`e$x
7 |  qxdv%1
8 | t8e $i@w@%i
8'@%vO2B
B'KF (@FZ@B'@FA@@@@}EXP1B
R
RATNUMPRLISTR
MTIMESPRF@
@BRD
C
MQUOTIENT@B'RD
C%SQRT@D
B&@DpBjl
XR-BQ-LISTDB0D
B@C*BASE@CALIKE1DDBD
D
BDBDD
BGD
XNEWD
CNEGEXP k %+zV


--------------------------------------------------------------------------------
/lmmaxq/pade.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenUFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0,PADEDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0,PADEDB0B:DB0F*pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPPADED

RUNTIMEC
MACSYMA-MODULE1D
SPECIALCTLISTTPFREDK
 2 |  @F@B^@FA@@@@CERRORRplSI,-- wrong number of args to a macro.@LISTRD
CP@CDRDDp,
COMPILER,
ARG-MAPD
D
pBfl
*MACROARG*DpBml
LOCAL-MAPD
D
BjD
ARGLISTBj%T:UX%T:58$`	$e)'@w
 3 | $@eD@CMACROB}OB^P0?K
 4 |  @F@B@FA@@@@BeRBh@BiRD
Bj@NULLDDBoD
D
BqDBvD
D
BjDBzBj%T:UX%T:58$`	$e)'@w
 5 | $@eD@B~BOBE0?K
 6 | #@F@B@FA@@@@BeRBh@BiRD
CEXPON@CZEROP@CARDDBoD
D
BqDBvD
D
BDBzB%T:UX%T:58$`	$e)'@w
 7 | $`$@eD@B~B&O'BCEPOS?K$@F@B(@FA@@@@BeRBh@BiRD
B@CSIGNP@CG@BDDBoD
D
BqDBvD
D
BDBzB%T:UX%T:58$`	$e)'@w
 8 | $$`$@eD@B~B:O;B(CENEG?K$@F@B<@FA@@@@BeRBh@BiRD
B@B0@CL@BDDBoD
D
BqDBvD
D
BDBzB%T:UX%T:58$`	$e)'@w
 9 | $$`$@eD@B~BMONB<NUMK
10 |  @F@BO@FA@@@@BeRBh@BiRD
CR@BDDBoD
D
BqDBvD
D
BVDBzBV%T:UX%T:58$`	$e)'@w
11 | $@eD@B~B`OaBOCDENOMK
12 |  @F@Bb@FA@@@@BeRBh@BiRD
BV@BlDDBoD
D
BqDBvD
D
BVDBzBV%T:UX%T:58$`	$e)'@w
13 | $@eD@B~BrOsBbENEGK
14 | )@F@Bt@FA@@@@BeRBh@BiRD
EXP@CONS@CMINUS@B@BlDDBoD
D
BqDBvD
D
B{DBzB{%T:UX%T:58$`	$e)'@w
15 | $ $`$@e`
16 | $@eD@B~B
O
BtC
PADE-LEXPK+@F@B	
@FA@@@@BeRBh@BiRD
POLY@COND@B@D
D
CEZERO@CLEDDBoD
D
BqDBvD
D
B
DBzB
%T:UX%T:58$`	$e)'@w
17 | $ $@e$v:`
%`
18 | $@eD@B~B
O 
B	



--------------------------------------------------------------------------------
/lmmaxq/polyrz.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteenx{FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0lPOLYRZDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0lPOLYRZDB0B:DB0F]pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCPOLYRZD

RUNTIMEC
MACSYMA-MODULE1D
 2 | 
SPECIALC
ERRRJFFLAG
$PROGRAMMODE
VARLIST
$RATEPSILONC
$RATPRINT
$FACTORFLAGCGENVARC
EQUATIONSC
$KEEPFLOAT
$RATFACC
$ROOTSEPSILON$MULTIPLICITIESC
$REALROOTSKG	2@F0@Bh@@@@}|{*LEXPR-ARGLIST*QBbqBd1F @@Fe@Fe@Fe@Fe@ARGRCMERRORRlWrong number of arguments - REALROOTS@CMEQHKRC$RATPRC
$RATDISREPRCMNUMPRCMNEGPR,Second argument to REALROOTS was not a~
 3 | 		      positive number: ~M@
STURMSEQD
Dp,
COMPILERl
LOCAL-MAPDD
BoD
CND
EXPD
EPS$T:AwA%8$Cw	A%8 eCwd `eBwBe8 BeBwCe8CeXC%u8$Ce6B%CeOBh
UNIPOLYK
 4 | @F@B
 5 | @FA@@@@RATFRAND@CMAPCARRATOM@BvR,Argument must be a univariate polynomialD
DpB,
ARG-MAPD
D
B e+w8$ 	$i
8
 6 | dOB
 7 | CMAKRATK
 8 | -@F@B @FA@@@@
RATIONALIZER
$BFLOATPR
BIGFLOAT2RATRBvR,~M Non-numeric argument@RATD
DBD
D
CPT%\8e%k8%%ve8eX	
 9 | $e1t8+%+:v	
10 | $eO1B B~K-*@F!@B~@F@O@@{B\QBaQB_QB^QBcQB[1D
CMLIST@
MULTOUTRC
FINDROOTSRCPSQFRRPABSRB
11 | RB RCSOLVE2DDBDD
BD
BDB
DD
B\D
BaD
B_D
B^D
Bc
12 | 8$
13 |  ` ``e`
ev` ``e`
e$$vOKB~CSTURM1K
14 | ,@F@BL@F@@@@zC
ROOT-BOUNDRCISOLATRCREFINEDDBDD
POLYD
BDB
DD
CBD
LISTD
pBl
MAP-RESULTD
pB,
MAP-TEMPNILD
INT i%v:@w %@'o:@)v:@eAwB7A%DwCwC%D'Ew %E'E)
et:CWXDDrYBOkBLBSK	-@F@BS@FA@@@@{LOG2RCEILDDBD
D
CPDB
DD
BD
LCFD
CLOGLCFD
COEFD
LOGB'@w+;Aw AeV:Bw%Dw5X%D%+;CWAUvYD%%  CeBS@%'Se3r;DwhO
BSBsK	@F
15 | @Bs@F@@@@CSIGNUMRC
REMAINDERD
DBDD
CAD
B[%
 `%
e3O
Bs
STURMAPCK@F@B
@FC@@@@B
D
DBDD
CFND
B]D

MULTIPLICITY

X!
g% %
)ev:vO#
B
B;K
16 |  @F@B;@F@@@@B;RCAPPENDRB
R
STURMOUT@BLD
DBDD
CLD
B
X'k8-
e 	$
17 |  '
ek`-
eO2
B;B+
K
18 | @F@B+
@FA@@@@B\1B]RDCMEQUALSIMP@CMIDOUTRCRHALFRCRPLUS*D
DBD
D
Bf$&	`
19 | ``'kOC
B+
B<
K@F@B<
@FA@@@@C$FLOAT1C
FPCOFRAT1RB]RDB+B:
D
DBD
D
B,)u
88'i	$'iOQ
B<
C
UPRIMITIVEK	
20 | @F@BR
@FA@@@@C
PQUOTIENTR
UCONTENTD
DBD
D
Bt%`eO_
BR
CSTURMK2@F @B`
@FA@@@@|BR
R
PDERIVATIVERB]RPREMR


--------------------------------------------------------------------------------
/lmmaxq/procs.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLIBMAXDB0lPROCSDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLIBMAXDB0lPROCSDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCPROCSD
CMACROC
MACSYMA-MODULEVERIFY-AS-SUBR-ARGUMENT-LISTKD(@F,@BY@FC@@@@C&REST@C
&OPTIONAL@CERRORRLISTR,bad argument list for a@l
property.@&AUX@C*@F@,argument list too long for a@,argument list for a@,property must be@llong.DDp,
COMPILER,
ARG-MAPDD

PROPERTYD
CLD
CNDpBml
LOCAL-MAPD
D
CLENGTH$
%X$
%8	 
2 | $%d
e
%T:$
%;T:S@w%
3 | t
4 | 8@%T
8@	 $%d
e%@
8@	 $%$%d
eOBYC
A-DEF-PROPERTYKC*@F,@B@FE
@@@@C
COMPILER-STA


--------------------------------------------------------------------------------
/lmmaxq/psolve.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen]{FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0lPSOLVEDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0lPSOLVEDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCPSOLVED

RUNTIMEC
MACSYMA-MODULE1D
SPECIALMULTC*ROOTSC
*FAILURESC
$SOLVEFACTORS1DplSIl
DEFCONST-1CFLAG4NILC
SOLVECUBICK'=
N@F2@Bg@FA@@@@oBZqBc1LISTRD
CMTIMES@DD
RATF@
F@RDISRC
RATREDUCERCPTERMRDD
BoDD
BqF
F$%IDD
CMEXPTFDD
BqF
F@D
CMPLUS@DD
BqF@
F@F@
@
RATPLUSR
RATTIMESRD@F
F@
RATEXPTRD@F@
F	@C
SIMPTIMESRDD
BqF
F@
SIMPNRTRF@D@F@F
@CSOLVE3RD@F
F@D@F@F
@D@F
F@D@F@
F@
SIMPLUSRD
B@
COMPLICATEDRC
ADISPLINER
SIMPEXPTDDp,
COMPILER,
ARG-MAPD
D
CXDpB4l
LOCAL-MAPDD
CS1D
CA0D
CA1D
CA2D
CDISCRD
CLCOEFD
CADIV3D

OMEGA^2D
CPDIV3D
CQDIV-2D
COMEGAD
CY1D
CUD
CY2D
pB4l
MAP-RESULTBdD
CJ+Ew 	$
2 | $` 
3 |  %eEeCWeFw 
4 |  %eEeBw 
5 |  %eEeAw$@w $$@eJw $$`	$$@eGw ` B%$
e` C%e$
eHwH%uE8  	$$`$    C%d`$A%
eMWed`	$$`Ce%eKw8K%d  `M%$
edMw K% $ 	$J%MeFe`$ 	$G%MeFeNwN%OwO'PwP%dOOxYN `   B%C%
e`$A%
e$
e` C%d $
eIwI%u8 H%eLwF%Kw1!  $ "$H%d`"$I%e%eDwD%u8 I%dLw D%eDw#De8


--------------------------------------------------------------------------------
/lmmaxq/rat3b.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen&*FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0lRAT3BDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0lRAT3BDB0B:DB0F_pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCRAT3BD

RUNTIMEC
MACSYMA-MODULE1DplSIl
DEFCONST-1C
$RATWTLVLNIL1DB[
$RATALGDENOMCTCRALGPK@F@Bd@FA@@@@CPALGPD
Dp,
COMPILER,
ARG-MAPD
D
CR giOtBdBkK		@F@Bk@FA@@@@ALGRBkDDBnD
D
POLYDpBll
LOCAL-MAPD
D
CP
Xe
8
)@w@k
8
@5@yYOBk1D
SPECIALCV**X*C*AFLAGC
TRUNCLISTCRATDXK"\ZD@F~@B@F@_ @@pB
 2 | Q
VARLISTQBQB	QCGENVARQBQB
 3 | CTRUNC@MRAT@RATFR
FULLRATSIMPRCNEWVARRCNCONCRCSDIFFR
ORDERPOINTERRLISTR
PUTPROPRD@F
@DIFF@CALIKE1RCSIGNPRCN@SIMP@PSDPR
PSDERIVATIVERCRATDX1RC
RATDERIVATIVEDDBnDD
CED
B
 4 | DB
DD
BD
BD
B	D
BD
BD
CAD
B
 5 | D
pBll
MAP-RESULTD
pBl,
MAP-TEMPB]B]D
B9D
CBD
pBl,
MAP-TEMD
CZD
CFF
 6 | $'8/7:v1tX ew%6:v%>:'
 7 | v
 8 | $T:$T:58G7$
 9 | $JwIwHwH%I'J'LwKwL%t:HWXIJI8JqYG%
10 | v dvd$GwMwJw M%J'NwOw `N%dOWed N%OeeMwGXM%GwM%S:MwJJcYG%Ew%E%v:v$
11 | $JwIw!I'J'LwNw$N%PXL%$dL% $N%Pz)d8N%d8L%	v
%vIJI8J[YD$	$P:i8$	$P:
88 $$$
12 | $$
13 | d8 i )	dv $$$
14 | d8 +m  )	dvOOB1DC
UNSPECIALB	B
15 | BBB
16 | B-K"@F@B-@F@@@@
RATQUOTIENTRCRATDIFR
RATTIMESRCRATDPRCPEXPTD
DBnDD
CUD
CV  
%%v:	 e
e`%%v:	 
e
e
17 |  
%e%vzOeB-B\K-@F@B\@FA@@@@B%@B(RB/@B&@CRATDP1RB!RFOO@CRATDP2D
DBnD
D
B
XD'	$P:g8
18 |  '$e%v:i
19 |  '$e%v:'	$P:iOsB\BlK
20 | "@F@Bl@F@@@@B%@B\R
RATPLUSRB[RCSUBSTRBm@BlD
DBnDD
CXD
B`

X
'u8
k	 
21 |  
'$e 
k
e`%
mO
BlBnKK@F-@Bn@FC@@@@B%@B\RBzRBnRB[RB{RBm@CPTIMESD
DBnDD
B|D
CDXD
B`
X'u8k'u8	 %
%m`
22 |  
%+%v:
e
23 | ` %$e k
e	 %
%m`
24 |  
%
25 |   'V:$e
26 |  'k%v:
e
e
27 | ` k '$e
eO
BnB.K;@F%@B.@F@@@@~
PDERIVATIVER
PGCDCOFACTSRC
RATREDUCER
PDIFFERENCERB	
RB(RB/@B]DDBnDD
RATD
VARDB
DD
NUMD
CDENOM')


--------------------------------------------------------------------------------
/lmmaxq/ratmac.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen7FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0lRATMACDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0lRATMACDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCRATMACD
CMACROC
MACSYMA-MODULECPCOEFPK
 2 |  @F@BY@FA@@@@CERRORRplSI,-- wrong number of args to a macro.@LISTRD
CE@ATOMDDp,
COMPILER,
ARG-MAPD
D
pBal
*MACROARG*DpBhl
LOCAL-MAPD
D
BeD
ARGLISTBe%T:UX%T:58$`	$e)'@w
 3 | $@eD@BTBxOyBYCPZEROPK
 4 | 
 5 | !@F@Bz@FA@@@@B`RBc@BdRD
CX@CSIGNP@BeDDBjD
D
BlDBqD
D
B
DBuB
%T:UX%T:58$`	$e)'@w
 6 | $$@eD@BTBO
 7 | BzCPZEROK
 8 | @F@B@FA@@@@B`RBc@BdDDBjD
D
BlD
Bu%T:58$`%eD@BTBOB
PTZEROPK
 9 |  @F@B@FA@@@@B`RBc@BdRD
CTERMS@NULLDDBjD
D
BlDBqD
D
B#DBuB#%T:UX%T:58$`	$e)'@w
10 | $@eD@BTB.O/BCPTZEROK
11 | @F@B0@FA@@@@B`RBc@BdDDBjD
D
BlD
Bu%T:58$`%eD@BTB<O=B0CCZEROPK
12 | 
13 | !@F@B>@FA@@@@B`RBc@BdRD
CC@B@BeDDBjD
D
BlDBqD
D
BEDBuBE%T:UX%T:58$`	$e)'@w
14 | $$@eD@BTBOOPB>CCMINUSK
15 |  @F@BQ@FA@@@@B`RBc@BdRD
BE@CMINUSDDBjD
D
BlDBqD
D
BEDBuBE%T:UX%T:58$`	$e)'@w
16 | $@eD@BTBbOcBQ
CMINUSPK
17 |  @F@Bd@FA@@@@B`RBc@BdRD
BE@CMINUSPDDBjD
D
BlDBqD
D
BEDBuBE%T:UX%T:58$`	$e)'@w
18 | $@eD@BTBuOvBd
CDERIVATIVEK@F@Bw@FA@@@@F@B`RBc@BdRDNILBDDBjD
D
BlDBuBB%T:TX%T:48$	`
19 | $eD@BTB
O
BwCDELETK, @F@B
@FA@@@@~F@B`RBc@BdRDITEMBd@CDELETE@CLIST*RCAPPEND@D
BDDBjD
D
BlDBqDD
B
D
BdDBuB
Bd%T:TX%T:48$	`
20 | $e)'@w))'Aw	$@%`
21 | $A%dD@BTB
O 
B
CVALGETK
22 |  @F@B!
@FA@@@@B`RBc@BdRD
B
@
SYMEVALDDBjD
D
BlDBqD
D
B
DBuB
%T:UX%T:58$`	$e)'@w
23 | $@eD@BTB2
O3
B!
ALGVK
24 | @F@B4
@FA@@@@BdRAND@C
$ALGEBRAIC@B
RGET@D
DB0
TELLRATD
DBjD
D
CL$$	`
25 | $+dD@BTBF
OG
B4
EQNK@F@BH
@FA@@@@CEQUALDDBjD
D
BlDBqD
D
BA
DBuC&RESTBA
)@w$@%vD@BTBY
OZ
BH
CRZEROK@F@B[
@FA@@@@B`RBc@BdRDB0D@F
DDBjD
D
BlD
Bu%T:58$`%e	D@BTBk
Ol
B[
CRZEROPK
26 | #@F@B


--------------------------------------------------------------------------------
/lmmaxq/residu.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen
 2 | 9FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lPAULWDB0lRESIDUDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lPAULWDB0lRESIDUDB0B:DB0FipB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCRESIDUD

RUNTIMEC
MACSYMA-MODULE1D
SPECIAL
$BREAKUP
$NOPRINCIPAL
VARLIST
LEADCOEFVARC*ROOTSC
*FAILURESCWFLAGNN*SN*SD*
$TELLRATLISTCGENVAR
SEMIRAT*DN*CZNNILNlBg
POLELISTK%4
 3 | 	J@FY@Bm@C@B@@yvyBZQBaQB[qBgqB^qB]1@@@F0@F1@@F0@F0@F0@F0@F0@F0@F2@@CT@F0
POLYINXRB]@C
SOLVECASER
FAILURE@CAPPENDRLISTRCPOWER*RCADD2*RCMUL2*RF@
DDp,
COMPILER,
ARG-MAPDD
CDD
CREGIOND

REGION1DpBl
LOCAL-MAPD
 4 | D
CROOTSD
BZD
CRD
CRRD
CSSD
CR1D
CSD
POLED
BaD
CCF %
 5 | $dv e@w@%t
8@X	8 F%BeT: D%CeT:58I%C%D%EeI%B%F%Ee@%6:Gw@+w8G%  ! 
 6 | $"`#$GeeI%v:v:Iw

Ge8%u8G%F%v:Fw G%eB%v:Bw
Ge	8XG%E%v:Ew
	8%u8G%D%v:Dw G%eC%v:Cw@5%O-BmBK
 7 | 	@F@B@FA@@@@B`qB_qB^1CAMONGRCSOLVERBD
DB
 8 | D
D
CE	$e
X66
 9 | %$e
8
XO;BRESK2u"@FC@B<@F
@@@@vB]qB^1BmRCSDIFFRADDNR
RESIDUER
$RESIDUERDIV*RBRBDDB
10 | DD
CND
BD
BD
BDBD
11 | D
CPLD
CDPD
CAD
CBD
CCD

FACTORSD
pBl
MAP-RESULTD
pB,
MAP-TEMPBlD
B% 
%%e6@w@
X@'Ew@@X@%+8	 
%dAw@8
12 |   %8E%

%@geBw
B@8
13 |  F7@+HwGw
14 | G%H'Iw 
15 |  %
e$Iet:GWXHHqYF%eCw
C@%+8
16 |  FwF7@%+:HwGw
17 | G%H'Iw 
18 |  %
e$Iet:GWXHHqYF%eDw
Dw B%CeDeOeB<BEK
19 | C@F(@BE@FC@`@@zBiQB]1C
REMFACTORRCRESM0RCRESM1RBGDDB
20 | DD
BiD
BYD
BODBDD
B\D
B_BlD
CJD

FACTOR1D

FACTOR28@7%BwAwA%B'Cw 
%C'dEwDwE'DwE)'Ew	 D%E%C'Ckt:AWXBBgY@@w@7%BwAwA%B'Cw
21 |   $
eCgt:AWXBBrY@O


--------------------------------------------------------------------------------
/lmmaxq/result.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATAD,GJClSetterK`%FPF
pB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0lRESULTDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0lRESULTDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCRESULTD

RUNTIMEC
MACSYMA-MODULE1D
SPECIAL
VARLISTCGENVAR
$RATFACC
$KEEPFLOAT
MODULUSC*ALPHACXVC$POLY_DISCRIMINANTK?&@F)@Bc@F@@@@}BZqB[1LISTRCRFORMR
PDEGREERCMERRORR,ARG. MUST BE A POLYNOMIAL IN VAR@PDISR
PRESIGNRC
PQUOTIENTRC
RESULTANTR
PDERIVATIVEDDp,
COMPILER,
ARG-MAPDD
POLYD
VARDpBtl
LOCAL-MAPDD
BkD
RVARD
CN 
eV6	 e@w$S:'Aw
 2 |  @'WAeBwB%
8B%X@)uXd
 3 | `B%B%V:s` %`%Ae%+zOBcC
$RESULTANTK)i.@F@@B@FC@E0@@wBZQB\QB[QB]BjRC$RATPRCNEWVARRCLMAKE2R
RATREP*R
RESULT1RCPTIMESRCPEXPTRC
PTIMESCHKR
MAKPRODRCPDIS*RBoDDBvDD
CAD
CBD

MAINVARDB~D	D
BZD

FORMFLAGD
B\D
RESD
ANSD
B[D
B]D
CL1D
CL2
 4 |  ev
%v%Dwe8
%Aw
e8
%Awe
e
 5 |   e+ew
 6 |   
e+e
w e):w%Gw"
%Hw G1H1eCw D%`C%+:Y8C' C'` C+eC%+zG/H/seDwHHbYGG\YA8DeDeO2BBK*c@F9@B@FC@@@@C
POINTERGPRBjRBlRBR
PCSUBSTYRC
PGCDEXPONRBrR
PEXPON*/D
DBvDD
CP1D
CP2D
By8%g8%%`
%e
8%
g8%
%`%e%/X
%/X%%e	 %+:
k
 7 |  %%
ek
%/
 8 | X	 
%+:k
 9 |  %%e
k e 
e;W58% 
10 |  %%e
11 | `
%%ee% %
eeOEB1DplSIl
DEFCONST-1BDB0
$SUBRES1DpBF,
DEFVAR-1
*RESULTLISTDB0DBI$MOD$REDBrK2$@F"@Br@F@@@@B1BpRBrRBI@C
SUBRESULTRBP@C
MODRESULTRBQ@C
REDRESULTRBmR,No such resultant algorithmD
DBvDD
B=D
B?
++58+
+s`
%e$	t8
12 | %
e$t8%
e$
13 | t8%
edOeBrBpK@F@Bp@F@@@@CPMINUSD
DBvDD
BD
CP%d8
e
OsBpB\K
14 |  M@F-@B\@F@@@@{BlRBRBqRBpRPREMRBDDBvDD
BnD
CQDB~DD
CGD
CHD
DEGQD
CDD
CH^1-D%@w%Aw 
%gBw+BSCwA%u8% A%C%VzDwB%Y8
%k8
%Y
8
 
%CeDe
%	 C%U:`
15 |  %
e`@%`A%De
w%w%+:@w  @%CeDeAwF`O
16 | 
B\B^K![2@F:@B^@@@@@|||@@F2@F
@F0@F2@@F2@F
CSIGNPRCE@BzRBRBRBlRBpRBqR
PQUOTIENTCHKDDBvDD
CUD
CVDB~DD
BD
CRD
CSIGMAD
CCD %
eAWe
8 C%`
%+:+
+S
+ A%gSSseCwB%+
+s3Bw A%gY	8B%`  A%@e
kCe
% A%@e 
%+:+U:
+o:3e@w%
w%w?O0
B^B]K@F@B]@F@@@@C
MODRESULT1RSORTRCUNION*RC
LISTOVARSRB9D
DBvDD
BD
B


--------------------------------------------------------------------------------
/lmmaxq/runtim.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lRUNTIMDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lRUNTIMDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCRUNTIMD

RUNTIMEC
MACSYMA-MODULEADDK3@F!@BY@@@@@}||F @F0@F0@F2@C
SIMPLIFYARD
CMPLUS@CLIST*D
Dp,
COMPILERl
LOCAL-MA


--------------------------------------------------------------------------------
/lmmaxq/scs.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen_|FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,MRGDB0,SCSDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,MRGDB0,SCSDB0B:DB0F<pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPSCSD

RUNTIMEC
MACSYMA-MODULE
$SCSIMPK2	 @F!@BY@@@@}||*LEXPR-ARGLIST*F @@Fe@Fe@FeCMEQUAL@ARGRSUBRBSD
Dp,
COMPILERl
LOCAL-MAPDD
B`D
CND
CID
ZRS$T:AwA%Bw$ Be1uX Be
2 |   Be+ Be+zC%v:CwBu%Bi9 eCeOuBYBSK	)@F@BS@F@@@@{
CONSSIZERCSUBSCSDDpBh,
ARG-MAPDD
CXD
BpDBjDD
FLAGD
CSZD
CNXD
NSZD
CL
% eAw@w
%Dw %D'eBw BeCwC%AU8B%wC%AwDDmY@w@gYOBSB}K@@F'@B}@FC@@@@{CSUBSCRCMPLUS@B|RB}RBgRADDNRCRECONCDDBD


--------------------------------------------------------------------------------
/lmmaxq/sinint.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlUC.RPKlLisp Machine Thirteen;m[FLF5pB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lJMDB0lSININTDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lJMDB0lSININTDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCSININTD

RUNTIMEC
MACSYMA-MODULE1D
SPECIAL
RISCHPFCGENVAR
$SAVEFACTORS
CHECKFACTORSEXPVAR
$FACTORFLAG
$RATFAC
$LOGABSC$EXPOPC$EXPONC
$KEEPFLOAT
RATFORMC
ROOTFACTOR
PARDENOMC
$ALGEBRAICC
WHOLEPART
PARNUMER
VARLIST
LOGPTDX
SWITCH1
ROOTFACK:@F$@Bq@FA@@@@|B_1PGCDR
PDERIVATIVERC
PQUOTIENTRLISTRC
POINTERGPR
REVERSEDDp,
COMPILER,
ARG-MAPD
D
CQDpB~l
LOCAL-MAPDD
CNTHDQD
CNTHDQ1D
C
SIMPROOTSD
ANS %`%d@w	 %@eBw
 2 |  	`B%`@%BeCw@8$@g8Ce  @%d@eAw	  @%Be`A%BeC%v:CwA%@weOBqCAPROGK1@F @B@FA@@@@}BhqBg1C
OLDCONTENTRBqRCPTIMESRB{RCPEXPTRB}DDBD
D
B
DBDD
CPDD
CRFD
CN ew	 kv
 3 |  'f(v:v f(%BwAw@w A'Be@%v:@wABUAvY
 4 |  @evO)BCCPROGK"U"@F3@B*@F@@@@|BkqBhqBj1
PDIVIDERB{RBRB}RCBPROGRC
RATDIVIDERCRATTIDDBDD
TOPD
CBOTTOMDBDD
CFRPARTD
C
PARDENOMCD

PPDENOMD
CTHEBPG	 %
e@w@'v@+@w$T:8
 5 |  @eV(Aw
 6 |  fBwA%T:X B'AgB%v:BwAt dAw
 7 |  A'BgCw  @%C)
eAg)$v:v  @%C'
eBg)@wABBX@%$v:V`OFB*
POLYINTK@F@BG@FA@@@@CRATQUR
POLYINT1R
RATNUMERATORRC
RATDENOMINATORD
DBD
D
CP `e	`eOWBGBOK
 8 | -@F@BO@FA@@@@B_1B{RB|RBOR
RATPLUSR
POLYINT2D
DBD
D
BR8%u8%%vX$%e'k
 9 | X$g8$%e	i
10 |  e	`mOdBOB_K	@F
11 | @B_@FA@@@@B_1B{D
DBD
D
BR $'U:k'U:vOoB_CDPROGK!E+B@Ff@Bp@FA@@@@vBjqBmqBkqBgqB_1B|RCDISREPRBGRBRBQRB*RBPRB}R
PDEGREERByRB2RB4RBRB^RBNR
RATMINUSRC
RATREDUCERB3RB1RB{RD
CMPLUSDDBD
D
CRATARGDBD
12 | D
KLTHD
CKXD
CAROOTFD
CDERIVD
BAD
CTHETOPD
CTHEBOTD
CPROD1D
CPROD2D
B
13 | %%v:Iw	8
14 | $k8
15 | `e`e e`e 	d	v dv	$T:@w@%KX	&Bw B%
16 | dY@X B%
17 | dCw B%CeDw@%V:Aw&Ew E%D'
eGw E%D)
eHw B%AeFw I%` He`A%F%
eIw G%`  H'
18 | dHiAeEw E%Fe)EwA%8 E%Be$v:vAuM	@u2 &	f$v:vI%u8
19 | `d  Ie`Ie+Ew$ 
20 | `d``E%`IeO
Bp
LOGMABSK@F@B
@FA@@@@Bb1B{RD
%LOG@C
SIMPLIFYARD
MABSD
DBD
D
CX$8	` 
21 | $ee
eO(
B
CNPASKK @F@B)
@FA@`@@B^CFREEOFR$%I@CLEARNRCLIST*RD
C
MNOTEQUAL@D
@
ASKSIGNRC
$POSITIVED
DBD
D
B^$d8	
22 |  $$d
e
23 | dO>
B)
CEPROGK:mt@F'
@B?
@FA@@ @@mSIGNQBhqBkqBlqB_qBn1BPRBQRBRCMEMBERRBxRDFF@C
ZEROCOEFLRF@
PMINUSPRC
INTFACTORRBNRByR
POLCOEFRB4RB{RD
CMTIMES@BwRB
RF@CE3PROGRDFFF@CENPROGRD
C
%INTEGRATE@D
C
MQUOTIENT@C
RATDIFFERENCERBRF@FREERB 
RB1
@B)
RC
$NEGATIVE@C$ZERO@
RATSQRTRD
B{@D
CMMINUS@C
EPROGRATDRByRD
C%ATAN@CPSIMPR
PCOEFADDRBRCFPROGRB*RB?
DDBD
D
BRDBDD
P1ED
P2ED
A1ED
A2ED
A3ED

DISCRIMD
CREPARTD
BF
D
NCCD
DCCD
CALLCCD
C


--------------------------------------------------------------------------------
/lmmaxq/sprdet.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenSvFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lPAULWDB0lSPRDETDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lPAULWDB0lSPRDETDB0B:DB0F<pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCSPRDETD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALCX
$SPARSEC$RATMXML*C
*DETSIGN*RZL*BSK#M=F@Fp@BS@@@@@zx|@@F0@F0@F0@F0@F2@F
@F0@F0@F0C*ARRAYRPTR@PTC@C
TMLATTICERCAPPENDRCMAPCARRCADRRCARR
PRMUSIGNRCLENGTHRBLK@
GPTIMESRBtRBuR
GPDIFFERENCERB}RTDBUDDp,
COMPILER,
ARG-MAPDD
CAXD
CNDpB
l
LOCAL-MAPDD
CJD
RODRD
CODRD
CBLD
DETD
CDMD
CRD
CI$
%
%Uz$
%
%Uz %$$
eCwC
X$C%;Aw $AeBw $AeAw Ae BesDw $CeCwFC
XDC'GwG%Ew$
%E%U:E%UzE%8 D%! F%Uz`F%UzgDwNE%+8 D%` ! F%Uz`F%Uz'! %F3e`%F3eg`! F%Uz`%F3e'! %F3e`F%UzgDw G%XE%@w@%8Guv! F%G3e`F%@3e'  G%@e_@uk D%!`$EeDwF%E3FwCOBSCMINORLK7}@FF@B @F
@`@@uBZQB_LISTRCSIGNNPRCDELETERBwRC
MEMBERCARRCSINGPDDBDD
BZD
BD
CLD
CNZDBDD
ANSD
CSD
B_D
COLD
CN2D
CDD
CDLD
CZD
CAD
ELMD
RULE
%DwDu%Cw%Fww%%v:w
X@'GwXF8F%@%v:@w
CUF%wFwk1HwGXJ8' H%JeWJw	X' H%eW%+W%-XPG'IwG	 I%HeAwA8
 2 |  I%`H%eEwE%FeXC%DUX
 3 | $E%C%
eXE%%v:F%v:Fw
@ E%A%I%C%VzJ%v:Jw6OLB 1DBYBB+K2@F @B+@F
@a@@}BZQBQB_1CMEMBERRZROWR
ANDMAPCRDpB ,
INTERNALB+DDBDD
BZD
CMLD
B9D
BDBDD
BD
BD
B.DpB ,INTERNAL-FEF-OFFSETSF%v
%Bw
8
'@w
	@%d
8

 4 | $@%%e8@%$v:V$5
8$Be
8
TuOmB+B[K	@F@B[@FA@@@@BqBZ1D
DBD
D
B %d%OxB[1DC
UNSPECIALBBKS*@F4@B@F@d@@{BZQB]QB^1
DETPIVOTRCX*@NZLRB RB'R
NREVERSERCINDEX*RTB2R
GPCTIMESRF@
@NBNDDBDD
BZD
BDBDD
BCD
B]D
CNLD
NMLD
CDD%v	$
e
 5 | $v $
eBw%B%
8 $
%
 6 |   `
e%vzBe@wBw@
X$@'
e%t:@'v:v@@	X$8$5$$5z@'CwCk9C'DwCDexO
BB
 7 | 
K="@F'@B
 8 | 
@A@@@@}}|BZ1@F2@@F0@F0CGPPLUSRB~RB
R
GETMINORDDBD
D
BGDBDD
B4D
BD
BC%*:AwA%u
8%1WAX%@%)v:XA'BwA @%
 9 | `B+8 B%+:B%7z B+`B%+:B%7z`Bg@w_O1
B
10 | 
B'
K
11 | 	@F@B'
@FA@@@@B]1CASSOCRB)D
DBD
D
CINDEX %dw
X)-V:X-


--------------------------------------------------------------------------------
/lmmaxq/sublis.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenoFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lSUBLISDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lSUBLISDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCSUBLISD

RUNTIMEC
MACSYMA-MODULE1DplSIl
DEFCONST-1$SUBLIS_APPLY_LAMBDACT1D
SPECIAL*MSUBLIS-MARKER*
$SUBLISK:@F#@Bd@F@@@@}C$LISTPRCMEQUAL@CMERRORR,Usage is SUBLIS([sym1=form1,...],expression)@
MSUBLISDDp,
COMPILER,
ARG-MAPDD
C
SUBSTITUTIONSD
FORMDpBpl
LOCAL-MAPDD
CLD
CNLD
TEMPe%8)@w@'BwB8B8B1t8B'B%'y8B'B%B'B%v:A%v:Aw	d@@aYA%w	d
2 | %
eOBd1DB`CSBoK @F@Bo@F@`@@BQBa1C
COPYSYMBOLRBa@C
MSUBLIS-SETUPRF,@F@C
MSUBLIS-SUBSTRMSUBLIS-UNSETUPD



--------------------------------------------------------------------------------
/lmmaxq/sumcon.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenMFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lSUMCONDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lSUMCONDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCSUMCOND

RUNTIMEC
MACSYMA-MODULE1D
SPECIALC
$GENINDEX$NICEINDICESPREFC
$SUMEXPAND
$SUMCONTRACTKH @F,@B_@FA@@@@|CMPLUS@%SUM@B_RCSUBST0RD
Bf@
NREVERSER
SUMCONTRACT1RADDNR
RECUR-APPLYDDp,
COMPILER,
ARG-MAPD
D
CEDpBnl
LOCAL-MAPDD
CXD
SUMSD

NOTSUMSD
CCAR-X
X1t.8)@w@'CwCXC%B%v:BwC1t8 CkC-v:A%v:AwC%B%v:Bw@@eYAX	
2 | $ Bev:e AeAw
3 | A%B%v:
e$eOB_
$INTOSUMK-p,@FC@B@FA@@@@|B\1CMTIMES@Bg@MULNRLISTRB_RBhRD
B
4 | @BjR
SIMPSUMRFREERC
GET-FREE-INDEXRCSUBSTRBmRBDDBpD
D
BqDBvDD
BwD
SUMD
CNOTSUMD
C
NEW-INDEX
%V
X1tN8)@w@X@'B%v:Bw@%(:t8AX@'	 
5 |  A%@g
eAw @gB%v:Bw@@bYAX
6 | $ Bev:e%B%v:A%+z8A%+: %A%B%v:vzCw C%A%+:AeAwA)	 A+B%v:
eWA'%XA%%
e$eOBBkK	@F@Bk@FA@@@@BlR
SUMCONTRACT2D
DBpD
D
By %e
eO+BkB&K
7 | @F@B&@F@@@@
SUMCOMBINE1RB&RCAPPENDDDBpDD
CRESULTD
LEFTDBvD
D
Bw



--------------------------------------------------------------------------------
/lmmaxq/system.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATAD,rhb,
SpanielO,FPFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXIIDB0lSYSTEMDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXIIDB0lSYSTEMDB0B:DB0F+pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCSYSTEMD

RUNTIMEC
MACSYMA-MODULE1D
SSTATUS
FEATURECMAXII
MAIN-PROMPTK@F@B^@@@@
$LINENUMq
$INCHAR1CFORMATR,
(~A~D) @
STRIPDOLLAR%	$
 2 |  ddOjB^
BREAK-PROMPTK

 3 | @F	@Bk@@@@
$PROMPT1BidOsBkCTOPLEVEL-MACSYMA-EVALK	@F@Bt@FA@@@@CERRORRplSI,-- wrong number of args to a macro.@LISTRD
CX@CMEVAL*DDp,
COMPILER,
ARG-MAPD
D
pB|l
*MACROARG*DpBl
LOCAL-MAPD
D
BD
ARGLISTB%T:UX%T:58$`	$e+@w
 4 | $@eD@CMACROBOBt1DpB|l
DEFCONST-1C$_DB0B1DBC$%DB0B1DB$__DB0B 1D
SPECIALC
*MREAD-PROMPT*1DpB|,
DEFVAR-1ACCUMULATED-TIMEG
CONTINUEK9<1	r@Fu@B.@@`@@zxwC
STANDARD-INPUTQB%qC
$SHOWTIMEqBqB*qBqB qSTANDARD-OUTPUTq
$OUTCHARqBf1F@@F@F0@F0@F0@F0@Fe@Fe@Fe@Fe@@FeBRMAKE-LINE-LABELSRB^RBgR,~%~A@CMREADRC$DONE@CTERPRIRpB ,
FORCE-OUTPUT@TIMERBRTIME-DIFFERENCERGx@CMTELLR,Evaluation took ~S seconds.@
DISPLAYINPUT@CDISPLARD
CMLABLE@pB ,DEMO@l~&Pausing.  Type any character to continue demo.~%@TYI@F@pB ,
CLEAR-SCREEN@pB ,WHICH-OPERATIONS@pB ,
TYI-NO-ECHO@F @F
 5 | @F	@pB l
UNTYI-NO-ECHODDBDD
B5D
CBATCH-OR-DEMO-FLAGDBDD
CRD

TIME-BEFORED
C
TIME-AFTERD
C
TIME-USEDD
EOFD
CC-TAGD
CD-TAGD
CHAR eDw $dFwEwF'EwF+Fw"V
8
 6 | $$d  $De@w@%Du
8!"d#d@%+:vE%$Z$"Aw% dv$"Bw& B%Ae'Cw
 7 | $C3
 8 | vF%$Z$	v8()$Ce@1*t8+`,$F%d
%-t8(.d
 9 |  /d081$
10 |  2d8
11 | 1d"
12 | d
83$ 2d8Gw 3dGwG%4
13 | XG%5XG%6X7$Ge
oO|B.BDK1	&@F"@BD@@@@|zzCLQ
$LABELSqBeqBf1F @@Fe@Fe@Fe@Fe@FeC
CHECKLABELRCCONCATD
DBDD
B
D
pBl
MAP-RESULTD
pB,
MAP-TEMPNILD
BwD
CLABEL	dXTA7$CwBwB%C'Dw D%dEw$E%(v:XE%t:BWXCCmYAO
BDC$BREAKK	@F@B
@@@@@C$PRINTR
MBREAK-LOOPD
DBD
D

ARG-LIST @%IzO*
B
B$
K;.@F)@B$
@@@@@B5qB%qplEHl
ERRSET-STATUSqpB1
,ERRSET-PRINT-MSGqTERMINAL-IO-SYNONYM1FQ@C
BREAK-EXIT@pB l
FRESH-LINE@BkRBFRC$EXIT@FN@pB1
,
ERRSET-CATCH@BRB


--------------------------------------------------------------------------------
/lmmaxq/tlimit.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen~xFOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,JIMDB0lTLIMITDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,JIMDB0lTLIMITDB0B:DB0F/pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTLIMITD

RUNTIMEC
MACSYMA-MODULE1D	
SPECIAL
$TLIMSWITCH
TAYLOREDEXPVARVALCLLCULCSILENT-TAYLOR-FLAG
$TLIMITK	@F@Bd@@@@~~{*LEXPR-ARGLIST*QBZ1F @@Fe@Fe@C$LIMIT@
LISTIFYD
Dp,
COMPILERl
LOCAL-MAPDD
BkD
CNARGS$T:Aw
%V$ AeOz


--------------------------------------------------------------------------------
/lmmaxq/ufact.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteena)FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0,RATDB0lUFACTDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0,RATDB0lUFACTDB0B:DB0F pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCUFACTD

RUNTIMEC
MACSYMA-MODULE1D
SPECIAL
MODULUSC
COEF-TYPECDPREPK$@F@B^@FA@@@@}
NREVERSEDDp,
COMPILER,
ARG-MAPD
D
CPDpBfl
LOCAL-MAPDD
CND
CED
CL''Aw@wA%']8+B%v:Bw5%B%v:BwAuA%mn9@% BevOxB^
DPDISREPK @F@By@FA@@@@}BeDDBhD
D
BsDBnDD
BsD
BoD
CLL'Y
8 i%Aw@w@'XA%@'B%v:v:Bw@AU@sYBO
2 | ByCDPGCDK
3 | .@F@B@F@@@@~CAPPENDR
DPREMQUORDF
DDBhDD
BiD
CQDBnDD
BiD
B'
'U8
%%
w%w %e 
%eAw@wA% @%A%eAw%@wA'u9A+
8@O!BCDPDIFKF@F'@B"@F@@@@|CDPDIF1DDBhDD
BiD
BDBnDD
CID
CPLD
BsD
CQL'
'58')Aw@w@%V:A)A'B%v:Bw%Aw%@w@%
'q9A%
)Be'
'U8
'
)BwCw@w@%V:C)C'o:B%v:Bw%Cw%@w@%'p9)C%Be)
)eO8B"B)K
4 | "@F@B)@FC@@@@}
CDIFFERENCERCDPSIMPRBeDDBhDD
CP1D
CQ1D
BsDBnDD
B0D
B3D
B%
%%BwAw@w@)A) @'AgB%v:Bw%Aw%@w@rY`BeONB)B@K	@F@B@@FA@@@@
STRIP-ZEROESRDD
DBhD
D
B0 ew
X%T:


--------------------------------------------------------------------------------
/lmmaxq/utils.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen-FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lUTILSDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lUTILSDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCUTILSD

RUNTIMEC
MACSYMA-MODULEC
*MAKE-LISTK@F@BY@FB@`@@SIZEDDp,
COMPILER,
ARG-MAPDD
B`D
VALDpBal
LOCAL-MAPD
D
CL
%@%v:@w$V:Vmw9@OpBYCMAP2CK@F@Bq@F@@@@~DDBcDD
CFD
BkDBjDD
LLTD
LANS
%@w!@'@kA%v:Aw@5@wYAOBq
ANDMAPCK@F@B@F@@@@D
DBcDD
BxD
Bk

g
X

yY
OBCORMAPCK@F
2 | @B@F@@@@DDBcDD
BxD
BkDBjD
D
CANSWER!
g@w@
8@

wYO"BC
ANDMAPCARK	@F@B#@F@@@@~
NREVERSEDDBcDD
BxD
BkDBjDD
CDD
B!
g@w@8@%A%v:Aw


rYAeO5B#XORK@F
3 | @B6@F@@@@D
DBcDD
CAD
CB%b:
x
%
%b:
xODB6CAMONGK@F@BE@F@@@@BED
DBcDD
CXD
Bk

X
X%
% %
g%
iO


--------------------------------------------------------------------------------
/lmmaxq/zero.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen`%FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lJMDB0,ZERODB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lJMDB0,ZERODB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPZEROD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALCSVAREXPCV1CVCR1CR2C$NUMERC
$LISTCONSTVARS
VARLISTCGENVARC
$ZEROEQUIVKC2@F.@Bg@F@w@@{B\QB[QBZQB^QBcQBdQBb1
SPECREPCHECKR
$LISTOFVARSRCALIKE1RC
$DONTKNOW@$EXPONENTIALIZERCSDIFFRCISINOPR
%DERIVATIVE@$RATR
RATNUMERATORRC
ZEROEQUIV1DDp,
COMPILER,
ARG-MAPDD
B\D
B[DpByl
LOCAL-MAPDD
CRD
BZD
B^D
BcD
Bd
2 |  dv6 d@w@	8


--------------------------------------------------------------------------------
/lmmaxr/acall.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATAD,GJClSetterKV&FPF
pB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lACALLDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lACALLDB0B:DB0FDpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCACALLD

RUNTIMEC
MACSYMA-MODULEC
INTERVAL-ERRORK	@F@BY@FC@@@@CMERRORR,Lower bound to ~:@M : ~M, not less than upper bound: ~MD
Dp,
COMPILER,
ARG-MAPDD
FUND
LOWD
HIGH$%
%eOnBY
MFUNCALLK@F@Bo@A@@@@CMAPPLYDDBdD
D
CFDpBbl
LOCAL-MAPD
D
CL%y8%|8%@%%@%eOBoC
MARRAYREFK$I6H@Fm@B@@@@@{
MUNBOUNDqC
FIXUNBOUNDqC
FLOUNBOUND1CTYPEPRCARRAY@C
ARRAY-TYPERDCFLONUMCFIXNUMCART-Q@MARRAYREF-GENSUBRB`RlBUG: Non-handled array created. ~M@CSYMBOL@C
SIMPLIFYARB@B@lBUG: Array pointer of unknown type: ~S@
ARRFINDRCLIST*RLISTRMGETRD
B@CHASHAR@
HARRFINDR
MQAPPLY@BRB@DCMLIST
$MATRIX@
LIST-REFRDB B@,Bad object to reference as an array: ~MDDBdDD
BD
IND1DB|DD
INDSD
CAPD
plSIl
*SELECTQ-ITEM*D
B2D
VAL	 eBwB%
 2 | t8 eCwC%$8

%@%IzC%
u8
 3 | %
%@e$eB%t\8%
 4 | $P:Aw-8@XA!
eA!
%@%IzDw AeCwC%t8D%C%t8D%	C%
u8D%t$Ae8 ` %e
%@e
D%( %
 5 | dAw8 `%$v:
%@e %dAw8 `%$v:
%@e%t8 
%@%Iz %$v:
%@eeB%t81$8  %
%@%vz !$%
%@ee"$eO:B
$ARRAYAPPLYK@F@B;@F@@@@C$LISTPRB`R,The second arg to ARRAYAPPLY must be a list.@BD
DBdDD
CARD
B,
eXd	%
)IzOJB;C
$ARRAYSETAPPLYK@F@BK@FC@@@@BBRB`R,The second arg to ARRAYAPPLY must be a list.@C
MARRAYSETD
DBdDD
BDD
B,D
B5
eXd	%%
)IzOZBKBSKTD8@Fp@BS@C@@@@xB
 6 | RB@BRDBBB@MARRAYSET-GENSUBRB`RlBUG: unhandled array type. ~M@B@BRB@
ARRSTORERD
B@BRDCMQUOTESIMP@B @BSRB@DB!B"@B$RlBad use of ":" on~%~M@,Bad argument to set as an array.~%~MDDBdDD
B5D
BD
B(DB|DD
B,D
B.D
B2D
B2D
pBbl
MAP-RESULTD
pBb,
MAP-TEMPNILD
CU 
eBwB%t8 
eCwC%	$8%
!%@%Iz_C%
u8
 7 | %
%%@e$
eB%
 8 | tl8
%$P:Aw8@X%A!e_%A!%@%Iz_X 
%dAw8@X%A!e_%A%%@%v:;_D 
%dAw8
%$v:D7%@%v:FwEw
 9 | E%F'Gw $Get:EWXFFtYD%v:e$
%t8%%@%Iz
%$v:DwD7%@%v:FwEw
10 | E%F'Gw $Get:EWXFFtYD%v:eB%t8
1$8
%%@%v:
%e$
e$
eO

BSB$K$W@F3@B$@F@@@@{B`RlERROR-> tried to take part of an atom.@B!@B"@,Improper index to list or matrix: ~M@,ERROR-> ~M  bad part subscript.@B$RBDDBdDD
B}D
CINDEXLD

SET-FLAGD
B5DB|DD
CND
CJD
B
D
B}D
RETXd
	1X
'@w@%[)8@%l&81tX1	t 8%@%)CwBwAwAUCC8A%By9CX 
11 | $Be8C%%W:
C'Dw
8D$@e	8 %
12 | `
g
)%e %
13 | `
g
iO
B$1D
SPECIALC
$DISPFLAGC
DISPLAY-FOR-TRKU:@F9@B#
@@@@@||zC
$NOLABELSqC
LINELABLEq
$LINENUMqC
$LINECHAR1@@F @F0@F2@@FeCMEQUAL@C
CHECKLABELRC
MAKELABELRBTRCDISPLARBRD
CMLABLE@
MTERPRIR
TIMEORGRD
B!@C$DONEDDBdDD

LABELSPD
C
EQUATIONSPDB|DD
ARGLD

LABLISTD
TIMD
ANS.@'Cw

14 | 8C%+8C)1:t8C%+:Cw8	d
XT	d$A%v:AwX$C%Z"Bw`$8$
%CeBe@@PY8$A%vOP
B#
CINSURE-A


--------------------------------------------------------------------------------
/lmmaxr/evalw.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenC1FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lEVALWDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lEVALWDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCEVALWD

RUNTIMEC
MACSYMA-MODULE1D


--------------------------------------------------------------------------------
/lmmaxr/fcall.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen1FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lFCALLDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lFCALLDB0B:DB0F(pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCFCALLD

RUNTIMEC
MACSYMA-MODULE1DplSIl
DEFCONST-1$TR_WARN_BAD_FUNCTION_CALLSCT1DpBY,
DEFVAR-1*TR-RUNTIME-WARNED*NILlThis is an alist of warnings which have been given$TR_WARNINGS_GETK
 2 |  @F@Bg@@@@@|Bb1D
CMLIST@LISTD
Dp,
COMPILERl
LOCAL-MAPDD
pBql
MAP-RESULTD
pBq,
MAP-TEMPBcD
CU$@7$BwAwA%B'Cw $C'Cit:AWXBBsY@%vOBgMFUNCTION-CALL-WARNK> @F'@B@F@@@@B\qBb1DDCFEXPRC
FEXPR-WARNEDPlThis may be due to lack of enough translation data base info.DCMACROC
MACRO-WARNEDP,Macros should to be loaded when you are translating.DC
UNDEFINEDUNDEFINED-WARNPlThe function was totaly undefined. Maybe you want to quote it.D
PUNT-NILC
PUNT-NIL-WARNPlIf you want the value of the function name, use APPLYDCMFEXPRC
MFEXPR-WARNEDPlMFEXPRS should be loaded at translating time. Use of them in
 3 | translated code (nay, any code!), is NOT recommened however.@
PUTPROPRCTERPRIRCPRINCRl
Warning: @CMGRINDRl has a function or macro call which has not been
 4 | translated properly.DDpBq,
ARG-MAPDD
CFD
TYPEDBsD
D
TABL%$R:(%
%v:$v:v8
%$R:)@w@%b:%@'P:	%
%@g
 5 | d
 6 | %ed@	8
 7 | @kO/B
MAPCAR-EVALK	
 8 | @F@B0@FA@@@@CMAPCARREVALD
DB#D
D
CX$eO>B0C
MFUNCTION-CALLK@F
 9 | @B?@ @@@@CMFUNCTION-CALL-AUXD
DBsD
D
CF+ARGL@'@)eOLB?BFK4>@FS@BF@FC@@@@
AUTOLOAD1DEXPRCLEXPR@B0RDSUBRCLSUBR@DBCFSUBR@BRB@B@B8RMGETRCMEXPR@
MFEXPRP@B@CMEVALRBpRCMAPPLYRa translated fcall.@BS@CMERRORR,~:@M, Function undefined after loading file:~A @C
NAMESTRINGRBFRB@BDDB#DD
B$D
ARGLD
AUTOLOADED-ALREADY?DBsD
D
CF-PROP%$Q:@w8@+ 
e%	$Q8% 
e%
10 | $Q8%d%
%%
11 | $P:@w8%
12 | d@a%
%vz %d@w8%d8%d e
%vz@% 
ed%$P:@w88$%`%$Pz%@%vz%
%
e%~	8%d e 
ee%d e 
evOqBF


--------------------------------------------------------------------------------
/lmmaxr/intpol.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen`;FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lINTPOLDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lINTPOLDB0B:DB0F
2 | pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCINTPOLD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALC
$INTPOLRELC
$INTPOLABS
$INTPOLERROR1DCORDCBOUNDPDB0B[DSETQB[G1DB_DB`DB0BZDBcBZG1DB_DB`DB0B\DBcB\CTC$INTERPOLATE_SUBRKR;.@Fi@Bt@FC@L@@wCRIGHTQ
TRAMP1$QB\qB[1
MAKE-TRAMP$RG@CMERRORR,function has same sign at endpoints~%~M@LISTRD
CMLIST@D
CMEQUAL@D
CF@G@@CINTERPOLATE-CHECKRG}ffff@FDDp,
COMPILER,
ARG-MAPDD
BD
LEFTD
B{DpBl
LOCAL-MAPD	D
B|D
BD
CAD
CBD
CCD
CFAD
CFBD
CFCD
LIN
3 |  %eAw
%(;Bw$(;CwC%B5XC%B%Cw%BwA!BeEwA!CeFwE%;	4
XBF%;	4
XCE%Fs48$
u8
4 | $`$ $ $BeEe`$ $CeFe


--------------------------------------------------------------------------------
/lmmaxr/mdefun.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATAD,rhb,
SpanielODFPFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLIBMAXDB0lMDEFUNDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLIBMAXDB0lMDEFUNDB0B:DB0F9pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMDEFUND
CMACROC
MACSYMA-MODULE1DplSI,
DEFVAR-1*KNOWN-FUNCTIONS-INFO-STACK*NILlWhen MDEFUN-TR expands it puts stuff here for MFUNCTION-CALL
2 |   to use.1DB[C*UNKNOWN-FUNCTIONS-INFO-STACK*B]lWhen MFUNCTION-CALL expands without info from
3 |   *KNOWN-FUNCTIONS-INFO-STACK* it puts stuff here to be barfed
4 |   at the end of compilation.C
MDEFUN-TRK
5 | @F@Be@FA@@@@CERRORR,obsolete macro form, please retranslate source code@
FAIL-ACTD
Dp,
COMPILER,
ARG-MAPD
D
FORM$%dD@BTBwOxBeBSK
6 | @F@BS@FA@@@@BlR,obsolete macro form, please retranslate source code@BnD
DBqD
D
Br$%dD@BTBOBSC
COMPILER-STATEK

7 | @F	@B@@@@
Y-OR-N-PR,Is COMPILER-STATE true?dOBCDEFMTRFUN-EXTERNALK4 @F"@B@FA@@@@}NAME1CLIST*R
DECLARE@LISTRC*L


--------------------------------------------------------------------------------
/lmmaxr/mudoc.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen<4FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lLMMAXDB0lMUDOCDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lLMMAXDB0lMUDOCDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCMUDOCD

RUNTIMEC
MACSYMA-MODULE1DplSI,
DEFVAR-1C
APROPOS-SEARCH1DB[CAPROPOS-STRING-LENGTH1DB[C
APROPOS-FOUNDDpB ,
PROPERTY
$APROPOS
MFEXPR*KE2@F/@Bi@FA@@@@|B\qBbqB_qSTANDARD-OUTPUT1CFORMATRl~A@C
FULLSTRIP1Rl ~
 2 |                     ~%APROPOS takes arguments which should be a symbols or strings.~
 3 |                     ~%It searches the symbol table, returning a list of all symbols~
 4 |                     ~%which contain the arguments as substrings of their print name.~%@D
D
CMLIST@MAX@CMAPCARRC
STRING-LENGTHR
MAPATOMSRDpB ,
INTERNALBi@BP@D
Bu@SORTR
STRING-LESSPDDp,
COMPILER,
ARG-MAPD
D
FORMDpBl
LOCAL-MAPDD
pBl
MAP-RESULTD
pB,
MAP-TEMPNILD
CUDpB ,INTERNAL-FEF-OFFSETSF@7)BwAwA%B'Cw
 5 |  %$`Cet:AWXBBrY@%VX
 6 | 	$
 7 | d$ $d;V6T$$e$ $dvOBiBK,@F@B@FA@@@@~BbqB\qB_1BzRC
CHARACTERRDF$F%F&@C
STRING-SEARCHDDBD
D
CSYMBOLDBDD
CSTRINGD
CL%g:@w	 @eTX
 8 |  @e$8$AwA'@%e
XAAwY%$v:VO4B1DpBYl
DEFCONST-1CDESCRIBE-DATA-FILElMC:LMMAXR;DOCDAT >1DB6DESCRIBE-DATA-FILE-OPEN-OPTIONSDB0DCFIXNUMpB l
BYTE-SIZEF1DB[C
DESCRIBE-ALISTB1DB[C
DESCRIBE-FILEBCLOAD-DESCRIBE-ALIST-IF-NEEDEDKP8@F6@BJ@@@@@~BDqBpqB;qB7qBG1CPROBEFRpB lABORT@Fa@F@OPENRpB lIN@BqRl~&; Loading describe database, please stand by...@pB ,
SET-POINTER@CLENGTH@F@READR,~&; Loading of describe database done.~%@pB ,
TRUENAME@CERRORPRCCLOSED
DBDD
CSTREAMD
pBY,.FILE-ABORTED-FLAG.
 9 | 8
10 | d-X$Aw
11 | $$/
% 	$$$vz@w$d@
$@!dRe@
$`@e @ev$d@!d
12 | VAw@8@eX@
$Ae-OlBJDBfC
$DESCRIBEBhK
13 | )@F@Bn@FA@@@@|CINTERNAL-$DESCRIBER,
DESCRIBE@C
STRING-UPCASERBqRl~A@BsDDBD
D
BDBDD
B
14 | D
BBD
CX	Xd$@7)BwAw
15 | A%B'Cw 	`%
16 | $`Cet:AWXBBqY@%O
BnBuK4$@F#@Bu@@@@@}B;qB71BJRBS@F<@F@BVRBX@CPRINT-DESCRIPTIONSRBbRBcD
DBDD
B/D
BdD
Bg	$Bw
17 | $$/
% $
18 | $$vzAw@'@%Ae@yY%BwA8AeXA
$Be-O
BuB
K: @F%@B
@F@@@@|BpqBD1CASSOCRBqRl~&No information for ~A~%@B[@F
19 | @TYO@TYIDDBDD
B-D

INPUT-STREAMDBDD
INFOD
B/D
CJD
CC %d@w@8@)	$
20 | $e%Aw

$Aq%Bw$Cw
21 | 
22 | $CeB%U:
!dCw%BwB%A/5r9AAgYO.
B
1DB6DESCRIBE-MASTER-FI


--------------------------------------------------------------------------------
/lmmaxr/rombrg.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen<FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lMAXSRCDB0lROMBRGDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lMAXSRCDB0lROMBRGDB0B:DB0F+pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCROMBRGD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALC
USER-TIMESOFAR1DplSIl
DEFCONST-1C
$ROMBERGITF1DB_
$ROMBERGMIN1DB_
$ROMBERGTOLGs[h,1DB_
$ROMBERGABSG1DB_$ROMBERGIT_USED1DpB],
DEFVAR-1C
ROMB-PRINTNILC
$ROMBERG_SUBRK!u
B@F@Bz@FC@H@@sCRIGHTQCSTq
TRAMP1$qBZqBvqBpqBdqBhqBlqB`1l&the first arg to ROMBERG@
MAKE-TRAMP$RG@C*ARRAYRCFLONUM@C
ROMB-TIMESOFAR@G@@F@CMTELLRlRomberg: ~A iterations; last error =~A;~
2 | 			    calculating F(~A).@G@@G@@G`@G
@@CMERRORRlROMBERG failed to convergeDDp,
COMPILER,
ARG-MAPDD

FUNCTIOND
LEFTD
B
DpBl
LOCAL-MAPD
3 | D
CFD
CAD
CBD
CXD
CTTD
CRRD
CLD
CMD
CYD
CZD
CERRD
CID
CK$V6 %e@w
%(;$(;$ %$d


--------------------------------------------------------------------------------
/lmmaxr/trans2.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen/FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRANS2DB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRANS2DB0B:DB0F'pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTRANS2D

RUNTIMEC
MACSYMA-MODULEDpB ,
PROPERTY
$RANDOMC
TRANSLATEK@F@B]@FA@@@@CLIST*R
$FIXNUM@CRANDOM@
TR-ARGSD
Dp,
COMPILER,
ARG-MAPD
D
FORM$$	`iOpB]DBZCMEQUALB\K@F@Br@FA@@@@LISTR$ANY@
SIMPLIFY@BdRBy@DB0D
Bq@BgD
DBjD
D
Bk$$	`
2 | $$`iOBrDBZCMCALLB\K
3 |  @F@B@FA@@@@~C
FUNCTION-MODERBz@BgRC
CALL-AND-SIMPRBDDBjD
D
BkDpBhl
LOCAL-MAPDD
MODED
COPX g
$@w ew'Aw	@%
4 | $A%)vzOB
TR-ARRAYCALLK/"@F @B@FA@@@@$TR_ARRAY_AS_REFqCARRAYS1C
ARRAY-MODE@BdRB#RBgRB\RD
C
MARRAYREF@ByRD
CMQUOTED
DBjD
D
Bk1$P81$X1$v:v	
5 |  q


--------------------------------------------------------------------------------
/lmmaxr/trans3.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen5/FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRANS3DB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRANS3DB0B:DB0F/pB.,
PACKAGEpB.,
MACSYMAC
FREE-LISP-VARSKR(@F3@BR@FA@@@@LISTRBR@FREE-LISP-VARS-MACRO@BRRCMACRO@DCFSUBRCFEXPR@C
WARN-FEXPRR,environment may fail to be correct.@CFREE-LISP-VARS-OF-ARGLRCLAMBDA@
SUM-VAR-SETSRCBARFORlBad lisp expression generated.DDp,
COMPILER,
ARG-MAPD
D
EXPDpBfl
LOCAL-MAPD
D
PROP
 2 | X8
%u
8%y8`e"X'$P:@w8@
e'$P:@w8	@ae'
 3 | $P:@w8	@ae'$Q8'
 4 | dii1t8	 g`idOtBRBaK
 5 | @F@Ba@FA@@@@C
UNION-VAR-SETRCMAPCARRBRD
DBhD
D
ARGL`$eOBaCREDUCE-VAR-SET&OPK@F@B@F@@@@}DDBhDD

VAR-SETD
COPDBnDD
REDUCED-VAR-SETD
VAR1D
VAR2'AwA8A'@%R:Bw8B%
!A)BiXA%@%v:@wjY@OBC
REDUCE-VAR-SETK	
 6 | @F@B@FA@@@@BRDpB ,
INTERNALBDDBhD
D
B
 7 | DpB ,INTERNAL-FEF-OFFSETSF%dO-BB$K@F	@B$@F@@@@D
DBhDD
CP1D
CP2%

O;B$DIFFERENCE-VAR-SETSK@F@B<@F@@@@BDDBhDD
CS1D
CS2DBnD
D
CS ew	1
%RX'@%v:@wuY@ONB<B{K	
 8 | @F@B{@FA@@@@BRCAPPENDD
DBhD
D
SET-OF-VAR-SETS$%{O[B{BcK	
 9 | @F@Bc@@@@@BRBUD
DBnD
D
CL$@%{OgBc
MAKE-VAR-SETK	
10 | @F@Bh@FA@@@@B|RCNCONSD
DBhD
D
VARS$eOuBhDpB ,
PROPERTYBbBRK@F@Bx@FA@@@@B<RBaRBhRBYD
DBhD
D
FORM mXeX`	`k`kO
BxDBwPROGBRK
11 | %@F@B
@FA@@@@|B<RB{RBRRBhDDBhD
D
BDBnDD
pBfl
MAP-RESULTD
pBf,
MAP-TEMPNILD
CU @7-BwAw
12 | A%B'CwCX% Cet:AWXBBqY@%e	`kO
B
DBwCGOBRK
	@F@B
@FA@@@@D
DBhD
D

IGNOREDO*
B
DBwCDOBRK.@F@B,
@FA@@@@|B<RBcRBaRB{RBhRB|RCARDDBhD
D
BDBnDD
B
D
B
B
D

DO-ITER  %/z %+z	`@7+BwAw	A%B'Cw Cit:AWXBBuY@%e
13 | ``$kO>
B,
DBwCONDBRK
14 | @F@B@
@FA@@@@B{RB|RBaD
DBhD
D
B`$iOK
B@
DBwB0BRK
	@F@BL
@FA@@@@D
DBhD
D
B%
OW
BL
DBw
FUNCTIONBRK
	@F@BY
@FA@@@@D
DBhD
D
B%
Od
BY
DBwSETQBRK
15 | @F@Bf
@FA@


--------------------------------------------------------------------------------
/lmmaxr/trans4.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATAD,GJClSetterK:&FPF
pB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRANS4DB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRANS4DB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTRANS4D

RUNTIMEC
MACSYMA-MODULEDpB ,
PROPERTY
MNCTIMESC
TRANSLATEK	 @F@B]@FA@@@@
TR-ARGSRCLIST*R$ANY@CNCMUL2@CNCMULN@LIST@D
NILD
Dp,
COMPILER,
ARG-MAPD
D
FORM iw%T:8$	$e$
 2 | $$%v:dOtB]DBZ
MNCEXPTB\K@F@Bv@FA@@@@BeRBf@
NCPOWER@BdD
DBnD
D
Bo$$	`iOBvDBZC
$REMAINDERB\K0$@F!@B@FA@@@@~C
TR-NARGS-CHECKRD
F@CMAPCARRB\@
$FIXNUM@BiRC
REMAINDER@C
CALL-AND-SIMPRBf@B@CDRDDBnD
D
BoDpBll
LOCAL-MAPDD
CND
Bd %d 	$iAw@w@%
 3 | 8A1
 4 | t
 5 | 8A%):
 6 | t8
 7 | $$A/A%-z
 8 | $$`$AeOBDBZC$BETAB\K@F@B @FA@@@@BiRBf@
SIMPLIFY@BeRBi@DB0D
B@BdD
DBnD
D
Bo$$	`
 9 | $$`iO.B DBZC
MFACTORIALB\K	" @F@B0@FA@@@@B\RB@BiR
$NUMBER@C
FACTORIAL@Bf@B'@plSIl
XR-BQ-LIST@DB0D
B/D
DBnD
D
Bo kw't8	$
10 | $i$$`
11 | $$iOBB0DBZ%SUMB\K@F@BD@FA@@@@BiRBf@CMEVAL@B0D
DBnD
D
Bo$$`	$eOPBDDBZ
%PRODUCTB\K@F@BR@FA@@@@BiRBf@BK@B0D
DBnD
D
Bo$$`	$eO]BRDBZC
%BINOMIALB\K
12 | @F@B_@FA@@@@BRDFG~ffff@BeRBf@C
$BINOMIAL@BdD
DBnD
D
Bo%d	$
13 | $`iOnB_1DMAPCDB0DCLAMBDAD
CXD
PUTPROPDCARBqDGETDBBqDB0
AUTOLOADDB0BxDB0DD@CPROC-$MATCHDECLAREC
$MATCHDECLARED@C
PROC-$DEFMATCHC
$DEFMATCHD@C
PROC-$DEFRULE
$DEFRULED@PROC-$TELLSIMPAFTERC
$TELLSIMPAFTERD@C
PROC-$TELLSIMPC
$TELLSIMPYUK-SU-META-PROPK @F@B
@F@@@@
META-PROP-Pq
META-PROP-L1BeRBf@CPROGN@DB0
COMPILE@BRCPATCH-UP-MEVAL-IN-FSETR
NREVERSED
DBnDD
CFD
Bo
%V6

i	$
14 | $$`
15 | $`dO&
B
DBZB
B\KK&@F/@B'
@FA@@@@zCMLIST@CAPPENDRBiRC$ANY.@BeRB
@DB0B
@C
DTRANSLATERD
$DEFINE_VARIABLE@D
CMQUOTE@D
Bf@D
CSUB_$MATCHDECLAREDDBnD
D
BoDBDD
CLD
VARSD
pBll
MAP-RESULTD
pBl,
MAP-TEMPBjD
VAR)@w@X@'A%v:Aw@%(:t8 @/AeAw@5@nY	$
16 | `$$`BwB7A%DwCwC%D'Ew
17 |  
18 | `$E% $Eedt:CWXDDoYB%`
19 | `$)vzOL
B'
DBZB8
B\K
20 | @F
21 | @BM
@FA@@@@B
RB@D
B
D
DBnD
D
Bo$$)vzOY
BM
DBZB
B\K	
22 | @F@BZ
@FA@@@@B
RB
D
DBnD
D
Bo$eOe
BZ
DBZB
B\K	
23 | @F@Bf
@FA@@@@B
RB



--------------------------------------------------------------------------------
/lmmaxr/trans5.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen/FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRANS5DB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRANS5DB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTRANS5D

RUNTIMEC
MACSYMA-MODULEDpB ,
PROPERTYC$DISPC
TRANSLATEK@F@B]@FA@@@@CLIST*R$ANY@C
DISPLAY-FOR-TR@C$LDISP@
TR-ARGSD
Dp,
COMPILER,
ARG-MAPD
D
FORM$$1	$;%
 2 | `iOqB]1D
PUTPROPDB0BgDCORDGETDB0B[DB0B\DCERRORDB0No TRANSLATE property to alias.DB0B[BwDBZ
$DISPLAYB\K
 3 | @F@B@FA@@@@BdRBe@Bf@C
$LDISPLAY@CMAPCARRCTR-EXP-TO-DISPLAYD
DBkD
D
Bl$$1	$;
%
 4 | `$iOB1DBrDB0B	DBtDBuDB0B
BwDByB{DB0B
Bw1DplSI,
DEFVAR-1
VALUE-ALISTNIL
MAKE-VALUESK
 5 | *@F@B @FA@@@@{B1D
TRD-MSYMEVALB0@CGENSYMDDBkD
D
C
EXPR-ARGSDpBil
LOCAL-MAPDD
pBil
MAP-RESULTD
pBi,
MAP-TEMPBD
ARGD
SYM@7%BwAwA%B'CwC8C'$8C%	"DwC%D%v:$v:vD%t:AWXBBfY@O=B 1DBR
RIGHT-OBD@
DISP-HACK-OBB>pBl
DEFSTRUCT-SLOTD
NAMED-SUBSTDB>Dp,SYS,FUNCTION-PARENTB?C
DEFSTRUCTD
B?DCDRB?OOB>1DBR
LEFT-OBD@B?BPBBDBEDBPDBHB?BIBLDCARB?OXBP1DBRCMAKE-DISP-HACK-OBB?pBl
DEFSTRUCT-NAME1D
FDEFINEDB0BYDB0D@CMACROpB,DEFSTRUCT-EXPAND-CONS-MACROCT1DBRCALTER-DISP-HACK-OBB?B[1DB^DB0BhDB0D@B`pB,DEFSTRUCT-EXPAND-ALTER-MACROBe1DBRB?DpB,ONEpB ,TREEpB,DEFSTRUCT-DONT-DISPLACEDDBPBpB,%%DEFSTRUCT-EMPTY%%pBlNOTYPEBBPDB>F
BBzB|BB>BD
D
BYBBFBB?BDEVAL
COMPILELOADBhBBeBBpBlDEFSTRUCT-DESCRIPTION1DpB,RECORD-SOURCE-FILE-NAMEDB0B?DB0BIB?OBJECT-FOR-DISPLAY-HACKKE ,@F[@B
@FA@@@@yLISTRB0@
SIMPLIFY@B
RC
MARRAYREF@B RBdRB
@Bd@D
DB0D
CARRAY@C
MFUNCTION-CALL@B
 6 | RB'@DCFSUBRCFEXPRB`@C
UNTRANS-OPDDBkD
D
EXPDB/DD
CVD
VALSD
OBSD
B1D
B4BD
CUX $e%v't8	 k@w@' $@iv'
 7 | t8 iAw 
 8 | $ $A'dAi
 9 | $A%v:v't8 mAw 
10 | $ $`kAe $+Aev'
11 | t*8 	$iBw
12 | $C7B%EwDwD%E'FwF't:DWXEEvYC%v:


--------------------------------------------------------------------------------
/lmmaxr/transf.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen</FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRANSFDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRANSFDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTRANSFD

RUNTIMEC
MACSYMA-MODULEDpB ,
PROPERTY%LOGC
TRANSLATEK
2 | )@F@B]@FA@@@@B\RC$FLOAT@LISP-FUNCTION-TO-USE@LISTR$ANY@
SIMPLIFY@Bf@B0DDp,
COMPILER,
ARG-MAPD
D
FORMDpBil
LOCAL-MAPD
D
ARG k@w@'t
3 | 81$P8	$1$P:@i	
4 | $$	`$	 
5 | $	`q@iOwB]1D
PUTPROPDB0%SINDCORDGETDB0B[DB0B\DCERRORDB0No TRANSLATE property to alias.DB0B[B~1DBxDB0%COSDB{DB|DB0B[B~DBBDB0B[B~1DBxDB0%TANDB{DB|DB0B[B~DBBDB0B[B~1DBxDB0%COTDB{DB|DB0B[B~DBBDB0B[B~1DBxDB0%CSCDB{DB|DB0B[B~DBBDB0B[B~1DBxDB0%SECDB{DB|DB0B[B~DBBDB0B[B~1DBxDB0C%ACOTDB{DB|DB0B[B~DBB


--------------------------------------------------------------------------------
/lmmaxr/trdata.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenY0FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRDATADB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRDATADB0B:DB0FCpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTRDATAD

RUNTIMEC
MACSYMA-MODULE1DMAPCDB0DCLAMBDAD
CXD
PUTPROPB[DB0
$FIXNUMDB0C
FUNCTION-MODEDB0D
$LENGTH
$NTERMSCRANDOM
$NROOTSC$RANKC
$POLYSIGNC$TIMEC$ARRAY_DIMENSION_N1DBYDB0DBZD
B[DB]B[DB0C$FLOATDB0B`DB0DC
$ROMBERG_SUBRC$INTERPOLATE_SUBR1DBYDB0DBZD
B[DB]B[DB0
$BOOLEANDB0B`DB0DC$ARRAY
$BFLOATPC$LISTP
$MATRIXP
$RATNUMPC
$CONSTANTPC$ATOM
$FREEOF
$SUBVARP
$SYMBOLPC$EVENPC$ODDP
$ORDERLESSP
$ORDERGREATP
$MAPATOMC
$INTEGERPC
$FLOATNUMP
$NONSCALARP
$NUMBERPC$RATP
$M


--------------------------------------------------------------------------------
/lmmaxr/trmode.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATAD,GJClBeagle:;FLF8pB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRMODEDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRMODEDB0B:DB0FEpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTRMODED

RUNTIMEC
MACSYMA-MODULE1DplSIl
DEFCONST-1
$MODE_CHECKPCT1DB[C$MODE_CHECK_WARNPB]1DB[C$MODE_CHECK_ERRORPNILCMSEEMINGLY-UNBOUNDK@F@Bg@FA@@@@D
Dp,
COMPILER,
ARG-MAPD
D
CX%~;b:%{:%OvBgCASSIGN-MODE-CHECKK*@F@Bw@F@@@@~B`qBc1MODE@$GETR
$VALUE_CHECK@C
CHEKVALUERCMCALLDDBpDD
VARD
CVALUEDpBnl
LOCAL-MAPDD
B~D
C
USER-LEVEL%$P:	 %
 2 | dAw@w@
 3 | 8
%V
%V%@%
e
A8A%
e
OBwDpB ,
PROPERTY$DEFINE_VARIABLEC
TRANSLATEK%i>@FD@B@FA@@@@{F@CLIST*RD

$DECLARE@D

$SPECIAL@LISTRD

$MODEDECLARE@BRPUSH-PRE-TRANSL-FORMR
DECLARE@
SPECIAL@$ANY@
PUTPROPRBw@CASSIGN@CPROGN@DB0
COMPILE@CMEVAL*@B0@BR@DBwB+@C
DEF-MTRVAR@C
DTRANSLATER
TR-TELLRlWrong number of argumentsDDBpD
D
FORMDB
 4 | DD
BD
VALD
B~D
C
SPEC-FORMD
C
MODE-FORM%T:4B8)BwB'@wBB'AwB+Bw $@%	d
 5 |  $@%BeDwCwCeDe
 6 | 
 7 | `$
 8 | `$kB%tX@%$d
 9 | $$$
10 |  $
11 | `$De
12 |  $
13 | `$CeB%tX $@%d
%
14 | `$+`%+z$eODBDBB
MFEXPR*K@,@F+@BF@FA@@@@CMERRORR,Wrong number of arguments to DEFINE_VARIABLE@lFirst arg to DEFINE_VARIABLE not a SYMBOL.@CMEVALRB#RD
B$@BRD
B@D
B!@B)@B*RBw@B+@BgRD
CMSETQD
DBpD
D
CL%T:5Xd'yXd	
15 | `$'%+z	`
16 | $'d%+:tX'$dg8	
17 | `$'k	gO[BFDBC
$MODE_IDENTITYBEK@F@B]@FA@@@@BMR,MODE_IDENTITY takes 2 arguments.@BPRB
RCIRDDBpD
D
BVDB
18 | D
D
CV%T:Xd k@w	+
19 |  g@e@OnB]DBB\BK	@F@Bo@FA@@@@BeRB2D
DBpD
D
B5 k %+zvOzBoDBB$BK	@F@B{@FA@@@@
DECLMODERBeDDBpD
D
B5DB
20 | D
D
BV)@w@' @k
e@5@xYO
21 | 
B{C
ASS-EQ-REFK
22 | 		@F@B
@@@@~}|*LEXPR-ARGLIST*F @@Fe@FeARGRFD
DB
23 | DD
B
D
CND
B:$T:Aw
24 |  e
25 |  eR:BwB
8B	A%8
26 | dO
B
C
ASS-EQ-SETK	@F@B 
@FC@@@@DDBpDD
B:D
CTABLED
KEYDB
27 | D
D
CELL%
%R:@w@8@%%X%%v:
%v:
w
O3
B 
DBB$BEK
28 | )@F@B4
@FA@@@@~BMR,MODE_DECLARE takes an even number of arguments.@B
RBeRD
CMLIST@
NREVERSEDDBpD
D
BqDB
29 | DD
BVD
CNL%T:d8d%@w
30 | @'	 @ke@'A%v:Aw@5@tY
31 | $ AevOH
B4
CTR-DECLARE-VARMODEK	@F@BI
@F@@@@C
DECLVALUERBeD
DBpDD

VARIABLED
B~% 
e
eO


--------------------------------------------------------------------------------
/lmmaxr/troper.qfasl.1:
--------------------------------------------------------------------------------
 1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenU/FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTROPERDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTROPERDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTROPERD

RUNTIMEC
MACSYMA-MODULEDpB ,
PROPERTYCMMINUSC
TRANSLATEK"[.@F9@B]@FA@@@@B\R
$FIXNUM@LISTRC-@C$FLOAT@C-$@
$NUMBER@CMINUS@C
$RATIONAL@RAT@B0@D
Bl@CRTIMES@F@
@$ANY@
*MMINUSD
Dp,
COMPILER,
ARG-MAPD
D
FORM kw)k8')o:v$'u8$	$i
 2 | $'u8
 3 | $$i$'u8$
 4 | $i$'u8%+8$%+:1u8%;:w$$`$'o:k$$$i$$iOzB]DBZCMPLUSB\KW2@F8@B|@FA@@@@}B\R
*UNION-MODER
NREVERSERBd@CLIST*RC+@CMAPCARRCDR@Bg@C+$@
DCONV-$FLOAT@Bk@CRPLUS@Bi@PLUS@Bp@ADD*@CDCONVXDDBtD
D
BuDpBrl
LOCAL-MAPDD
ARGSD
MODED
CL)Bw Bg@%v:@w @''AeAwBBsY @e@w	$Au8
 5 | 	$$`
 6 | $@e$Au8
 7 | $$`$@e$Au8
 8 | $$`
 9 | $@e$Au8
10 | $$`
11 | $@e
12 | $$`$@eOB|
NESTIFYK@F@B@F@@@@~BeDDBtDD
COPD
BDBDD
BD
CNL
)
'Aw@w %A%@gAw@@xYAO0BDBZCMTIMESB\K$e:@FA@B2@FA@@@@}F@
@B\RBeRD
B[@D
B1@BRBRBd@BRC*@BRB@Bg@C*$@B
13 | @Bk@Bn@Bi@CTIMES@Bp@MUL*@BDDBtD
D
BuDBDD
BD
BD
B$+u8`	$
14 | $-vz)Bw Bg@%v:@w @''AeAwBBsY @e@w
15 | $Au8
16 | $$`$@e$Au8$$`$@e$Au8$$`$@e$Au8$$`$@e$$`$@eOIB2DBZC
MQUOTIENTB\K!Z0@F9@BK@FA@@@@}C
$TR_NUMER1B\RBRCDCONVRBg@CMEMBERRDF
G
@@BeRBRC/$@Bd@CFLOAT@DBdBk@Bk@C
RREMAINDER@Bp@DIVDDBtD
D
BuDBDD
ARG1D
ARG2D
B k@w %+zAw @'AgBw	 @%Be@w	 A%BeAw
17 | $Bu8@%d8
18 |  Ae
19 |  @%Ae@w
20 | $$@eB%t8	8
21 | 
22 | $$
23 |  $@e
24 | `$AeB%$8
25 | $$@%Ae
26 | $$@%AeOhBKDBZCMEXPTB\KG,<@Fe@Bj@FA@@@@BASqBR1$%E@B\RBeRD
$EXP@Bd@Bg@C^$@CEXPT$@BY@Bp@CPOWER@Bk@SQRT@F@
@BX@Bl@EXPT@BgRC


--------------------------------------------------------------------------------
/lmmaxr/trpred.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteeno0FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRPREDDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRPREDDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTRPREDD

RUNTIMEC
MACSYMA-MODULE1DplSI,
DEFVAR-1C
WRAP-AN-ISDB0C
IS-BOOLE-CHECKlHow to verify booleansDpB ,
PROPERTY$ISC
TRANSLATEK@F@Bf@FA@@@@B\1B]@
$BOOLEAN@TRANSLATE-PREDICATED
Dp,
COMPILER,
ARG-MAPD
D
FORM$V$	 kvOwBfDBcC$MAYBEBeK@F@By@FA@@@@B\1CMAYBE-BOOLE-CHECK@$ANY@BnD
DBqD
D
Br$V$	 kvOByDBcMNOTBeK	
2 | @F@B@FA@@@@Bm@BnD
DBqD
D
Br$ evOB1D
PUTPROPDB0MANDDCORDGETDB0BDB0BeDCERRORDB0No TRANSLATE property to alias.DB0BB1DBDB0MORDBDBDB0BBDBBDB0BBDBcC
MNOTEQUALBeK@F@B.@FA@@@@LISTRB
@
SIMPLIFY@CLIST*RB5@B0@
TR-ARGSD
DBqD
D
Br$$	`
3 | $ $`q`iO=B.1DBDB0CMEQUALDBDBDB0B-BDBBDB0B-B1DBDB0C$EQUALDBDBDB0B-BDBBDB0B-B1DBDB0C
MGREATERPDBDBDB0B-BDBBDB0B-B1DBDB0CMGEQPDBDBDB0B-BDBBDB0B-B1DBDB0CMLESSPDBDBDB0B-BDBBDB0B-B1DBDB0CMLEQPDBDBDB0B-BDBBDB0B-BBnK'2N@FY@Bn@FA@@@@~BeRBm@B\RB@
TRP-MNOTRB@
TRP-MANDRB$@
TRP-MORRB-@C
TRP-MNOTEQUALRB>@C
TRP-MEQUALRBG@C
TRP-$EQUALRBP@C
TRP-MGREATERPRBY@C
TRP-MGEQPRBb@C
TRP-MLESSPRBk@C
TRP-MLEQPRCMPROGN@CPROGN@CAPPENDRB8R
NREVERSER
REVERSERB5RBnRBOOLEAN-CONVERTDDBqD
D
BrDpBol
LOCAL-MAPDD
CTFORMD
MODEX e@w$@'u
8@	@)e	$1u8
4 | e$1u8e
5 | $1u8e$1u8e$1u8e$1u8e$1u8e$1u8e$1u8e$1u8e$1u
6 | 8$   !`" ii#`$`)S:gv e@w@'Aw@%A%@%eO
BnB	
K	@F
7 | @B	
@FC@@@@Bm@B\D
DBqDD
B
D
EXPD
Br%t
8

%eO$
B	
BzK
8 | 
9 | @F@Bz@FA@@@@


--------------------------------------------------------------------------------
/lmmaxr/trprop.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine SixteenZ1FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRPROPDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRPROPDB0B:DB0F
pB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTRPROPD

RUNTIMEC
MACSYMA-MODULE1DplSIl
DEFCONST-1
META-PROP-PNIL1DB[
META-PROP-LB]
META-OUTPUTK
2 | @F@Bc@FA@@@@B`q*IN-TRANSLATE-FILE*1EVALD
Dp,
COMPILER,
ARG-MAPD
D
FORM8%$v:veOtBc
META


--------------------------------------------------------------------------------
/lmmaxr/trutil.qfasl.1:
--------------------------------------------------------------------------------
1 | hF0s2Dp,,
COMPILE-DATADlLMMAX,Lisp Machine Sixteen0FOFpB ,SOURCE-FILE-GENERIC-PATHNAME1DplFSlMAKE-FASLOAD-PATHNAMEDplGLOBALlQUOTElMCDB0,DSKDB0lTRANSLDB0lTRUTILDB0pB l
UNSPECIFICDB0B:pB ,QFASL-SOURCE-FILE-UNIQUE-ID1DB-DB0B1DB0,DSKDB0lTRANSLDB0lTRUTILDB0B:DB0FpB.,
PACKAGEpB.,
MACSYMA1D
DEFPROPCTRUTILD

RUNTIMEC
MACSYMA-MODULE1D
SPECIALCTR-GENSYM-KOUNTERN]BZC
TR-GENSYMK@F@B^@F
@@@@BZ1
IMPLODERCNCONCR
EXPLODECRC
tr-gensym~D
Dp,
COMPILER,
ARG-MAPD
D
CK8%v `	 
2 | d	`dTOqB^1DC
UNSPECIALBZCONSERVE-EVAL-ARGS-DATAK	%@F@Bu@FA@@@@}B^R
NREVERSEDDBkD
D
CLDpBil
LOCAL-MAPDD
CSUBLISD
CNLD
SYMX'A%v:Aw"BwB%'v:@%v:@wB%A%v:AwjY@% AevOBuTR-TRACE-HANDLEKN(@F1@B
3 | @FA@@@@|CLEVEL1C
TR-TRACE-LEVEL@LISTRCTERPRIRCPRIN1RCPRINCR
 Enter @CMGRINDRCGETOPR
SUBRCALLRC
OTRANSLATE@
 Exit  @
SPRINTERDDBkD
D
FORMDBDD
C
LEVEL-SYMD
COPD
pBil
PROGV-VARSD
pBil
PROGV-VALS1$P:@w@%{:U:V1Aw @e dCwBwB8B'q:C'BCw	
4 | dd
5 |  Aee	
6 | %e %A%$P:ew	
7 | dd
8 |  AeeeO2B
9 | 1DBRGET!DCMTRACEFASLDSKCMACSYM
AUTOLOAD
TR-TRACEK, @F@B<@FA@@@@B@C
TR-UNTRACERCGENSYMR
PUTPROPRB@B


--------------------------------------------------------------------------------
/macrak/logarc.lisp.27:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1981 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module logarc)
 6 | 
 7 | ;;;  Logarc and Halfangles
 8 | 
 9 | (defmfun $logarc (exp)
10 | 	 (cond ((atom exp) exp)
11 | 	       ((arcp (caar exp)) (logarc (caar exp) ($logarc (cadr exp))))
12 | 	       ((eq (caar exp) '$atan2)
13 | 		(logarc '%atan ($logarc (div (cadr exp) (caddr exp)))))
14 | 	       (t (recur-apply #'$logarc exp))))
15 | 
16 | (defmfun logarc (f x)
17 |   ;;Gives logarithmic form of arc trig and hyperbolic functions
18 |  (let ((s (memq f '(%acos %atan %asinh %atanh))))
19 |    (cond 
20 |     ((memq f '(%acos %asin))
21 |      (mul (min%i)
22 | 	  (take '(%log)
23 | 		(add (mul (if s '$%i 1)
24 | 			   (root (add 1 (neg (power x 2))) 2))
25 | 		     (mul (if s 1 '$%i) x)))))
26 |     ((memq f '(%atan %acot))
27 |      (mul (i//2)
28 | 	  (take '(%log) (div (add 1 (morp s (mul '$%i x)))
29 | 			     (add (mul '$%i x) (porm s 1))))))
30 |     ((memq f '(%asinh %acosh))
31 |      (take '(%log) (add x (root (add (power x 2) (porm s 1)) 2))))
32 |     ((memq f '(%atanh %acoth))
33 |      (mul (half) (take '(%log) (div (add 1 x) (morp s (add x -1))))))
34 |     ((memq f '(%asec %acsc %asech %acsch))
35 |      (logarc (get (get (get f '$inverse) 'recip) '$inverse) (inv x)))
36 |     (t (merror "Bad argument to Logarc")))))
37 | 
38 | (defun halfangle (f a)
39 |        (and (mtimesp a)
40 | 	    (ratnump (cadr a))
41 | 	    (equal (caddr (cadr a)) 2)
42 | 	    (halfangleaux f (mul 2 a))))
43 | 
44 | (defun halfangleaux (f a)  ;; f=function; a=twice argument
45 |    (let ((sw (memq f '(%cos %cot %coth %cosh))))
46 |      (cond ((memq f '(%sin %cos))
47 | 	    (power (div (add 1 (porm sw (take '(%cos) a))) 2) (1//2)))
48 | 	   ((memq f '(%tan %cot))
49 | 	    (div (add 1 (porm sw (take '(%cos) a))) (take '(%sin) a)))
50 | 	   ((memq f '(%sinh %cosh))
51 | 	    (power (div (add (take '(%cosh) a) (porm sw 1)) 2) (1//2)))
52 | 	   ((memq f '(%tanh %coth))
53 | 	    (div (add (take '(%cosh) a) (porm sw 1)) (take '(%sinh) a)))
54 | 	   ((memq f '(%sec %csc %sech %csch))
55 | 	    (inv (halfangleaux (get f 'recip) a))))))
56 | 


--------------------------------------------------------------------------------
/maxsrc/inmis.lisp.98:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1981 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module inmis)
 6 | 
 7 | (DEFMVAR $LISTCONSTVARS NIL
 8 |   "Causes LISTOFVARS to include %E, %PI, %I, and any variables declared
 9 |    constant in the list it returns if they appear in exp.  The default is
10 |    to omit these." BOOLEAN SEE-ALSO $LISTOFVARS)
11 | 
12 | (DECLARE (SPECIAL LISTOFVARS))
13 | 
14 | (SETQ $COMBINEFLAG NIL $POLYFACTOR NIL)
15 | 
16 | (DEFMFUN $UNKNOWN (F) (*CATCH NIL (UNKNOWN (MRATCHECK F))))
17 | 
18 | (DEFUN UNKNOWN (F)
19 |  (AND (NOT (MAPATOM F))
20 |       (COND ((AND (EQ (CAAR F) 'MQAPPLY)
21 | 		  (NOT (GET (CAAADR F) 'SPECSIMP)))
22 | 	     (*THROW NIL T))
23 | 	    ((NOT (GET (CAAR F) 'OPERATORS)) (*THROW NIL T))
24 | 	    (T (MAPC 'UNKNOWN (CDR F)) NIL))))
25 | 
26 | (DEFMFUN $LISTOFVARS (E) 
27 |        ((LAMBDA (LISTOFVARS) 
28 | 	 (COND (($RATP E)
29 | 		(AND (MEMQ 'TRUNC (CDDAR E))
30 | 		     (SETQ E ($TAYTORAT E)))
31 | 		(SETQ E
32 | 		      (CONS '(MLIST)
33 | 			    (SUBLIS (MAPCAR 'CONS
34 | 					    (CAR (CDDDAR E))
35 | 					    ;;GENSYMLIST
36 | 					    (CADDAR E))
37 | 				    ;;VARLIST
38 | 				    (UNION* (LISTOVARS (CADR E))
39 | 					    (LISTOVARS (CDDR E))))))))
40 | 	 (ATOMVARS E)
41 | 	 LISTOFVARS)
42 | 	(LIST '(MLIST)))) 
43 | 
44 | (DEFUN ATOMVARS (E) 
45 |        (COND ((AND (EQ (TYPEP E) 'SYMBOL)
46 | 		   (OR $LISTCONSTVARS (NOT ($CONSTANTP E))))
47 | 	      (ADD2LNC E LISTOFVARS))
48 | 	     ((ATOM E))
49 | 	     ((EQ (CAAR E) 'MRAT) (ATOMVARS (RATDISREP E)))
50 | 	     ((MEMQ 'ARRAY (CAR E)) (MYADD2LNC E LISTOFVARS))
51 | 	     (T (MAPC 'ATOMVARS (CDR E))))) 
52 | 
53 | (DEFUN MYADD2LNC (ITEM LIST) 
54 |        (AND (NOT (MEMALIKE ITEM LIST)) (NCONC LIST (NCONS ITEM)))) 
55 | 
56 | ;; Reset the settings of all Macsyma user-level switches to their initial
57 | ;; values.
58 | 
59 | #+ITS
60 | (DEFMFUN $RESET NIL 
61 |        (load '((DSK MACSYM) RESET FASL))
62 |        '$DONE)
63 | 
64 | #+Multics
65 | (DEFMFUN $RESET ()
66 |   (LOAD (EXECUTABLE-DIR "RESET"))
67 |   '$DONE)
68 | 
69 | #+NIL
70 | (DEFMFUN $REST ()
71 |   (LOAD "[MACSYMA]RESET"))
72 | 
73 | ;; Please do not use the following version on MC without consulting with me.
74 | ;; I already fixed several bugs in it, but the +ITS version works fine on MC 
75 | ;; and takes less address space. - JPG
76 | (DECLARE (SPECIAL MODULUS $FPPREC))
77 | #-(or ITS Multics NIL) ;This version should be eventually used on Multics.
78 | (DEFMFUN $RESET ()
79 |         (SETQ BASE 10. IBASE 10. *NOPOINT T MODULUS NIL ZUNDERFLOW T)
80 |         ($DEBUGMODE NIL)
81 |         (COND ((NOT (= $FPPREC 16.)) ($FPPREC 16.) (SETQ $FPPREC 16.))) 
82 |    #+GC ($DSKGC NIL)
83 |         (LOAD #+PDP10   '((ALJABR) INIT RESET)
84 | 	      #+Lispm   "MC:ALJABR;INIT RESET"
85 | 	      #+Multics (executable-dir "init_reset")
86 | 	      #+Unix	???)
87 | 	;; *** This can be flushed when all Macsyma user-switches are defined
88 | 	;; *** with DEFMVAR.  This is part of an older mechanism.
89 |  #+PDP10 (LOAD '((MACSYM) RESET FASL))
90 |         '$DONE)
91 | 


--------------------------------------------------------------------------------
/maxsrc/intpol.lisp.13:
--------------------------------------------------------------------------------
  1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
  2 | ;;;     (c) Copyright 1981 Massachusetts Institute of Technology         ;;;
  3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  4 | ;;; Interpolation routine by CFFK.
  5 | 
  6 | (macsyma-module intpol)
  7 | (load-macsyma-macros transm numerm)
  8 | 
  9 | (declare (special $intpolrel $intpolabs $intpolerror)
 10 | 	 (flonum $intpolrel $intpolabs a b c fa fb fc)
 11 | 	 (fixnum lin)
 12 | 	 (notype (interpolate-check flonum flonum flonum flonum))) 
 13 | 
 14 | (COMMENT  |  For historical information ONLY.  |
 15 | (defun fmeval2 (x) 
 16 |        (cond ((fixp (setq x (meval x))) (float x))
 17 | 	     ((floatp x) x)
 18 | 	     (t (displa x) (error '|not floating point|))))
 19 | (defun qeval (y x z) (cond (x (fmeval2 (list '($ev) y (list '(mequal) x z) '$numer)))
 20 | 			   (t (funcall y z))))
 21 | )
 22 | 
 23 | (or (boundp '$intpolabs) (setq $intpolabs 0.0)) 
 24 | (or (boundp '$intpolrel) (setq $intpolrel 0.0))
 25 | (or (boundp '$intpolerror) (setq $intpolerror t))
 26 | 
 27 | (Defun $interpolate_SUBR (F LEFT RIGHT)
 28 |   (BIND-TRAMP1$
 29 |    F F
 30 |    (prog (a b c fa fb fc lin)
 31 |      (declare (flonum a b c fa fb fc) (fixnum lin))
 32 |      (setq A (FLOAT LEFT)
 33 | 	   B (FLOAT RIGHT))
 34 |      (or (> b a) (setq a (prog2 niL b (setq b a))))
 35 |      (setq fa (FCALL$ f a)
 36 | 	   fb (FCALL$ f b))
 37 |      (or (> (abs fa) $intpolabs) (return a))
 38 |      (or (> (abs fb) $intpolabs) (return b))
 39 |      (and (> (*$ fa fb) 0.0)
 40 | 	  (cond ((eq $intpolerror t)
 41 | 		 (merror "function has same sign at endpoints~%~M"
 42 | 			 `((mlist)
 43 | 			   ((mequal) ((f) ,a) ,fa)
 44 | 			   ((mequal) ((f) ,b) ,fb))))
 45 | 		(t (return $intpolerror))))
 46 |      (and (> fa 0.0)
 47 | 	  (setq fa (prog2 nil fb (setq fb fa)) a (prog2 nil b (setq b a))))
 48 |      (setq lin 0.)
 49 |     binary
 50 |      (setq c (//$ (+$ a b) 2.0)
 51 | 	   fc
 52 | 	   (FCALL$ f c))
 53 |      (and (interpolate-check a c b fc) (return c))
 54 |      (cond ((< (abs (-$ fc (//$ (+$ fa fb) 2.0))) (*$ 0.1 (-$ fb fa)))
 55 | 	    (setq lin (1+ lin)))
 56 | 	   (t (setq lin 0.)))
 57 |      (cond ((> fc 0.0) (setq fb fc b c)) (t (setq fa fc a c)))
 58 |      (or (= lin 3.) (go binary))
 59 |     falsi
 60 |      (setq c (cond ((> (+$ fb fa) 0.0)
 61 | 		    (+$ a (*$ (-$ b a) (//$ fa (-$ fa fb)))))
 62 | 		   (t (+$ b (*$ (-$ a b) (//$ fb (-$ fb fa)))))) 
 63 | 	   fc (FCALL$ f c))
 64 |      (and (interpolate-check a c b fc) (return c))
 65 |      (cond ((> fc 0.0) (setq fb fc b c)) (t (setq fa fc a c)))
 66 |      (go falsi))))
 67 | 
 68 | (defun interpolate-check (a c b fc)
 69 |        (not (and (prog2 nil (> (abs fc) $intpolabs) (setq fc (max (abs a) (abs b))))
 70 | 		 (> (abs (-$ b c)) (*$ $intpolrel fc))
 71 | 		 (> (abs (-$ c a)) (*$ $intpolrel fc)))))
 72 | 
 73 | 
 74 | 
 75 | 
 76 | (DEFUN INTERPOLATE-MACRO (FORM TRANSLP)
 77 |        (SETQ FORM (CDR FORM))
 78 |        (COND ((= (LENGTH FORM) 3)
 79 | 	      (COND (TRANSLP
 80 | 		     `(($INTERPOLATE_SUBR) ,@FORM))
 81 | 		    (T
 82 | 		     `((MPROG) ((MLIST) ((msetq) $NUMER T))
 83 | 			       (($INTERPOLATE_SUBR)  ,@FORM)))))
 84 | 	     ((= (LENGTH FORM) 4)
 85 | 	      (LET (((EXP VAR . BNDS) FORM))
 86 | 		   (SETQ EXP (SUB ($LHS EXP) ($RHS EXP)))
 87 | 		   (COND (TRANSLP
 88 | 			  `(($INTERPOLATE_SUBR)
 89 | 			    ((LAMBDA-I) ((MLIST) ,VAR)
 90 | 					(($MODEDECLARE) ,VAR $FLOAT)
 91 | 					,EXP)
 92 | 			    ,@BNDS))
 93 | 			 (T
 94 | 			  `((MPROG) ((MLIST) ((msetq) $NUMER T))
 95 | 				    (($INTERPOLATE_SUBR)
 96 | 				     ((LAMBDA) ((MLIST) ,VAR) ,EXP)
 97 | 				     ,@BNDS))))))
 98 | 	     (T (merror "wrong number of args to INTERPOLATE"))))
 99 | 
100 | (DEFMSPEC $INTERPOLATE (FORM)
101 |   (MEVAL (INTERPOLATE-MACRO FORM NIL)))
102 | 
103 | (def-translate-property $INTERPOLATE (FORM)
104 |   (let (($tr_numer t))
105 |     (TRANSLATE (INTERPOLATE-MACRO FORM t))))
106 | 
107 | 
108 | 


--------------------------------------------------------------------------------
/maxsrc/ldisp.lisp.43:
--------------------------------------------------------------------------------
  1 | ;;; -*- LISP -*-
  2 | ;;; Auxiliary DISPLA package for doing 1-D display
  3 | ;;;
  4 | ;;; (c) 1979 Massachusetts Institute of Technology
  5 | ;;;
  6 | ;;; See KMP for details
  7 | 
  8 | (DECLARE (*EXPR MSTRING STRIPDOLLAR)
  9 | 	 (SPECIAL LINEAR-DISPLAY-BREAK-TABLE FORTRANP))
 10 | 
 11 | #-LISPM
 12 | (EVAL-WHEN (EVAL COMPILE)
 13 | 	   (SSTATUS MACRO /# '+INTERNAL-/#-MACRO SPLICING))
 14 | 
 15 | ;;; (LINEAR-DISPLA <thing-to-display>)
 16 | ;;;
 17 | ;;; Display text linearly. This function should be usable in any case
 18 | ;;;  DISPLA is usable and will attempt to do something reasonable with
 19 | ;;;  its input.
 20 | 
 21 | (DEFUN LINEAR-DISPLA (X)
 22 |        (TERPRI)
 23 |        (COND ((NOT (ATOM X))
 24 | 	      (COND ((EQ (CAAR X) 'MLABLE)
 25 | 		     (COND ((CADR X)
 26 | 			    (PRIN1 (LIST (STRIPDOLLAR (CADR X))))
 27 | 			    (TYO 32.)))
 28 | 		     (LINEAR-DISPLA1 (CADDR X) (CHARPOS T)))
 29 | 		    ((EQ (CAAR X) 'MTEXT)
 30 | 		     (DO ((X (CDR X) (CDR X))
 31 | 			  (FORTRANP))			; Atoms in MTEXT
 32 | 			 ((NULL X))			;  should omit ?'s
 33 | 			 (SETQ FORTRANP (ATOM (CAR X)))
 34 | 			 (LINEAR-DISPLA1 (CAR X) 0.)
 35 | 			 (TYO 32.)))
 36 | 		    (T
 37 | 		     (LINEAR-DISPLA1 X 0.))))
 38 | 	     (T
 39 | 	      (LINEAR-DISPLA1 X 0.)))
 40 |         (TERPRI))
 41 | 
 42 | ;;; LINEAR-DISPLAY-BREAK-TABLE
 43 | ;;;  Table entries have the form (<char> . <illegal-predecessors>)
 44 | ;;;
 45 | ;;;  The linear display thing will feel free to break BEFORE any
 46 | ;;;  of these <char>'s unless they are preceded by one of the
 47 | ;;;  <illegal-predecessor> characters.
 48 | 
 49 | (SETQ LINEAR-DISPLAY-BREAK-TABLE
 50 |       '((#/= #/: #/=)
 51 | 	(#/( #/( #/[)
 52 | 	(#/) #/) #/])
 53 | 	(#/[ #/( #/[)
 54 | 	(#/] #/) #/])
 55 | 	(#/: #/:)
 56 | 	(#/+ #/E #/B)
 57 | 	(#/- #/E #/B)
 58 | 	(#/* #/*)
 59 | 	(#/^)))
 60 | 	
 61 | ;;; (FIND-NEXT-BREAK <list-of-fixnums>)
 62 | ;;;   Tells how long it will be before the next allowable
 63 | ;;;   text break in a list of chars.
 64 | 
 65 | (DEFUN FIND-NEXT-BREAK (L)
 66 |        (DO ((I 0. (1+ I))
 67 | 	    (TEMP)
 68 | 	    (L L (CDR L)))
 69 | 	   ((NULL L) I)
 70 | 	   (COND ((MEMBER (CAR L) '(#\SPACE #/,)) (RETURN I))
 71 | 		 ((AND (SETQ TEMP (ASSQ (CADR L) LINEAR-DISPLAY-BREAK-TABLE))
 72 | 		       (NOT (MEMQ (CAR L) (CDR TEMP))))
 73 | 		  (RETURN I)))))
 74 | 
 75 | ;;; (LINEAR-DISPLA1 <object> <indent-level>)
 76 | ;;;  Displays <object> as best it can on this line.
 77 | ;;;  If atom is too long to go on line, types # and a carriage return.
 78 | ;;;  If end of line is found and an elegant break is seen 
 79 | ;;;   (see FIND-NEXT-BREAK), it will type a carriage return and indent
 80 | ;;;   <indent-level> spaces.
 81 | 
 82 | (DEFUN LINEAR-DISPLA1 (X INDENT)
 83 |        (LET ((CHARS (MSTRING X)))
 84 | 	    (DO ((END-COLUMN  (- (LINEL T) 3.))
 85 | 		 (CHARS CHARS (CDR CHARS))
 86 | 		 (I (CHARPOS T) (1+ I))
 87 | 		 (J (FIND-NEXT-BREAK CHARS) (1- J)))
 88 | 		((NULL CHARS) T)
 89 | 		(TYO (CAR CHARS))
 90 | 		(COND ((< J 1)
 91 | 		       (SETQ J (FIND-NEXT-BREAK (CDR CHARS)))
 92 | 		       (COND ((> (+ I J) END-COLUMN)
 93 | 			      (TERPRI)
 94 | 			      (DO ((I 0. (1+ I))) ((= I INDENT)) (TYO 32.))
 95 | 			      (SETQ I INDENT))))
 96 | 		      ((= I END-COLUMN)
 97 | 		       (PRINC '/#)
 98 | 		       (TERPRI)
 99 | 		       (SETQ I -1.))))))
100 | 
101 | 


--------------------------------------------------------------------------------
/maxsrc/mutils.lisp.11:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1980 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module mutils)
 6 | 
 7 | ;;; General purpose Macsyma utilities.  This file contains runtime functions 
 8 | ;;; which perform operations on Macsyma functions or data, but which are
 9 | ;;; too general for placement in a particular file.
10 | ;;;
11 | ;;; Every function in this file is known about externally.
12 | 
13 | 
14 | 
15 | ;;; (ASSOL item A-list)
16 | ;;;
17 | ;;;  Like ASSOC, but uses ALIKE1 as the comparison predicate rather
18 | ;;;  than EQUAL.
19 | ;;;
20 | ;;;  Meta-Synonym:	(ASS #'ALIKE1 ITEM ALIST)
21 | 
22 | (DEFMFUN ASSOL (ITEM ALIST)
23 |   (DOLIST (PAIR ALIST)
24 | 	  (IF (ALIKE1 ITEM (CAR PAIR)) (RETURN PAIR))))
25 | ;;; 
26 | 
27 | (DEFMFUN ASSOLIKE (ITEM ALIST) 
28 |   (CDR (ASSOL ITEM ALIST)))
29 | 
30 | ; Old ASSOLIKE definition:
31 | ;
32 | ; (defun assolike (e l) 
33 | ;	 (prog nil 
34 | ;	  loop (cond ((null l) (return nil))
35 | ;		     ((alike1 e (caar l)) (return (cdar l))))
36 | ;	       (setq l (cdr l))
37 | ;	       (go loop)))
38 | 
39 | ;;; (MEM #'ALIKE1 X L)
40 | 
41 | (DEFMFUN MEMALIKE (X L)
42 |   (DO L L (CDR L) (NULL L)
43 |       (COND ((ALIKE1 X (CAR L)) (RETURN L)))))
44 | 
45 | ;;;Do we want MACROS for these on MC and on Multics?? -Jim 1/29/81
46 | #+Multics
47 | (PROGN 'COMPILE
48 |   (DEFMFUN MSTRINGP (X)
49 |     (AND (SYMBOLP X)
50 | 	 (EQUAL (GETCHARN X 1) #/&)))
51 | 
52 |   (DEFMFUN MSTRING-TO-STRING (X)
53 |     (SUBSTRING (STRING X) 1))
54 | 
55 |   (DEFMFUN STRING-TO-MSTRING (X)
56 |     (MAKE-SYMBOL (STRING-APPEND "&" X)))
57 | )
58 | 


--------------------------------------------------------------------------------
/maxsrc/runtim.lisp.19:
--------------------------------------------------------------------------------
  1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
  2 | ;;;     (c) Copyright 1981 Massachusetts Institute of Technology         ;;;
  3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  4 | 
  5 | (macsyma-module runtim)
  6 | 
  7 | ;; This file contains functions which are also defined as macros in the
  8 | ;; standard Macsyma environment.  They are defined here for the benefit
  9 | ;; interpreted code in the fix file.  This file is used only in the ITS
 10 | ;; implementation, as the Macsyma macros are present at runtime in large
 11 | ;; address space systems.
 12 | 
 13 | ;; The above comment is idiotic. These functions are open-codeable,
 14 | ;; and defined as macros only for efficiency. However, the correct
 15 | ;; way to hack efficiency is through compiler:optimizers, which is
 16 | ;; what we use now. This file is no longer its-only.
 17 | 
 18 | ;; Defined in LIBMAX;MAXMAC.
 19 | 
 20 | ;(DEFUN COPY (L) (SUBST NIL NIL L))  
 21 | ;(DEFUN COPY1 (X) (APPEND X NIL))
 22 | 
 23 | ;; Defined in RAT;RATMAC.
 24 | 
 25 | ;(DEFUN EQN (X Y) (EQUAL X Y))
 26 | ;(DEFUN PCOEFP (X) (ATOM X))
 27 | ;(DEFUN PZEROP (L) (SIGNP E L))
 28 | ;(DEFUN RCINV (X) (RATINVERT X))
 29 | 
 30 | ;; Defined in RAT;LESFAC.
 31 | 
 32 | ;(DEFUN GETDIS (X) (GET X 'DISREP))
 33 | ;(DEFUN CONS1 (X) (CONS X 1))
 34 | 
 35 | ;; Defined in LIBMAX;MAXMAC.
 36 | 
 37 | ;(DEFPROP ERLIST ERLIST1 EXPR)
 38 | 
 39 | ;; Subr definitions of ADD* and MUL* needed at runtime for functions generated
 40 | ;; by TRANSL.  If a function is defined as both a macro and a function, the
 41 | ;; compiler expands the macro, but still puts the function definitions in the
 42 | ;; fasl.  We don't need these on the Lisp Machine or Multics since macros are
 43 | ;; around at run time. 
 44 | 
 45 | ;; ADD and MUL to be flushed shortly.  Around for compatibility only.
 46 | ;; (another CWH comment????) -gjc
 47 | 
 48 | #+PDP10
 49 | (PROGN 'COMPILE
 50 |        (DEFUN ADD (&REST L) (SIMPLIFYA (CONS '(MPLUS) L) t))
 51 |        (DEFUN MUL (&REST L) (SIMPLIFYA (CONS '(MTIMES) L) t))
 52 |        (DEFUN ADD* (&REST L) (SIMPLIFYA (CONS '(MPLUS) L) nil))
 53 |        (DEFUN MUL* (&REST L) (SIMPLIFYA (CONS '(MTIMES) L) nil)))
 54 | 
 55 | #+NIL
 56 | (PROGN 'COMPILE
 57 |        (DEFUN ADD (&RESTL L) (SIMPLIFYA (CONS '(MPLUS) L) t))
 58 |        (DEFUN MUL (&RESTL L) (SIMPLIFYA (CONS '(MTIMES) L) t))
 59 |        (DEFUN ADD* (&RESTL L) (SIMPLIFYA (CONS '(MPLUS) L) nil))
 60 |        (DEFUN MUL* (&RESTL L) (SIMPLIFYA (CONS '(MTIMES) L) nil))
 61 | 
 62 | (DEFUN SETF-MGET (A B VALUE) (MPUTPROP A VALUE B))
 63 | 
 64 | (DEFUN SETF-$GET (A B VALUE) ($PUT A VALUE B))
 65 | )
 66 | 
 67 | #+LISPM
 68 | (PROGN 'COMPILE
 69 | 
 70 | ;; on the LISPM the &REST list is a stack-allocated cdr-coded list.
 71 | ;; We have to copy it, so might as well try out some optimizations.
 72 | 
 73 | (DEFUN ADD (&REST V)
 74 |   (DO ((L NIL)(R)
 75 | 	      (ACC 0))
 76 |       ((NULL V)
 77 |        (IF (NULL L)
 78 | 	   ACC
 79 | 	   (IF (ZEROP ACC)
 80 | 	       (SIMPLIFYA (CONS '(MPLUS) L) T)
 81 | 	       (SIMPLIFYA (LIST* '(MPLUS) ACC L) T))))
 82 |     (SETQ R (POP V))
 83 |     (IF (NUMBERP R)
 84 | 	(SETQ ACC (PLUS R ACC))
 85 | 	(PUSH R L))))
 86 | 
 87 | (DEFUN MUL (&REST V)
 88 |   (DO ((L NIL)(R)
 89 | 	      (ACC 1))
 90 |       ((NULL V)
 91 |        (IF (NULL L)
 92 | 	   ACC
 93 | 	   (IF (EQUAL ACC 1)
 94 | 	       (SIMPLIFYA (CONS '(MTIMES) L) T)
 95 | 	       (SIMPLIFYA (LIST* '(MTIMES) ACC L) T))))
 96 |     (SETQ R (POP V))
 97 |     (IF (NUMBERP R)
 98 | 	(SETQ ACC (TIMES R ACC))
 99 | 	(PUSH R L))))
100 | 
101 | (DEFUN ADD* (&REST L) (SIMPLIFYA (CONS '(MPLUS) (copylist L)) nil))
102 | (DEFUN MUL* (&REST L) (SIMPLIFYA (CONS '(MTIMES)(copylist L)) nil))
103 | 
104 | )


--------------------------------------------------------------------------------
/mrg/scs.lisp.60:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1980 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module scs)
 6 | 
 7 | (DECLARE (*EXPR $RATSUBST CONSSIZE))
 8 | 
 9 | (DEFMFUN $SCSIMP N 
10 |   (DO ((I N (1- I)) (ZRS)) ((= 1 I) (SCS (ARG 1) ZRS))
11 |       (SETQ ZRS (CONS (IFN (EQ 'MEQUAL (CAAR (ARG I))) (ARG I)
12 | 			   (SUB (CADR (ARG I)) (CADDR (ARG I)))) ZRS))))
13 | 
14 | (DEFUN SCS (X ZRS)
15 |   (DO ((FLAG T) (SZ (CONSSIZE X)) (NX) (NSZ)) ((NOT FLAG) X)
16 |       (DO ((L ZRS (CDR L))) ((NULL L) (SETQ FLAG NIL))
17 | 	  (SETQ NX (SUBSCS 0 (CAR L) X) NSZ (CONSSIZE NX))
18 | 	  (IF (< NSZ SZ) (RETURN (SETQ X NX SZ NSZ))))))
19 | 
20 | (DEFUN SUBSCS (A B C)
21 |   (COND ((ATOM B) (SUBSC A B C))
22 | 	((EQ 'MPLUS (CAAR B))
23 | 	 (DO ((L (CDR B) (CDR L)) (SZ (CONSSIZE C)) (NL) (NC) (NSZ)) ((NULL L) C)
24 | 	     (SETQ NC (SUBSCS (SUB A (ADDN (RECONC NL (CDR L)) T)) (CAR L) C)
25 | 		   NSZ (CONSSIZE NC) NL (CONS (CAR L) NL))
26 | 	     (IF (< NSZ SZ) (SETQ C NC SZ NSZ))))
27 | 	(T (SUBSC A B C))))
28 | 
29 | (DEFUN SUBSC (A B C) ($EXPAND ($RATSUBST A B C)))
30 | 
31 | (DEFMFUN $DISTRIB (EXP)
32 |   (COND ((OR (MNUMP EXP) (SYMBOLP EXP)) EXP)
33 | 	((EQ 'MTIMES (CAAR EXP))
34 | 	 (SETQ EXP (MAPCAR '$DISTRIB (CDR EXP)))
35 | 	 (DO ((L (CDR EXP) (CDR L))
36 | 	      (NL (IF (MPLUSP (CAR EXP)) (CDAR EXP) (LIST (CAR EXP)))))
37 | 	     ((NULL L) (ADDN NL T))
38 | 	     (IF (MPLUSP (CAR L))
39 | 		 (DO ((M (CDAR L) (CDR M)) (ML)) ((NULL M) (SETQ NL ML))
40 | 		     (SETQ ML (DSTRB (CAR M) NL ML)))
41 | 		 (SETQ NL (DSTRB (CAR L) NL NIL)))))
42 | 	((EQ 'MEQUAL (CAAR EXP))
43 | 	 (LIST '(MEQUAL) ($DISTRIB (CADR EXP)) ($DISTRIB (CADDR EXP))))
44 | 	((EQ 'MRAT (CAAR EXP)) ($DISTRIB (RATDISREP EXP)))
45 | 	(T EXP)))
46 | 
47 | (DEFUN DSTRB (X L NL)
48 |   (DO () ((NULL L) NL)
49 |       (SETQ NL (CONS (MUL X (CAR L)) NL) L (CDR L))))
50 | 
51 | (DEFMFUN $FACOUT (X Y)
52 |   (IFN (EQ 'MPLUS (CAAR Y)) Y
53 |        (MUL X (ADDN (MAPCAR #'(LAMBDA (L) (DIV L X)) (CDR Y)) T))))
54 | 


--------------------------------------------------------------------------------
/rat/ratmac.lisp.30:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1980 Massachusetts Institute of Technology         ;;;
 3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 4 | 
 5 | (macsyma-module ratmac macro)
 6 | 
 7 | ;; Macros for manipulating rational functions.
 8 | 
 9 | (DEFMACRO PCOEFP (E) `(ATOM ,E))
10 | (DEFMACRO PZEROP (X) `(SIGNP E ,X))			;TRUE FOR 0 OR 0.0
11 | (DEFMACRO PZERO () 0)
12 | 
13 | (DEFMACRO PTZEROP (TERMS) `(NULL ,TERMS))		;for poly terms
14 | (DEFMACRO PTZERO () '())
15 | 
16 | (DEFMACRO CZEROP (C) `(SIGNP E ,C))
17 | (DEFMACRO CMINUS (C) `(MINUS ,C))
18 | (DEFMACRO CMINUSP (C) `(MINUSP ,C))
19 | (DEFMACRO CDERIVATIVE (NIL NIL) 0)
20 | 
21 | ;; Similar to REMOVE on the Lisp Machine
22 | (DEFMACRO DELET (ITEM LIST) `(DELETE ,ITEM (APPEND ,LIST NIL)))
23 | 
24 | (DEFMACRO VALGET (ITEM) `(SYMEVAL ,ITEM))
25 | 
26 | (DEFUN ALGV MACRO (L) `(AND $ALGEBRAIC (GET ,(CADR L) 'TELLRAT)))
27 | 
28 | (DEFMACRO EQN (&REST L) `(EQUAL . ,L))
29 | 
30 | (DEFMACRO RZERO () ''(0 . 1))
31 | (DEFMACRO RZEROP (A) `(PZEROP (CAR ,A)))
32 | 
33 | (defmacro PRIMPART (p) `(cadr (oldcontent ,p)))
34 | 
35 | ;;poly constructor
36 | 
37 | (defmacro make-poly (var &optional (terms-or-e nil options?) (c nil e-c?)
38 | 			 (terms nil terms?))
39 |   (cond ((null options?) `(cons ,var '(1 1)))
40 | 	((null e-c?) `(psimp ,var ,terms-or-e))
41 | 	((null terms?) `(list ,var ,terms-or-e ,c))
42 | 	(t `(psimp ,var (list* ,terms-or-e ,c ,terms)))))
43 | 
44 | ;;Poly selector functions
45 | 
46 | (defmacro P-VAR (p) `(car ,p))
47 | 
48 | (defmacro P-TERMS (p) `(cdr ,p))
49 | 
50 | (defmacro P-LC (p) `(caddr ,p))			;leading coefficient
51 | 
52 | (defmacro P-LE (p) `(cadr ,p))
53 | 
54 | (defmacro P-RED (p) `(cdddr ,p))
55 | 
56 | ;;poly terms selectors
57 | 
58 | (defmacro PT-LC (terms) `(cadr ,terms))
59 | 
60 | (defmacro PT-LE (terms) `(car ,terms))
61 | 
62 | (defmacro PT-RED (terms) `(cddr ,terms))
63 | 
64 | ;; Taken from SININT and RISCH.  Somebody document these please.
65 | 
66 | (DEFMACRO R+ (R . L)
67 | 	  (COND ((NULL L) R)
68 | 		(T `(RATPL ,R (R+ ,@L)))))
69 | 
70 | (DEFMACRO R* (R . L)
71 | 	  (COND ((NULL L) R)
72 | 		(T `(RATTI ,R (R* ,@L) T))))
73 | 
74 | (DEFMACRO R- (R . L)
75 | 	  (COND ((NULL L) `(RATMINUS (RATFIX ,R)))
76 | 		(T `(RATDIF (RATFIX ,R) (R+ ,@L)))))
77 | 
78 | 


--------------------------------------------------------------------------------
/rz/macros.lisp.47:
--------------------------------------------------------------------------------
  1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
  2 | ;;;     (c) Copyright 1980 Massachusetts Institute of Technology         ;;;
  3 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  4 | 
  5 | (macsyma-module rzmac macro)
  6 | 
  7 | ;;;   *****************************************************************
  8 | ;;;   ***** MACROS ******* ASSORTED MACROS FOR GENERAL REPRESENTATION *
  9 | ;;;   *****************************************************************
 10 | 
 11 | (defmacro repeat (index limit . body)
 12 | 	  `(do ((,index 0 (1+ ,index)))
 13 | 	      ((not (< ,index ,limit))) . ,body))
 14 | 
 15 | (defmacro logor frobs `(boole 7 . ,frobs))
 16 | 
 17 | (defmacro add-to-set (set frob)
 18 | 	 `((lambda (temp)
 19 | 		   (or (memq temp ,set)
 20 | 		       (setq ,set (cons temp ,set))))
 21 | 	   ,frob))
 22 | 
 23 | #+ITS
 24 | (defmacro compiling ()
 25 | 	  `(and (boundp 'compiler-state)
 26 | 		(not (eq compiler-state 'toplevel))))
 27 | #-ITS
 28 | (defmacro compiling nil t)
 29 | 
 30 | (defun *bind* macro (l)
 31 |        ((lambda (bindings body)
 32 | 		(nconc (list 'do (mapcar (fn (q)
 33 | 					     (cond ((atom q)
 34 | 						    (list q))
 35 | 						   ((eq (cadr q) '|<-|)
 36 | 						    (list (car q) (caddr q)))
 37 | 						   (t q)))
 38 | 					 bindings)
 39 | 			     nil)
 40 | 		       (maplist (fn (x) (cond ((null (cdr x))
 41 | 					       (cons 'return x))
 42 | 					      ((car x))))
 43 | 				body)))
 44 | 	(cadr l) (cddr l)))
 45 | 
 46 | (defmacro displace2 (form new-car new-cdr)
 47 | 	  `(rplaca (rplacd ,form ,new-cdr) ,new-car))
 48 | 
 49 | ;; Returns the negation of VALUE if PREDICATE is true.  Otherwise, just
 50 | ;; returns VALUE.
 51 | 
 52 | (defmacro negate-if (predicate value &aux (temp (gensym)))
 53 | 	  `(let ((,temp ,predicate))
 54 | 		(cond (,temp (neg ,value))
 55 | 		      (t ,value))))
 56 | 
 57 | (defmacro either (which first second)
 58 | 	  `(cond (,which ,first) (,second)))
 59 | 
 60 | ;; Setq's the first variable to VALUE if SWITCH is true, and sets the second
 61 | ;; variable otherwise.
 62 | 
 63 | (defmacro set-either (first-var second-var switch value &aux (temp (gensym)))
 64 | 	  `(let ((,temp ,value))
 65 | 		(cond (,switch (setq ,first-var ,temp))
 66 | 		      (t (setq ,second-var ,temp)))))
 67 | 
 68 | (defmacro \* (&rest l) `(remainder . ,l))
 69 | 
 70 | 
 71 | (comment Symbolic Arithmetic Macros)
 72 | 
 73 | (defmacro m+ body `(add* . ,body))
 74 | 
 75 | (defmacro m* body `(mul* . ,body))
 76 | 
 77 | (defmacro m1+ (x) `(add* 1 ,x))
 78 | 
 79 | (defmacro m1- (x) `(add* -1 ,x))
 80 | 
 81 | (defmacro m// (a1 &optional (a2 nil 2args))
 82 | 	  (cond (2args `(div* ,a1 ,a2))
 83 | 		(t `(inv* ,a1))))
 84 | 
 85 | (defmacro m- (a1 &optional (a2 nil 2args))
 86 | 	  (cond (2args `(sub* ,a1 ,a2))
 87 | 		(t `(mul* -1 ,a1))))
 88 | 
 89 | (defmacro m^ (b e) `(power* ,b ,e))
 90 | 
 91 | (defmacro m+l (l) `(addn ,l nil))
 92 | 
 93 | (defmacro m*l (l) `(muln ,l nil))
 94 | 
 95 | ;With 
 96 | (defmacro m+t body `(add . ,body))
 97 | 
 98 | (defmacro m*t body `(mul . ,body))
 99 | 
100 | (defmacro m1+t (x) `(add 1 ,x))
101 | 
102 | (defmacro m1-t (x) `(add -1 ,x))
103 | 
104 | (defmacro m//t (a1 &optional (a2 nil 2args))
105 | 	  (cond (2args `(div ,a1 ,a2))
106 | 		(t `(inv ,a1))))
107 | 
108 | (defmacro m-t (a1 &optional (a2 nil 2args))
109 | 	  (cond (2args `(sub ,a1 ,a2))
110 | 		(t `(neg ,a1))))
111 | 
112 | (defmacro m^t (b e) `(power ,b ,e))
113 | 
114 | (defmacro m+lt (l) `(addn ,l ,t))
115 | 
116 | (defmacro m*lt (l) `(muln ,l ,t))
117 | 


--------------------------------------------------------------------------------
/transl/evalw.lisp.11:
--------------------------------------------------------------------------------
 1 | ;;; -*- Mode: Lisp; Package: Macsyma -*-
 2 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 3 | ;;;       (c) Copyright 1981 Massachusetts Institute of Technology       ;;;
 4 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 5 | 
 6 | (macsyma-module evalw)
 7 | 
 8 | ;;; Assuming that this will only be a top-level form, it will
 9 | ;;; only be see by MEVAL when a file is batched.
10 | 
11 | ;;; EVAL_WHEN(TRANSLATE,FOO(ME),BAZ())$
12 | ;;; EVAL_WHEN([LOADFILE,BATCH],INITIALIZE())$
13 | 
14 | (DECLARE (SPECIAL $VERSION STATE-PDL BATCONL))
15 | 
16 | ;; Gosh. Seems it was really stupid to have EVAL_WHEN for BATCH and DEMO,
17 | ;; people use it for the most random things. -gjc
18 | 
19 | (DEFMSPEC $EVAL_WHEN (ARGL)
20 |   (SETQ ARGL (CDR ARGL))
21 |   (COND ((OR (< (LENGTH ARGL) 2)
22 | 	     (NOT (OR (ATOM (CAR ARGL))
23 | 		      ($LISTP (CAR ARGL)))))
24 | 	 (MERROR "Bad whens form to EVAL_WHEN~%~M" (CAR ARGL))))
25 |   (LET ((DEMOP #-MAXII (IF (AND (EQ (TYPEP $VERSION) 'FIXNUM)
26 | 				(> $VERSION 296.))
27 | 			   (CADDR BATCONL)
28 | 			   (CADDDR BATCONL))
29 | 	       #+Maxii  NIL)
30 | 	(WHENS (COND (($LISTP (CAR ARGL)) (CDAR ARGL))
31 | 		     (T (LIST (CAR ARGL))))))
32 |     (COND ((COND (#-MAXII (MEMQ 'BATCH STATE-PDL)
33 | 		  #+MAXII T ; foo for now!
34 | 		  (IF DEMOP (OR (MEMQ '$DEMO WHENS) (MEMQ '$BATCH WHENS))
35 | 			    (MEMQ '$BATCH WHENS)))
36 | 		 (T
37 | 		  ;; this is a form typed in on a c-line by
38 | 		  ;; the user. or, perhaps it is inside a
39 | 		  ;; program. Which is an error in the translator.
40 | 		  ;; What *was* I doing here? -gjc
41 | 		  (MEMQ '$TOPLEVEL WHENS)))
42 | 	   `(($EVALUATED_WHEN) ,@(MAPCAR 'MEVAL (CDR ARGL))))
43 | 	  (T
44 | 	   '$NOT_EVALUATED_WHEN))))
45 | 


--------------------------------------------------------------------------------
/transl/transf.lisp.11:
--------------------------------------------------------------------------------
 1 | ;;; -*- Mode: Lisp; Package: Macsyma -*-
 2 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 3 | ;;;       (c) Copyright 1980 Massachusetts Institute of Technology       ;;;
 4 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 5 | 
 6 | ;;; TRANSLATION PROPERTIES FOR MACSYMA OPERATORS AND FUNCTIONS.
 7 | 
 8 | ;;; This file is for list and array manipulation optimizations.
 9 | 
10 | (macsyma-module transf)
11 | 
12 | 
13 | (TRANSL-MODULE TRANSF)
14 | 
15 | ;;; some floating point translations. with tricks.
16 | 
17 | (DEF%TR %LOG (FORM) 
18 |   (LET   (ARG)
19 |     (SETQ ARG (TRANSLATE (CADR FORM)))
20 |     (COND ((AND (EQ (CAR ARG) '$FLOAT) (GET (CAAR FORM) 'LISP-FUNCTION-TO-USE))
21 | 	   `($FLOAT ,(GET (CAAR FORM) 'LISP-FUNCTION-TO-USE) ,(CDR ARG)))
22 | 	  (T `($ANY SIMPLIFY (LIST ',(LIST (CAAR FORM)) ,(CDR ARG)))))))
23 | 
24 | (DEF-SAME%TR %SIN %LOG)
25 | (DEF-SAME%TR %COS %LOG)
26 | (DEF-SAME%TR %TAN %LOG)
27 | (DEF-SAME%TR %COT %LOG)
28 | (DEF-SAME%TR %CSC %LOG)
29 | (DEF-SAME%TR %SEC %LOG)
30 | (DEF-SAME%TR %ACOT %LOG)
31 | (DEF-SAME%TR %SINH %LOG)
32 | (DEF-SAME%TR %COSH %LOG)
33 | (DEF-SAME%TR %TANH %LOG)
34 | (DEF-SAME%TR %COTH %LOG)
35 | (DEF-SAME%TR %CSCH %LOG)
36 | (DEF-SAME%TR %SECH %LOG)
37 | (DEF-SAME%TR %ASINH %LOG)
38 | (DEF-SAME%TR %ACSCH %LOG)
39 | (DEF-SAME%TR %ERF %LOG)
40 | 
41 | (comment not used
42 | ; defsubr1 is also obsolete. see DEF-PROCEDURE-PROPERTY.
43 | (DEFsubr1 TRANSLATE-$NUMBER (FORM) 
44 |   (LET   (ARG)
45 |     (SETQ ARG (TRANSLATE (CADR FORM)))
46 |     (IF (AND (COVERS '$NUMBER (CAR ARG)) (GET (CAAR FORM) 'LISP-FUNCTION-TO-USE))
47 | 	(LIST (CAR ARG) (GET (CAAR FORM) 'LISP-FUNCTION-TO-USE) (CDR ARG))
48 | 	(CONS (CAR ARG) `(SIMPLIFY (LIST ',(LIST (CAAR FORM)) ,(CDR ARG))))))))
49 | 
50 | 
51 | (DEFMVAR $TR_FLOAT_CAN_BRANCH_COMPLEX T
52 | 	 "States wether the arc functions might return complex
53 | 	 results. The arc functions are SQRT,LOG,ACOS, etc.
54 | 	 e.g. When it is TRUE then ACOS(X) will be of mode ANY even if X is
55 | 	 of mode FLOAT. When FALSE then ACOS(X) will be of mode FLOAT
56 | 	 if and only if X is of mode FLOAT.")
57 | 
58 | (def%TR %ACOS (form)
59 |   (LET ((arg (translate (cadr form))))
60 |     (cond ((and (eq (car arg) '$float)
61 | 		(get (caar form) 'lisp-function-to-use))
62 | 	   `(,(cond ($TR_FLOAT_CAN_BRANCH_COMPLEX
63 | 		     '$ANY)
64 | 		    (T '$FLOAT))
65 | 	     . (,(GET (CAAR FORM) 'LISP-FUNCTION-TO-USE)
66 | 		,(CDR ARG))))
67 | 	  (T
68 | 	   `($ANY . (SIMPLIFY (LIST '(,(CAAR FORM)) ,(CDR ARG))))))))
69 | 
70 | (DEF-SAME%TR %ASIN %ACOS)
71 | (DEF-SAME%TR %ASEC %ACOS)
72 | (DEF-SAME%TR %ASEC %ACOS)
73 | (DEF-SAME%TR %ACSC %ACOS)
74 | 


--------------------------------------------------------------------------------
/transl/trdata.lisp.67:
--------------------------------------------------------------------------------
 1 | ;;; -*- Mode: Lisp; Package: Macsyma -*-
 2 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 3 | ;;; If you see bogus or missing data here, please tell GJC or JPG.	 ;;;
 4 | ;;;       (c) Copyright 1981 Massachusetts Institute of Technology       ;;;
 5 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 6 | 
 7 | (macsyma-module trdata)
 8 | 
 9 | ;;; N.B. This is some data. Boy, does it have subtle effect on the code
10 | ;;; produced by TRANSLATE. It should be carefully checked and updated.
11 | ;;; Since it is so small, and compiles so quickly it sometimes serves
12 | ;;; as a fix (i.e. hack) file. so be careful.
13 | 
14 | 
15 | (TRANSL-MODULE TRDATA)
16 | 
17 | (EVAL-WHEN (COMPILE)
18 | 	   (SETQ *DEF%TR-PRODUCES-AUTOLOAD-FILE* NIL))
19 | 
20 | ;; this should go someplace else perhaps.
21 | 
22 | (DEF-AUTOLOAD-TRANSLATE $romberg $interpolate)
23 | 
24 | ;;; MODEDECLARE(FUNCTION(LENGTH),FIXNUM)
25 | 
26 | (MAPC '(LAMBDA (X) (PUTPROP X '$FIXNUM 'FUNCTION-MODE))
27 |       '($LENGTH $NTERMS RANDOM $NROOTS $RANK $POLYSIGN $TIME
28 | 		$ARRAY_DIMENSION_N))
29 | 
30 | ;;; MODEDECLARE(FUNCTION(ROMBERG_SUBR),FLOAT)
31 | ;;; ROMBERG is a macsyma macro.
32 | 
33 | (MAPC '(LAMBDA (X) (PUTPROP X '$FLOAT 'FUNCTION-MODE))
34 |       '($ROMBERG_SUBR $INTERPOLATE_SUBR))
35 | 
36 | ;;; Functions of BOOLEAN return VALUE. i.e. PREDICATES
37 | 
38 | (MAPC '(LAMBDA (X) (PUTPROP X '$BOOLEAN 'FUNCTION-MODE))
39 |       '($ARRAY $BFLOATP $LISTP $MATRIXP $RATNUMP $CONSTANTP
40 | 	$ATOM $FREEOF $subvarp $SYMBOLP
41 | 	$evenp $oddp $orderlessp $ordergreatp $mapatom
42 | 	$INTEGERP $FLOATNUMP $NONSCALARP $NUMBERP $RATP $MEMBER
43 | 	$EMPTYP))
44 | 
45 | ;;; MODEDECLARE(TRUE,BOOLEAN)
46 | 
47 | (MAPC '(LAMBDA (X) (PUTPROP X '$BOOLEAN 'MODE))
48 |       '($TRUE $FALSE $DOALLMXOPS $DOMXMXOPS $DOSCMXOPS $DETOUT
49 | 	      $DOTASSOC $DOTDISTRIB $DOTSCRULES $EXPONENTIALIZE
50 | 	      $KEEPFLOAT $LISTARITH $LOGEXPAND $LOGSIMP
51 | 	      $MAXAPPLYHEIGHT $MAXAPPLYDEPTH $MAPERROR $POWERDISP
52 | 	      $SCALARMATRIX $SIMP $TTYOFF $UNDERFLOW $INFEVAL
53 | 	      $XAXIS $YAXIS $LOADPRINT
54 | 	      $RATFAC 
55 | 	      ))
56 | 
57 | (MAPC '(LAMBDA (X) (PUTPROP X (STRIPDOLLAR X) 'LISP-FUNCTION-TO-USE))
58 |       '(%LOG %SIN %COS %TAN %COT %CSC %SEC %ACOT
59 | 	     %ASIN %ACOS %ACSC %ASEC
60 | 	%SINH %COSH %TANH %COTH %CSCH %SECH %ASINH %ACSCH %ERF))
61 | 
62 | (MAPC '(LAMBDA (X) (PUTPROP X T 'IMPLIED-QUOTEP))
63 |       '($EVAL $DONE $%I $%PI $%E $%PHI $%GAMMA
64 | 	      MQAPPLY ; important for array referencing conventions.
65 | 	      ))
66 | 
67 | 
68 | ;;; The result of a part function never needs simplification.
69 | ;;;  $CONS for example has the same property, although it
70 | ;;; is not a "PART" function.
71 | 
72 | ;;; ELL has just shown a bug with FIRST and REST interaction with
73 | ;;; DEFMATCH and MATCHDECLARE. The extra simplification needed
74 | ;;; it seems. LIST mode must be implemented, untill then the
75 | ;;; cost of the extra SIMPLFY call is not much compared with the
76 | ;;; consing involved. Above all, we must have correct code !!!
77 | 
78 | (MAPC '(LAMBDA (L) (PUTPROP L t 'TR-NOSIMP))
79 |       '(;$FIRST $REST $LAST
80 | 	$PRINT
81 | 	$NUM $DENOM $LHS $RHS $PART
82 | 	$CONS $REVERSE $ENDCONS $APPEND
83 | 	$UNION $INTERSECTION $SETDIFF $SYMDIFF
84 | 	$MAPSET $PREDSET |${| $ELEMENTOF
85 | 	))
86 | 
87 | (DEFPROP $REALPART $REALPART LISP-FUNCTION-TO-USE)
88 | 
89 | 


--------------------------------------------------------------------------------
/transl/trprop.lisp.1:
--------------------------------------------------------------------------------
 1 | ;;;;;;;;;;;;;;;;;;; -*- Mode: Lisp; Package: Macsyma -*- ;;;;;;;;;;;;;;;;;;;
 2 | ;;;     (c) Copyright 1981 Massachusetts Institute of Technology         ;;;
 3 | ;;;                 GJC 10:11pm  Tuesday, 14 July 1981                   ;;;
 4 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 5 | 
 6 | (macsyma-module trprop)
 7 | 
 8 | ;; Many macsyma extension commands, e.g. $INFIX, $TELLSIMP,
 9 | ;; $DEFTAYLOR work by doing explicit PUTPROPS.
10 | ;; These META-PROP functions allow selected commands to
11 | ;; also output DEFPROP's when processed in the Macsyma->lisp translation.
12 | 
13 | (DEFMVAR META-PROP-P NIL)
14 | (DEFMVAR META-PROP-L NIL)
15 | 
16 | (DEFUN META-OUTPUT (FORM)
17 |   (IF *IN-TRANSLATE-FILE* (PUSH FORM META-PROP-L))
18 |   ;; unfortunately, MATCOM needs to see properties in order
19 |   ;; to compose tellsimps. so eval it always.
20 |   (EVAL FORM))
21 | 
22 | (DEFMFUN META-ADD2LNC (ITEM SYMBOL)
23 |   (IF META-PROP-P
24 |       (META-OUTPUT `(ADD2LNC ',ITEM ,SYMBOL))
25 |       (ADD2LNC ITEM (SYMEVAL SYMBOL))))
26 | 
27 | (DEFMFUN META-PUTPROP (SYMBOL ITEM KEY)
28 |   (IF META-PROP-P
29 |       (PROG1 ITEM (META-OUTPUT `(DEFPROP ,SYMBOL ,ITEM ,KEY)))
30 |       (PUTPROP SYMBOL ITEM KEY)))
31 | 
32 | (DEFMFUN META-MPUTPROP (SYMBOL ITEM KEY)
33 |   (IF META-PROP-P
34 |       (PROG1 ITEM (META-OUTPUT `(MDEFPROP ,SYMBOL ,ITEM ,KEY)))
35 |       (MPUTPROP SYMBOL ITEM KEY)))
36 | 
37 | (DEFMFUN META-FSET (SYMBOL DEFINITION)
38 |   (IF META-PROP-P
39 |       (PROG1 DEFINITION (META-OUTPUT `(FSET ',SYMBOL ',DEFINITION)))
40 |       (FSET SYMBOL DEFINITION)))
41 | 


--------------------------------------------------------------------------------