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

RETURN[boxes];

};

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

leftBox: BOX ← MathBox.GetBox[$leftAbs, boxes];

rightBox: BOX ← MathBox.GetBox[$rightAbs, boxes];

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

right and left absolute value bars must be as tall as expression "a"

scaleFactor: REAL ← MAX[0.25, 1.1 * aBox.Height[] / leftBox.Height[] ]; -- don't allow scaling to less than 1/4 size

leftBox ← MathBox.Scale[leftBox, [1.2 * scaleFactor, scaleFactor]]; -- make wider than tall

rightBox ← MathBox.Scale[rightBox, [1.2 * scaleFactor, scaleFactor]];

RETURN[LIST[aBox, leftBox, rightBox]];

};

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: 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 ($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 ($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 ($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 ($abs $a) with symbols

$absBar and $absBar

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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, MathConstructors.MakeSpace[$medium]];

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

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

};

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, MathConstructors.MakeSpace[$thin]];

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

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

};

local declarations

sumClass, fractionClass, differenceClass, powClass, productClass, negationClass, inverseClass: CompoundClass;

baseArg, exponentArg, numeratorArg, denominatorArg: Argument;

lineSym, numerSpSym, denomSpSym: Symbol;

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

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

exponentArg ← MakeArgument[$exponent, 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, MathConstructors.MakeSpace[$thin]];

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

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

define compound classes

inverseClass ← MakeUnaryOpClass[$invert, $inv, $a, MathConstructors.MakePlainRope["inv"], "inv a", "recip($a)", "$a ** (-1)"];

negationClass ← MakeUnaryOpClass[$negation, $minus, $a, MathConstructors.MakePlainSym['-], "-a", "-$a", "minus($a)", "Minus[$a]"];

sumClass ← MakeBinOpClass[$sum, $plus, $addend, $augend, MathConstructors.MakePlainSym['+], "a + b", "$addend + $augend", "plus($addend, $augend)", "Plus[$addend, $augend]"];

differenceClass ← MakeBinOpClass[$difference, $minus, $subtrahend, $minuend, MathConstructors.MakePlainSym['-], "a - b", "$subtrahend - $minuend", "difference($subtrahend, $minuend)", "Minus[$subtrahend, $minuend]"];

productClass ← MakeBinOpClass[$product, $times, $multiplier, $multiplicand, MathConstructors.MakeSpace[$product], "a * b", "$multiplier * $multiplicand", "times($multiplier, $multiplicand)", "Mult[$multiplier, $multiplicand]"];

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

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

Register compound classes in user-friendly order

MathDB.InstallCompoundClass[sumClass];

MathDB.AddOperator[sumClass, $Arithmetic];

MathDB.InstallCompoundClass[negationClass];

MathDB.AddOperator[negationClass, $Arithmetic];

MathDB.InstallCompoundClass[differenceClass];

MathDB.AddOperator[differenceClass, $Arithmetic];

MathDB.InstallCompoundClass[productClass];

MathDB.AddOperator[productClass, $Arithmetic];

MathDB.InstallCompoundClass[gcdClass];

MathDB.AddOperator[gcdClass, $Arithmetic];

MathDB.InstallCompoundClass[powClass];

MathDB.AddOperator[powClass, $Arithmetic];

MathDB.InstallCompoundClass[fractionClass];

MathDB.AddOperator[fractionClass, $Arithmetic];

MathDB.InstallCompoundClass[inverseClass];

MathDB.AddOperator[inverseClass, $Arithmetic];

};

local declarations

absClass, factorialClass: CompoundClass;

aAbsArg, factorialArg: Argument;

leftAbsSym, rightAbsSym, factorialSym, factorialSpSym: Symbol;

define info for "| a |"

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

leftAbsSym ← MakeSymbol[$leftAbs, NIL, normal, MathConstructors.MakePlainSym['\174]];

rightAbsSym ← MakeSymbol[$rightAbs, NIL, normal, MathConstructors.MakePlainSym['\174]];

define into for factorial

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

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

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

absClass ← MakeCompoundClass[$abs, paren, "| a |", LIST[aAbsArg], LIST[leftAbsSym, rightAbsSym], AbsBoxRule, AbsCompRule, "| $a |"];

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

MathDB.InstallCompoundClass[absClass];

MathDB.AddOperator[absClass, $Arithmetic];

MathDB.InstallCompoundClass[factorialClass];

MathDB.AddOperator[factorialClass, $Arithmetic];

};