DIRECTORY Rope, IO, Basics, Atom, Convert, AlgebraClasses, Points, Reals; RealsImpl: CEDAR PROGRAM IMPORTS IO, Convert EXPORTS Reals = BEGIN OPEN Reals, Convert, AC: AlgebraClasses, PTS: Points; RealsError: PUBLIC SIGNAL [reason: ATOM _ $Unspecified] = CODE; bitsPerWord: CARDINAL = Basics.bitsPerWord; CARD: TYPE = LONG CARDINAL; ROPE: TYPE = Rope.ROPE; STREAM: TYPE = IO.STREAM; RealOne: Real _ FromREAL[1.0]; RealZero: Real _ FromREAL[0.0]; ClassPrintName: AC.PrintNameProc = { RETURN["Reals"]; }; ClassLegalFirstChar: AC.LegalFirstCharOp = { SELECT char FROM = '., IN ['0..'9] => RETURN[TRUE]; ENDCASE; RETURN[FALSE]; }; ClassRead: AC.ReadOp = { RETURN[Read[in]]; }; ClassFromRope: AC.FromRopeOp = { stream: IO.STREAM _ IO.RIS[in]; RETURN[ ClassRead[stream] ]; }; ClassToRope: AC.ToRopeOp = { RETURN[ ToRope[NARROW[in, Real] ] ] }; ClassWrite: AC.WriteOp = { Write[stream, NARROW[in, Real] ] }; ClassCharacteristic: AC.StructureRankOp = { RETURN[ 0 ] }; ClassAdd: AC.BinaryOp = { RETURN[ Add[NARROW[firstArg, Real], NARROW[secondArg, Real] ] ] }; ClassNegate: AC.UnaryOp = { RETURN[ Negate[ NARROW[arg, Real] ] ]; }; ClassSubtract: AC.BinaryOp = { RETURN[ Subtract[NARROW[firstArg, Real], NARROW[secondArg, Real] ] ] }; ClassZero: AC.NullaryOp = { RETURN[ RealZero ] }; ClassMultiply: AC.BinaryOp = { RETURN[ Multiply[NARROW[firstArg, Real], NARROW[secondArg, Real] ] ] }; ClassInvert: AC.UnaryOp = { RETURN[ Invert[NARROW[arg, Real] ] ] }; ClassDivide: AC.BinaryOp = { RETURN[ Divide[NARROW[firstArg, Real], NARROW[secondArg, Real] ] ] }; ClassOne: AC.NullaryOp = { RETURN[ RealOne ] }; ClassEqual: AC.EqualityOp = { RETURN[ Compare[NARROW[firstArg, Real], NARROW[secondArg, Real] ] = equal ] }; ClassSign: AC.CompareToZeroOp = { RETURN[ Sign[NARROW[arg, Real] ] ] }; ClassAbs: AC.UnaryOp = { RETURN[ Abs[NARROW[arg, Real] ] ] }; ClassCompare: AC.BinaryCompareOp = { RETURN[ Compare[NARROW[firstArg, Real], NARROW[secondArg, Real] ] ] }; RealClass: AC.StructureClass _ NEW[AC.StructureClassRec _ [ flavor: field, printName: ClassPrintName, characteristic: ClassCharacteristic, legalFirstChar: ClassLegalFirstChar, read: ClassRead, fromRope: ClassFromRope, toRope: ClassToRope, write: ClassWrite, add: ClassAdd, negate: ClassNegate, subtract: ClassSubtract, zero: ClassZero, multiply: ClassMultiply, commutative: TRUE, invert: ClassInvert, divide: ClassDivide, one: ClassOne, equal: ClassEqual, ordered: TRUE, sign: ClassSign, abs: ClassAbs, compare: ClassCompare, completeField: TRUE, realField: TRUE, realClosedField: TRUE, algebraicallyClosedField: FALSE, propList: NIL ] ]; Reals: PUBLIC AC.Structure _ NEW[AC.StructureRec _ [ class: RealClass, instanceData: NIL ] ]; Read: PUBLIC PROC [in: IO.STREAM] RETURNS [out: Real] ~ { RETURN[NEW[RealRep _ [IO.GetReal[in] ] ] ]; }; FromRope: PUBLIC PROC [rope: ROPE] RETURNS [Real] = { RETURN[NEW[RealRep _ [Convert.RealFromRope[rope] ] ] ]; }; ToRope: PUBLIC PROC [real: Real] RETURNS [out: ROPE] = { RETURN[ Convert.RopeFromReal[real.val] ]; }; Write: PUBLIC PROC [stream: IO.STREAM, in: Real] = { IO.PutRope[ stream, ToRope[in] ] }; FromREAL: PUBLIC PROC [real: REAL] RETURNS [Real] = { RETURN[NEW[RealRep _ [real] ] ]; }; ToREAL: PUBLIC PROC [real: Real] RETURNS [REAL] = { RETURN[real.val]; }; Add: PUBLIC PROC [firstArg, secondArg: Real] RETURNS [result: Real] ~ { RETURN [NEW[RealRep _ [firstArg.val + secondArg.val]]]; }; Negate: PUBLIC PROC [arg: Real] RETURNS [result: Real] ~ { RETURN [NEW[RealRep _ [ - arg.val]]]; }; Subtract: PUBLIC PROC [firstArg, secondArg: Real] RETURNS [result: Real] ~ { RETURN [NEW[RealRep _ [firstArg.val - secondArg.val]]]; }; Multiply: PUBLIC PROC [firstArg, secondArg: Real] RETURNS [result: Real] ~ { RETURN [NEW[RealRep _ [firstArg.val * secondArg.val]]]; }; Invert: PUBLIC PROC [arg: Real] RETURNS [result: Real] ~ { RETURN [NEW[RealRep _ [ 1.0 / arg.val]]]; }; Divide: PUBLIC PROC [firstArg, secondArg: Real] RETURNS [result: Real]~ { RETURN [NEW[RealRep _ [firstArg.val / secondArg.val]]]; }; Sign: PUBLIC PROC [arg: Real] RETURNS [Basics.Comparison] = { SELECT arg.val FROM < 0.0 => RETURN[less]; = 0.0 => RETURN[equal]; ENDCASE => RETURN[greater]; }; Abs: PUBLIC PROC [arg: Real] RETURNS [result: Real] ~ { RETURN [NEW[RealRep _ [ ABS[arg.val] ]]]; }; Compare: PUBLIC PROC [firstArg, secondArg: Real] RETURNS [Basics.Comparison] ~ { SELECT firstArg.val FROM < secondArg.val => RETURN[less]; = secondArg.val => RETURN[equal]; ENDCASE => RETURN[greater]; }; END. ’RealsImpl.mesa Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT Types and Constants Variables I/O and Conversion Arithmetic Comparison ΚΠ˜Jšœ™J™3J™šΟk ˜ Jšœ˜Icodešœ˜K˜K˜K˜J˜J˜Jšœ˜—J˜head2šœ œ˜Jšœœ ˜Jšœ˜ J˜—Jš œœœœœ ˜=headšΟn™Jš œ œœ œœ˜?Kšœ œ˜+Kšœœœœ˜Kšœœœ˜Kšœœœœ˜Kšœ˜Kšœ˜—šž ™ šžœœ˜$Jšœ ˜J˜—šžœœ˜,šœ˜Kšœ œœ˜"Kšœ˜—Kšœœ˜J˜—šž œœ ˜Jšœ ˜J˜—šž œœ˜ Kš œœœœœ˜Kšœ˜K˜—šž œœ ˜Jšœ œ˜#J˜—šž œœ ˜Jšœœ ˜ Jšœ˜—šžœœ˜+Jšœ˜ Jšœ˜—šžœœ ˜Jšœœœ˜?Jšœ˜—šž œœ ˜Jšœ œ˜&Jšœ˜—šž œœ ˜Jšœ œœ˜DJšœ˜—šž œœ˜Jšœ ˜Jšœ˜—šž œœ ˜Jšœ œœ˜DJšœ˜—šž œœ ˜Jšœ œ˜$Jšœ˜—šž œœ ˜Jšœ œœ˜BJšœ˜—šžœœ˜Jšœ ˜Jšœ˜—šž œœ˜Jšœ œœ˜KJšœ˜—šž œœ˜!Jšœœ˜"Jšœ˜—šžœœ ˜Jšœœ˜!Jšœ˜—šž œœ˜$Jšœ œœ˜CJšœ˜—šž œœœœ˜;J˜J˜Jšœ$˜$J˜Jšœ$˜$Jšœ˜Jšœ˜Jšœ˜Jšœ˜J˜Kšœ˜Kšœ˜Kšœ˜K˜K˜Kšœ˜Kšœ œ˜Kšœ˜Kšœ˜K˜K˜K˜K˜Kšœ œ˜Kšœ˜K˜Kšœ˜K˜Kšœœ˜Kšœ œ˜Kšœœ˜Kšœœ˜ K˜Jšœ ˜ K˜—K˜š žœœœ œœ˜4Jšœ˜Jšœ˜K˜——šœ™š žœœœœœœ˜9Kšœœ!˜+K˜K˜—š žœœœœœ ˜5Kšœœ-˜7K˜K˜—š žœœœœœ˜8Kšœ#˜)K˜K˜—š žœœœ œœ˜4Jšœ˜ Jšœ˜J˜—š žœœœœœ ˜5Kšœœ˜ K˜K˜—šžœ œœœ˜3Kšœ ˜K˜——šž ™ šžœœœœ˜GKšœœ,˜7K˜J˜—šžœœœ œ˜:Kšœœ˜%K˜J˜—šžœœœœ˜LKšœœ,˜7K˜J˜—šžœœœœ˜LKšœœ,˜7K˜J˜—šžœœœ œ˜:Kšœœ˜)K˜J˜—šžœœœœ˜IKšœœ,˜7K˜J˜——šœ ™ šžœœœ œ˜>šœ ˜Kšœ œ˜Kšœ œ˜Kšœœ ˜—Jšœ˜J™—šžœœœ œ˜7Kšœœ œ˜)J˜J˜—šžœ œœ˜Pšœ˜Kšœœ˜ Kšœœ˜!Kšœœ ˜—J˜——˜J˜—Jšœ˜J˜—…—”φ