DIRECTORY
MathExpr,
MathRules,
MathDB,
MathTypes,
MathBox,
Imager,
Rope,
Vector,
MathConstructors;


MathExprClassesSet: CEDAR PROGRAM 
IMPORTS MathBox, MathRules, MathExpr, 
MathDB, MathConstructors
 ~

BEGIN

EXPR: TYPE ~ MathExpr.EXPR;
BOX: TYPE ~ MathBox.BOX;
ROPE: TYPE ~ Rope.ROPE;
VEC: TYPE ~ Vector.VEC;
CompoundBoxProc: TYPE ~ MathRules.CompoundBoxProc;
CompositionProc: TYPE ~ MathRules.CompositionProc;
Alignment2D: TYPE ~ MathRules.Alignment2D;
Offset: TYPE ~ MathRules.Offset;
Size: TYPE ~ MathRules.Size;

Argument: TYPE ~ MathExpr.Argument;
Symbol: TYPE ~ MathExpr.Symbol;
CompoundClass: TYPE ~ MathExpr.CompoundClass;
FormatClass: TYPE ~ MathTypes.FormatClass;
Style: TYPE ~ MathTypes.Style;
MakeArgument: PROC[name: ATOM, aliases: LIST OF ATOM, size: Size] RETURNS[Argument] ~ MathExpr.MakeArgument;

MakeSymbol: PROC[name: ATOM, aliases: LIST OF ATOM, size: Size, value: EXPR] RETURNS[Symbol] ~ MathExpr.MakeSymbol;

MakeCompoundClass: PROC[name: ATOM, formatClass: FormatClass, description: ROPE, args: LIST OF Argument, syms: LIST OF Symbol, boxRule: CompoundBoxProc, compBox: CompositionProc, cvtAS, cvtReduce, cvtSMP, cvtOther: ROPE _ NIL] RETURNS[CompoundClass] ~ MathExpr.MakeCompoundClass;
smallGap: REAL = 0.05;
medGap: REAL = 0.10;
bigGap: REAL = 0.25;
FixedSizeBoxRule: CompoundBoxProc ~ {
RETURN[boxes];
};
FractionBoxRule: CompoundBoxProc ~ {

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];

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

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

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

dDxBoxRule: CompoundBoxProc ~ {

fbarBox: BOX _ MathBox.GetBox[$fractionBar, boxes];
dOfBox: BOX _ MathBox.GetBox[$dOf, boxes];
dxBox: BOX _ MathBox.GetBox[$dx, boxes];
differandBox: BOX _ MathBox.GetBox[$differand, boxes];
wrtBox: BOX _ MathBox.GetBox[$wrt, boxes];
topSpaceBox: BOX _ MathBox.GetBox[$topSpace, boxes];
bottomSpaceBox: BOX _ MathBox.GetBox[$bottomSpace, boxes];

scaleX: REAL _ 1.1 * MAX[dOfBox.Width[]+differandBox.Width[], dxBox.Width[]+wrtBox.Width[] ] / fbarBox.Width[];

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

RETURN[LIST[fbarBox, dOfBox, dxBox, differandBox, wrtBox, topSpaceBox, bottomSpaceBox]];
};

PartialDerivBoxRule: CompoundBoxProc ~ {

fbarBox: BOX _ MathBox.GetBox[$fractionBar, boxes];
partialOfBox: BOX _ MathBox.GetBox[$partialOf, boxes];
partialWrtBox: BOX _ MathBox.GetBox[$partialWrt, boxes];
differandBox: BOX _ MathBox.GetBox[$differand, boxes];
wrtBox: BOX _ MathBox.GetBox[$wrt, boxes];
topSpaceBox: BOX _ MathBox.GetBox[$topSpace, boxes];
bottomSpaceBox: BOX _ MathBox.GetBox[$bottomSpace, boxes];

scaleX: REAL _ 1.1 * MAX[partialOfBox.Width[]+differandBox.Width[], partialWrtBox.Width[]+wrtBox.Width[] ] / fbarBox.Width[];

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

RETURN[LIST[fbarBox, partialOfBox, partialWrtBox, differandBox, wrtBox, topSpaceBox, bottomSpaceBox]];
};

ParenBoxRule: CompoundBoxProc ~ {
leftParenBox: BOX _ MathBox.GetBox[$leftParen, boxes];
rightParenBox: BOX _ MathBox.GetBox[$rightParen, boxes];
aBox: BOX _ MathBox.GetBox[$a, boxes];

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]];
};

CurlyBoxRule: CompoundBoxProc ~ {
leftCurlyBox: BOX _ MathBox.GetBox[$leftCurly, boxes];
rightCurlyBox: BOX _ MathBox.GetBox[$rightCurly, boxes];
aBox: BOX _ MathBox.GetBox[$a, boxes];

scaleFactor: REAL _ MAX[0.25, 1.1 * aBox.Height[] / leftCurlyBox.Height[]];
leftCurlyBox _ MathBox.Scale[leftCurlyBox, [scaleFactor, scaleFactor]];
rightCurlyBox _ MathBox.Scale[rightCurlyBox, [scaleFactor, scaleFactor]];

RETURN[LIST[aBox, leftCurlyBox, rightCurlyBox]];
};

SquareBoxRule: CompoundBoxProc ~ {
leftSquareBox: BOX _ MathBox.GetBox[$leftSquare, boxes];
rightSquareBox: BOX _ MathBox.GetBox[$rightSquare, boxes];
aBox: BOX _ MathBox.GetBox[$a, boxes];

scaleFactor: REAL _ MAX[0.25, 1.1 * aBox.Height[] / leftSquareBox.Height[]];
leftSquareBox _ MathBox.Scale[leftSquareBox, [scaleFactor, scaleFactor]];
rightSquareBox _ MathBox.Scale[rightSquareBox, [scaleFactor, scaleFactor]];

RETURN[LIST[aBox, leftSquareBox, rightSquareBox]];
};

AbsBoxRule: CompoundBoxProc ~ {
leftBox: BOX _ MathBox.GetBox[$leftAbs, boxes];
rightBox: BOX _ MathBox.GetBox[$rightAbs, boxes];
aBox: BOX _ MathBox.GetBox[$a, boxes];

scaleFactor: REAL _ MAX[0.25, 1.1 * aBox.Height[] / leftBox.Height[]];
leftBox _ MathBox.Scale[leftBox, [scaleFactor, scaleFactor]];
rightBox _ MathBox.Scale[rightBox, [scaleFactor, scaleFactor]];

RETURN[LIST[aBox, leftBox, rightBox]];
};
NRadicalBoxRule: CompoundBoxProc ~ {

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];

