IF value.Length[] < 1 THEN RETURN["unknown"]

ELSE RETURN[CharToGreekName[value.Fetch[0]]];

};

RETURN["?"];

};

RETURN["infinity"];

};

effects: Paints value onto context in absBox

check type

IF (absBox.Type[] # absolute) THEN ERROR wrongBoxType

};

effects: Paints value as a sequence of centered superimposed characters.

This is useful for things like negated symbols (/ slashed through)...

check types

IF (absBox.Type[] # absolute) THEN ERROR wrongBoxType

};

effects: Paints value onto context in absBox

check types

IF (absBox.Type[] # absolute) THEN ERROR wrongBoxType

};

effects: Paints a line onto context filling absBox

caveats: Ignores value & style

r: Imager.Rectangle ← [x: absBox.Offset[].x + absBox.Extents[].leftExtent, y: absBox.Offset[].y + absBox.Extents[].descent, w: absBox.Width[], h: absBox.Height[]];

Imager.MaskRectangle[context, r];

};

effects: none

RETURN;

};

effects: Returns a bounding box for a line

Note that this is always a dummy value

don't really need any data from value; always returns protoypical line size

RETURN[[leftExtent: 0.0, rightExtent: 1.0, descent: 0.0, ascent: 0.03]];

};

effects: Returns a bounding box for value

font: ImagerFont.Font ← ImagerFont.Scale[ImagerFont.Find[style.font], style.scale];

RETURN[ImagerFont.RopeBoundingBox[font, value]];

};

effects: Returns a bounding box for value as a sequence of overlayed chars

font: ImagerFont.Font ← ImagerFont.Scale[ImagerFont.Find[style.font], style.scale];

farLeft, farRight, farUp, farDown: REAL ← 0.0; -- extreme edges of overlayed extents

FOR i:INT IN [0..value.Length[]-1] DO

RETURN[[leftExtent: farLeft, rightExtent: farRight, descent: farDown, ascent: farUp]];

};

effects: Returns a bounding box for value

font: ImagerFont.Font ← ImagerFont.Scale[ImagerFont.Find[style.font], style.scale];

RETURN[ImagerFont.RopeBoundingBox[font, value]];

};

effects: Returns a bounding box for value

size: ATOM ← Convert.AtomFromRope[value];

RETURN[

};

effects: Returns unaltered boxes (i.e. no resizing takes place)

RETURN[boxes];

};

effects: Sizes boxes for expr of form ($fractionBar $numerator $denominator)

should ENABLE noSuchBox

fbarBox: BOX ← MathBox.GetBox[$fractionBar, boxes];

numBox: BOX ← MathBox.GetBox[$numerator, boxes];

denomBox: BOX ← MathBox.GetBox[$denominator, boxes];

topSpaceBox: BOX ← MathBox.GetBox[$topSpace, boxes];

bottomSpaceBox: BOX ← MathBox.GetBox[$bottomSpace, boxes];

fraction bar must be as wide as the wider of numerator, denominator

scaleX: REAL ← 1.1 * MAX[numBox.Width[], denomBox.Width[]] / fbarBox.Width[];

adjust fbarBox extents

fbarBox ← MathBox.Scale[fbarBox, [scaleX, 1.0]];

RETURN[LIST[fbarBox, numBox, denomBox, topSpaceBox, bottomSpaceBox]];

};

effects: Sizes boxes for expr of form ($paren $a)

leftParenBox: BOX ← MathBox.GetBox[$leftParen, boxes];

rightParenBox: BOX ← MathBox.GetBox[$rightParen, boxes];

aBox: BOX ← MathBox.GetBox[$a, boxes];

right and left parentheses must be as tall as expression "a"

scaleFactor: REAL ← MAX[0.25, 1.1 * aBox.Height[] / leftParenBox.Height[]];

leftParenBox ← MathBox.Scale[leftParenBox, [scaleFactor, scaleFactor]];

rightParenBox ← MathBox.Scale[rightParenBox, [scaleFactor, scaleFactor]];

RETURN[LIST[aBox, leftParenBox, rightParenBox]];

};

effects: Sizes boxes for expr of form ($radRoot $radLine $n $radicand)

should ENABLE noSuchBox

radRootBox: BOX ← MathBox.GetBox[$radRoot, boxes];

radLineBox: BOX ← MathBox.GetBox[$radLine, boxes];

nBox: BOX ← MathBox.GetBox[$n, boxes];

spaceBox: BOX ← MathBox.GetBox[$space, boxes];

radicandBox: BOX ← MathBox.GetBox[$radicand, boxes];

line must be exactly as long as radicand,

root symbol must be as tall as radicand + 2*space

rootScale: REAL ← ((2 * spaceBox.Height[]) + radicandBox.Height[]) / radRootBox.Height[];

lineScale: VEC ← [radicandBox.Width[]/radLineBox.Width[], 1.0];

adjust symbol extents

