DIRECTORY MathRules USING [AtomBoxProc, AtomPaintProc, CompoundBoxProc, CompositionProc, AtomToASRopeProc, Size], MathBox USING [BOX], MathTypes USING [Style, FormatClass], Vector USING [VEC], Rope USING [ROPE]; MathExpr: CEDAR DEFINITIONS ~ BEGIN ROPE: TYPE ~ Rope.ROPE; VEC: TYPE ~ Vector.VEC; BOX: TYPE ~ MathBox.BOX; Style: TYPE ~ MathTypes.Style; FormatClass: TYPE ~ MathTypes.FormatClass; AtomBoxProc: TYPE ~ MathRules.AtomBoxProc; AtomPaintProc: TYPE ~ MathRules.AtomPaintProc; AtomToASRopeProc: TYPE ~ MathRules.AtomToASRopeProc; CompoundBoxProc: TYPE ~ MathRules.CompoundBoxProc; CompositionProc: TYPE ~ MathRules.CompositionProc; Size: TYPE ~ MathRules.Size; EXPR: TYPE ~ REF MathExprRep; -- external abstract type MathExprRep: TYPE; -- internal concrete rep AtomEXPR: TYPE ~ REF AtomExprRep; -- abstract AtomExprRep: TYPE; -- concrete CompoundEXPR: TYPE ~ REF CompoundExprRep; -- abstract CompoundExprRep: TYPE; -- concrete MatrixEXPR: TYPE ~ REF MatrixExprRep; -- abstract MatrixExprRep: TYPE; -- concrete ExprFlavors: TYPE ~ {atom, compound, matrix}; TaggedMathExpr: TYPE ~ RECORD [ id: ATOM, expression: EXPR ]; AtomFlavor: TYPE ~ {symbol, argument, placeholder}; AtomClass: TYPE ~ REF AtomClassRep; AtomClassRep: TYPE ~ RECORD [ name: ATOM, -- class identifier, e.g. $integer formatClass: FormatClass, -- e.g. atom flavor: AtomFlavor, -- type of atom: symbol, argument, placeholder style: Style, -- font info boxRule: MathRules.AtomBoxProc, -- returns info about atom size paintRule: MathRules.AtomPaintProc, -- paints atom onto imager context cvtASRope: MathRules.AtomToASRopeProc -- converts atom for AlgebraStructures ]; CompoundClass: TYPE ~ REF CompoundClassRep; CompoundClassRep: TYPE ~ RECORD [ name: ATOM, -- class identifier, e.g. $product formatClass: FormatClass, -- e.g. binaryOp description: ROPE, -- for menu buttons, etc. to describe how expr looks, e.g. "a + b" arguments: LIST OF Argument, symbols: LIST OF Symbol, boxRule: MathRules.CompoundBoxProc, compBox: MathRules.CompositionProc, cvtAS: ROPE _ NIL -- conversion specification to Dennis Arnon's AlgebraStructures ]; MatrixClass: TYPE ~ REF MatrixClassRep; MatrixClassRep: TYPE ~ RECORD [ name: ATOM, -- class identifier, e.g. $matrix or $determinant formatClass: FormatClass, -- e.g. matrix openSym, closeSym, space: EXPR -- expressions to use for (, ), and inter-elt spacing ]; Argument: TYPE ~ RECORD [ name: ATOM, -- unique (within enclosing class) identifier for argument aliases: LIST OF ATOM, -- aliases for name using convention $aliasFoo, $aliasBar size: Size -- relative sizing information (big, script, etc.) ]; Symbol: TYPE ~ RECORD[ name: ATOM, -- unique (within enclosing class) identifier for symbol aliases: LIST OF ATOM, -- aliases for name using convention $aliasFoo, $aliasBar size: Size, -- relative sizing information (big, script, etc.) value: EXPR -- a symbol is an expression ]; MakeArgument: PROC[name: ATOM, aliases: LIST OF ATOM, size: Size] RETURNS[Argument]; MakeSymbol: PROC[name: ATOM, aliases: LIST OF ATOM, size: Size, value: EXPR] RETURNS[Symbol]; MakeAtomClass: PROC[name: ATOM, formatClass: FormatClass, flavor: AtomFlavor, style: Style, boxRule: AtomBoxProc, paintRule: AtomPaintProc, cvtASRule: AtomToASRopeProc _ NIL] RETURNS[AtomClass]; MakeCompoundClass: PROC[name: ATOM, formatClass: FormatClass, description: ROPE, args: LIST OF Argument, syms: LIST OF Symbol, boxRule: CompoundBoxProc, compBox: CompositionProc, cvtAS: ROPE _ NIL] RETURNS[CompoundClass]; MakeMatrixClass: PROC[name: ATOM, formatClass: FormatClass, openSym, closeSym, space: EXPR] RETURNS[MatrixClass]; MakeAtomicExpr: PROC[class: ATOM, value: ROPE] RETURNS[EXPR]; MakeCompoundExpr: PROC[class: ATOM, args: LIST OF TaggedMathExpr] RETURNS[EXPR]; MakeMatrixExpr: PROC[class: ATOM, nRows, nCols: NAT, elements: LIST OF TaggedMathExpr] RETURNS[EXPR]; RopeFromExpr: PROC[expr: EXPR] RETURNS[ROPE]; ExprFromRope: PROC[r: ROPE] RETURNS[EXPR]; GetType: PROC[expr: EXPR] RETURNS[ExprFlavors]; GetAtomClass: PROC[expr: AtomEXPR] RETURNS[AtomClass]; GetAtomExpr: PROC[expr: EXPR] RETURNS[AtomEXPR]; GetValue: PROC[expr: AtomEXPR] RETURNS[ROPE]; GetCompoundClass: PROC[expr: CompoundEXPR] RETURNS[CompoundClass]; GetCompoundExpr: PROC[expr: EXPR] RETURNS[CompoundEXPR]; GetMatrixExpr: PROC[expr: EXPR] RETURNS[MatrixEXPR]; GetSubExprs: PROC[expr: CompoundEXPR] RETURNS[LIST OF TaggedMathExpr]; GetMatrixElements: PROC[expr: MatrixEXPR] RETURNS[LIST OF TaggedMathExpr]; GetMatrixSize: PROC[expr: MatrixEXPR] RETURNS[NAT, NAT]; GetMatrixClass: PROC[expr: MatrixEXPR] RETURNS[MatrixClass]; GetTaggedExpr: PROC[tag: ATOM, exprs: LIST OF TaggedMathExpr] RETURNS[TaggedMathExpr]; badAtomClass: ERROR; badCompoundClass: ERROR; badMatrixClass: ERROR; badExprs: ERROR[reason: ATOM]; exprNotFound: ERROR; wrongExprType: ERROR; parseError: ERROR; END. ΈMathExpr.mesa Carl Waldspurger, August 23, 1986 4:39:44 pm PDT Definitions for Mathematics Expressions Abbreviations from Imported Interfaces Mathematics Expressions An EXPR is an IMMUTABLE mathematical expression with formatting information. Expression Class Type Definitions Other Types Constructors Primitive Constructors effects: constructs and returns an argument object effects: constructs and returns a symbol object effects: constructs and returns a new atom class object effects: constructs and returns a new compound class object effects: constructs and returns a new matrix class object Math Expression Constructors effects: constructs and returns a new atomic expression object SIGNALS badAtomClass if class is unrecognized effects: constructs and returns a new compound expression object SIGNALS badCompoundClass if class is unrecognized SIGNALS badExprs if exprs has the wrong number or wrong type of elements effects: constructs and returns a new matrix expression object SIGNALS badMatrixClass if class is unrecognized SIGNALS badMatrixSize if nRows or nCols is invalid SIGNALS badMatrix if rows has the wrong number or wrong type of elements Parse/UnParse Routines effects: Returns a ROPE in a canonical format which can be parsed by ExprFromRope[]. effects: Parses r as an EXPR in canonical format output by RopeFromExpr[]. SIGNALS parseError if r is malformed. Selectors effect: Returns atom if expr is an AtomEXPR, Returns compound if expr is a CompoundEXPR effects: Returns the class of atomic expression expr. effects: If expr.Type = atom, returns atomic expression. Otherwise SIGNALS wrongExprType effects: Returns the value of atomic expression expr. effects: Returns the class of compound expression expr. effects: If expr.Type = compound, returns compound expression. Otherwise SIGNALS wrongExprType effects: IF expr.Type[] = matrix, returns matrix expression Otherwise SIGNALS wrongExprType effects: Returns the subexpressions for compound expression expr. effects: Returns the rows of expression for matrix expression expr. effects: Returns the size (dimensions) of expr as [nRows, nCols] effects: Returns the flavor of expr. List Selectors effects: Returns the TaggedMathExpr in exprs associated with tag. SIGNALS exprNotFound if no association exists. Signals & Errors ΚŠ˜Jšœ ™ Jšœ0™0J˜JšΟn'™'J˜codešΟk ˜ Kšœ žœX˜gKšœžœžœ˜Kšœ žœ˜%Kšœžœžœ˜Kšœžœžœ˜—K˜K˜šœžœž œ˜K˜šž˜K˜—Kš&œ™'˜Kšžœžœžœ˜Kšžœžœ žœ˜K˜Kšžœžœ žœ˜Kšœžœ˜Kšœ žœ˜*Kšœ žœ˜*Kšœžœ˜.Kšœžœ˜4Kšœžœ˜2Kšœžœ˜2Kšœžœ˜—K™K™Kš™™KšœL™L—˜KšžœžœžœΟc˜8Kšœ žœŸ˜,K˜Kšœ žœžœŸ ˜.Kšœ žœŸ ˜KšœžœžœŸ ˜6KšœžœŸ ˜#Kšœ žœžœŸ ˜2KšœžœŸ ˜!K˜Kšœ žœ˜-K˜šœžœ˜šžœ˜Kšœžœ˜ Kšœ ž˜K˜—K˜—K˜—Kš!™!˜Jšœ žœ#˜3Jšœ žœžœ˜#šœžœ˜šžœ˜KšœžœŸ"˜/KšœŸ ˜'KšœŸ/˜DKšœŸ ˜Kšœ!Ÿ˜@Kšœ%Ÿ"˜GKšœ'Ÿ&˜MK˜—K˜—Kšœžœžœ˜+šœžœ˜šžœ˜KšœžœŸ"˜/KšœŸ˜+Kšœ žœŸB˜VKšœ žœžœ ˜Kšœ žœžœ˜K˜#K˜#KšœžœžœŸ?˜RK˜—K˜—Kšœ žœžœ˜'šœžœž˜KšœžœŸ1˜=KšœŸ˜)KšœžœŸ5˜UK˜K˜—K˜K˜—š ™ K™šœ žœžœ˜KšœžœŸ;˜HKšœ žœžœžœŸ9˜PKšœ Ÿ2˜=K˜K˜—šœžœžœ˜KšœžœŸ8˜EKšœ žœžœžœŸ9˜PKšœ Ÿ1œ˜>KšœžœŸ˜(Kšœ˜—K˜K˜˜K˜——Kš ™ ˜Kš™K™š œžœžœ žœžœžœžœ ˜TKšœ3™3—K˜š œžœžœ žœžœžœžœžœ ˜]Kšœ0™0K˜—š  œžœžœŒžœžœ ˜ΒKšœ8™8—K˜šœžœžœ)žœžœžœžœžœDžœžœžœ˜έKšœ=™=—K™š œžœžœ7žœžœ˜rKšœ:™:—K™K™K˜Kš™K˜š œžœžœ žœžœžœ˜=Kšœ?™?Kšœ7™7K˜—šœžœžœžœžœžœžœ˜PKšœA™AKšœ;™;KšœR™R—K™šœžœžœžœ žœžœžœžœ˜fKšœ?™?Kšœ9™9Kšœ<™