rootScale: REAL _ ((2 * spaceBox.Height[]) + radicandBox.Height[]) / radRootBox.Height[];
lineScale: VEC _ [radicandBox.Width[]/radLineBox.Width[], 1.0];

radRootBox _ MathBox.Scale[radRootBox, [rootScale, rootScale]];
radLineBox _ MathBox.Scale[radLineBox, lineScale];

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

SummationBoxRule: CompoundBoxProc ~ {

sigmaBox: BOX _ MathBox.GetBox[$sigma, boxes];
lowerboundBox: BOX _ MathBox.GetBox[$lowerbound, boxes];
upperboundBox: BOX _ MathBox.GetBox[$upperbound, boxes];
summandBox: BOX _ MathBox.GetBox[$summand, boxes];

scaleFac: REAL _ MAX[summandBox.Height[]/sigmaBox.Height[], 1.0];

sigmaBox _ MathBox.Scale[sigmaBox, [scaleFac, scaleFac] ];

RETURN[LIST[sigmaBox, lowerboundBox, upperboundBox, summandBox]];
};

IndefiniteIntBoxRule: CompoundBoxProc ~ {

integralBox: BOX _ MathBox.GetBox[$integral, boxes];  
integrandBox: BOX _ MathBox.GetBox[$integrand, boxes];
spaceBox: BOX _ MathBox.GetBox[$space, boxes];
dxBox: BOX _ MathBox.GetBox[$dx, boxes];
wrtBox: BOX _ MathBox.GetBox[$wrt, boxes];

scaleFac: REAL _ MAX[integrandBox.Height[]/integralBox.Height[], 1.0];

integralBox _ MathBox.Scale[integralBox, [scaleFac, scaleFac] ];

RETURN[LIST[integralBox, integrandBox, dxBox, wrtBox, spaceBox]];
};

DefiniteIntBoxRule: CompoundBoxProc ~ {

integralBox: BOX _ MathBox.GetBox[$integral, boxes];
lowerlimitBox: BOX _ MathBox.GetBox[$lowerlimit, boxes];
upperlimitBox: BOX _ MathBox.GetBox[$upperlimit, boxes];
integrandBox: BOX _ MathBox.GetBox[$integrand, boxes];
spaceBox: BOX _ MathBox.GetBox[$space, boxes];
dxBox: BOX _ MathBox.GetBox[$dx, boxes];
wrtBox: BOX _ MathBox.GetBox[$wrt, boxes];

scaleFac: REAL _ MAX[integrandBox.Height[]/integralBox.Height[], 1.0];

integralBox _ MathBox.Scale[integralBox, [scaleFac, scaleFac] ];

RETURN[LIST[integralBox, lowerlimitBox, upperlimitBox, integrandBox, dxBox, wrtBox, spaceBox]];
};

RadicalBoxRule: CompoundBoxProc ~ {

radRootBox: BOX _ MathBox.GetBox[$radRoot, boxes];  
radLineBox: BOX _ MathBox.GetBox[$radLine, boxes];  
spaceBox: BOX _ MathBox.GetBox[$space, boxes];
radicandBox: BOX _ MathBox.GetBox[$radicand, boxes];

rootScale: REAL _ ((2 * spaceBox.Height[]) + radicandBox.Height[]) / radRootBox.Height[];
lineScale: VEC _ [radicandBox.Width[]/radLineBox.Width[], 1.0];

radRootBox _ MathBox.Scale[radRootBox, [rootScale, rootScale]];
radLineBox _ MathBox.Scale[radLineBox, lineScale];

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

FunctionBoxRule: CompoundBoxProc ~ {

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];

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]];
};
BinaryFunctionBoxRule: CompoundBoxProc ~ {

commaBox: BOX _ MathBox.GetBox[$comma, boxes];
lParenBox: BOX _ MathBox.GetBox[$leftParen, boxes];
rParenBox: BOX _ MathBox.GetBox[$rightParen, boxes];
spaceBox: BOX _ MathBox.GetBox[$space, boxes];
fBox: BOX _ MathBox.GetBox[$f, boxes];
firstArgBox: BOX _ MathBox.GetBox[$firstArg, boxes];
secondArgBox: BOX _ MathBox.GetBox[$secondArg, boxes];

scaleFactor: REAL _ MAX[
1.0,
1.1 * MAX[firstArgBox.Height[], secondArgBox.Height[] ] / lParenBox.Height[]
];
lParenBox _ MathBox.Scale[lParenBox, [scaleFactor, scaleFactor]];
commaBox _ MathBox.Scale[commaBox, [scaleFactor, scaleFactor]];
rParenBox _ MathBox.Scale[rParenBox, [scaleFactor, scaleFactor]];
RETURN[LIST[fBox, spaceBox, commaBox, lParenBox, rParenBox, firstArgBox, secondArgBox]];
};
PowCompRule: CompositionProc ~ {

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 {
horizOffsetBase _ [origin, hintBox.Offset[].x + hintBox.Extents[].rightExtent];
IF (hintBox.Height[] * baseBox.Height[]) > exponentBox.Height[] THEN {
vertOffsetExponent _ [bottom, 0.2];
vertOffsetBase _ [origin, hintBox.Offset[].y + hintBox.Extents[].ascent];  
}
ELSE {
vertOffsetExponent _ [bottom];
vertOffsetBase _ [origin, 0.8 * (hintBox.Offset[].y + hintBox.Extents[].ascent)];  
};
}
ELSE {
horizOffsetBase _ [right];
IF baseBox.Height[] > exponentBox.Height[] THEN {
vertOffsetExponent _ [bottom, 0.2];
vertOffsetBase _ [top];
}
ELSE {
vertOffsetExponent _ [bottom];
vertOffsetBase _ [top, -0.2];
};
};

alignments _ LIST[
[$exponent,
[$base, [left], horizOffsetBase],
[$base, vertOffsetExponent, vertOffsetBase]]];

[tempBox, tempBoxes] _
 MathRules.Compose[boxes, alignments, [$base, [origin]], [$base, [origin]]];

RETURN[tempBox, tempBoxes];
};
SubscriptCompRule: CompositionProc ~ {

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 {
vertOffsetSubscript _ [top, -0.2];
vertOffsetBase _ [bottom];
}
ELSE {
vertOffsetSubscript _ [top];
vertOffsetBase _ [bottom, +0.2];
};

alignments _ LIST[
[$subscript,
[$base, [left], [right]],
[$base, vertOffsetSubscript, vertOffsetBase]]];


[tempBox, tempBoxes] _ 
MathRules.Compose[boxes, alignments, [$base, [origin]], [$base, [origin]]];

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

RETURN[tempBox, tempBoxes];
};
FractionCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$topSpace,
[$fractionBar, [center], [center]],
[$fractionBar, [bottom], [top]]],
[$bottomSpace,
[$fractionBar, [center], [center]],
[$fractionBar, [top], [bottom]]],
[$numerator,
[$fractionBar, [center], [center]],
[$topSpace, [bottom], [top]]],
[$denominator,
[$fractionBar, [center], [center]],
[$bottomSpace, [top], [bottom]]]];

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