radRootBox ← MathBox.Scale[radRootBox, [rootScale, rootScale]];

radLineBox ← MathBox.Scale[radLineBox, lineScale];

RETURN[LIST[radRootBox, radLineBox, nBox, radicandBox, spaceBox]];

};

effects: Sizes boxes for expr of form ($radRoot $radLine $radicand)

should ENABLE noSuchBox

radRootBox: BOX ← MathBox.GetBox[$radRoot, boxes];

radLineBox: BOX ← MathBox.GetBox[$radLine, boxes];

spaceBox: BOX ← MathBox.GetBox[$space, boxes];

radicandBox: BOX ← MathBox.GetBox[$radicand, boxes];

line must be exactly as long as radicand,

root symbol must be as tall as radicand + 2*space

rootScale: REAL ← ((2 * spaceBox.Height[]) + radicandBox.Height[]) / radRootBox.Height[];

lineScale: VEC ← [radicandBox.Width[]/radLineBox.Width[], 1.0];

adjust symbol extents

radRootBox ← MathBox.Scale[radRootBox, [rootScale, rootScale]];

radLineBox ← MathBox.Scale[radLineBox, lineScale];

RETURN[LIST[radRootBox, radLineBox, radicandBox, spaceBox]];

};

effects: Sizes boxes for expr of form ($f $space $args $leftParen $rightParen)

should ENABLE noSuchBox

lParenBox: BOX ← MathBox.GetBox[$leftParen, boxes];

rParenBox: BOX ← MathBox.GetBox[$rightParen, boxes];

spaceBox: BOX ← MathBox.GetBox[$space, boxes];

fBox: BOX ← MathBox.GetBox[$f, boxes];

argsBox: BOX ← MathBox.GetBox[$args, boxes];

parens must be as big as args

right and left parentheses must be as tall as expression "a"

scaleFactor: REAL ← MAX[1.0, 1.1 * argsBox.Height[] / lParenBox.Height[]];

lParenBox ← MathBox.Scale[lParenBox, [scaleFactor, scaleFactor]];

rParenBox ← MathBox.Scale[rParenBox, [scaleFactor, scaleFactor]];

RETURN[LIST[fBox, spaceBox, lParenBox, rParenBox, argsBox]];

};

effects: Composes layout for expr of form ($exponent $base)

tempBox: BOX;

tempBoxes: LIST OF BOX;

vertOffsetExponent, vertOffsetBase, horizOffsetBase: Offset;

alignments: LIST OF Alignment2D ← NIL;

baseBox: BOX ← MathBox.GetBox[$base, boxes];

exponentBox: BOX ← MathBox.GetBox[$exponent, boxes];

hintBox: BOX ← baseBox.SuperscriptHint[]; -- hint about where to place subscript w/i base

IF hintBox # NIL THEN {

