<> <> <> <> 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]; <<0.8 way up on hint box>> 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 ~ { <> << $summand)>> 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 ~ { <> << $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 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]], <<[$space, [origin], [origin]]], -- Carl's original y-alignment>> [$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,]], <<[$space, [origin], [origin]]], -- Carl's original y-alignment>> [$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 ~ { <> << symbols $aliasLeftSpace & $aliasRightSpace.>> <<>> 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 ~ { <> << symbols $aliasLeftSpace & $aliasRightSpace.>> <<>> 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 ~ { <> << $leftParen and $rightParen>> 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 ~ { <> << $leftCurly and $rightCurly>> 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 ~ { <> << $leftSquare and $rightSquare>> 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 ~ { <> << $absBar and $absBar>> 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] ~ { <> << 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]]; }; MakeBinOpClass: PUBLIC PROC[class, op, a, b: ATOM, operation: EXPR, description: ROPE, cvtAS, cvtReduce, cvtSMP, cvtOther: ROPE _ NIL] RETURNS[CompoundClass] ~ { <> << 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]]; }; MakeRelationClass: PUBLIC PROC[class, rel, lhs, rhs: ATOM, relation: EXPR, description: ROPE, cvtAS, cvtReduce, cvtSMP, cvtOther: ROPE _ NIL] RETURNS[CompoundClass] ~ { <> << 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, 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.