DIRECTORY Basics, Rope, Convert, List USING [AList, Assoc, PutAssoc], MathExpr USING [AtomClass, CompoundClass, MatrixClass], MathDB; MathDBImpl: CEDAR PROGRAM IMPORTS List, Convert EXPORTS MathDB ~ BEGIN AtomClass: TYPE ~ MathExpr.AtomClass; CompoundClass: TYPE ~ MathExpr.CompoundClass; MatrixClass: TYPE ~ MathExpr.MatrixClass; ROPE: TYPE ~ Rope.ROPE; AList: TYPE ~ List.AList; GlobalAtomClasses: List.AList _ NIL; GlobalCompoundClasses: List.AList _ NIL; GlobalMatrixClasses: List.AList _ NIL; AtomClassNames: PUBLIC LIST OF ATOM _ NIL; CompoundClassNames: PUBLIC LIST OF ATOM _ NIL; MatrixClassNames: PUBLIC LIST OF ATOM _ NIL; ResetAtomClasses: PUBLIC PROC[] ~ { GlobalAtomClasses _ NIL; AtomClassNames _ NIL; }; ResetCompoundClasses: PUBLIC PROC[] ~ { GlobalCompoundClasses _ NIL; CompoundClassNames _ NIL; }; ResetMatrixClasses: PUBLIC PROC[] ~ { GlobalMatrixClasses _ NIL; MatrixClassNames _ NIL; }; InstallAtomClass: PUBLIC PROC[class: AtomClass] ~ { GlobalAtomClasses _ List.PutAssoc[key: class.name, val: class, aList: GlobalAtomClasses]; AtomClassNames _ CONS[class.name, AtomClassNames]; }; InstallCompoundClass: PUBLIC PROC[class: CompoundClass] ~ { GlobalCompoundClasses _ List.PutAssoc[key: class.name, val: class, aList: GlobalCompoundClasses]; CompoundClassNames _ CONS[class.name, CompoundClassNames]; }; InstallMatrixClass: PUBLIC PROC[class: MatrixClass] ~ { GlobalMatrixClasses _ List.PutAssoc[key: class.name, val: class, aList: GlobalMatrixClasses]; MatrixClassNames _ CONS[class.name, MatrixClassNames]; }; LookupAtomClass: PUBLIC PROC[name: ATOM] RETURNS[AtomClass] ~ { atomClass: AtomClass _ NARROW[List.Assoc[key: name, aList: GlobalAtomClasses]]; IF atomClass = NIL THEN ERROR notFound; RETURN[atomClass]; }; LookupCompoundClass: PUBLIC PROC[name: ATOM] RETURNS[CompoundClass] ~ { compoundClass: CompoundClass _ NARROW[List.Assoc[key: name, aList: GlobalCompoundClasses]]; IF compoundClass = NIL THEN ERROR notFound; RETURN[compoundClass]; }; LookupMatrixClass: PUBLIC PROC[name: ATOM] RETURNS[MatrixClass] ~ { matrixClass: MatrixClass _ NARROW[List.Assoc[key: name, aList: GlobalMatrixClasses]]; IF matrixClass = NIL THEN ERROR notFound; RETURN[matrixClass]; }; DescriptionFromName: PUBLIC PROC[className: ATOM] RETURNS[ROPE]~ { a: AtomClass; c: CompoundClass; m: MatrixClass; a _ LookupAtomClass[className ! notFound => CONTINUE]; IF a#NIL THEN RETURN[Convert.RopeFromAtom[from: className, quote: FALSE] ]; c _ LookupCompoundClass[className ! notFound => CONTINUE]; IF c#NIL THEN RETURN[c.description]; m _ LookupMatrixClass[className ! notFound => CONTINUE]; IF m#NIL THEN RETURN[Convert.RopeFromAtom[from: className, quote: FALSE] ]; ERROR notFound; }; DescriptionsFromNames: PUBLIC PROC [in: LIST OF ATOM] RETURNS[LIST OF ROPE] ~ { out, out2: LIST OF ROPE; IF in = NIL THEN RETURN[NIL]; out _ out2 _ LIST[DescriptionFromName[in.first] ]; FOR l: LIST OF ATOM _ in.rest, l.rest UNTIL l=NIL DO out2 _ out2.rest _ LIST[DescriptionFromName[l.first] ]; ENDLOOP; RETURN[out]; }; GlobalOperatorTable: List.AList _ NIL; ResetOperatorTable: PUBLIC PROC[] ~ { GlobalOperatorTable _ NIL; }; AddOperator: PUBLIC PROC[class: CompoundClass, familyName: ATOM] ~ { family: LIST OF REF _ NARROW[List.Assoc[key: familyName, aList: GlobalOperatorTable]]; IF family=NIL THEN { GlobalOperatorTable _ List.PutAssoc[key: familyName, val: LIST[class.name], aList: GlobalOperatorTable]; RETURN }; family _ CONS[class.name, family]; -- maybe should put at end GlobalOperatorTable _ List.PutAssoc[key: familyName, val: family, aList: GlobalOperatorTable]; }; OpFamiliesNames: PUBLIC PROC[] RETURNS[LIST OF ATOM]~ { names: LIST OF ATOM _ NIL; FOR l:List.AList _ GlobalOperatorTable, l.rest UNTIL l = NIL DO names _ CONS[NARROW[l.first.key], names]; ENDLOOP; RETURN[names]; }; OpFamilyNames: PUBLIC PROC[familyName: ATOM] RETURNS[LIST OF ATOM]~ { family: LIST OF REF _ NARROW[List.Assoc[key: familyName, aList: GlobalOperatorTable]]; names: LIST OF ATOM _ NIL; IF family=NIL THEN ERROR notFound; FOR l:LIST OF REF _ family, l.rest UNTIL l = NIL DO names _ CONS[NARROW[l.first], names]; ENDLOOP; RETURN[names]; }; CompareOps: PUBLIC PROC[op1, op2: ATOM] RETURNS[Basics.Comparison]~ { SELECT op1 FROM $sum, $difference => SELECT op2 FROM $sum, $difference => RETURN[equal]; $negation => RETURN[less]; $product, $fraction, $pow => RETURN[less]; $dDx, $partialDeriv => RETURN[less]; ENDCASE => RETURN[equal]; $negation => SELECT op2 FROM $sum, $difference => RETURN[greater]; $negation => RETURN[equal]; $product, $fraction => RETURN[equal]; $pow => RETURN[less]; $dDx, $partialDeriv => RETURN[less]; ENDCASE => RETURN[equal]; $product, $fraction => SELECT op2 FROM $sum, $difference => RETURN[greater]; $negation => RETURN[equal]; $product, $fraction => RETURN[equal]; $pow => RETURN[less]; $dDx, $partialDeriv => RETURN[less]; ENDCASE => RETURN[equal]; ENDCASE => RETURN[equal]; }; RopesFromAtoms: PUBLIC PROC [in: LIST OF ATOM] RETURNS[LIST OF ROPE] ~ { out, out2: LIST OF ROPE; IF in = NIL THEN RETURN[NIL]; out _ out2 _ LIST[Convert.RopeFromAtom[from: in.first, quote: FALSE] ]; FOR l: LIST OF ATOM _ in.rest, l.rest UNTIL l=NIL DO out2 _ out2.rest _ LIST[Convert.RopeFromAtom[from: l.first, quote: FALSE] ]; ENDLOOP; RETURN[out]; }; KillAssoc: PUBLIC PROC [key: REF ANY, aList: AList] RETURNS[AList]~ { l, l1: AList _ NIL; l _ aList; UNTIL l = NIL DO IF l.first.key = key THEN { IF l1 = NIL THEN RETURN[l.rest]; -- ref was first object on list l1.rest _ l.rest; RETURN[aList]; }; l1 _ l; l _ l.rest; ENDLOOP; RETURN [aList]; -- not found }; notFound: PUBLIC ERROR = CODE; ResetAtomClasses[]; ResetCompoundClasses[]; ResetMatrixClasses[]; ResetOperatorTable[]; END. *MathDBImpl.mesa Carl Waldspurger, August 22, 1986 3:29:18 pm PDT Math Object "DataBase" Operations Abbreviations from Imported Interfaces Private (Name, Class) ALists for Expression Classes, by Expr Type Public Lists of Expression Class Names, by Expr Type Operations on Public Lists of Expression Class Names, by Expr Type effects: Resets (i.e. destroys) the global AtomClass DataBase effects: Resets (i.e. destroys) the global CompoundClass DataBase effects: Resets (i.e. destroys) the global MatrixClass DataBase effects: Installs class in global AtomClass DataBase add atom class to database - not very efficient, but does the job add atom class name to index effects: Installs class in global CompoundClass DataBase add compound class to database - not very efficient, but does the job add compound class name to index effects: Installs class in global MatrixClass DataBase add matrix class to database add matrix class name to index effects: Returns the AtomClass object associated with name. SIGNALS notFound if no association exists effects: Returns the CompoundClass object associated with name. SIGNALS notFound if no association exists effects: Returns the MatrixClass object associated with name. SIGNALS notFound if no association exists effects: lookup the class in the entire (Atom, Compound, and Matrix) Expression Class database, and return its description. Signals error if not found. effects: lookup the class of each element in the entire (Atom, Compound, and Matrix) Expression Class database, and return its description. Signals error if some class not found not found. Public Lists of Operator Names (Operators assumed to be CompoundExprs) Operations on Public Lists of Operator Names effects: Installs an operator name in the public list effects: Returns the list of all Op families effects: Returns the list of Op Names associated with familyName. SIGNALS notFound if no association exists Operator Precedence effects: compute operator precedence Utility Proc Apply RopeFromAtom to each element if NOT descriptions, else DescriptionFromName to each element. kills the value associated with key in aList, if any. Destructive to list structure, and only removes the first occurrence. Like List.DRemove. Signals & Errors Start Code (Reset Database) Κ )˜Jšœ™Jšœ0™0J˜JšΟn!™!J˜codešΟk ˜ Kšœ˜Kšœ˜Kšœ˜Kšœžœ˜$Kšœ žœ)˜7Kšœ˜K˜K˜—š œžœžœ˜Kšžœ˜Kšžœ ˜K˜Kšž˜K˜—headš&™&K˜Kšœ žœ˜%Kšœžœ˜-Kšœ žœ˜)Kšžœžœžœ˜Kšœžœ˜K˜—šA™AKšœžœ˜$Kšœžœ˜(Kšœžœ˜&—š4™4Kš œžœžœžœžœžœ˜*Kš œžœžœžœžœžœ˜.Kš œžœžœžœžœžœ˜,—šB™Bšœž œ˜#Kšœ>™>Kšœžœ˜Kšœžœ˜K˜K˜—šœž œ˜'KšœB™BKšœžœ˜Kšœžœ˜K˜K˜—šœž œ˜%Kšœ@™@Kšœžœ˜Kšœžœ˜K˜—K˜šœžœžœ˜3Kšœ5™5K™KšœB™BK˜YK˜Kšœ™Kšœžœ˜2K˜K˜—šœžœžœ˜;Kšœ9™9K™KšœE™EK˜aK˜Kšœ ™ Kšœžœ!˜:K˜K˜—šœž œ˜7Kšœ7™7K™Kšœ™K˜]K˜Kšœ™Kšœžœ˜6K˜—K˜K˜š œžœžœžœžœ˜?Kšœ<™™>Kšœ3™3K™Kšœžœ4˜UKšžœžœžœžœ ˜)Kšžœ˜K˜K˜—K˜š œžœžœ žœžœžœ˜BKšœ™™™Kšœ ˜ Kšœ˜Kšœ˜Kšœ,žœ˜6Kš žœžœžœžœ.žœ˜KKšœ0žœ˜:Kšžœžœžœžœ˜$Kšœ.žœ˜8Kš žœžœžœžœ.žœ˜KKšžœ ˜K˜K˜—šœžœžœžœžœžœžœžœžœžœ˜OKšœΎ™ΎJšœ žœžœžœ˜Jš žœžœžœžœžœ˜Jšœ žœ!˜2š žœžœžœžœžœžœž˜4Jšœžœ ˜7Jšžœ˜—Jšžœ˜ J˜——šF™FKšœžœ˜&—š,™,šœžœžœ˜%Kšœžœ˜K˜K˜—š œžœžœ#žœ˜DKšœ6™6Kš œžœžœžœžœ:˜Všžœžœžœ˜Kšœ:žœ*˜hKšž˜K˜—Kšœ žœΟc˜=Kšœ^˜^K˜K˜—šœžœžœžœžœžœžœ˜7Kšœ-™-Kš œžœžœžœžœ˜šžœ,žœžœž˜?Kšœžœžœ˜)Kšžœ˜—Kšžœ˜K˜K˜—š œžœžœ žœžœžœžœžœ˜EKšœB™BKšœ žœ"™3Kš œžœžœžœžœ:˜VKš œžœžœžœžœ˜Kšžœžœžœžœ ˜"š žœžœžœžœžœžœž˜3Kšœžœžœ˜%Kšžœ˜—Kšžœ˜K˜——š™š  œžœžœ žœžœ˜EKšœ%™%šžœž˜šœžœž˜$Kšœžœ˜#Kšœ žœ˜Kšœžœ˜*Kšœžœ˜$Kšžœžœ˜—šœ žœž˜Kšœžœ ˜%Kšœ žœ˜Kšœžœ˜%Kšœžœ˜Kšœžœ˜$Kšžœžœ˜—šœžœž˜&Kšœžœ ˜%Kšœ žœ˜Kšœžœ˜%Kšœžœ˜Kšœžœ˜$Kšžœžœ˜—Kšžœžœ˜—K˜——š ™ šœžœžœžœžœžœžœžœžœžœ˜HJšœa™aJšœ žœžœžœ˜Jš žœžœžœžœžœ˜Jšœ žœ-žœ˜Gš žœžœžœžœžœžœž˜4Jšœžœ,žœ˜LJšžœ˜—Jšžœ˜ J˜J™—š  œžœžœžœžœžœ ˜EKšœ™šœžœ˜Kšœ ˜ šžœžœž˜šžœžœ˜Kš žœžœžœžœ Ÿ˜@K˜Kšžœ˜Kšœ˜—K˜K˜ Kšžœ˜—Kšžœ Ÿ ˜Kšœ˜———š™Kšœ žœžœžœ˜K˜—š™K˜K˜K˜Kšœ˜K˜K˜K˜—šžœ˜K˜——…—J)