ELSE {

alignments ← LIST[

[tempBox, tempBoxes] ←

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($base $subscript)

tempBox: BOX;

tempBoxes: LIST OF BOX;

vertOffsetSubscript, vertOffsetBase: Offset;

alignments: LIST OF Alignment2D ← NIL;

IF MathBox.GetBox[$base, boxes].Height[] >
MathBox.GetBox[$subscript, boxes].Height[] THEN {

ELSE {

alignments ← LIST[

[tempBox, tempBoxes] ←

make hint to place superscript over base instead of entire expression

tempBox ← tempBox.ChangeSuperHint[MathBox.GetBox[$base, tempBoxes]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($fractionBar $numerator $denominator)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$fractionBar, [origin]],
[$fractionBar, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($comma $car $cdr) with symbol $space.

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$car, [origin]], [$comma, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($f $space $args $leftParen $rightParen)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$f, [origin]], [$f, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($lim $approaches $of $space)

tempBox: BOX;

tempBoxes: LIST OF BOX;

limBox: BOX ← MathBox.GetBox[$lim, boxes];

approachesBox: BOX ← MathBox.GetBox[$approaches, boxes];

alignments: LIST OF Alignment2D;

IF approachesBox.Width[] > limBox.Width[] THEN {

ELSE {

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$approaches, [origin]], [$of, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($summation $lowerbound $upperbound

$summand)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← NIL;

vertSigmaOffset, vertSummandOffset: Offset;

SELECT MathBox.GetBox[$summand, boxes].FormatClass[] FROM

alignments ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$sigma, [origin]], [$sigma, [center, -0.2]]];

RETURN[tempBox, tempBoxes];

};

effects: Compose layout for expr of form ($radRoot $radLine $n $radicand)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$n, [origin]], [$radicand, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Compose layout for expr of form ($radRoot $radLine $radicand)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$radicand, [origin]],
[$radicand, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($integral $lowerlimit

$upperlimit $integrand $dx $wrt)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← NIL;

vertIntegralOffset, vertIntegrandOffset: Offset;

SELECT MathBox.GetBox[$integrand, boxes].FormatClass[] FROM

alignments ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$lowerlimit, [origin]], [$integral, [center, -0.2]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($integral $integrand $dx $wrt)

tempBox: BOX;

tempBoxes: LIST OF BOX;

vertIntegralOffset, vertIntegrandOffset: Offset;

alignments: LIST OF Alignment2D ← NIL;

SELECT MathBox.GetBox[$integrand, boxes].FormatClass[] FROM

alignments ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$integral, [origin]],
[$integral, [center, -0.2]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($aliasUnaryOp $aliasA).

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$aliasUnaryOp, [origin]],
[$aliasUnaryOp, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($aliasBinOp $aliasA $aliasB) with

symbols $aliasLeftSpace & $aliasRightSpace.

tempBox: BOX;

tempBoxes: LIST OF BOX;

leftVertOffsetA, leftVertOffsetOp, rightVertOffsetB, rightVertOffsetOp: Offset;

alignments: LIST OF Alignment2D;

set vertical offset depending on format classes of A & B arguments

SELECT MathBox.GetBox[$aliasA, boxes].FormatClass[] FROM

SELECT MathBox.GetBox[$aliasB, boxes].FormatClass[] FROM

alignments ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$aliasA, [origin]], [$aliasBinOp, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($aliasRelation $aliasLHS $aliasRHS) with

symbols $aliasLeftSpace & $aliasRightSpace.

tempBox: BOX;

tempBoxes: LIST OF BOX;

leftVertOffsetLHS, leftVertOffsetRel, rightVertOffsetRHS, rightVertOffsetRel: Offset;

alignments: LIST OF Alignment2D;

set vertical offset depending on format classes of lhs & rhs arguments

SELECT MathBox.GetBox[$aliasLHS, boxes].FormatClass[] FROM

SELECT MathBox.GetBox[$aliasRHS, boxes].FormatClass[] FROM

alignments ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$aliasLHS, [origin]],
[$aliasRelation, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($complex $a $b)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ←

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$a, [origin]], [$plus, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($bang $a $space)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$a, [origin]], [$a, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($paren $a) with symbols

$leftParen and $rightParen

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$leftParen, [origin]],
[$self, [center, -0.25]]];

RETURN[tempBox, tempBoxes];

};

effects: Creates and returns standard binary operation compound class named "class".

The alignment is "a operation b"; alignment is thru baselines.

All of a, b, op are of fixed size "normal".

aArg: Argument ← MakeArgument[a, LIST[$aliasA, $aliasHot], normal];

bArg: Argument ← MakeArgument[b, LIST[$aliasB], normal];

opSym: Symbol ← MakeSymbol[op, LIST[$aliasBinOp], normal, operation];

leftSpace: Symbol ← MakeSymbol[$leftThinSpace, LIST[$aliasLeftSpace], normal, MakeSpace[$thin]];

rightSpace: Symbol ← MakeSymbol[$rightThinSpace, LIST[$aliasRightSpace], normal, MakeSpace[$thin]];

RETURN[MakeCompoundClass[class, binaryOp, description, LIST[aArg, bArg], LIST[opSym, leftSpace, rightSpace], FixedSizeBoxRule, BinaryOpCompRule, cvtAS]];

};

effects: Creates and returns standard relation compound class named "class".

The alignment is "lhs relation rhs"; alignment is thru baselines.

All of lhs, rhs, rel are of fixed size "normal".

lhsArg: Argument ← MakeArgument[lhs, LIST[$aliasLHS, $aliasHot], normal];

rhsArg: Argument ← MakeArgument[rhs, LIST[$aliasRHS], normal];

relSym: Symbol ← MakeSymbol[rel, LIST[$aliasRelation], normal, relation];

leftSpace: Symbol ← MakeSymbol[$leftSpace, LIST[$aliasLeftSpace], normal, MakeSpace[$thick]];

rightSpace: Symbol ← MakeSymbol[$rightSpace, LIST[$aliasRightSpace], normal, MakeSpace[$thick]];

RETURN[MakeCompoundClass[class, relation, description, LIST[lhsArg, rhsArg], LIST[relSym, leftSpace, rightSpace], FixedSizeBoxRule, RelationCompRule, cvtAS]];

};

effects: Creates and returns standard unary operation compound class named "class".

The alignment is "operation arg"; alignment is thru baselines.

Both op, arg are of fixed size "normal".

argArg: Argument ← MakeArgument[arg, LIST[$aliasA, $aliasHot], normal];

spaceSym: Symbol ← MakeSymbol[$Space, LIST[$aliasSpace], normal, MakeSpace[$medium]];

unaryOpSym: Symbol ← MakeSymbol[op, LIST[$aliasUnaryOp], normal, operation];

RETURN[MakeCompoundClass[class, unaryOp, description, LIST[argArg], LIST[unaryOpSym, spaceSym], FixedSizeBoxRule, UnaryOpCompRule, cvtAS]];

};

