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


MathExprClassesAnalysis: 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]];
topSpaceBox _ MathBox.Scale[topSpaceBox, [scaleX, 1.0]];
bottomSpaceBox _ MathBox.Scale[bottomSpaceBox, [scaleX, 1.0]];

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

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

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]]],
[$differand,
[$fractionBar, [right], [right, -0.05]],
[$topSpace, [bottom], [top]]],
[$partialOf,
[$differand, [right], [left]],
[$differand, [origin], [origin]]],
[$partialWrt,
[$fractionBar, [right], [center]],
[$bottomSpace, [top], [bottom]]],
[$wrt,
[$partialWrt, [left], [right]],
[$partialWrt, [origin], [origin]]]
];

[tempBox, tempBoxes] _
 MathRules.Compose[boxes, alignments, [$fractionBar, [origin]],
  [$fractionBar, [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, [center, -0.4]]];

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


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

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]];
};
wrongBoxType: PUBLIC ERROR = CODE;
InstallAnalysisClassesAA: PROC [] ~ {

summationClass, integrationClass, indefIntClass, nRadicalClass, radicalClass,  limitClass, dDxClass, partialDerivClass: CompoundClass;
lbArg, ubArg, summandArg, llimArg, ulimArg, integrandArg, wrtArg, nArg, radicandArg,  ofArg, approachesArg, differandArg: Argument;
sigmaSym, integralSym, dxSym, lineSym, radRootSym, radLineSym, integralSpaceSym, limSym, limSpaceSym, radSpaceSym, dOfSym, partialOfSym, partialWrtSym: Symbol;
numerSpSym, denomSpSym: Symbol;


lbArg _ MakeArgument[$lowerbound, NIL, script];
ubArg _ MakeArgument[$upperbound, NIL, script];
summandArg _ MakeArgument[$summand, LIST[$aliasHot], normal];
sigmaSym _ MakeSymbol[$sigma, LIST[$aliasOp], normal, MathConstructors.MakeBigMathSym['\172]];

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, MathConstructors.MakeBigMathSym['\165]];
dxSym _ MakeSymbol[$dx, NIL, normal, MathConstructors.MakeItalSym['d]];
integralSpaceSym _ MakeSymbol[$space, LIST[$aliasSpace], normal, MathConstructors.MakeSpace[$thick]];

denomSpSym _ MakeSymbol[$bottomSpace, LIST[$aliasSpace], normal, MathConstructors.MakeSpace[$medium]];
numerSpSym _ MakeSymbol[$topSpace, LIST[$aliasSpace], normal, MathConstructors.MakeSpace[$medium]];
lineSym _ MakeSymbol[$fractionBar, LIST[$aliasLine], normal, MathConstructors.MakeLine[]];
differandArg _ MakeArgument[$differand, LIST[$aliasHot], normal];
dOfSym _ MakeSymbol[$dOf, NIL, normal, MathConstructors.MakeItalSym['d]];

partialOfSym _ MakeSymbol[$partialOf, NIL, normal, MathConstructors.MakeBigMathSym['\272]];
partialWrtSym _ MakeSymbol[$partialWrt, NIL, normal, MathConstructors.MakeBigMathSym['\272]];

nArg _ MakeArgument[$n, LIST[$aliasB], script];
radicandArg _ MakeArgument[$radicand, LIST[$aliasA, $aliasHot], normal];
radRootSym _ MakeSymbol[$radRoot, NIL, normal, MathConstructors.MakeBigMathSym['\174]];
radLineSym_ MakeSymbol[$radLine, LIST[$aliasLine], normal, MathConstructors.MakeLine[]];
radSpaceSym _ MakeSymbol[$space, LIST[$aliasSpace], normal, MathConstructors.MakeSpace[$medium]];

ofArg _ MakeArgument[$of, LIST[$aliasA, $aliasHot], normal];
approachesArg _ MakeArgument[$approaches, NIL, script];
limSpaceSym _ MakeSymbol[$space, LIST[$aliasSpace], normal, MathConstructors.MakeSpace[$limit]];
limSym _ MakeSymbol[$lim, NIL, script, MathConstructors.MakePlainRope["lim"]];


summationClass _ MakeCompoundClass[$summation, op, "summation", LIST[lbArg, ubArg, summandArg], LIST[sigmaSym], SummationBoxRule, SummationCompRule, "(summation $lowerbound $upperbound $summand)"];
integrationClass _ MakeCompoundClass[$integration, op, "def integration", LIST[llimArg, ulimArg, integrandArg, wrtArg], LIST[integralSym, dxSym, integralSpaceSym], DefiniteIntBoxRule, IntegrationCompRule, "(integral $lowerlimit $upperlimit $integrand $wrt)", "Int[$integrand, $wrt, $lowerlimit, $upperlimit]"];
indefIntClass _ MakeCompoundClass[$indefInt, op, "indef integration", LIST[integrandArg, wrtArg], LIST[integralSym, dxSym, integralSpaceSym], IndefiniteIntBoxRule, IndefiniteIntCompRule, "(indefIntegral $integrand $wrt)", "int($integrand, $wrt)", "Int[$integrand, $wrt]"];
dDxClass _ MakeCompoundClass[$dDx, over, "dF / dx", LIST[differandArg, wrtArg], LIST[lineSym, dOfSym, dxSym, numerSpSym, denomSpSym], dDxBoxRule, dDxCompRule, "d $differand / d $wrt", "df($differand, $wrt)", "Diff[$differand, $wrt]"];
partialDerivClass _ MakeCompoundClass[$partialDeriv, over, "partial Derivative", LIST[differandArg, wrtArg], LIST[lineSym, partialOfSym, partialWrtSym, numerSpSym, denomSpSym], PartialDerivBoxRule, PartialDerivCompRule, "partial $differand / partial  $wrt", "df($differand, $wrt)", "Diff[$differand, $wrt]"];
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)"];



MathDB.InstallCompoundClass[summationClass];
MathDB.AddOperator[summationClass, $Analysis];
MathDB.InstallCompoundClass[limitClass];
MathDB.AddOperator[limitClass, $Analysis];
MathDB.InstallCompoundClass[integrationClass];
MathDB.AddOperator[integrationClass, $Analysis];
MathDB.InstallCompoundClass[indefIntClass];
MathDB.AddOperator[indefIntClass, $Analysis];
MathDB.InstallCompoundClass[dDxClass];
MathDB.AddOperator[dDxClass, $Analysis];
MathDB.InstallCompoundClass[partialDerivClass];
MathDB.AddOperator[partialDerivClass, $Analysis];
MathDB.InstallCompoundClass[radicalClass];
MathDB.AddOperator[radicalClass, $Analysis];
MathDB.InstallCompoundClass[nRadicalClass];
MathDB.AddOperator[nRadicalClass, $Analysis];
};


InstallAnalysisClassesB: PROC [] ~ {

approxEqFormulaClass, approachesClass: CompoundClass;

approxEqFormulaClass _ MakeRelationClass[$approxEqFormula, $equals, $lhs, $rhs, MathConstructors.MakeBigMathSym['\167], "a approx= b", "$lhs approx= $rhs"];
approachesClass _ MakeRelationClass[$approachesFormula, $approaches, $lhs, $rhs, MathConstructors.MakePlainSym['\256], "a -> b", "$lhs -> $rhs"];

MathDB.InstallCompoundClass[approachesClass];
MathDB.AddOperator[approachesClass, $Analysis];
MathDB.InstallCompoundClass[approxEqFormulaClass];
MathDB.AddOperator[approxEqFormulaClass, $Analysis];
};

InstallAnalysisClassesAA[];
InstallAnalysisClassesB[];

END.




ΎMathExprClassesAnalysis.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 x-extents
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
Composition Procs for Compound Expr Classes
effects:  Composes layout for expr of form ($fractionBar $numerator $denominator)
effects:  Composes layout for expr of form ($fractionBar $differand $wrt)
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, [origin], [origin]]],
[$partialWrt,
[$fractionBar, [right], [center]],
[$bottomSpace, [top], [bottom]]],
[$wrt,
[$partialWrt, [left], [right]],
[$partialWrt, [origin], [origin]]]
];

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

RETURN[tempBox, tempBoxes];
};
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
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
define info for "summation lowerbound upperbound summand"
define info for indefinite & definite integrals (normal & surface)
define info for "dDx differandArg wrtArg"
define info for "PartialDeriv differandArg wrtArg"
define info for "radical n radicand"
define info for limits
Register compound classes in user-friendly order 

local declarations
relations

Install Classes Defined in this Module
Κ
–

"cedar" style˜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š
œ8˜8Kš
œ>˜>K˜Kšœ
œ[˜fK˜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š
œ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šœ	œ
˜
Kšœœ
œ
œ
˜šœœ
œœ
˜'˜K˜#K˜!—˜K˜#K˜!—š
œ˜Kš
œ(˜(Kš
œ˜—š
œ˜Kš
œ˜Kš
œ"˜"—š
œ
˜
K˜"K˜!—š
œ˜Kš
œ˜Kš
œ"˜"—˜K˜——K˜sK˜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˜jK˜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Οc˜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š
œT™TKš
œJ™JKš
œ2™2K™Kšœ%œ˜GKšœ&œ<˜fKšœ$œ%˜MKšœ0œ
œC˜‹
K˜K˜—K˜šžœœ
œœ
œœ&œœœ˜’
Kš
œU™UKš
œJ™JKš
œ5™5K˜Kšœ!œ˜CKšœ!œ˜8Kšœœ"˜EKšœ/œ>˜qKšœ1œ?˜tK˜Kšœ1œœL˜™
K˜—K˜šžœœ
œœœœ&œœœ˜©
Kš
œM™MKš
œM™MKš
œ:™:K˜Kšœ%œ ˜IKšœ%œ˜>Kšœ!œ$˜IKšœ+œ?˜nKšœ-œ@˜qK˜Kšœ1œœM˜ž
K˜——š
ž™Kšœœ
œœ
˜"—š
ž$™$šžœœ˜%K˜Kš
œ™Kš
Ϡ
˜†
Kš
œƒ
˜ƒ
Kš
œŸ
˜Ÿ
Kš
œ˜K˜K˜Kš
œ9™9Kšœ"œ
˜/Kšœ"œ
˜/Kšœ$œ˜=Kšœœ<˜^K˜Kš
œB™BKšœ$œ
˜1Kšœ$œ
˜1Kšœ(œ˜AKšœœ
˜)Kšœ$œ<˜dKšœœ,˜GKšœ&œ;˜eK˜Kš
œ)™)Kšœ&œ<˜fKšœ#œ<˜cKšœ#œ3˜ZKšœ(œ˜AKšœœ,˜IK˜Kš
œ2™2Kšœ&œ2˜[Kšœ(œ2˜]K˜Kš
œ$™$Kšœœ˜/Kšœ&œ˜HKšœ"œ2˜WKšœ!œ3˜XKšœ!œ<˜aK˜Kš
œ™Kšœœ˜<Kšœ*œ
˜7Kšœ!œ;˜`Kšœœ1˜NK˜K˜Kšœ@œœžœE˜Ε
KšœJœ*œ(žœ€
˜ΆKšœFœœ(žœn˜Kšœ4œœ–
˜κ
KšœQœœΓ
˜΄KšœEœœd˜Ζ
Kšœ?œœ\˜²
Kšœ7œœS˜ͺ
K˜K˜K™1K™K˜K˜,Kšœžœ˜.K˜(Kšœžœ˜*K˜.Kšœžœ˜0K˜+Kšœžœ˜-Kš
œ&˜&Kšœžœ˜(Kš
œ/˜/Kšœžœ˜1K˜*Kšœžœ˜,K˜+Kšœžœ˜-K˜K˜K˜—šžœœ˜$K˜Kš
œ™Kš
œ5˜5K˜Kš
œ	™	Kš
œœ
˜œ
Kš
œ‘
˜‘
K˜K™K˜-Kšœžœ˜/K˜2Kšœžœ"˜4K˜K˜——š
ž&™&Kš
œ˜Kš
œ˜—K˜šœ
˜K˜—J˜J˜J˜—…—]†ΰ