RETURN[tempBox, tempBoxes];
};
dDxCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$topSpace,
[$fractionBar, [center], [center]],
[$fractionBar, [bottom], [top]]],
[$bottomSpace,
[$fractionBar, [center], [center]],
[$fractionBar, [top], [bottom]]],
[$dOf,
[$fractionBar, [left], [left, 0.05]],
[$topSpace, [bottom], [top]]],
[$differand,
[$dOf, [left], [right]],
[$dOf, [bottom], [bottom]]],
[$dx,
[$fractionBar, [left], [left, 0.05]],
[$bottomSpace, [top], [bottom]]],
[$wrt,
[$dx, [left], [right]],
[$dx, [origin], [origin]]]
];

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

RETURN[tempBox, tempBoxes];
};
PartialDerivCompRule: CompositionProc ~ {
tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$topSpace,
[$fractionBar, [center], [center]],
[$fractionBar, [bottom], [top]]],
[$bottomSpace,
[$fractionBar, [center], [center]],
[$fractionBar, [top], [bottom]]],
[$partialOf,
[$fractionBar, [left], [left, 0.05]],
[$topSpace, [bottom], [top]]],
[$differand,
[$partialOf, [left], [right]],
[$partialOf, [bottom], [bottom]]],
[$partialWrt,
[$fractionBar, [left], [left, 0.05]],
[$bottomSpace, [top], [bottom]]],
[$wrt,
[$partialWrt, [left], [right]],
[$partialWrt, [origin], [origin]]]
];

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

RETURN[tempBox, tempBoxes];
};
AboveCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$bottomSpace,
[$bottomArg, [center], [center]],
[$bottomArg, [bottom], [top]]],
[$topSpace,
[$bottomArg, [center], [center]],
[$bottomSpace, [bottom], [top]]],
[$topArg,
[$bottomArg, [center], [center]],
[$topSpace, [bottom], [top]]]
];
[tempBox, tempBoxes] _
 MathRules.Compose[boxes, alignments, [$topArg, [origin]],
  [$bottomSpace, [top]]];

RETURN[tempBox, tempBoxes];
};
HatCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$bottomSpace,
[$base, [center], [center]],
[$base, [bottom], [top]]],
[$hat,
[$base, [center], [center]],
[$bottomSpace, [bottom], [top]]]
];
[tempBox, tempBoxes] _
 MathRules.Compose[boxes, alignments, [$base, [origin]],  [$base, [origin]]];

RETURN[tempBox, tempBoxes];
};
ListCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$car,
[$comma, [right], [left]],
[$comma, [origin], [origin]]],
[$space,
[$comma, [left], [right]],
[$comma, [origin], [origin]]],
[$cdr,
[$space, [left], [right]],
[$comma, [origin], [origin]]]];

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

RETURN[tempBox, tempBoxes];
};
FunctionCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$leftParen,
[$args, [right], [left]],
[$args, [center], [center]]],
[$rightParen,
[$args, [left], [right]],
[$args, [center], [center]]],
[$space,
[$leftParen, [right], [left]],
[$args, [origin], [origin]]],
[$f,
[$space, [right], [left]],
[$args, [origin], [origin]]]];

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

RETURN[tempBox, tempBoxes];
};
BinaryFunctionCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$leftParen,
[$firstArg, [right], [left]],
[$firstArg, [center], [center]]],
[$comma,
[$firstArg, [left], [right]],
[$firstArg, [origin], [origin]]],
[$secondArg,
[$comma, [left], [right, medGap]],
[$comma, [origin], [origin]]],
[$rightParen,
[$secondArg, [left], [right]],
[$secondArg, [center], [center]]],
[$space,
[$leftParen, [right], [left]],
[$firstArg, [origin], [origin]]],
[$f,
[$space, [right], [left]],
[$firstArg, [origin], [origin]]]];

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

RETURN[tempBox, tempBoxes];
};
LimitCompRule: CompositionProc ~ {

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 {
alignments _ LIST[
[$space,
[$of, [right], [left]],
[$of, [center], [center]]],
[$approaches,
[$space, [right], [left]],
[$space, [top], [bottom]]],
[$lim,
[$approaches, [center], [center]],
[$space, [bottom], [top]]]];
}
ELSE {
alignments _ LIST[
[$space,
[$of, [right], [left]],
[$of, [center], [center]]],
[$lim,
[$space, [right], [left]],
[$space, [bottom], [top]]],
[$approaches,
[$lim, [center], [center]],
[$space, [top], [bottom]]]];
};

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

RETURN[tempBox, tempBoxes];
};
SummationCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ NIL;
vertSigmaOffset, vertSummandOffset: Offset;

SELECT MathBox.GetBox[$summand, boxes].FormatClass[] FROM
over, radical, matrix => {
vertSigmaOffset _ [center];
vertSummandOffset _ [center];
};
ENDCASE => {
vertSummandOffset _ [origin];
vertSigmaOffset _ [center, -0.2];
};
alignments _ LIST[
[$lowerbound,
[$sigma, [center], [center]],
[$sigma, [top], [bottom, -smallGap]]],
[$upperbound, 
[$sigma, [center], [center]],
[$sigma, [bottom], [top, +smallGap]]],
[$summand, 
[$sigma, [left], [right, medGap]],
[$sigma, vertSummandOffset, vertSigmaOffset]]];

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

RETURN[tempBox, tempBoxes];
};
NRadicalCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$radRoot, 
[$radicand, [right], [left]],
[$radicand, [center], [center]]],
[$space,
[$radicand, [center], [center]],
[$radicand, [bottom], [top]]],
[$radLine,
[$radRoot, [left], [right]],
[$radRoot, [top], [top]]],
[$n, 
[$radRoot, [right], [left, bigGap]],
[$radRoot, [bottom], [center, +smallGap]]]];

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

RETURN[tempBox, tempBoxes];
};

RadicalCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$radRoot, 
[$radicand, [right], [left]],
[$radicand, [center], [center]]],
[$space,
[$radicand, [center], [center]],
[$radicand, [bottom], [top]]],
[$radLine,
[$radRoot, [left], [right]],
[$radRoot, [top], [top]]]];

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

