DIRECTORY MathRules USING [AtomBoxProc, AtomPaintProc, CompoundBoxProc, CompositionProc, AtomToASRopeProc, Size], MathBox USING [BOX], MathTypes USING [Style, FormatClass], Vector USING [VEC], IO, 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; 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 ]; 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 cvtReduceRope: MathRules.AtomToASRopeProc _ NIL, -- converts atom for Reduce cvtSMPRope: MathRules.AtomToASRopeProc _ NIL, -- converts atom for SMP cvtOtherRope: MathRules.AtomToASRopeProc _ NIL -- converts atom for Other ]; 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 AlgebraStructures cvtReduce: ROPE _ NIL, -- conversion specification to Reduce cvtSMP: ROPE _ NIL, -- conversion specification to SMP cvtOther: ROPE _ NIL -- conversion specification to Other ]; 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 ]; EXPR: TYPE ~ REF MathExprRep; -- external abstract type MathExprRep: TYPE ~ RECORD [ SELECT type:* FROM atom => [ class: AtomClass, -- atomic data type value: ROPE -- atomic value, e.g. integer as rope ], compound => [ class: CompoundClass, -- compound operation class, e.g. summation or product subExprs: LIST OF TaggedMathExpr _ NIL -- class operation arguments ], matrix => [ class: MatrixClass, -- type of matrix op, e.g. determinant or matrix, etc. nRows, nCols: INT, -- matrix size as rows x cols elements: LIST OF TaggedMathExpr _ NIL -- matrix elements ], ENDCASE ]; AtomExprRep: PUBLIC TYPE ~ atom MathExprRep; CompoundExprRep: PUBLIC TYPE ~ compound MathExprRep; MatrixExprRep: PUBLIC TYPE ~ matrix MathExprRep; AtomEXPR: TYPE ~ REF AtomExprRep; CompoundEXPR: TYPE ~ REF CompoundExprRep; MatrixEXPR: TYPE ~ REF MatrixExprRep; ExprFlavors: TYPE ~ {atom, compound, matrix}; TaggedMathExpr: TYPE ~ RECORD [ id: ATOM, expression: EXPR ]; 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, cvtReduceRule, cvtSMPRule, cvtOtherRule: 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, cvtReduce, cvtSMP, cvtOther: 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]; ExprFromStream: PROC[stream: IO.STREAM] 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 Type Abbreviations from Imported Interfaces Expression Class Type Definitions Expression Type Definitions An EXPR is an IMMUTABLE mathematical expression with formatting information. -------------- commented out 3/2/87 ------- MathExprRep: TYPE; -- internal concrete rep -- 3/2/87 - give up opacity to implement Eval, i.e. Evaluator needs to know internal rep of expressions. Perhaps should define "abstract" internal Editor expression rep(s), and give Evaluator access by means of selectors on the abstract rep. --------------------------- -------------- copied in from MathExprImpl 3/2/87 ------- A Math Expression is either an atomic, compound, or matrix expression --------------------------- ---- commented out 3/2/87 AtomEXPR: TYPE ~ REF AtomExprRep; -- abstract AtomExprRep: TYPE; -- concrete CompoundEXPR: TYPE ~ REF CompoundExprRep; -- abstract CompoundExprRep: TYPE; -- concrete MatrixEXPR: TYPE ~ REF MatrixExprRep; -- abstract MatrixExprRep: TYPE; -- concrete --------------------- -------------- copied in from MathExprImpl 3/2/87 ------- privately (n.b. not public) redefine opaque types in terms of concrete rep EXPR: TYPE ~ REF MathExprRep; --------------------- Expression Class 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 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. effects: Parses r as an EXPR in canonical format output by RopeFromExpr[]. SIGNALS parseError if r is malformed. Expression 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˜——headš+™+Kšžœžœžœ˜Kšžœžœ žœ˜K˜Kšžœžœ žœ˜Kšœžœ˜Kšœ žœ˜*Kšœ žœ˜*Kšœžœ˜.Kšœžœ˜4Kšœžœ˜2Kšœžœ˜2Kšœžœ˜—š!™!šœ žœžœ˜KšœžœΟc;˜HKšœ žœžœžœŸ9˜PKšœ Ÿ2˜=K˜K˜—šœžœžœ˜KšœžœŸ8˜EKšœ žœžœžœŸ9˜PKšœ Ÿ1œ˜>KšœžœŸ˜(Kšœ˜—K˜Jšœ žœ#˜3Jšœ žœžœ˜#šœžœ˜šžœ˜KšœžœŸ"˜/KšœŸ ˜'KšœŸ/˜DKšœŸ ˜Kšœ!Ÿ˜@Kšœ%Ÿ"˜GKšœ(Ÿ&˜NKšœ,žœŸ˜MKšœ)žœŸ˜GKšœ+žœŸ˜JK˜—K˜—Kšœžœžœ˜+šœžœ˜šžœ˜KšœžœŸ"˜/KšœŸ˜+Kšœ žœŸB˜VKšœ žœžœ ˜Kšœ žœžœ˜K˜#K˜#KšœžœžœŸ0˜DKšœ žœžœŸ%˜=KšœžœžœŸ"˜7Kšœ žœžœŸ$˜:K˜—K˜—Kšœ žœžœ˜'šœžœž˜KšœžœŸ1˜=KšœŸ˜)KšœžœŸ5˜UK˜——š™KšœL™LK™KšžœžœžœŸ˜8K˜KšœŸ œ™+Kšœ žœŸŠ™žK™K™K™K™9KšœE™Ešœ žœ˜šžœ˜šžœž˜˜ KšœŸ˜&KšœžœŸ%˜2K˜—˜ KšœŸ6˜MKšœ žœžœžœŸ˜CK˜—˜ KšœŸ6˜JKšœžœŸ˜1Kšœ žœžœžœŸ˜:K˜—Kšž˜—K˜——K™K˜K˜KšŸ™Kšœ žœžœŸ ™.Kšœ žœŸ ™KšœžœžœŸ ™6KšœžœŸ ™#Kšœ žœžœŸ ™2KšœžœŸ ™!K™K™K™K™9Kšœ žœžœ˜,Kšœžœžœ˜4Kšœžœžœ˜0K˜KšœJ™JKšžœžœžœ ™Kšœ žœžœ ˜!Kšœžœžœ˜)Kšœ žœžœ˜%K™K™K˜Kšœ žœ˜-K˜šœžœ˜šžœ˜Kšœžœ˜ Kšœ ž˜K˜———š™š œžœžœ žœžœžœžœ ˜TKšœ3™3—K˜š œžœžœ žœžœžœžœžœ ˜]Kšœ0™0K˜—š  œžœžœ΅žœžœ ˜λKšœ8™8—K˜šœžœžœ)žœžœžœžœžœažœžœžœ˜ϊKšœ=™=—K™š œžœžœ7žœžœ˜rKšœ:™:——š™š œžœžœ žœžœžœ˜=Kšœ?™?Kšœ7™7K˜—šœžœžœžœžœžœžœ˜PKšœA™AKšœ;™;KšœR™RK™—šœžœžœžœ žœžœžœžœ˜fKšœ?™?Kšœ9™9Kšœ<™