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

RETURN[boxes];

};

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

should ENABLE noSuchBox

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

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

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

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

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

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

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

adjust fbarBox extents

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

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

};

effects: Sizes boxes for expr of form ($dDx $differand $wrt)

should ENABLE noSuchBox

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

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

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

adjust fbarBox extents

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

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

};

should ENABLE noSuchBox

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

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

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

adjust x-extents

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

};

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

should ENABLE noSuchBox

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

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

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

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

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

line must be exactly as long as radicand,

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

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

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

adjust symbol extents

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

radLineBox ← MathBox.Scale[radLineBox, lineScale];

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

};

effects: Sizes boxes for expr of form ($summation $lowerbound $upperbound $summand)

dsa 4/17/87

should ENABLE noSuchBox

sigmaBox: BOX ← MathBox.GetBox[$sigma, boxes];

lowerboundBox: BOX ← MathBox.GetBox[$lowerbound, boxes];

upperboundBox: BOX ← MathBox.GetBox[$upperbound, boxes];

summandBox: BOX ← MathBox.GetBox[$summand, boxes];

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

summation sign must grow if summand does

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

adjust symbol extents

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

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

};

effects: Sizes boxes for expr of form ($integral $integrand $dx $wrt)

dsa 4/17/87

should ENABLE noSuchBox

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

integral sign must grow if integrand does

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

adjust symbol extents

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

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

};

effects: Sizes boxes for expr of form ($integral $lowerlimit $upperlimit $integrand $dx $wrt)

dsa 4/17/87

should ENABLE noSuchBox

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

integral sign must grow if integrand does

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

adjust symbol extents

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

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

};

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

should ENABLE noSuchBox

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

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

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

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

line must be exactly as long as radicand,

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

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

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

adjust symbol extents

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

radLineBox ← MathBox.Scale[radLineBox, lineScale];

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

};

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

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

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

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($fractionBar $differand $wrt)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

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

RETURN[tempBox, tempBoxes];

};

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

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

RETURN[tempBox, tempBoxes];

};

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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

tempBox: BOX;

tempBoxes: LIST OF BOX;

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

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

alignments: LIST OF Alignment2D;

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

ELSE {

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

RETURN[tempBox, tempBoxes];

};

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

$summand)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← NIL;

vertSigmaOffset, vertSummandOffset: Offset;

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

alignments ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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

$upperlimit $integrand $dx $wrt)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← NIL;

vertIntegralOffset, vertIntegrandOffset: Offset;

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

alignments ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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

tempBox: BOX;

tempBoxes: LIST OF BOX;

vertIntegralOffset, vertIntegrandOffset: Offset;

alignments: LIST OF Alignment2D ← NIL;

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

alignments ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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

symbols $aliasLeftSpace & $aliasRightSpace.

tempBox: BOX;

tempBoxes: LIST OF BOX;

leftVertOffsetA, leftVertOffsetOp, rightVertOffsetB, rightVertOffsetOp: Offset;

alignments: LIST OF Alignment2D;

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

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

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

alignments ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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

symbols $aliasLeftSpace & $aliasRightSpace.

tempBox: BOX;

tempBoxes: LIST OF BOX;

leftVertOffsetLHS, leftVertOffsetRel, rightVertOffsetRHS, rightVertOffsetRel: Offset;

alignments: LIST OF Alignment2D;

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

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

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

alignments ← LIST[

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

RETURN[tempBox, tempBoxes];

};

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

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

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

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

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

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

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

};

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

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

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

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

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

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

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

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

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

};

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

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

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

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

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

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

leftSpace: Symbol ← MakeSymbol[$leftSpace, LIST[$aliasLeftSpace], normal, 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]];

};

local declarations

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;

define info for "summation lowerbound upperbound summand"

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

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

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

sigmaSym ← MakeSymbol[$sigma, LIST[$aliasOp], normal, MathConstructors.MakeBigMathSym['\172]];

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

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

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

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

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

integralSym ← MakeSymbol[$integral, LIST[$aliasOp], normal, MathConstructors.MakeBigMathSym['\165]];

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

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

define info for "dDx differandArg wrtArg"

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

define info for "PartialDeriv differandArg wrtArg"

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

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

define info for "radical n radicand"

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

define info for limits

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

Register compound classes in user-friendly order

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

};

local declarations

approxEqFormulaClass, approachesClass: CompoundClass;

relations

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

};