RETURN[tempBox, tempBoxes];
};
IntegrationCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ NIL;
vertIntegralOffset, vertIntegrandOffset: Offset;

SELECT MathBox.GetBox[$integrand, boxes].FormatClass[] FROM
over, radical, matrix => {
vertIntegralOffset _ [center];
vertIntegrandOffset _ [center];
};
ENDCASE => {
vertIntegralOffset _ [center, -0.2];
vertIntegrandOffset _ [origin];
};
alignments _ LIST[
[$lowerlimit,
[$integral, [right], [left, +bigGap]],
[$integral, [top], [bottom, -smallGap]]],
[$upperlimit,
[$integral, [right], [right]],
[$integral, [bottom], [top, +smallGap]]],
[$integrand,
[$integral, [left], [right]],
[$integral, vertIntegrandOffset, vertIntegralOffset]],  
[$space,
[$integrand, [left], [right]],
[$integrand, [origin], [origin]]],
[$dx, 
[$space, [left], [right]],
[$integral, vertIntegrandOffset, vertIntegralOffset ]], -- dsa 4/15/87
[$wrt,
[$dx, [left], [right]],
[$dx, [origin], [origin]]]];

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

RETURN[tempBox, tempBoxes];
};
IndefiniteIntCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
vertIntegralOffset, vertIntegrandOffset: Offset;
alignments: LIST OF Alignment2D _ NIL; 

SELECT MathBox.GetBox[$integrand, boxes].FormatClass[] FROM
over, radical, matrix => {
vertIntegralOffset _ [center];
vertIntegrandOffset _ [center];
};
ENDCASE => {
vertIntegralOffset _ [center, -0.2];
vertIntegrandOffset _ [origin];
};
alignments _ LIST[
[$integrand,
[$integral, [left], [right]],
[$integral, vertIntegrandOffset, vertIntegralOffset ]],
[$space,
[$integrand, [left], [right]],
[$integrand, [origin], [origin]]],
[$dx, 
[$space, [left], [right,]],
[$integral, vertIntegrandOffset, vertIntegralOffset ]], -- dsa 4/15/87
[$wrt,
[$dx, [left], [right]],
[$dx, [origin], [origin]]]];

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

RETURN[tempBox, tempBoxes];
};
UnaryOpCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$aliasSpace,
[$aliasUnaryOp, [left], [right]],
[$aliasUnaryOp, [origin], [origin]]],
[$aliasA,
[$aliasSpace, [left], [right]],
[$aliasSpace, [origin], [origin]]]];

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

RETURN[tempBox, tempBoxes];
};

BinaryOpCompRule: CompositionProc ~ {
tempBox: BOX;
tempBoxes: LIST OF BOX;
leftVertOffsetA, leftVertOffsetOp, rightVertOffsetB, rightVertOffsetOp: Offset;
alignments: LIST OF Alignment2D;

SELECT MathBox.GetBox[$aliasA, boxes].FormatClass[] FROM
over => {
leftVertOffsetA _ [origin];
leftVertOffsetOp _ [center];
};
matrix => {
leftVertOffsetA _ [center];
leftVertOffsetOp _ [center];
};
ENDCASE => {
leftVertOffsetA _ [origin];
leftVertOffsetOp _ [origin];
};

SELECT MathBox.GetBox[$aliasB, boxes].FormatClass[] FROM
over => {
rightVertOffsetB _ [origin];
rightVertOffsetOp _ [center];
};
matrix => {
rightVertOffsetB _ [center];
rightVertOffsetOp _ [center];
};
ENDCASE => {
rightVertOffsetB _ [origin];
rightVertOffsetOp _ [origin];
};

alignments _ LIST[
[$aliasLeftSpace,
[$aliasBinOp, [right], [left]],
[$aliasBinOp, [origin], [origin]]],
[$aliasA, 
[$aliasLeftSpace, [right], [left]],
[$aliasBinOp, leftVertOffsetA, leftVertOffsetOp]],
[$aliasRightSpace,
[$aliasBinOp, [left], [right]],
[$aliasBinOp, [origin], [origin]]],
[$aliasB,
[$aliasRightSpace, [left], [right]],
[$aliasBinOp, rightVertOffsetB, rightVertOffsetOp]]];

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

RETURN[tempBox, tempBoxes];
};
RelationCompRule: CompositionProc ~ {
tempBox: BOX;
tempBoxes: LIST OF BOX;
leftVertOffsetLHS, leftVertOffsetRel, rightVertOffsetRHS, rightVertOffsetRel: Offset;
alignments: LIST OF Alignment2D;

SELECT MathBox.GetBox[$aliasLHS, boxes].FormatClass[] FROM
over => {
leftVertOffsetLHS _ [origin];
leftVertOffsetRel _ [center];
};
matrix => {
leftVertOffsetLHS _ [center];
leftVertOffsetRel _ [center];
};
ENDCASE => {
leftVertOffsetLHS _ [origin];
leftVertOffsetRel _ [origin];
};

SELECT MathBox.GetBox[$aliasRHS, boxes].FormatClass[] FROM
over => {
rightVertOffsetRHS _ [origin];
rightVertOffsetRel _ [center];
};
matrix => {
rightVertOffsetRHS _ [center];
rightVertOffsetRel _ [center];
};
ENDCASE => {
rightVertOffsetRHS _ [origin];
rightVertOffsetRel _ [origin];
};

alignments _ LIST[
[$aliasLeftSpace,
[$aliasRelation, [right], [left]],
[$aliasRelation, [origin], [origin]]],
[$aliasLHS, 
[$aliasLeftSpace, [right], [left]],
[$aliasRelation, leftVertOffsetLHS, leftVertOffsetRel]],
[$aliasRightSpace,
[$aliasRelation, [left], [right]],
[$aliasRelation, [origin], [origin]]],
[$aliasRHS,
[$aliasRightSpace, [left], [right]],
[$aliasRelation, rightVertOffsetRHS, rightVertOffsetRel]]];

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

RETURN[tempBox, tempBoxes];
};
ComplexCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _
LIST[
[$a, [$plus, [right], [left, -medGap]],
[$plus, [origin], [origin]]],
[$leftParen, [$a, [right], [left, -medGap]],
[$plus, [origin], [origin]]],
[$b, [$plus, [left], [right, medGap]],
[$plus, [origin], [origin]]],      
[$i, [$b, [left], [right, medGap]],
[$b, [origin], [origin]]],      
[$rightParen, [$i, [left], [right, medGap]],
[$plus, [origin], [origin]]]
];

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

RETURN[tempBox, tempBoxes];
};
FactorialCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$space,
[$a, [left], [right]],
[$a, [origin], [origin]]],
[$bang,
[$space, [left], [right]],
[$a, [origin], [origin]]]];

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