RETURN[MathExpr.MakeAtomicExpr[$plainSym, Rope.FromChar[c]]];

};

RETURN[MathExpr.MakeAtomicExpr[$plainSym, r]];

};

effects: Returns a symbol expression which is all the chars in r superimposed.

RETURN[MathExpr.MakeAtomicExpr[$overlaySym, r]];

};

RETURN[MathExpr.MakeAtomicExpr[$bigMathSym, Rope.FromChar[c]]];

};

RETURN[MathExpr.MakeAtomicExpr[$smallMathSym, Rope.FromChar[c]]];

};

RETURN[MathExpr.MakeAtomicExpr[$italicSym, Rope.FromChar[c]]];

};

RETURN[MathExpr.MakeAtomicExpr[$mathItalicSym, Rope.FromChar[c]]];

};

RETURN[MathExpr.MakeAtomicExpr[$line, "LINE"]];

};

RETURN[MathExpr.MakeAtomicExpr[$space, Convert.RopeFromAtom[size, FALSE]]];

};

RETURN[MathExpr.MakeAtomicExpr[$placeholder, "\056\057"]];

};

effects: Constructs and returns an expression for +infinity.

RETURN[MathExpr.MakeAtomicExpr[$infinity, "\061"]];

};

effects: Constructs and returns an integer expression for n.

SIGNALS badFormat if n is not a legal integer.

IF n.Length[] = 0 THEN ERROR badFormat;

SELECT n.Fetch[0] FROM

check that each char in n is a legal digit

FOR i:INT IN[1..n.Length[]-1] DO

RETURN[MathExpr.MakeAtomicExpr[$integer, n]];

};

effects: Constructs and returns a real expression for n.

RETURN[MathExpr.MakeAtomicExpr[$real, Convert.RopeFromReal[r]]];

};

effects: Constructs and returns a variable expression for var.

SIGNALS badFormat if n is not a legal variable (e.g. invalid chars).

IF var.Length[] = 0 THEN ERROR badFormat;

check that each char is an alphabetic char A thru Z, either case (disabled 9/30/86)

FOR i:INT IN[0..var.Length[]-1] DO

RETURN[MathExpr.MakeAtomicExpr[$variable, var]];

};

effects: Returns the greek TeX character named by name.

SIGNALS badFormat if names is unrecognized

