\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{\$SPAD/src/algebra outform.spad}
\author{Stephen M. Watt}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\section{package NUMFMT NumberFormats}
<<package NUMFMT NumberFormats>>=
)abbrev package NUMFMT NumberFormats
++ SMW March 88
++ Keywords: string manipulation, roman numerals, format
++ Description:
++ NumberFormats provides function to format and read arabic and
++ roman numbers, to convert numbers to strings and to read
++ floating-point numbers.
NumberFormats(): NFexports == NFimplementation where
PI ==> PositiveInteger
I ==> Integer
C ==> Character
F ==> Float
S ==> String
V ==> PrimitiveArray
NFexports ==> with
FormatArabic: PI -> S
++ FormatArabic(n) forms an Arabic numeral
++ string from an integer n.
ScanArabic: S -> PI
++ ScanArabic(s) forms an integer from an Arabic numeral string s.
FormatRoman: PI -> S
++ FormatRoman(n) forms a Roman numeral string from an integer n.
ScanRoman: S -> PI
++ ScanRoman(s) forms an integer from a Roman numeral string s.
ScanFloatIgnoreSpaces: S -> F
++ ScanFloatIgnoreSpaces(s) forms a floating point number from
++ the string s ignoring any spaces. Error is generated if the
++ string is not recognised as a floating point number.
ScanFloatIgnoreSpacesIfCan: S -> Union(F, "failed")
++ ScanFloatIgnoreSpacesIfCan(s) tries to form a floating point number from
++ the string s ignoring any spaces.
NFimplementation ==> add
import SExpression
import Symbol
replaceD: C -> C
replaced: C -> C
contract: S -> S
check: S ->Boolean
replaceD c ==
if c = char "D" then char "E" else c
replaced c ==
if c = char "d" then char "E" else c
contract s ==
s:= map(replaceD,s)
s:= map(replaced,s)
ls:List S := split(s,char " ")$String
s:= concat ls
check s ==
NUMBERP(READ_-FROM_-STRING(s)$Lisp)$Lisp and
-- if there is an "E" then there must be a "."
-- this is not caught by code above
-- also if the exponent is v.big the above returns false
not (any?(#1=char "E",s) and not any?(#1=char ".",s) )
-- Original interpreter function:
-- )lis (defun scanstr(x) (spadcomp::|parseFromString| x))
sexfloat:SExpression:=convert(coerce("Float")@Symbol)$SExpression
ScanFloatIgnoreSpaces s ==
s := contract s
not check s => error "Non-numeric value"
sex := interpret(packageTran(ncParseFromString(s)$Lisp)$Lisp)$Lisp
sCheck := car(car(sex))
if (sCheck=sexfloat) = true then
f := (cdr cdr sex) pretend Float
else
if integer?(cdr sex) = true then
f := (cdr sex) pretend Integer
f::F
else
error "Non-numeric value"
ScanFloatIgnoreSpacesIfCan s ==
s := contract s
not check s => "failed"
sex := interpret(packageTran(ncParseFromString(s)$Lisp)$Lisp)$Lisp
sCheck := car(car(sex))
if (sCheck=sexfloat) = true then
f := (cdr cdr sex) pretend Float
else
if integer?(cdr sex) = true then
f := (cdr sex) pretend Integer
f::F
else
"failed"
units:V S :=
construct ["","I","II","III","IV","V","VI","VII","VIII","IX"]
tens :V S :=
construct ["","X","XX","XXX","XL","L","LX","LXX","LXXX","XC"]
hunds:V S :=
construct ["","C","CC","CCC","CD","D","DC","DCC","DCCC","CM"]
umin := minIndex units
tmin := minIndex tens
hmin := minIndex hunds
romval:V I := new(256, -1)
romval ord char(" ")$C := 0
romval ord char("I")$C := 1
romval ord char("V")$C := 5
romval ord char("X")$C := 10
romval ord char("L")$C := 50
romval ord char("C")$C := 100
romval ord char("D")$C := 500
romval ord char("M")$C := 1000
thou:C := char "M"
plen:C := char "("
pren:C := char ")"
ichar:C := char "I"
FormatArabic n == STRINGIMAGE(n)$Lisp
ScanArabic s == PARSE_-INTEGER(s)$Lisp
FormatRoman pn ==
n := pn::Integer
-- Units
d := (n rem 10) + umin
n := n quo 10
s := units.d
zero? n => s
-- Tens
d := (n rem 10) + tmin
n := n quo 10
s := concat(tens.d, s)
zero? n => s
-- Hundreds
d := (n rem 10) + hmin
n := n quo 10
s := concat(hunds.d, s)
zero? n => s
-- Thousands
d := n rem 10
n := n quo 10
s := concat(new(d::NonNegativeInteger, thou), s)
zero? n => s
-- Ten thousand and higher
for i in 2.. while not zero? n repeat
-- Coefficient of 10**(i+2)
d := n rem 10
n := n quo 10
zero? d => "iterate"
m0:String := concat(new(i,plen),concat("I",new(i,pren)))
mm := concat([m0 for j in 1..d]$List(String))
-- strictly speaking the blank is gratuitous
if #s > 0 then s := concat(" ", s)
s := concat(mm, s)
s
-- ScanRoman
--
-- The Algorithm:
-- Read number from right to left. When the current
-- numeral is lower in magnitude than the previous maximum
-- then subtract otherwise add.
-- Shift left and repeat until done.
ScanRoman s ==
s := upperCase s
tot: I := 0
Max: I := 0
i: I := maxIndex s
while i >= minIndex s repeat
-- Read a single roman digit
c := s.i; i := i-1
n := romval ord c
-- (I)=1000, ((I))=10000, (((I)))=100000, etc
if n < 0 then
c ~= pren =>
error ["Improper character in Roman numeral: ",c]
nprens: PI := 1
while c = pren and i >= minIndex s repeat
c := s.i; i := i-1
if c = pren then nprens := nprens+1
c ~= ichar =>
error "Improper Roman numeral: (x)"
for k in 1..nprens while i >= minIndex s repeat
c := s.i; i := i-1
c ~= plen =>
error "Improper Roman numeral: unbalanced ')'"
n := 10**(nprens + 2)
if n < Max then
tot := tot - n
else
tot := tot + n
Max := n
tot < 0 => error ["Improper Roman numeral: ", tot]
tot::PI
@
\section{domain OUTFORM OutputForm}
<<domain OUTFORM OutputForm>>=
)abbrev domain OUTFORM OutputForm
++ Keywords: output, I/O, expression
++ SMW March/88
++ Description:
++ This domain is used to create and manipulate mathematical expressions
++ for output. It is intended to provide an insulating layer between
++ the expression rendering software (e.g.FORTRAN, TeX, or Script) and
++ the output coercions in the various domains.
OutputForm(): SetCategory with
--% Printing
print : $ -> Void
++ print(u) prints the form u.
message: String -> $
++ message(s) creates an form with no string quotes
++ from string s.
messagePrint: String -> Void
++ messagePrint(s) prints s without string quotes. Note:
++ \spad{messagePrint(s)} is equivalent to \spad{print message(s)}.
--% Creation of atomic forms
outputForm: Integer -> $
++ outputForm(n) creates an form for integer n.
outputForm: Symbol -> $
++ outputForm(s) creates an form for symbol s.
outputForm: String -> $
++ outputForm(s) creates an form for string s.
outputForm: DoubleFloat -> $
++ outputForm(sf) creates an form for small float sf.
empty : () -> $
++ empty() creates an empty form.
--% Sizings
width: $ -> Integer
++ width(f) returns the width of form f (an integer).
height: $ -> Integer
++ height(f) returns the height of form f (an integer).
width: -> Integer
++ width() returns the width of the display area (an integer).
height: -> Integer
++ height() returns the height of the display area (an integer).
subHeight: $ -> Integer
++ subHeight(f) returns the height of form f below the base line.
superHeight: $ -> Integer
++ superHeight(f) returns the height of form f above the base line.
--% Space manipulations
hspace: Integer -> $ ++ hspace(n) creates white space of width n.
vspace: Integer -> $ ++ vspace(n) creates white space of height n.
rspace: (Integer,Integer) -> $
++ rspace(n,m) creates rectangular white space, n wide by m high.
--% Area adjustments
left: ($,Integer) -> $
++ left(f,n) left-justifies form f within space of width n.
right: ($,Integer) -> $
++ right(f,n) right-justifies form f within space of width n.
center: ($,Integer) -> $
++ center(f,n) centers form f within space of width n.
left: $ -> $
++ left(f) left-justifies form f in total space.
right: $ -> $
++ right(f) right-justifies form f in total space.
center: $ -> $
++ center(f) centers form f in total space.
--% Area manipulations
hconcat: ($,$) -> $
++ hconcat(f,g) horizontally concatenate forms f and g.
vconcat: ($,$) -> $
++ vconcat(f,g) vertically concatenates forms f and g.
hconcat: List $ -> $
++ hconcat(u) horizontally concatenates all forms in list u.
vconcat: List $ -> $
++ vconcat(u) vertically concatenates all forms in list u.
--% Application formers
prefix: ($, List $) -> $
++ prefix(f,l) creates a form depicting the n-ary prefix
++ application of f to a tuple of arguments given by list l.
infix: ($, List $) -> $
++ infix(f,l) creates a form depicting the n-ary application
++ of infix operation f to a tuple of arguments l.
infix: ($, $, $) -> $
++ infix(op, a, b) creates a form which prints as: a op b.
postfix: ($, $) -> $
++ postfix(op, a) creates a form which prints as: a op.
infix?: $ -> Boolean
++ infix?(op) returns true if op is an infix operator,
++ and false otherwise.
elt: ($, List $) -> $
++ elt(op,l) creates a form for application of op
++ to list of arguments l.
--% Special forms
string: $ -> $
++ string(f) creates f with string quotes.
label: ($, $) -> $
++ label(n,f) gives form f an equation label n.
box: $ -> $
++ box(f) encloses f in a box.
matrix: List List $ -> $
++ matrix(llf) makes llf (a list of lists of forms) into
++ a form which displays as a matrix.
zag: ($, $) -> $
++ zag(f,g) creates a form for the continued fraction form for f over g.
root: $ -> $
++ root(f) creates a form for the square root of form f.
root: ($, $) -> $
++ root(f,n) creates a form for the nth root of form f.
over: ($, $) -> $
++ over(f,g) creates a form for the vertical fraction of f over g.
slash: ($, $) -> $
++ slash(f,g) creates a form for the horizontal fraction of f over g.
assign: ($, $) -> $
++ assign(f,g) creates a form for the assignment \spad{f := g}.
rarrow: ($, $) -> $
++ rarrow(f,g) creates a form for the mapping \spad{f -> g}.
differentiate: ($, NonNegativeInteger) -> $
++ differentiate(f,n) creates a form for the nth derivative of f,
++ e.g. \spad{f'}, \spad{f''}, \spad{f'''},
++ "f super \spad{iv}".
binomial: ($, $) -> $
++ binomial(n,m) creates a form for the binomial coefficient of n and m.
--% Scripts
sub: ($, $) -> $
++ sub(f,n) creates a form for f subscripted by n.
super: ($, $) -> $
++ super(f,n) creates a form for f superscripted by n.
presub: ($, $) -> $
++ presub(f,n) creates a form for f presubscripted by n.
presuper:($, $) -> $
++ presuper(f,n) creates a form for f presuperscripted by n.
scripts: ($, List $) -> $
++ \spad{scripts(f, [sub, super, presuper, presub])}
++ creates a form for f with scripts on all 4 corners.
supersub:($, List $) -> $
++ supersub(a,[sub1,super1,sub2,super2,...])
++ creates a form with each subscript aligned
++ under each superscript.
--% Diacritical marks
quote: $ -> $
++ quote(f) creates the form f with a prefix quote.
dot: $ -> $
++ dot(f) creates the form with a one dot overhead.
dot: ($, NonNegativeInteger) -> $
++ dot(f,n) creates the form f with n dots overhead.
prime: $ -> $
++ prime(f) creates the form f followed by a suffix prime (single quote).
prime: ($, NonNegativeInteger) -> $
++ prime(f,n) creates the form f followed by n primes.
overbar: $ -> $
++ overbar(f) creates the form f with an overbar.
overlabel: ($, $) -> $
++ overlabel(x,f) creates the form f with "x overbar" over the top.
--% Plexes
sum: ($) -> $
++ sum(expr) creates the form prefixing expr by a capital sigma.
sum: ($, $) -> $
++ sum(expr,lowerlimit) creates the form prefixing expr by
++ a capital sigma with a lowerlimit.
sum: ($, $, $) -> $
++ sum(expr,lowerlimit,upperlimit) creates the form prefixing expr by
++ a capital sigma with both a lowerlimit and upperlimit.
prod: ($) -> $
++ prod(expr) creates the form prefixing expr by a capital pi.
prod: ($, $) -> $
++ prod(expr,lowerlimit) creates the form prefixing expr by
++ a capital pi with a lowerlimit.
prod: ($, $, $) -> $
++ prod(expr,lowerlimit,upperlimit) creates the form prefixing expr by
++ a capital pi with both a lowerlimit and upperlimit.
int: ($) -> $
++ int(expr) creates the form prefixing expr with an integral sign.
int: ($, $) -> $
++ int(expr,lowerlimit) creates the form prefixing expr by an
++ integral sign with a lowerlimit.
int: ($, $, $) -> $
++ int(expr,lowerlimit,upperlimit) creates the form prefixing expr by
++ an integral sign with both a lowerlimit and upperlimit.
--% Matchfix forms
brace: $ -> $
++ brace(f) creates the form enclosing f in braces (curly brackets).
brace: List $ -> $
++ brace(lf) creates the form separating the elements of lf
++ by commas and encloses the result in curly brackets.
bracket: $ -> $
++ bracket(f) creates the form enclosing f in square brackets.
bracket: List $ -> $
++ bracket(lf) creates the form separating the elements of lf
++ by commas and encloses the result in square brackets.
paren: $ -> $
++ paren(f) creates the form enclosing f in parentheses.
paren: List $ -> $
++ paren(lf) creates the form separating the elements of lf
++ by commas and encloses the result in parentheses.
--% Separators for aggregates
pile: List $ -> $
++ pile(l) creates the form consisting of the elements of l which
++ displays as a pile, i.e. the elements begin on a new line and
++ are indented right to the same margin.
commaSeparate: List $ -> $
++ commaSeparate(l) creates the form separating the elements of l
++ by commas.
semicolonSeparate: List $ -> $
++ semicolonSeparate(l) creates the form separating the elements of l
++ by semicolons.
blankSeparate: List $ -> $
++ blankSeparate(l) creates the form separating the elements of l
++ by blanks.
--% Specific applications
"=": ($, $) -> $
++ f = g creates the equivalent infix form.
"~=": ($, $) -> $
++ f ~= g creates the equivalent infix form.
"<": ($, $) -> $
++ f < g creates the equivalent infix form.
">": ($, $) -> $
++ f > g creates the equivalent infix form.
"<=": ($, $) -> $
++ f <= g creates the equivalent infix form.
">=": ($, $) -> $
++ f >= g creates the equivalent infix form.
"+": ($, $) -> $
++ f + g creates the equivalent infix form.
"-": ($, $) -> $
++ f - g creates the equivalent infix form.
"-": ($) -> $
++ - f creates the equivalent prefix form.
"*": ($, $) -> $
++ f * g creates the equivalent infix form.
"/": ($, $) -> $
++ f / g creates the equivalent infix form.
"**": ($, $) -> $
++ f ** g creates the equivalent infix form.
"div": ($, $) -> $
++ f div g creates the equivalent infix form.
"rem": ($, $) -> $
++ f rem g creates the equivalent infix form.
"quo": ($, $) -> $
++ f quo g creates the equivalent infix form.
"exquo": ($, $) -> $
++ exquo(f,g) creates the equivalent infix form.
"and": ($, $) -> $
++ f and g creates the equivalent infix form.
"or": ($, $) -> $
++ f or g creates the equivalent infix form.
"not": ($) -> $
++ not f creates the equivalent prefix form.
SEGMENT: ($,$) -> $
++ SEGMENT(x,y) creates the infix form: \spad{x..y}.
SEGMENT: ($) -> $
++ SEGMENT(x) creates the prefix form: \spad{x..}.
== add
import NumberFormats
-- Todo:
-- program forms, greek letters
-- infix, prefix, postfix, matchfix support in OUT BOOT
-- labove rabove, corresponding overs.
-- better super script, overmark, undermark
-- bug in product, paren blankSeparate []
-- uniformize integrals, products, etc as plexes.
cons ==> CONS$Lisp
car ==> CAR$Lisp
cdr ==> CDR$Lisp
Rep := List $
a, b: $
l: List $
s: String
e: Symbol
n: Integer
nn:NonNegativeInteger
sform: String -> $
eform: Symbol -> $
iform: Integer -> $
print x == mathprint(x)$Lisp
message s == (empty? s => empty(); s pretend $)
messagePrint s == print message s
(a:$ = b:$):Boolean == EQUAL(a, b)$Lisp
(a:$ = b:$):$ == [sform "=", a, b]
coerce(a):OutputForm == a pretend OutputForm
outputForm n == n pretend $
outputForm e == e pretend $
outputForm(f:DoubleFloat) == f pretend $
sform s == s pretend $
eform e == e pretend $
iform n == n pretend $
outputForm s ==
sform concat(quote()$Character, concat(s, quote()$Character))
width(a) == outformWidth(a)$Lisp
height(a) == height(a)$Lisp
subHeight(a) == subspan(a)$Lisp
superHeight(a) == superspan(a)$Lisp
height() == 20
width() == 66
center(a,w) == hconcat(hspace((w - width(a)) quo 2),a)
left(a,w) == hconcat(a,hspace((w - width(a))))
right(a,w) == hconcat(hspace(w - width(a)),a)
center(a) == center(a,width())
left(a) == left(a,width())
right(a) == right(a,width())
vspace(n) ==
n = 0 => empty()
vconcat(sform " ",vspace(n - 1))
hspace(n) ==
n = 0 => empty()
sform(fillerSpaces(n)$Lisp)
rspace(n, m) ==
n = 0 or m = 0 => empty()
vconcat(hspace n, rspace(n, m - 1))
matrix ll ==
lv:$ := [LIST2VEC$Lisp l for l in ll]
CONS(eform MATRIX, LIST2VEC$Lisp lv)$Lisp
pile l == cons(eform SC, l)
commaSeparate l == cons(eform AGGLST, l)
semicolonSeparate l == cons(eform AGGSET, l)
blankSeparate l ==
c:=eform CONCATB
l1:$:=[]
for u in reverse l repeat
if EQCAR(u,c)$Lisp
then l1:=[:cdr u,:l1]
else l1:=[u,:l1]
cons(c, l1)
brace a == [eform BRACE, a]
brace l == brace commaSeparate l
bracket a == [eform BRACKET, a]
bracket l == bracket commaSeparate l
paren a == [eform PAREN, a]
paren l == paren commaSeparate l
sub (a,b) == [eform SUB, a, b]
super (a, b) == [eform SUPERSUB,a,sform " ",b]
presub(a,b) == [eform SUPERSUB,a,sform " ",sform " ",sform " ",b]
presuper(a, b) == [eform SUPERSUB,a,sform " ",sform " ",b]
scripts (a, l) ==
null l => a
null rest l => sub(a, first l)
cons(eform SUPERSUB, cons(a, l))
supersub(a, l) ==
if odd?(#l) then l := append(l, [empty()])
cons(eform ALTSUPERSUB, cons(a, l))
hconcat(a,b) == [eform CONCAT, a, b]
hconcat l == cons(eform CONCAT, l)
vconcat(a,b) == [eform VCONCAT, a, b]
vconcat l == cons(eform VCONCAT, l)
a ~= b == [sform "~=", a, b]
a < b == [sform "<", a, b]
a > b == [sform ">", a, b]
a <= b == [sform "<=", a, b]
a >= b == [sform ">=", a, b]
a + b == [sform "+", a, b]
a - b == [sform "-", a, b]
- a == [sform "-", a]
a * b == [sform "*", a, b]
a / b == [sform "/", a, b]
a ** b == [sform "**", a, b]
a div b == [sform "div", a, b]
a rem b == [sform "rem", a, b]
a quo b == [sform "quo", a, b]
a exquo b == [sform "exquo", a, b]
a and b == [sform "and", a, b]
a or b == [sform "or", a, b]
not a == [sform "not", a]
SEGMENT(a,b)== [eform SEGMENT, a, b]
SEGMENT(a) == [eform SEGMENT, a]
binomial(a,b)==[eform BINOMIAL, a, b]
empty() == [eform NOTHING]
infix? a ==
e:$ :=
IDENTP$Lisp a => a
STRINGP$Lisp a => INTERN$Lisp a
return false
if GET(e,QUOTE(INFIXOP$Lisp)$Lisp)$Lisp then true else false
elt(a, l) ==
cons(a, l)
prefix(a,l) ==
not infix? a => cons(a, l)
hconcat(a, paren commaSeparate l)
infix(a, l) ==
null l => empty()
null rest l => first l
infix? a => cons(a, l)
hconcat [first l, a, infix(a, rest l)]
infix(a,b,c) ==
infix? a => [a, b, c]
hconcat [b, a, c]
postfix(a, b) ==
hconcat(b, a)
string a == [eform STRING, a]
quote a == [eform QUOTE, a]
overbar a == [eform OVERBAR, a]
dot a == super(a, sform ".")
prime a == super(a, sform ",")
dot(a,nn) == (s := new(nn, char "."); super(a, sform s))
prime(a,nn) == (s := new(nn, char ","); super(a, sform s))
overlabel(a,b) == [eform OVERLABEL, a, b]
box a == [eform BOX, a]
zag(a,b) == [eform ZAG, a, b]
root a == [eform ROOT, a]
root(a,b) == [eform ROOT, a, b]
over(a,b) == [eform OVER, a, b]
slash(a,b) == [eform SLASH, a, b]
assign(a,b)== [eform LET, a, b]
label(a,b) == [eform EQUATNUM, a, b]
rarrow(a,b)== [eform TAG, a, b]
differentiate(a, nn)==
zero? nn => a
nn < 4 => prime(a, nn)
r := FormatRoman(nn::PositiveInteger)
s := lowerCase(r::String)
super(a, paren sform s)
sum(a) == [eform SIGMA, empty(), a]
sum(a,b) == [eform SIGMA, b, a]
sum(a,b,c) == [eform SIGMA2, b, c, a]
prod(a) == [eform PI, empty(), a]
prod(a,b) == [eform PI, b, a]
prod(a,b,c)== [eform PI2, b, c, a]
int(a) == [eform INTSIGN,empty(), empty(), a]
int(a,b) == [eform INTSIGN,b, empty(), a]
int(a,b,c) == [eform INTSIGN,b, c, a]
@
\section{OUTFORM.lsp BOOTSTRAP}
{\bf OUTFORM} depends on itself.
We need to break this cycle to build the algebra. So we keep a
cached copy of the translated {\bf OUTFORM} category which we can write
into the {\bf MID} directory. We compile the lisp code and copy the
{\bf OUTFORM.o} file to the {\bf OUT} directory. This is eventually
forcibly replaced by a recompiled version.
Note that this code is not included in the generated catdef.spad file.
<<OUTFORM.lsp BOOTSTRAP>>=
(/VERSIONCHECK 2)
(PUT '|OUTFORM;print;$V;1| '|SPADreplace| '|mathprint|)
(DEFUN |OUTFORM;print;$V;1| (|x| $) (|mathprint| |x|))
(DEFUN |OUTFORM;message;S$;2| (|s| $)
(COND
((SPADCALL |s| (QREFELT $ 11)) (SPADCALL (QREFELT $ 12)))
('T |s|)))
(DEFUN |OUTFORM;messagePrint;SV;3| (|s| $)
(SPADCALL (SPADCALL |s| (QREFELT $ 13)) (QREFELT $ 8)))
(PUT '|OUTFORM;=;2$B;4| '|SPADreplace| 'EQUAL)
(DEFUN |OUTFORM;=;2$B;4| (|a| |b| $) (EQUAL |a| |b|))
(DEFUN |OUTFORM;=;3$;5| (|a| |b| $)
(LIST (|OUTFORM;sform| "=" $) |a| |b|))
(PUT '|OUTFORM;coerce;$Of;6| '|SPADreplace| '(XLAM (|a|) |a|))
(DEFUN |OUTFORM;coerce;$Of;6| (|a| $) |a|)
(PUT '|OUTFORM;outputForm;I$;7| '|SPADreplace| '(XLAM (|n|) |n|))
(DEFUN |OUTFORM;outputForm;I$;7| (|n| $) |n|)
(PUT '|OUTFORM;outputForm;S$;8| '|SPADreplace| '(XLAM (|e|) |e|))
(DEFUN |OUTFORM;outputForm;S$;8| (|e| $) |e|)
(PUT '|OUTFORM;outputForm;Df$;9| '|SPADreplace| '(XLAM (|f|) |f|))
(DEFUN |OUTFORM;outputForm;Df$;9| (|f| $) |f|)
(PUT '|OUTFORM;sform| '|SPADreplace| '(XLAM (|s|) |s|))
(DEFUN |OUTFORM;sform| (|s| $) |s|)
(PUT '|OUTFORM;eform| '|SPADreplace| '(XLAM (|e|) |e|))
(DEFUN |OUTFORM;eform| (|e| $) |e|)
(PUT '|OUTFORM;iform| '|SPADreplace| '(XLAM (|n|) |n|))
(DEFUN |OUTFORM;iform| (|n| $) |n|)
(DEFUN |OUTFORM;outputForm;S$;13| (|s| $)
(|OUTFORM;sform|
(SPADCALL (SPADCALL (QREFELT $ 26))
(SPADCALL |s| (SPADCALL (QREFELT $ 26)) (QREFELT $ 27))
(QREFELT $ 28))
$))
(PUT '|OUTFORM;width;$I;14| '|SPADreplace| '|outformWidth|)
(DEFUN |OUTFORM;width;$I;14| (|a| $) (|outformWidth| |a|))
(PUT '|OUTFORM;height;$I;15| '|SPADreplace| '|height|)
(DEFUN |OUTFORM;height;$I;15| (|a| $) (|height| |a|))
(PUT '|OUTFORM;subHeight;$I;16| '|SPADreplace| '|subspan|)
(DEFUN |OUTFORM;subHeight;$I;16| (|a| $) (|subspan| |a|))
(PUT '|OUTFORM;superHeight;$I;17| '|SPADreplace| '|superspan|)
(DEFUN |OUTFORM;superHeight;$I;17| (|a| $) (|superspan| |a|))
(PUT '|OUTFORM;height;I;18| '|SPADreplace| '(XLAM NIL 20))
(DEFUN |OUTFORM;height;I;18| ($) 20)
(PUT '|OUTFORM;width;I;19| '|SPADreplace| '(XLAM NIL 66))
(DEFUN |OUTFORM;width;I;19| ($) 66)
(DEFUN |OUTFORM;center;$I$;20| (|a| |w| $)
(SPADCALL
(SPADCALL (QUOTIENT2 (- |w| (SPADCALL |a| (QREFELT $ 30))) 2)
(QREFELT $ 36))
|a| (QREFELT $ 37)))
(DEFUN |OUTFORM;left;$I$;21| (|a| |w| $)
(SPADCALL |a|
(SPADCALL (- |w| (SPADCALL |a| (QREFELT $ 30))) (QREFELT $ 36))
(QREFELT $ 37)))
(DEFUN |OUTFORM;right;$I$;22| (|a| |w| $)
(SPADCALL
(SPADCALL (- |w| (SPADCALL |a| (QREFELT $ 30))) (QREFELT $ 36))
|a| (QREFELT $ 37)))
(DEFUN |OUTFORM;center;2$;23| (|a| $)
(SPADCALL |a| (SPADCALL (QREFELT $ 35)) (QREFELT $ 38)))
(DEFUN |OUTFORM;left;2$;24| (|a| $)
(SPADCALL |a| (SPADCALL (QREFELT $ 35)) (QREFELT $ 39)))
(DEFUN |OUTFORM;right;2$;25| (|a| $)
(SPADCALL |a| (SPADCALL (QREFELT $ 35)) (QREFELT $ 40)))
(DEFUN |OUTFORM;vspace;I$;26| (|n| $)
(COND
((EQL |n| 0) (SPADCALL (QREFELT $ 12)))
('T
(SPADCALL (|OUTFORM;sform| " " $)
(SPADCALL (- |n| 1) (QREFELT $ 44)) (QREFELT $ 45)))))
(DEFUN |OUTFORM;hspace;I$;27| (|n| $)
(COND
((EQL |n| 0) (SPADCALL (QREFELT $ 12)))
('T (|OUTFORM;sform| (|fillerSpaces| |n|) $))))
(DEFUN |OUTFORM;rspace;2I$;28| (|n| |m| $)
(COND
((OR (EQL |n| 0) (EQL |m| 0)) (SPADCALL (QREFELT $ 12)))
('T
(SPADCALL (SPADCALL |n| (QREFELT $ 36))
(SPADCALL |n| (- |m| 1) (QREFELT $ 46)) (QREFELT $ 45)))))
(DEFUN |OUTFORM;matrix;L$;29| (|ll| $)
(PROG (#0=#:G1437 |l| #1=#:G1438 |lv|)
(RETURN
(SEQ (LETT |lv|
(PROGN
(LETT #0# NIL |OUTFORM;matrix;L$;29|)
(SEQ (LETT |l| NIL |OUTFORM;matrix;L$;29|)
(LETT #1# |ll| |OUTFORM;matrix;L$;29|) G190
(COND
((OR (ATOM #1#)
(PROGN
(LETT |l| (CAR #1#)
|OUTFORM;matrix;L$;29|)
NIL))
(GO G191)))
(SEQ (EXIT (LETT #0# (CONS (LIST2VEC |l|) #0#)
|OUTFORM;matrix;L$;29|)))
(LETT #1# (CDR #1#) |OUTFORM;matrix;L$;29|)
(GO G190) G191 (EXIT (NREVERSE0 #0#))))
|OUTFORM;matrix;L$;29|)
(EXIT (CONS (|OUTFORM;eform| 'MATRIX $) (LIST2VEC |lv|)))))))
(DEFUN |OUTFORM;pile;L$;30| (|l| $)
(CONS (|OUTFORM;eform| 'SC $) |l|))
(DEFUN |OUTFORM;commaSeparate;L$;31| (|l| $)
(CONS (|OUTFORM;eform| 'AGGLST $) |l|))
(DEFUN |OUTFORM;semicolonSeparate;L$;32| (|l| $)
(CONS (|OUTFORM;eform| 'AGGSET $) |l|))
(DEFUN |OUTFORM;blankSeparate;L$;33| (|l| $)
(PROG (|c| |u| #0=#:G1446 |l1|)
(RETURN
(SEQ (LETT |c| (|OUTFORM;eform| 'CONCATB $)
|OUTFORM;blankSeparate;L$;33|)
(LETT |l1| NIL |OUTFORM;blankSeparate;L$;33|)
(SEQ (LETT |u| NIL |OUTFORM;blankSeparate;L$;33|)
(LETT #0# (SPADCALL |l| (QREFELT $ 53))
|OUTFORM;blankSeparate;L$;33|)
G190
(COND
((OR (ATOM #0#)
(PROGN
(LETT |u| (CAR #0#)
|OUTFORM;blankSeparate;L$;33|)
NIL))
(GO G191)))
(SEQ (EXIT (COND
((EQCAR |u| |c|)
(LETT |l1|
(SPADCALL (CDR |u|) |l1|
(QREFELT $ 54))
|OUTFORM;blankSeparate;L$;33|))
('T
(LETT |l1| (CONS |u| |l1|)
|OUTFORM;blankSeparate;L$;33|)))))
(LETT #0# (CDR #0#) |OUTFORM;blankSeparate;L$;33|)
(GO G190) G191 (EXIT NIL))
(EXIT (CONS |c| |l1|))))))
(DEFUN |OUTFORM;brace;2$;34| (|a| $)
(LIST (|OUTFORM;eform| 'BRACE $) |a|))
(DEFUN |OUTFORM;brace;L$;35| (|l| $)
(SPADCALL (SPADCALL |l| (QREFELT $ 51)) (QREFELT $ 56)))
(DEFUN |OUTFORM;bracket;2$;36| (|a| $)
(LIST (|OUTFORM;eform| 'BRACKET $) |a|))
(DEFUN |OUTFORM;bracket;L$;37| (|l| $)
(SPADCALL (SPADCALL |l| (QREFELT $ 51)) (QREFELT $ 58)))
(DEFUN |OUTFORM;paren;2$;38| (|a| $)
(LIST (|OUTFORM;eform| 'PAREN $) |a|))
(DEFUN |OUTFORM;paren;L$;39| (|l| $)
(SPADCALL (SPADCALL |l| (QREFELT $ 51)) (QREFELT $ 60)))
(DEFUN |OUTFORM;sub;3$;40| (|a| |b| $)
(LIST (|OUTFORM;eform| 'SUB $) |a| |b|))
(DEFUN |OUTFORM;super;3$;41| (|a| |b| $)
(LIST (|OUTFORM;eform| 'SUPERSUB $) |a| (|OUTFORM;sform| " " $) |b|))
(DEFUN |OUTFORM;presub;3$;42| (|a| |b| $)
(LIST (|OUTFORM;eform| 'SUPERSUB $) |a| (|OUTFORM;sform| " " $)
(|OUTFORM;sform| " " $) (|OUTFORM;sform| " " $) |b|))
(DEFUN |OUTFORM;presuper;3$;43| (|a| |b| $)
(LIST (|OUTFORM;eform| 'SUPERSUB $) |a| (|OUTFORM;sform| " " $)
(|OUTFORM;sform| " " $) |b|))
(DEFUN |OUTFORM;scripts;$L$;44| (|a| |l| $)
(COND
((SPADCALL |l| (QREFELT $ 66)) |a|)
((SPADCALL (SPADCALL |l| (QREFELT $ 67)) (QREFELT $ 66))
(SPADCALL |a| (SPADCALL |l| (QREFELT $ 68)) (QREFELT $ 62)))
('T (CONS (|OUTFORM;eform| 'SUPERSUB $) (CONS |a| |l|)))))
(DEFUN |OUTFORM;supersub;$L$;45| (|a| |l| $)
(SEQ (COND
((ODDP (SPADCALL |l| (QREFELT $ 71)))
(LETT |l|
(SPADCALL |l| (LIST (SPADCALL (QREFELT $ 12)))
(QREFELT $ 73))
|OUTFORM;supersub;$L$;45|)))
(EXIT (CONS (|OUTFORM;eform| 'ALTSUPERSUB $) (CONS |a| |l|)))))
(DEFUN |OUTFORM;hconcat;3$;46| (|a| |b| $)
(LIST (|OUTFORM;eform| 'CONCAT $) |a| |b|))
(DEFUN |OUTFORM;hconcat;L$;47| (|l| $)
(CONS (|OUTFORM;eform| 'CONCAT $) |l|))
(DEFUN |OUTFORM;vconcat;3$;48| (|a| |b| $)
(LIST (|OUTFORM;eform| 'VCONCAT $) |a| |b|))
(DEFUN |OUTFORM;vconcat;L$;49| (|l| $)
(CONS (|OUTFORM;eform| 'VCONCAT $) |l|))
(DEFUN |OUTFORM;~=;3$;50| (|a| |b| $)
(LIST (|OUTFORM;sform| "~=" $) |a| |b|))
(DEFUN |OUTFORM;<;3$;51| (|a| |b| $)
(LIST (|OUTFORM;sform| "<" $) |a| |b|))
(DEFUN |OUTFORM;>;3$;52| (|a| |b| $)
(LIST (|OUTFORM;sform| ">" $) |a| |b|))
(DEFUN |OUTFORM;<=;3$;53| (|a| |b| $)
(LIST (|OUTFORM;sform| "<=" $) |a| |b|))
(DEFUN |OUTFORM;>=;3$;54| (|a| |b| $)
(LIST (|OUTFORM;sform| ">=" $) |a| |b|))
(DEFUN |OUTFORM;+;3$;55| (|a| |b| $)
(LIST (|OUTFORM;sform| "+" $) |a| |b|))
(DEFUN |OUTFORM;-;3$;56| (|a| |b| $)
(LIST (|OUTFORM;sform| "-" $) |a| |b|))
(DEFUN |OUTFORM;-;2$;57| (|a| $) (LIST (|OUTFORM;sform| "-" $) |a|))
(DEFUN |OUTFORM;*;3$;58| (|a| |b| $)
(LIST (|OUTFORM;sform| "*" $) |a| |b|))
(DEFUN |OUTFORM;/;3$;59| (|a| |b| $)
(LIST (|OUTFORM;sform| "/" $) |a| |b|))
(DEFUN |OUTFORM;**;3$;60| (|a| |b| $)
(LIST (|OUTFORM;sform| "**" $) |a| |b|))
(DEFUN |OUTFORM;div;3$;61| (|a| |b| $)
(LIST (|OUTFORM;sform| "div" $) |a| |b|))
(DEFUN |OUTFORM;rem;3$;62| (|a| |b| $)
(LIST (|OUTFORM;sform| "rem" $) |a| |b|))
(DEFUN |OUTFORM;quo;3$;63| (|a| |b| $)
(LIST (|OUTFORM;sform| "quo" $) |a| |b|))
(DEFUN |OUTFORM;exquo;3$;64| (|a| |b| $)
(LIST (|OUTFORM;sform| "exquo" $) |a| |b|))
(DEFUN |OUTFORM;and;3$;65| (|a| |b| $)
(LIST (|OUTFORM;sform| "and" $) |a| |b|))
(DEFUN |OUTFORM;or;3$;66| (|a| |b| $)
(LIST (|OUTFORM;sform| "or" $) |a| |b|))
(DEFUN |OUTFORM;not;2$;67| (|a| $)
(LIST (|OUTFORM;sform| "not" $) |a|))
(DEFUN |OUTFORM;SEGMENT;3$;68| (|a| |b| $)
(LIST (|OUTFORM;eform| 'SEGMENT $) |a| |b|))
(DEFUN |OUTFORM;SEGMENT;2$;69| (|a| $)
(LIST (|OUTFORM;eform| 'SEGMENT $) |a|))
(DEFUN |OUTFORM;binomial;3$;70| (|a| |b| $)
(LIST (|OUTFORM;eform| 'BINOMIAL $) |a| |b|))
(DEFUN |OUTFORM;empty;$;71| ($) (LIST (|OUTFORM;eform| 'NOTHING $)))
(DEFUN |OUTFORM;infix?;$B;72| (|a| $)
(PROG (#0=#:G1491 |e|)
(RETURN
(SEQ (EXIT (SEQ (LETT |e|
(COND
((IDENTP |a|) |a|)
((STRINGP |a|) (INTERN |a|))
('T
(PROGN
(LETT #0# 'NIL |OUTFORM;infix?;$B;72|)
(GO #0#))))
|OUTFORM;infix?;$B;72|)
(EXIT (COND ((GET |e| 'INFIXOP) 'T) ('T 'NIL)))))
#0# (EXIT #0#)))))
(PUT '|OUTFORM;elt;$L$;73| '|SPADreplace| 'CONS)
(DEFUN |OUTFORM;elt;$L$;73| (|a| |l| $) (CONS |a| |l|))
(DEFUN |OUTFORM;prefix;$L$;74| (|a| |l| $)
(COND
((NULL (SPADCALL |a| (QREFELT $ 98))) (CONS |a| |l|))
('T
(SPADCALL |a|
(SPADCALL (SPADCALL |l| (QREFELT $ 51)) (QREFELT $ 60))
(QREFELT $ 37)))))
(DEFUN |OUTFORM;infix;$L$;75| (|a| |l| $)
(COND
((SPADCALL |l| (QREFELT $ 66)) (SPADCALL (QREFELT $ 12)))
((SPADCALL (SPADCALL |l| (QREFELT $ 67)) (QREFELT $ 66))
(SPADCALL |l| (QREFELT $ 68)))
((SPADCALL |a| (QREFELT $ 98)) (CONS |a| |l|))
('T
(SPADCALL
(LIST (SPADCALL |l| (QREFELT $ 68)) |a|
(SPADCALL |a| (SPADCALL |l| (QREFELT $ 101))
(QREFELT $ 102)))
(QREFELT $ 75)))))
(DEFUN |OUTFORM;infix;4$;76| (|a| |b| |c| $)
(COND
((SPADCALL |a| (QREFELT $ 98)) (LIST |a| |b| |c|))
('T (SPADCALL (LIST |b| |a| |c|) (QREFELT $ 75)))))
(DEFUN |OUTFORM;postfix;3$;77| (|a| |b| $)
(SPADCALL |b| |a| (QREFELT $ 37)))
(DEFUN |OUTFORM;string;2$;78| (|a| $)
(LIST (|OUTFORM;eform| 'STRING $) |a|))
(DEFUN |OUTFORM;quote;2$;79| (|a| $)
(LIST (|OUTFORM;eform| 'QUOTE $) |a|))
(DEFUN |OUTFORM;overbar;2$;80| (|a| $)
(LIST (|OUTFORM;eform| 'OVERBAR $) |a|))
(DEFUN |OUTFORM;dot;2$;81| (|a| $)
(SPADCALL |a| (|OUTFORM;sform| "." $) (QREFELT $ 63)))
(DEFUN |OUTFORM;prime;2$;82| (|a| $)
(SPADCALL |a| (|OUTFORM;sform| "," $) (QREFELT $ 63)))
(DEFUN |OUTFORM;dot;$Nni$;83| (|a| |nn| $)
(PROG (|s|)
(RETURN
(SEQ (LETT |s|
(MAKE-FULL-CVEC |nn| (SPADCALL "." (QREFELT $ 110)))
|OUTFORM;dot;$Nni$;83|)
(EXIT (SPADCALL |a| (|OUTFORM;sform| |s| $) (QREFELT $ 63)))))))
(DEFUN |OUTFORM;prime;$Nni$;84| (|a| |nn| $)
(PROG (|s|)
(RETURN
(SEQ (LETT |s|
(MAKE-FULL-CVEC |nn| (SPADCALL "," (QREFELT $ 110)))
|OUTFORM;prime;$Nni$;84|)
(EXIT (SPADCALL |a| (|OUTFORM;sform| |s| $) (QREFELT $ 63)))))))
(DEFUN |OUTFORM;overlabel;3$;85| (|a| |b| $)
(LIST (|OUTFORM;eform| 'OVERLABEL $) |a| |b|))
(DEFUN |OUTFORM;box;2$;86| (|a| $)
(LIST (|OUTFORM;eform| 'BOX $) |a|))
(DEFUN |OUTFORM;zag;3$;87| (|a| |b| $)
(LIST (|OUTFORM;eform| 'ZAG $) |a| |b|))
(DEFUN |OUTFORM;root;2$;88| (|a| $)
(LIST (|OUTFORM;eform| 'ROOT $) |a|))
(DEFUN |OUTFORM;root;3$;89| (|a| |b| $)
(LIST (|OUTFORM;eform| 'ROOT $) |a| |b|))
(DEFUN |OUTFORM;over;3$;90| (|a| |b| $)
(LIST (|OUTFORM;eform| 'OVER $) |a| |b|))
(DEFUN |OUTFORM;slash;3$;91| (|a| |b| $)
(LIST (|OUTFORM;eform| 'SLASH $) |a| |b|))
(DEFUN |OUTFORM;assign;3$;92| (|a| |b| $)
(LIST (|OUTFORM;eform| 'LET $) |a| |b|))
(DEFUN |OUTFORM;label;3$;93| (|a| |b| $)
(LIST (|OUTFORM;eform| 'EQUATNUM $) |a| |b|))
(DEFUN |OUTFORM;rarrow;3$;94| (|a| |b| $)
(LIST (|OUTFORM;eform| 'TAG $) |a| |b|))
(DEFUN |OUTFORM;differentiate;$Nni$;95| (|a| |nn| $)
(PROG (#0=#:G1521 |r| |s|)
(RETURN
(SEQ (COND
((ZEROP |nn|) |a|)
((< |nn| 4) (SPADCALL |a| |nn| (QREFELT $ 112)))
('T
(SEQ (LETT |r|
(SPADCALL
(PROG1 (LETT #0# |nn|
|OUTFORM;differentiate;$Nni$;95|)
(|check-subtype| (> #0# 0)
'(|PositiveInteger|) #0#))
(QREFELT $ 125))
|OUTFORM;differentiate;$Nni$;95|)
(LETT |s| (SPADCALL |r| (QREFELT $ 126))
|OUTFORM;differentiate;$Nni$;95|)
(EXIT (SPADCALL |a|
(SPADCALL (|OUTFORM;sform| |s| $)
(QREFELT $ 60))
(QREFELT $ 63))))))))))
(DEFUN |OUTFORM;sum;2$;96| (|a| $)
(LIST (|OUTFORM;eform| 'SIGMA $) (SPADCALL (QREFELT $ 12)) |a|))
(DEFUN |OUTFORM;sum;3$;97| (|a| |b| $)
(LIST (|OUTFORM;eform| 'SIGMA $) |b| |a|))
(DEFUN |OUTFORM;sum;4$;98| (|a| |b| |c| $)
(LIST (|OUTFORM;eform| 'SIGMA2 $) |b| |c| |a|))
(DEFUN |OUTFORM;prod;2$;99| (|a| $)
(LIST (|OUTFORM;eform| 'PI $) (SPADCALL (QREFELT $ 12)) |a|))
(DEFUN |OUTFORM;prod;3$;100| (|a| |b| $)
(LIST (|OUTFORM;eform| 'PI $) |b| |a|))
(DEFUN |OUTFORM;prod;4$;101| (|a| |b| |c| $)
(LIST (|OUTFORM;eform| 'PI2 $) |b| |c| |a|))
(DEFUN |OUTFORM;int;2$;102| (|a| $)
(LIST (|OUTFORM;eform| 'INTSIGN $) (SPADCALL (QREFELT $ 12))
(SPADCALL (QREFELT $ 12)) |a|))
(DEFUN |OUTFORM;int;3$;103| (|a| |b| $)
(LIST (|OUTFORM;eform| 'INTSIGN $) |b| (SPADCALL (QREFELT $ 12)) |a|))
(DEFUN |OUTFORM;int;4$;104| (|a| |b| |c| $)
(LIST (|OUTFORM;eform| 'INTSIGN $) |b| |c| |a|))
(DEFUN |OutputForm| ()
(PROG ()
(RETURN
(PROG (#0=#:G1535)
(RETURN
(COND
((LETT #0# (HGET |$ConstructorCache| '|OutputForm|)
|OutputForm|)
(|CDRwithIncrement| (CDAR #0#)))
('T
(UNWIND-PROTECT
(PROG1 (CDDAR (HPUT |$ConstructorCache| '|OutputForm|
(LIST
(CONS NIL (CONS 1 (|OutputForm;|))))))
(LETT #0# T |OutputForm|))
(COND
((NOT #0#) (HREM |$ConstructorCache| '|OutputForm|)))))))))))
(DEFUN |OutputForm;| ()
(PROG (|dv$| $ |pv$|)
(RETURN
(PROGN
(LETT |dv$| '(|OutputForm|) . #0=(|OutputForm|))
(LETT $ (|newShell| 138) . #0#)
(QSETREFV $ 0 |dv$|)
(QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
(|haddProp| |$ConstructorCache| '|OutputForm| NIL (CONS 1 $))
(|stuffDomainSlots| $)
(QSETREFV $ 6 (|List| $))
$))))
(MAKEPROP '|OutputForm| '|infovec|
(LIST '#(NIL NIL NIL NIL NIL NIL '|Rep| (|Void|)
|OUTFORM;print;$V;1| (|Boolean|) (|String|) (0 . |empty?|)
|OUTFORM;empty;$;71| |OUTFORM;message;S$;2|
|OUTFORM;messagePrint;SV;3| |OUTFORM;=;2$B;4|
|OUTFORM;=;3$;5| (|OutputForm|) |OUTFORM;coerce;$Of;6|
(|Integer|) |OUTFORM;outputForm;I$;7| (|Symbol|)
|OUTFORM;outputForm;S$;8| (|DoubleFloat|)
|OUTFORM;outputForm;Df$;9| (|Character|) (5 . |quote|)
(9 . |concat|) (15 . |concat|) |OUTFORM;outputForm;S$;13|
|OUTFORM;width;$I;14| |OUTFORM;height;$I;15|
|OUTFORM;subHeight;$I;16| |OUTFORM;superHeight;$I;17|
|OUTFORM;height;I;18| |OUTFORM;width;I;19|
|OUTFORM;hspace;I$;27| |OUTFORM;hconcat;3$;46|
|OUTFORM;center;$I$;20| |OUTFORM;left;$I$;21|
|OUTFORM;right;$I$;22| |OUTFORM;center;2$;23|
|OUTFORM;left;2$;24| |OUTFORM;right;2$;25|
|OUTFORM;vspace;I$;26| |OUTFORM;vconcat;3$;48|
|OUTFORM;rspace;2I$;28| (|List| 49) |OUTFORM;matrix;L$;29|
(|List| $) |OUTFORM;pile;L$;30|
|OUTFORM;commaSeparate;L$;31|
|OUTFORM;semicolonSeparate;L$;32| (21 . |reverse|)
(26 . |append|) |OUTFORM;blankSeparate;L$;33|
|OUTFORM;brace;2$;34| |OUTFORM;brace;L$;35|
|OUTFORM;bracket;2$;36| |OUTFORM;bracket;L$;37|
|OUTFORM;paren;2$;38| |OUTFORM;paren;L$;39|
|OUTFORM;sub;3$;40| |OUTFORM;super;3$;41|
|OUTFORM;presub;3$;42| |OUTFORM;presuper;3$;43|
(32 . |null|) (37 . |rest|) (42 . |first|)
|OUTFORM;scripts;$L$;44| (|NonNegativeInteger|) (47 . |#|)
(|List| $$) (52 . |append|) |OUTFORM;supersub;$L$;45|
|OUTFORM;hconcat;L$;47| |OUTFORM;vconcat;L$;49|
|OUTFORM;~=;3$;50| |OUTFORM;<;3$;51| |OUTFORM;>;3$;52|
|OUTFORM;<=;3$;53| |OUTFORM;>=;3$;54| |OUTFORM;+;3$;55|
|OUTFORM;-;3$;56| |OUTFORM;-;2$;57| |OUTFORM;*;3$;58|
|OUTFORM;/;3$;59| |OUTFORM;**;3$;60| |OUTFORM;div;3$;61|
|OUTFORM;rem;3$;62| |OUTFORM;quo;3$;63|
|OUTFORM;exquo;3$;64| |OUTFORM;and;3$;65|
|OUTFORM;or;3$;66| |OUTFORM;not;2$;67|
|OUTFORM;SEGMENT;3$;68| |OUTFORM;SEGMENT;2$;69|
|OUTFORM;binomial;3$;70| |OUTFORM;infix?;$B;72|
|OUTFORM;elt;$L$;73| |OUTFORM;prefix;$L$;74| (58 . |rest|)
|OUTFORM;infix;$L$;75| |OUTFORM;infix;4$;76|
|OUTFORM;postfix;3$;77| |OUTFORM;string;2$;78|
|OUTFORM;quote;2$;79| |OUTFORM;overbar;2$;80|
|OUTFORM;dot;2$;81| |OUTFORM;prime;2$;82| (63 . |char|)
|OUTFORM;dot;$Nni$;83| |OUTFORM;prime;$Nni$;84|
|OUTFORM;overlabel;3$;85| |OUTFORM;box;2$;86|
|OUTFORM;zag;3$;87| |OUTFORM;root;2$;88|
|OUTFORM;root;3$;89| |OUTFORM;over;3$;90|
|OUTFORM;slash;3$;91| |OUTFORM;assign;3$;92|
|OUTFORM;label;3$;93| |OUTFORM;rarrow;3$;94|
(|PositiveInteger|) (|NumberFormats|) (68 . |FormatRoman|)
(73 . |lowerCase|) |OUTFORM;differentiate;$Nni$;95|
|OUTFORM;sum;2$;96| |OUTFORM;sum;3$;97|
|OUTFORM;sum;4$;98| |OUTFORM;prod;2$;99|
|OUTFORM;prod;3$;100| |OUTFORM;prod;4$;101|
|OUTFORM;int;2$;102| |OUTFORM;int;3$;103|
|OUTFORM;int;4$;104| (|SingleInteger|))
'#(~= 78 |zag| 90 |width| 96 |vspace| 105 |vconcat| 110
|supersub| 121 |superHeight| 127 |super| 132 |sum| 138
|subHeight| 156 |sub| 161 |string| 167 |slash| 172
|semicolonSeparate| 178 |scripts| 183 |rspace| 189 |root|
195 |right| 206 |rem| 217 |rarrow| 223 |quote| 229 |quo|
234 |prod| 240 |print| 258 |prime| 263 |presuper| 274
|presub| 280 |prefix| 286 |postfix| 292 |pile| 298 |paren|
303 |overlabel| 313 |overbar| 319 |over| 324 |outputForm|
330 |or| 350 |not| 356 |messagePrint| 361 |message| 366
|matrix| 371 |left| 376 |latex| 387 |label| 392 |int| 398
|infix?| 416 |infix| 421 |hspace| 434 |height| 439
|hconcat| 448 |hash| 459 |exquo| 464 |empty| 470 |elt| 474
|dot| 480 |div| 491 |differentiate| 497 |commaSeparate|
503 |coerce| 508 |center| 513 |bracket| 524 |brace| 534
|box| 544 |blankSeparate| 549 |binomial| 554 |assign| 560
|and| 566 SEGMENT 572 >= 583 > 589 = 595 <= 607 < 613 /
619 - 625 + 636 ** 642 * 648)
'NIL
(CONS (|makeByteWordVec2| 1 '(0 0 0))
(CONS '#(|SetCategory&| |BasicType&| NIL)
(CONS '#((|SetCategory|) (|BasicType|)
(|CoercibleTo| 17))
(|makeByteWordVec2| 137
'(1 10 9 0 11 0 25 0 26 2 10 0 0 25 27
2 10 0 25 0 28 1 6 0 0 53 2 6 0 0 0
54 1 6 9 0 66 1 6 0 0 67 1 6 2 0 68 1
6 70 0 71 2 72 0 0 0 73 1 72 0 0 101
1 25 0 10 110 1 124 10 123 125 1 10 0
0 126 2 0 0 0 0 77 2 0 9 0 0 1 2 0 0
0 0 115 0 0 19 35 1 0 19 0 30 1 0 0
19 44 1 0 0 49 76 2 0 0 0 0 45 2 0 0
0 49 74 1 0 19 0 33 2 0 0 0 0 63 2 0
0 0 0 129 3 0 0 0 0 0 130 1 0 0 0 128
1 0 19 0 32 2 0 0 0 0 62 1 0 0 0 105
2 0 0 0 0 119 1 0 0 49 52 2 0 0 0 49
69 2 0 0 19 19 46 1 0 0 0 116 2 0 0 0
0 117 1 0 0 0 43 2 0 0 0 19 40 2 0 0
0 0 89 2 0 0 0 0 122 1 0 0 0 106 2 0
0 0 0 90 3 0 0 0 0 0 133 1 0 0 0 131
2 0 0 0 0 132 1 0 7 0 8 2 0 0 0 70
112 1 0 0 0 109 2 0 0 0 0 65 2 0 0 0
0 64 2 0 0 0 49 100 2 0 0 0 0 104 1 0
0 49 50 1 0 0 49 61 1 0 0 0 60 2 0 0
0 0 113 1 0 0 0 107 2 0 0 0 0 118 1 0
0 10 29 1 0 0 23 24 1 0 0 21 22 1 0 0
19 20 2 0 0 0 0 93 1 0 0 0 94 1 0 7
10 14 1 0 0 10 13 1 0 0 47 48 1 0 0 0
42 2 0 0 0 19 39 1 0 10 0 1 2 0 0 0 0
121 3 0 0 0 0 0 136 2 0 0 0 0 135 1 0
0 0 134 1 0 9 0 98 2 0 0 0 49 102 3 0
0 0 0 0 103 1 0 0 19 36 0 0 19 34 1 0
19 0 31 1 0 0 49 75 2 0 0 0 0 37 1 0
137 0 1 2 0 0 0 0 91 0 0 0 12 2 0 0 0
49 99 2 0 0 0 70 111 1 0 0 0 108 2 0
0 0 0 88 2 0 0 0 70 127 1 0 0 49 51 1
0 17 0 18 1 0 0 0 41 2 0 0 0 19 38 1
0 0 0 58 1 0 0 49 59 1 0 0 49 57 1 0
0 0 56 1 0 0 0 114 1 0 0 49 55 2 0 0
0 0 97 2 0 0 0 0 120 2 0 0 0 0 92 1 0
0 0 96 2 0 0 0 0 95 2 0 0 0 0 81 2 0
0 0 0 79 2 0 0 0 0 16 2 0 9 0 0 15 2
0 0 0 0 80 2 0 0 0 0 78 2 0 0 0 0 86
1 0 0 0 84 2 0 0 0 0 83 2 0 0 0 0 82
2 0 0 0 0 87 2 0 0 0 0 85)))))
'|lookupComplete|))
(MAKEPROP '|OutputForm| 'NILADIC T)
@
\section{License}
<<license>>=
--Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
--All rights reserved.
--
--Redistribution and use in source and binary forms, with or without
--modification, are permitted provided that the following conditions are
--met:
--
-- - Redistributions of source code must retain the above copyright
-- notice, this list of conditions and the following disclaimer.
--
-- - Redistributions in binary form must reproduce the above copyright
-- notice, this list of conditions and the following disclaimer in
-- the documentation and/or other materials provided with the
-- distribution.
--
-- - Neither the name of The Numerical ALgorithms Group Ltd. nor the
-- names of its contributors may be used to endorse or promote products
-- derived from this software without specific prior written permission.
--
--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
--IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
--TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
--PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
--OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
--EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
--PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
--PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
--LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
--NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@
<<*>>=
<<license>>
<<package NUMFMT NumberFormats>>
<<domain OUTFORM OutputForm>>
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}