RETURN[tempBox, tempBoxes];
};
ParenCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$leftParen, 
[$a, [right], [left]],
[$a, [center], [center]]],
[$rightParen,
[$a, [left], [right]],
[$a, [center], [center]]]];

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

RETURN[tempBox, tempBoxes];
};

CurlyCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$leftCurly, 
[$a, [right], [left]],
[$a, [center], [center]]],
[$rightCurly,
[$a, [left], [right]],
[$a, [center], [center]]]];

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

RETURN[tempBox, tempBoxes];
};

SquareCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$leftSquare, 
[$a, [right], [left]],
[$a, [center], [center]]],
[$rightSquare,
[$a, [left], [right]],
[$a, [center], [center]]]];

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

RETURN[tempBox, tempBoxes];
};

AbsCompRule: CompositionProc ~ {

tempBox: BOX;
tempBoxes: LIST OF BOX;
alignments: LIST OF Alignment2D _ LIST[
[$leftAbs, 
[$a, [right], [left]],
[$a, [center], [center]]],
[$rightAbs,
[$a, [left], [right]],
[$a, [center], [center]]]];

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

RETURN[tempBox, tempBoxes];
};

MakeUnaryOpClass: PUBLIC PROC[class, op, arg: ATOM, operation: EXPR, description: ROPE, cvtAS, cvtReduce, cvtSMP, cvtOther: ROPE _ NIL] RETURNS[CompoundClass] ~ {
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]];
};


MakeBinOpClass: PUBLIC PROC[class, op, a, b: ATOM, operation: EXPR, 
description: ROPE, cvtAS, cvtReduce, cvtSMP, cvtOther: ROPE _ NIL] RETURNS[CompoundClass] ~ {

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]];
};

MakeRelationClass: PUBLIC PROC[class, rel, lhs, rhs: ATOM, relation: EXPR, 
description: ROPE, cvtAS, cvtReduce, cvtSMP, cvtOther: ROPE _ NIL] RETURNS[CompoundClass] ~ {

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, MathConstructors.MakeSpace[$thick]];
rightSpace: Symbol _ MakeSymbol[$rightSpace, LIST[$aliasRightSpace], normal, MathConstructors.MakeSpace[$thick]];

RETURN[MakeCompoundClass[class, relation, description, LIST[lhsArg, rhsArg], LIST[relSym, leftSpace, rightSpace], FixedSizeBoxRule, RelationCompRule, cvtAS, cvtReduce, cvtSMP, cvtOther]];
};
wrongBoxType: PUBLIC ERROR = CODE;
InstallSetClassesA: PROC [] ~ {

differenceClass: CompoundClass;


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


MathDB.InstallCompoundClass[differenceClass];
MathDB.AddOperator[differenceClass, $Set];

};