RETURN[

effects: Returns the name associated with the greek TeX character c.

If no such association exists, returns "unknown".

RETURN[

effects: Constructs and returns a greek variable expression for the

lowercase greek letter associated with name (e.g. "gamma", "lambda").

SIGNALS badFormat if name does not name a greek letter.

greekRope: ROPE ← Rope.FromChar[GreekNameToChar[name ! badFormat => {ERROR badFormat}]];

RETURN[MathExpr.MakeAtomicExpr[$greekVar, greekRope]];

};

RETURN[MathExpr.MakeCompoundExpr[$sum, LIST[[$addend, addend], [$augend, augend]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$difference, LIST[[$subtrahend, subtrahend], [$minuend, minuend]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$and, LIST[[$a, a], [$b, b]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$or, LIST[[$a, a], [$b, b]]]];

};

effects: Constructs and returns a matrix expression of size nRows by nCols from rows.

SIGNALS badFormat if dimensions given don't exactly match dimension(rows).

local declarations

elements: LIST OF MathExpr.TaggedMathExpr ← NIL;

rowCount, colCount: NAT ← 0;

FOR l: LIST OF LIST OF EXPR ← rows, l.rest UNTIL l = NIL DO

IF rowCount # nRows THEN ERROR badFormat; -- wrong # rows

RETURN[MathExpr.MakeMatrixExpr[$matrix, nRows, nCols, elements]];

};

effects: Constructs and returns a vector expression of size dimension from elements.

SIGNALS badFormat if dimension doesn't exactly match dimension(elements).

local declarations

elts: LIST OF MathExpr.TaggedMathExpr ← NIL;

rowCount, colCount: NAT ← 0;

IF row THEN rowCount ← 1 ELSE colCount ← 1; -- row vec has 1 row, col vec has 1 col

FOR l: LIST OF EXPR ← elements, l.rest UNTIL l = NIL DO

complain if dimension does not agree with length(elements)

IF row THEN {

ELSE {

RETURN[MathExpr.MakeMatrixExpr[$vector, rowCount, colCount, elts]];

};

RETURN[MathExpr.MakeCompoundExpr[$complex, LIST[[$a, a], [$b, b]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$product, LIST[[$multiplier, multiplier], [$multiplicand, multiplicand]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$fraction, LIST[[$numerator, numerator], [$denominator, denominator]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$pow, LIST[[$base, base], [$exponent, exponent]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$subscript, LIST[[$base, base], [$subscript, subscript]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$paren, LIST[[$a, a]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$eqFormula, LIST[[$lhs, lhs], [$rhs, rhs]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$notEqFormula, LIST[[$lhs, lhs], [$rhs, rhs]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$ltFormula, LIST[[$lhs, lhs], [$rhs, rhs]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$leFormula, LIST[[$lhs, lhs], [$rhs, rhs]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$gtFormula, LIST[[$lhs, lhs], [$rhs, rhs]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$geFormula, LIST[[$lhs, lhs], [$rhs, rhs]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$nRadical, LIST[[$radicand, radicand], [$n, n]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$summation, LIST[[$lowerbound, lb], [$summand, summand], [$upperbound, ub]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$integration, LIST[[$lowerlimit, llim], [$upperlimit, ulim], [$integrand, integrand], [$wrt, wrt]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$indefInt, LIST[[$integrand, integrand], [$wrt, wrt]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$not, LIST[[$a, a]]]];

};

RETURN[MathExpr.MakeCompoundExpr[$negation, LIST[[$a, a]]]];

};

local declarations (lots of 'em)

cmr10, cmti10, cmmi10, cmex10, cmsy10: Style;

integerClass, realClass, variableClass, plainSymClass, overlaySymClass, smallMathSymClass, bigMathSymClass, italSymClass, mathItalSymClass, lineClass, placeholderClass, spaceClass, greekVarClass, infinityClass: AtomClass;

sumClass, summationClass, fractionClass, integrationClass, indefIntClass, differenceClass, powClass, eqFormulaClass, approxEqFormulaClass, notEqFormulaClass, ltFormulaClass, leFormulaClass, geFormulaClass, gtFormulaClass, nRadicalClass, radicalClass, complexClass, productClass, orClass, notClass, negationClass, andClass, parenClass, subscriptClass, listClass, functionClass, altFunctionClass, limitClass, factorialClass, approachesClass: CompoundClass;

matrixClass, vectorClass: MatrixClass;

lbArg, ubArg, summandArg, llimArg, ulimArg, integrandArg, wrtArg, baseArg, exponentArg, numeratorArg, denominatorArg, nArg, radicandArg, realPartArg, imaginaryPartArg, aParenArg, subscriptArg, carArg, cdrArg, fArg, argsArg, ofArg, approachesArg, factorialArg: Argument;

plusSym, sigmaSym, integralSym, dxSym, lineSym, radRootSym, radLineSym, iSym, leftParenSym, rightParenSym, numerSpSym, denomSpSym, integralSpaceSym, commaSym, listSpSym, funSpaceSym, funLParenSym, funRParenSym, altFunLP, altFunRP, limSym, factorialSym, factorialSpSym, limSpaceSym, radSpaceSym: Symbol;

reset current DB state (i.e. clean slate)

MathDB.ResetAtomClasses[];

MathDB.ResetCompoundClasses[];

MathDB.ResetMatrixClasses[];

plain vanilla TeX fonts

cmr10 ← [font: "xerox/pressfonts/cmr60"]; -- standard times roman (1 unit high)

cmti10 ← [font: "xerox/pressfonts/cmti60"]; -- italic (1 unit high)

cmex10 ← [font: "xerox/pressfonts/cmex60"]; -- math extentsion font (1 unit high)

cmmi10 ← [font: "xerox/pressfonts/cmmi60"]; -- math italic font (1 unit high)

cmsy10 ← [font: "xerox/pressfonts/cmsy60"]; -- math symbols font (1 unit high)

define Atom Classes

integerClass ← MakeAtomClass[$integer, atom, argument, cmr10, RopeBox, PaintRope];

realClass ← MakeAtomClass[$real, atom, argument, cmr10, RopeBox, PaintRope];

variableClass ← MakeAtomClass[$variable, atom, argument, cmti10, RopeBox, PaintRope];

greekVarClass ← MakeAtomClass[$greekVar, atom, argument, cmmi10, CharBox, PaintChar, GreekVarToASRope];

plainSymClass ← MakeAtomClass[$plainSym, atom, symbol, cmr10, RopeBox, PaintRope];

overlaySymClass ← MakeAtomClass[$overlaySym, atom, symbol, cmr10, OverlayBox, PaintOverlay];

bigMathSymClass ← MakeAtomClass[$bigMathSym, atom, symbol, cmex10, CharBox, PaintChar];

smallMathSymClass ← MakeAtomClass[$smallMathSym, atom, symbol, cmsy10, CharBox, PaintChar];

mathItalSymClass ← MakeAtomClass[$mathItalicSym, atom, symbol, cmmi10, CharBox, PaintChar];

italSymClass ← MakeAtomClass[$italicSym, atom, symbol, cmti10, CharBox, PaintChar];

lineClass ← MakeAtomClass[$line, atom, symbol, cmr10, LineBox, PaintLine];

placeholderClass ← MakeAtomClass[$placeholder, atom, placeholder, cmmi10, RopeBox, PaintRope, PlaceHolderToASRope];

spaceClass ← MakeAtomClass[$space, atom, symbol, cmr10, SpaceBox, PaintSpace];

infinityClass ← MakeAtomClass[$infinity, atom, argument, cmsy10, CharBox, PaintChar, InfinityToASRope];

register atom classes

MathDB.InstallAtomClass[integerClass];

MathDB.InstallAtomClass[realClass];

MathDB.InstallAtomClass[variableClass];

MathDB.InstallAtomClass[greekVarClass];

MathDB.InstallAtomClass[plainSymClass];

MathDB.InstallAtomClass[overlaySymClass];

MathDB.InstallAtomClass[italSymClass];

MathDB.InstallAtomClass[smallMathSymClass];

MathDB.InstallAtomClass[bigMathSymClass];

MathDB.InstallAtomClass[mathItalSymClass];

MathDB.InstallAtomClass[lineClass];

MathDB.InstallAtomClass[placeholderClass];

MathDB.InstallAtomClass[spaceClass];

MathDB.InstallAtomClass[infinityClass];

define info for "complex a b" (a + bi)

realPartArg ← MakeArgument[$a, LIST[$aliasA, $aliasHot], normal];

imaginaryPartArg ← MakeArgument[$b, LIST[$aliasB], normal];

iSym ← MakeSymbol[$i, NIL, normal, MakeItalSym['i]];

plusSym ← MakeSymbol[$plus, LIST[$aliasBinOp], normal, MakePlainSym['+]];

define info for "summation lowerbound upperbound summand"

lbArg ← MakeArgument[$lowerbound, NIL, script];

ubArg ← MakeArgument[$upperbound, NIL, script];

summandArg ← MakeArgument[$summand, LIST[$aliasHot], normal];

sigmaSym ← MakeSymbol[$sigma, LIST[$aliasOp], normal, MakeBigMathSym['\130]];

define info for indefinite & definite integrals (normal & surface)

llimArg ← MakeArgument[$lowerlimit, NIL, script];

ulimArg ← MakeArgument[$upperlimit, NIL, script];

integrandArg ← MakeArgument[$integrand, LIST[$aliasHot], normal];

wrtArg ← MakeArgument[$wrt, NIL, normal];

integralSym ← MakeSymbol[$integral, LIST[$aliasOp], normal, MakeBigMathSym['\132]];

dxSym ← MakeSymbol[$dx, NIL, normal, MakeItalSym['d]];

integralSpaceSym ← MakeSymbol[$space, LIST[$aliasSpace], normal, MakeSpace[$thick]];

define info for "pow base exponent" & "subscript base subscript"

baseArg ← MakeArgument[$base, LIST[$aliasA, $aliasHot], normal];

exponentArg ← MakeArgument[$exponent, LIST[$aliasB], script];

subscriptArg ← MakeArgument[$subscript, LIST[$aliasB], script];

define info for "fraction numerator denominator"

numeratorArg ← MakeArgument[$numerator, LIST[$aliasA, $aliasHot], normal];

denominatorArg ← MakeArgument[$denominator, LIST[$aliasB], normal];

denomSpSym ← MakeSymbol[$bottomSpace, LIST[$aliasSpace], normal, MakeSpace[$thin]];

numerSpSym ← MakeSymbol[$topSpace, LIST[$aliasSpace], normal, MakeSpace[$thin]];

lineSym ← MakeSymbol[$fractionBar, LIST[$aliasLine], normal, MakeLine[]];

define info for "radical n radicand"

nArg ← MakeArgument[$n, LIST[$aliasB], script];

radicandArg ← MakeArgument[$radicand, LIST[$aliasA, $aliasHot], normal];

radRootSym ← MakeSymbol[$radRoot, NIL, normal, MakeBigMathSym['\162]];

radLineSym← MakeSymbol[$radLine, LIST[$aliasLine], normal, MakeLine[]];

radSpaceSym ← MakeSymbol[$space, LIST[$aliasSpace], normal, MakeSpace[$medium]];

define info for "( a )"

aParenArg ← MakeArgument[$a, LIST[$aliasA, $aliasHot], normal];

leftParenSym ← MakeSymbol[$leftParen, NIL, normal, MakeBigMathSym['\040]];

rightParenSym ← MakeSymbol[$rightParen, NIL, normal, MakeBigMathSym['\041]];

define info for "$list $car $cdr"

carArg ← MakeArgument[$car, LIST[$aliasA, $aliasHot], normal];

cdrArg ← MakeArgument[$cdr, LIST[$aliasB], normal];

commaSym ← MakeSymbol[$comma, NIL, normal, MakeItalSym[',]];

listSpSym ← MakeSymbol[$space, LIST[$aliasSpace], normal, MakeSpace[$thick]];

define info for functions

fArg ← MakeArgument[$f, LIST[$aliasA, $aliasHot], normal];

argsArg ← MakeArgument[$args, LIST[$aliasB], normal];

funSpaceSym ← MakeSymbol[$space, LIST[$aliasSpace], normal, MakeSpace[$medium]];

funLParenSym ← MakeSymbol[$leftParen, NIL, normal, MakePlainSym['\050]];

funRParenSym ← MakeSymbol[$rightParen, NIL, normal, MakePlainSym['\051]];

altFunLP ← MakeSymbol[$leftParen, NIL, normal, MakeSpace[$null]];

altFunRP ← MakeSymbol[$rightParen, NIL, normal, MakeSpace[$null]];

define info for limits

ofArg ← MakeArgument[$of, LIST[$aliasA, $aliasHot], normal];

approachesArg ← MakeArgument[$approaches, NIL, script];

limSpaceSym ← MakeSymbol[$space, LIST[$aliasSpace], normal, MakeSpace[$limit]];

limSym ← MakeSymbol[$lim, NIL, script, MakePlainRope["lim"]];

define into for factorial

factorialArg ← MakeArgument[$a, LIST[$aliasA, $aliasHot], normal];

factorialSym ← MakeSymbol[$bang, NIL, normal, MakePlainSym['!]];

factorialSpSym ← MakeSymbol[$space, LIST[$aliasSpace], normal, MakeSpace[$thin]];

define compound classes

binary operations

sumClass ← MakeBinOpClass[$sum, $plus, $addend, $augend, MakePlainSym['+], "a + b", "$addend + $augend"];

differenceClass ← MakeBinOpClass[$difference, $minus, $subtrahend, $minuend, MakePlainSym['\173], "a - b", "$subtrahend - $minuend"];

productClass ← MakeBinOpClass[$product, $times, $multiplier, $multiplicand, MakeSpace[$product], "a * b", "$multiplier * $multiplicand"];

andClass ← MakeBinOpClass[$and, $andOp, $a, $b, MakeSmallMathSym['\136], "a AND b", "$a & $b"];

orClass ← MakeBinOpClass[$or, $orOp, $a, $b, MakeSmallMathSym['\137], "a OR b", "$a | $b"];

unary operations

negationClass ← MakeUnaryOpClass[$negation, $minus, $a, MakePlainSym['-], "-a", "-$a"];

notClass ← MakeUnaryOpClass[$not, $notOp, $a, MakeSmallMathSym['\072], "~a", "~ $a"];

relations

eqFormulaClass ← MakeRelationClass[$eqFormula, $equals, $lhs, $rhs, MakePlainSym['=], "lhs = rhs", "$lhs = $rhs"];

notEqFormulaClass ← MakeRelationClass[$notEqFormula, $equals, $lhs, $rhs, MakeOverlaySym["=/"], "lhs # rhs", "$lhs # $rhs"];

ltFormulaClass ← MakeRelationClass[$ltFormula, $lt, $lhs, $rhs, MakeMathItalSym['<], "lhs < rhs", "$lhs < $rhs"];

gtFormulaClass ← MakeRelationClass[$gtFormula, $gt, $lhs, $rhs, MakeMathItalSym['>], "lhs > rhs", "$lhs > $rhs"];

leFormulaClass ← MakeRelationClass[$leFormula, $le, $lhs, $rhs, MakeSmallMathSym['\024], "lhs <= rhs", "$lhs <= $rhs"];

geFormulaClass ← MakeRelationClass[$geFormula, $ge, $lhs, $rhs, MakeSmallMathSym['\025], "lhs >= rhs", "$lhs >= $rhs"];

approxEqFormulaClass ← MakeRelationClass[$approxEqFormula, $equals, $lhs, $rhs, MakeSmallMathSym['\031], "lhs approx= rhs", "$lhs approx= $rhs"];

approachesClass ← MakeRelationClass[$approachesFormula, $approaches, $lhs, $rhs, MakeSmallMathSym['\041], "lhs -> rhs", "$lhs -> $rhs"];

others

listClass ← MakeCompoundClass[$list, other, "a, b", LIST[carArg, cdrArg], LIST[commaSym, listSpSym], FixedSizeBoxRule, ListCompRule, "($car $cdr)"];

functionClass ← MakeCompoundClass[$function, other, "function(args)", LIST[fArg, argsArg], LIST[funLParenSym, funRParenSym, funSpaceSym], FunctionBoxRule, FunctionCompRule, "(function $f $args)"];

altFunctionClass ← MakeCompoundClass[$altFunction, other, "function args", LIST[fArg, argsArg], LIST[altFunLP, altFunRP, funSpaceSym], FixedSizeBoxRule, FunctionCompRule, "(function $f $args)"];

complexClass ← MakeCompoundClass[$complex, other, "a + bi", LIST[realPartArg, imaginaryPartArg], LIST[iSym, plusSym], FixedSizeBoxRule, ComplexCompRule, "($a + $bi)"];

summationClass ← MakeCompoundClass[$summation, op, "summation", LIST[lbArg, ubArg, summandArg], LIST[sigmaSym], FixedSizeBoxRule, SummationCompRule, "(summation $lowerbound $upperbound $summand)"];

integrationClass ← MakeCompoundClass[$integration, op, "def integration", LIST[llimArg, ulimArg, integrandArg, wrtArg], LIST[integralSym, dxSym, integralSpaceSym], FixedSizeBoxRule, IntegrationCompRule, "(integral $lowerlimit $upperlimit $integrand $wrt)"];

indefIntClass ← MakeCompoundClass[$indefInt, op, "indef integration", LIST[integrandArg, wrtArg], LIST[integralSym, dxSym, integralSpaceSym], FixedSizeBoxRule, IndefiniteIntCompRule, "(indefIntegral $integrand $wrt)"];

powClass ← MakeCompoundClass[$pow, other, "a^b", LIST[baseArg, exponentArg], NIL, FixedSizeBoxRule, PowCompRule, "$base^$exponent"];

subscriptClass ← MakeCompoundClass[$subscript, other, "a sub b", LIST[baseArg, subscriptArg], NIL, FixedSizeBoxRule, SubscriptCompRule, "$baseSub$subscript"];

parenClass ← MakeCompoundClass[$paren, paren, "( a )", LIST[aParenArg], LIST[leftParenSym, rightParenSym], ParenBoxRule, ParenCompRule, "( $a )"];

fractionClass ← MakeCompoundClass[$fraction, over, "a / b", LIST[numeratorArg, denominatorArg], LIST[lineSym, numerSpSym, denomSpSym], FractionBoxRule, FractionCompRule, "$numerator / $denominator"];

nRadicalClass ← MakeCompoundClass[$nRadical, radical, "nth radical", LIST[nArg, radicandArg], LIST[radRootSym, radLineSym, radSpaceSym], NRadicalBoxRule, NRadicalCompRule, "(nthRoot $radicand $n)"];

radicalClass ← MakeCompoundClass[$radical, radical, "radical", LIST[radicandArg], LIST[radRootSym, radLineSym, radSpaceSym], RadicalBoxRule, RadicalCompRule, "(Root $radicand)"];

limitClass ← MakeCompoundClass[$limit, other, "limit", LIST[approachesArg, ofArg], LIST[limSpaceSym, limSym], FixedSizeBoxRule, LimitCompRule, "(limit $approaches $of)"];

factorialClass ← MakeCompoundClass[$factorial, other, "a!", LIST[factorialArg], LIST[factorialSym, factorialSpSym], FixedSizeBoxRule, FactorialCompRule, "$a!"];

register compound classes

binary ops

MathDB.InstallCompoundClass[sumClass];

MathDB.InstallCompoundClass[differenceClass];

MathDB.InstallCompoundClass[andClass];

MathDB.InstallCompoundClass[orClass];

unary ops

MathDB.InstallCompoundClass[notClass];

MathDB.InstallCompoundClass[negationClass];

others

MathDB.InstallCompoundClass[listClass];

MathDB.InstallCompoundClass[factorialClass];

MathDB.InstallCompoundClass[functionClass];

MathDB.InstallCompoundClass[altFunctionClass];

MathDB.InstallCompoundClass[powClass];

MathDB.InstallCompoundClass[subscriptClass];

MathDB.InstallCompoundClass[parenClass];

MathDB.InstallCompoundClass[complexClass];

MathDB.InstallCompoundClass[productClass];

MathDB.InstallCompoundClass[summationClass];

MathDB.InstallCompoundClass[limitClass];

MathDB.InstallCompoundClass[approachesClass];

MathDB.InstallCompoundClass[integrationClass];

MathDB.InstallCompoundClass[indefIntClass];

MathDB.InstallCompoundClass[fractionClass];

MathDB.InstallCompoundClass[radicalClass];

MathDB.InstallCompoundClass[nRadicalClass];

relations

MathDB.InstallCompoundClass[eqFormulaClass];

MathDB.InstallCompoundClass[notEqFormulaClass];

MathDB.InstallCompoundClass[ltFormulaClass];

MathDB.InstallCompoundClass[leFormulaClass];

MathDB.InstallCompoundClass[gtFormulaClass];

MathDB.InstallCompoundClass[geFormulaClass];

MathDB.InstallCompoundClass[approxEqFormulaClass];

define matrix classes

matrixClass ← MathExpr.MakeMatrixClass[$matrix, matrix, MakeBigMathSym['\042], MakeBigMathSym['\043], MakeSpace[$matrix]];

vectorClass ← MathExpr.MakeMatrixClass[$vector, matrix, MakeBigMathSym['\042], MakeBigMathSym['\043], MakeSpace[$matrix]];

install matrix classes

MathDB.InstallMatrixClass[matrixClass];

MathDB.InstallMatrixClass[vectorClass];

};