InstallSetClassesB: PROC [] ~ {

eqFormulaClass, notEqFormulaClass, subsetClass, elementOfClass, unionClass, intersectClass: CompoundClass;

eqFormulaClass _ MakeRelationClass[$eqFormula, $equals, $lhs, $rhs, MathConstructors.MakePlainSym['=], "a = b", "$lhs = $rhs", "equal($lhs, $rhs)", "Eq[$lhs, $rhs]"];
notEqFormulaClass _ MakeRelationClass[$notEqFormula, $equals, $lhs, $rhs, MathConstructors.MakeOverlaySym["=/"], "a # b", "$lhs # $rhs"];
subsetClass _ MakeRelationClass[$subset, $subset, $lhs, $rhs, MathConstructors.MakeBigMathSym['\133], "a subset b", "$lhs subset $rhs"];
elementOfClass _ MakeRelationClass[$elementOf, $elementOf, $lhs, $rhs, MathConstructors.MakeBigMathSym['\112], "a elementOf b", "$lhs elementOf $rhs"];
unionClass _ MakeRelationClass[$union, $union, $lhs, $rhs, MathConstructors.MakeBigMathSym['\127], "a union b", "$lhs union $rhs"];
intersectClass _ MakeRelationClass[$intersect, $intersect, $lhs, $rhs, MathConstructors.MakeBigMathSym['\126], "a intersect b", "$lhs intersect $rhs"];

MathDB.InstallCompoundClass[eqFormulaClass];
MathDB.AddOperator[eqFormulaClass, $Set];
MathDB.InstallCompoundClass[notEqFormulaClass];
MathDB.AddOperator[notEqFormulaClass, $Set];
MathDB.InstallCompoundClass[subsetClass];
MathDB.AddOperator[subsetClass, $Set];
MathDB.InstallCompoundClass[elementOfClass];
MathDB.AddOperator[elementOfClass, $Set];
MathDB.InstallCompoundClass[unionClass];
MathDB.AddOperator[unionClass, $Set];
MathDB.InstallCompoundClass[intersectClass];
MathDB.AddOperator[intersectClass, $Set];
};

InstallSetClassesA[];
InstallSetClassesB[];

END.




ΰMathExprClassesSet.mesa
Carl Waldspurger, August 30, 1986 7:12:37 pm PDT
Bier, November 20, 1986 2:02:38 pm PST
Arnon, March 24, 1987 4:15:37 pm PST
Type Abbreviations from Imported Interfaces
Procedure Abbreviations from Imported Interfaces
Constants
Box Procs for Compound Expr Classes
effects:  Returns unaltered boxes (i.e. no resizing takes place)
effects:  Sizes boxes for expr of form ($fractionBar $numerator $denominator)
should ENABLE noSuchBox
fraction bar must be as wide as the wider of numerator, denominator
adjust fbarBox extents
effects:  Sizes boxes for expr of form ($dDx $differand $wrt)
should ENABLE noSuchBox
fraction bar must be as wide as the wider of numerator, denominator
adjust fbarBox extents
should ENABLE noSuchBox
fraction bar must be as wide as the wider of numerator, denominator
adjust fbarBox extents
effects:  Sizes boxes for expr of form ($paren $a)

right and left parentheses must be as tall as expression "a"
effects:  Sizes boxes for expr of form ($curly $a)

right and left curly brackets must be as tall as expression "a"
effects:  Sizes boxes for expr of form ($square $a)

right and left square brackets must be as tall as expression "a"
effects:  Sizes boxes for expr of form ($abs $a)

right and left absolute value bars must be as tall as expression "a"
effects:  Sizes boxes for expr of form ($radRoot $radLine $n $radicand)
should ENABLE noSuchBox
line must be exactly as long as radicand,
root symbol must be as tall as radicand + 2*space
adjust symbol extents
effects:  Sizes boxes for expr of form ($summation $lowerbound $upperbound $summand)
dsa 4/17/87
should ENABLE noSuchBox
spaceBox: BOX _ MathBox.GetBox[$space, boxes];
summation sign must grow if summand does
adjust symbol extents
effects:  Sizes boxes for expr of form ($integral $integrand $dx $wrt)
dsa 4/17/87
should ENABLE noSuchBox
integral sign must grow if integrand does
adjust symbol extents
effects:  Sizes boxes for expr of form ($integral $lowerlimit $upperlimit $integrand $dx $wrt)
dsa 4/17/87
should ENABLE noSuchBox
integral sign must grow if integrand does
adjust symbol extents
effects:  Sizes boxes for expr of form ($radRoot $radLine $radicand)
should ENABLE noSuchBox
line must be exactly as long as radicand,
root symbol must be as tall as radicand + 2*space
adjust symbol extents
effects:  Sizes boxes for expr of form ($f $space $args $leftParen $rightParen)
should ENABLE noSuchBox
parens must be as big as args
right and left parentheses must be as tall as expression "a"

effects:  Sizes boxes for expr of form ($f $space $firstArg $secondArg $leftParen $rightParen)
should ENABLE noSuchBox
right and left parentheses must be as tall as max of expressions "a" and "b"

Composition Procs for Compound Expr Classes
effects:  Composes layout for expr of form ($exponent $base)
hint, so align exponent with base via hintBox
top of hint box inside base box
0.8 way up on hint box
no hint, so align exponent directly with base
effects:  Composes layout for expr of form ($base $subscript)
make hint to place superscript over base instead of entire expression
effects:  Composes layout for expr of form ($fractionBar $numerator $denominator)
effects:  Composes layout for expr of form ($fractionBar $differand $wrt)
effects:  Composes layout for expr of form ($above $topArg $bottomArg)
effects:  Composes layout for expr of form ($hat $base $hat)
effects:  Composes layout for expr of form ($comma $car $cdr) with symbol $space.
effects:  Composes layout for expr of form ($f $space $args $leftParen $rightParen)
effects:  Composes layout for expr of form ($f $space $firstArg $secondArg $comma $leftParen $rightParen)
effects:  Composes layout for expr of form ($lim $approaches $of $space)
effects:  Composes layout for expr of form ($summation $lowerbound $upperbound
          $summand)
effects:  Compose layout for expr of form ($radRoot $radLine $n $radicand)
effects:  Compose layout for expr of form ($radRoot $radLine $radicand)
effects:  Composes layout for expr of form ($integral $lowerlimit 
          $upperlimit $integrand $dx $wrt)
[$space, [origin], [origin]]], -- Carl's original y-alignment
effects:  Composes layout for expr of form ($integral $integrand $dx $wrt)
[$space, [origin], [origin]]], -- Carl's original y-alignment
effects:  Composes layout for expr of form ($aliasUnaryOp $aliasA).
effects:  Composes layout for expr of form ($aliasBinOp $aliasA $aliasB) with
          symbols $aliasLeftSpace & $aliasRightSpace.

set vertical offset depending on format classes of A & B arguments
effects:  Composes layout for expr of form ($aliasRelation $aliasLHS $aliasRHS) with
          symbols $aliasLeftSpace & $aliasRightSpace.

set vertical offset depending on format classes of lhs & rhs arguments
effects:  Composes layout for expr of form ($complex $a $b)
effects:  Composes layout for expr of form ($bang $a $space)
effects:  Composes layout for expr of form ($paren $a) with symbols 
          $leftParen and $rightParen
effects:  Composes layout for expr of form ($curly $a) with symbols 
          $leftCurly and $rightCurly
effects:  Composes layout for expr of form ($square $a) with symbols 
          $leftSquare and $rightSquare
effects:  Composes layout for expr of form ($abs $a) with symbols 
          $absBar and $absBar
Class Constructors
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".

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".
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".
Signals & Errors
Define & Install Expression Classes 
local declarations
differenceClass _ MakeBinOpClass[$difference, $minus, $subtrahend, $minuend, MathConstructors.MakePlainSym['-], "a - b", "$subtrahend - $minuend", "$subtrahend - $minuend", "Minus[$subtrahend, $minuend]"];
Register compound classes in user-friendly order 

local declarations
relations

Install Classes Defined in this Module
Κϋ˜Jš
œ™š
œ0™0Icode™&K™$—J˜J˜š
Οk	˜	Kš
œ	˜	Kš
œ
˜
K˜K˜
K˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—J˜šΟnœœ
œ
˜"šœ˜&Jš
œ˜—Jš
œ˜J˜Jš
˜—J˜
headš
ž+™+Jšœœœ
˜Jšœœœ
˜Jšœœœ
˜Jšœœ
œ
˜Jšœœ˜2Jšœœ˜2Jšœ
œ˜*Jšœœ˜ Jšœœ˜J˜Jšœ
œ˜#Jšœœ˜Jšœœ˜-Jšœ
œ˜*Jšœœ˜—š
ž0™0Jšžœœœœ
œ
œœ#˜lJ˜Jšž
œœœœ
œ
œœœ˜sJ˜Jšžœœœ)œœ
œœ
œaœœœ-˜——š
ž	™	Jšœ
œ˜Jšœœ˜Jšœœ˜—š
ž#™#šžœ˜%Kš
œ@™@Kšœ˜K˜—šžœ˜$Kš
œM™MK˜Kš
œ™Kšœ	œ'˜3Kšœœ%˜0Kšœ
œ'˜4K˜4K˜:K˜Kš
œC™CKšœœ	œ6˜NK˜Kš
œ™Kš
œ0˜0K˜Kšœ
œ:˜EK˜K˜—šž
œ˜Kš
œ=™=K˜Kšœœ
™Kšœ	œ'˜3Kšœœ˜*Kšœœ˜(Kšœœ%˜6Kšœœ˜*Kšœ
œ$˜4Kšœœ'˜:K˜Kš
œC™CKšœœ	œW˜oK˜Kš
œ™K˜0K˜Kšœ
œM˜XK˜K˜—šžœ˜(K˜Kšœœ
™Kšœ	œ'˜3Kšœœ%˜6Kšœœ&˜8Kšœœ%˜6Kšœœ˜*Kšœ
œ$˜4Kšœœ'˜:K˜Kš
œC™CKšœœ	œe˜}K˜Kš
œ™K˜0K˜Kšœ
œ[˜fK˜K˜—šžœ˜!Kš
œ2™2K™Kšœœ%˜6Kšœœ&˜8Kšœœ˜&K˜Kš
œ<™<Kšœ
œœ4˜KK˜GK˜IK˜Kšœ
œ%˜0K˜K˜—šžœ˜!Kš
œ2™2K™Kšœœ%˜6Kšœœ&˜8Kšœœ˜&K˜Kš
œ?™?Kšœ
œœ4˜KKš
œG˜GKš
œI˜IK˜Kšœ
œ%˜0K˜K˜—šž
œ˜"Kš
œ3™3K™Kšœœ&˜8Kšœœ'˜:Kšœœ˜&K˜Kš
œ@™@Kšœ
œœ5˜LKš
œI˜IKš
œK˜KK˜Kšœ
œ'˜2K˜K˜—šž
œ˜Kš
œ0™0K™Kšœ	œ#˜/Kšœ
œ$˜1Kšœœ˜&K˜Kš
œD™DKšœ
œœ/˜FKš
œ=˜=Kš
œ?˜?K˜Kšœ
œ˜&K˜—šžœ˜$Kš
œG™GK˜Kš
œ™Kšœœ%˜4Kšœœ%˜4Kšœœ˜'Kšœ
œ!˜.Kšœ
œ$˜4K˜Kš
œ)™)Kš
œ1™1KšœœJ˜YKšœœ1˜?K˜Kš
œ™K˜?K˜2K˜Kšœ
œ7˜BK˜K˜—šžœ˜%Kš
œT™TK™K˜Kš
œ™Kšœ
œ!˜.Kšœœ&˜8Kšœœ&˜8Kšœœ#˜2Kšœ
œ!™.K˜Kš
œ(™(Kšœ
œœ-˜AK˜Kš
œ™Kš
œ:˜:K˜Kšœ
œ6˜AK˜K˜—šžœ˜)Kš
œF™FK™K˜Kš
œ™Kšœ
œ&˜6Kšœœ%˜6Kšœ
œ!˜.Kšœœ˜(Kšœœ˜*K˜Kš
œ)™)Kšœ
œœ2˜FK˜Kš
œ™Kš
œ@˜@K˜Kšœ
œ6˜AK˜K˜—šžœ˜'Kš
œ^™^K™K˜Kš
œ™Kšœ
œ$˜4Kšœœ&˜8Kšœœ&˜8Kšœœ%˜6Kšœ
œ!˜.Kšœœ˜(Kšœœ˜*K˜Kš
œ)™)Kšœ
œœ2˜FK˜Kš
œ™Kš
œ@˜@K˜Kšœ
œT˜_K˜K˜—šžœ˜#Kš
œD™DK˜Kš
œ™Kšœœ%˜4Kšœœ%˜4Kšœ
œ!˜.Kšœ
œ$˜4K˜Kš
œ)™)Kš
œ1™1KšœœJ˜YKšœœ1˜?K˜Kš
œ™K˜?K˜2K˜Kšœ
œ1˜<K˜K˜—šžœ˜$Kš
œO™OK˜Kš
œ™Kšœœ%˜3Kšœœ&˜4Kšœ
œ!˜.Kšœœ˜&Kšœ	œ ˜,K˜Kš
œ™Kš
œ<™<Kšœ
œœ3˜JK˜AK˜AK™Kšœ
œ1˜<K˜—šžœ˜*Kš
œ^™^K˜Kš
œ™Kšœ
œ!˜.Kšœœ%˜3Kšœœ&˜4Kšœ
œ!˜.Kšœœ˜&Kšœ
œ$˜4Kšœœ%˜6K˜Kš
œL™Lšœ
œœ
˜Kš
œ˜KšœœC˜LKš
œ˜—K˜AKš
œ?˜?K˜AK™Kšœ
œM˜XK˜——š
ž+™+šžœ˜ Kš
œ<™<K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜K˜<Kšœœ
œœ
˜&Kšœ	œ ˜,Kšœ
œ$˜4Kšœ	œΟc/˜ZK˜šœœ
œ˜Kš
œ-™-K˜Ošœ>œ˜FK˜#Kš
œ™Kš
œK˜KK˜
—šœ˜Kš
œ˜Kš
œ™Kš
œS˜SK˜—K˜
—šœ˜Kš
œ-™-K˜šœ)œ˜1K˜#K˜K˜
—šœ˜K˜K˜K˜—K˜K˜—šœ
œ
˜˜K˜!K˜.K˜——˜K˜LK˜—Kšœ˜K˜—šžœ˜&Kš
œ=™=K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜K˜,Kšœœ
œœ
˜&K˜šœUœ˜]K˜"K˜K˜
—šœ˜K˜K˜ K˜K˜—šœ
œ
˜˜K˜K˜/K˜——K˜˜K˜K—K˜Kš
œE™EK˜DK˜Kšœ˜K˜—šžœ˜%Kš
œQ™QK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜#K˜!—˜K˜#K˜!—˜K˜#K˜—˜K˜#K˜"K˜——K˜sK˜Kšœ˜K˜—šžœ˜ Kš
œI™IK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜#K˜!—˜K˜#K˜!—š
œ˜K˜%K˜—š
œ˜Kš
œ˜Kš
œ˜—š
œ˜K˜%K˜!—š
œ˜Kš
œ˜Kš
œ˜—˜K˜——K˜sK˜Kšœ˜K˜—šžœ˜)Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜#K˜!—˜K˜#K˜!—š
œ˜K˜%K˜—š
œ˜Kš
œ˜Kš
œ"˜"—š
œ
˜
K˜%K˜!—š
œ˜Kš
œ˜Kš
œ"˜"—˜K˜——K˜sK˜Kšœ˜K˜—šž
œ˜"Kš
œF™FK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜Kš
œ!˜!Kš
œ˜—˜Kš
œ!˜!Kš
œ!˜!—š
œ	˜	Kš
œ!˜!Kš
œ˜—K˜—Kš
œk˜kK˜Kšœ˜K˜—šžœ˜ Kš
œ<™<K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜Kš
œ˜Kš
œ˜—š
œ˜Kš
œ˜Kš
œ ˜ —K˜—Kš
œd˜dK˜Kšœ˜K˜—šžœ˜!Kš
œQ™QK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜K˜—˜K˜K˜—˜K˜K˜—K˜—K˜cK˜Kšœ˜K˜—šžœ˜%Kš
œS™SK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜K˜—˜
K˜K˜—˜K˜K˜—˜K˜K˜—K˜—K˜]K˜Kšœ˜K˜—šžœ˜+Kš
œi™iK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜K˜!—˜K˜K˜!—˜Kš
œ"˜"K˜—˜
K˜K˜"—˜K˜K˜!—˜K˜K˜"—K˜—K˜]K˜Kšœ˜K˜—šž
œ˜"Kš
œH™HK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜Kšœœ˜*Kšœœ&˜8Kšœœ
œ
˜ K˜šœ(œ˜0šœ
œ
˜˜K˜K˜—˜
K˜K˜—˜K˜"K˜——K˜
—šœ˜šœ
œ
˜˜K˜K˜—˜K˜K˜—˜
K˜K˜——K˜K˜—K˜gK˜Kšœ˜K˜—šžœ˜&Kš
œN™NKš
œ™K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜Kšœœ
œœ
˜&K˜+K˜šœ/˜9˜K˜K˜K˜—šœ˜K˜K˜!K˜——š
œ˜˜
K˜K˜&—˜K˜K˜&—˜K˜"K˜/——K˜K˜kK˜Kšœ˜K˜—šžœ˜%Kš
œJ™JK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜K˜!—˜K˜ K˜—˜
K˜K˜—˜K˜$K˜,—K˜—K˜dK˜Kšœ˜K˜K˜—šžœ˜$Kš
œG™GK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜K˜!—˜K˜ K˜—˜
K˜K˜—K˜—K˜mK˜Kšœ˜K˜—šžœ˜(Kš
œB™BKš
œ*™*K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜Kšœœ
œœ
˜&K˜0K˜šœ1˜;˜K˜K˜K˜—šœ˜K˜$K˜K˜——šœ
œ
˜˜
K˜&K˜)—˜
K˜K˜)—˜K˜Kš
œ8˜8—˜K˜K˜"—˜K˜K™=Kšœ8Ÿ˜F—˜K˜K˜K˜——K˜sK˜Kšœ˜Kš
œ˜—šžœ˜*Kš
œJ™JK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜K˜0Kšœœ
œœ˜'K˜šœ1˜;˜K˜K˜K˜—šœ˜K˜$Kš
œ˜K˜——šœ
œ
œ
˜˜K˜Kš
œ7˜7—˜K˜K˜"—˜K˜K™=Kšœ8Ÿ˜F—˜K˜K˜K˜——K˜rK˜Kšœ˜K˜—šžœ˜$Kš
œC™CK˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜
K˜!K˜%—˜	K˜K˜$K˜——K˜sK˜Kšœ˜˜K˜——šžœ˜%Kš
œM™MK™5K™Kšœ	œ
˜
Kšœœ
œ
œ
˜K˜OKšœœ
œ
˜ K˜Kš
œB™Bšœ.˜8˜	K˜K˜K˜—˜K˜K˜K˜—šœ˜K˜K˜K˜K˜——šœ.˜8˜	K˜K˜K˜—˜K˜K˜K˜—šœ˜K˜K˜K˜——K˜šœ
œ
˜˜Kš
œ˜K˜#—˜
K˜#K˜2—˜K˜K˜#—˜	K˜$K˜5K˜——K˜jK˜Kšœ˜K˜—šžœ˜%Kš
œT™TK™5K™Kšœ	œ
˜
Kšœœ
œ
œ
˜K˜UKšœœ
œ
˜ K˜Kš
œF™Fšœ0˜:˜	K˜K˜K˜—˜K˜K˜K˜—šœ˜K˜K˜K˜K˜——šœ0˜:˜	K˜K˜K˜—˜K˜K˜K˜—šœ˜K˜K˜K˜——K˜šœ
œ
˜˜K˜"K˜&—˜K˜#K˜8—˜K˜"K˜&—˜K˜$K˜;K˜——K˜oK˜Kšœ˜K˜—šžœ˜$Kš
œ;™;K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œ˜!Kšœ
˜š
œ'˜'K˜—š
œ,˜,K˜—š
œ&˜&K˜#—š
œ#˜#K˜ —š
œ,˜,K˜—K˜—K˜K˜_K˜Kšœ˜K˜—šžœ˜&Kš
œ<™<K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜K˜—˜K˜K˜K˜——K˜\K˜Kšœ˜K˜—šž
œ˜"Kš
œD™DKš
œ$™$K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜
K˜K˜—˜
K˜K˜K˜——K˜oK˜Kšœ˜K˜K˜—šž
œ˜"Kš
œD™DKš
œ$™$K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'š
œ
˜
K˜K˜—š
œ
˜
K˜K˜K˜——Kš
œo˜oK˜Kšœ˜K˜K˜—šžœ˜#Kš
œE™EKš
œ&™&K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'š
œ˜K˜K˜—š
œ˜K˜K˜K˜——Kš
œp˜pK˜Kšœ˜K˜K˜—šžœ˜ Kš
œB™BKš
œ™K˜Kšœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'š
œ˜K˜K˜—š
œ˜K˜K˜K˜——Kš
œm˜mK˜Kšœ˜K˜K˜——š
ž™Kšžœœ
œœ
œœ&œœœ˜’
š
œT™TKš
œJ™JKš
œ2™2K™Kšœ%œ˜GKšœ&œ<˜fKšœ$œ%˜MKšœ0œ
œ`˜¨
K˜K˜—K˜šžœœ
œœ
œœ&œœœ˜’
Kš
œU™UKš
œJ™JKš
œ5™5K˜Kšœ!œ˜CKšœ!œ˜8Kšœœ"˜EKšœ/œ>˜qKšœ1œ?˜tK˜Kšœ1œœi˜Ά
K˜—K˜šžœœ
œœœœ&œœœ˜©
Kš
œM™MKš
œM™MKš
œ:™:K˜Kšœ%œ ˜IKšœ%œ˜>Kšœ!œ$˜IKšœ+œ?˜nKšœ-œ@˜qK˜Kšœ1œœj˜»
K˜——š
ž™Kšœœ
œœ
˜"—š
ž$™$šžœœ˜K˜Kš
œ™Kš
œ˜K˜K˜Kš
œΝ
™Ν
Kš
œΨ
˜Ψ
K˜K˜K™1K™K˜-Kšœžœ˜*K˜K˜K˜K˜—šžœœ˜K˜Kš
œ™Kš
œj˜jK˜Kš
œ	™	Kš
œ¦
˜¦
Kš
œ‰
˜‰
Kš
œˆ
˜ˆ
Kš
œ—
˜—
Kš
œƒ
˜ƒ
Kš
œ—
˜—
K˜K™K˜,Kšœžœ˜)K˜/Kšœžœ˜,Kš
œ)˜)Kšœžœ˜&Kš
œ,˜,Kšœžœ˜)Kš
œ(˜(Kšœžœ˜%Kš
œ,˜,Kšœžœ˜)K˜K˜——š
ž&™&Kš
œ˜Kš
œ˜—K˜šœ
˜K˜—J˜J˜J˜—…—u˜¬s