DIRECTORY Rope, IO, Basics, Atom, Convert, AlgebraClasses, Points, Ints; IntsImpl: CEDAR PROGRAM IMPORTS IO, Convert EXPORTS Ints = BEGIN OPEN Ints, Convert, AC: AlgebraClasses, PTS: Points; IntsError: PUBLIC SIGNAL [reason: ATOM _ $Unspecified] = CODE; bitsPerWord: CARDINAL = Basics.bitsPerWord; CARD: TYPE = LONG CARDINAL; ROPE: TYPE = Rope.ROPE; STREAM: TYPE = IO.STREAM; IntOne: Int _ FromINT[1]; IntZero: Int _ FromINT[0]; ClassPrintName: AC.PrintNameProc = { RETURN["Ints"]; }; 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, Int] ] ] }; ClassWrite: AC.WriteOp = { Write[stream, NARROW[in, Int] ] }; ClassCharacteristic: AC.StructureRankOp = { RETURN[ 0 ] }; ClassAdd: AC.BinaryOp = { RETURN[ Add[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ] }; ClassNegate: AC.UnaryOp = { RETURN[ Negate[ NARROW[arg, Int] ] ]; }; ClassSubtract: AC.BinaryOp = { RETURN[ Subtract[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ] }; ClassZero: AC.NullaryOp = { RETURN[ IntZero ] }; ClassMultiply: AC.BinaryOp = { RETURN[ Multiply[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ] }; ClassRemainder: AC.BinaryOp = { RETURN[ Remainder[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ] }; ClassGcd: AC.BinaryOp = { RETURN[ Gcd[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ] }; ClassOne: AC.NullaryOp = { RETURN[ IntOne ] }; ClassEqual: AC.EqualityOp = { RETURN[ Equal[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ] }; ClassSign: AC.CompareToZeroOp = { RETURN[ Sign[NARROW[arg, Int] ] ] }; ClassAbs: AC.UnaryOp = { RETURN[ Abs[NARROW[arg, Int] ] ] }; ClassCompare: AC.BinaryCompareOp = { RETURN[ Compare[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ] }; IntClass: AC.StructureClass _ NEW[AC.StructureClassRec _ [ flavor: ring, 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, one: ClassOne, equal: ClassEqual, ordered: TRUE, sign: ClassSign, abs: ClassAbs, compare: ClassCompare, integralDomain: TRUE, gcdDomain: TRUE, gcd: ClassGcd, euclideanDomain: TRUE, remainder: ClassRemainder, propList: NIL ] ]; Ints: PUBLIC AC.Structure _ NEW[AC.StructureRec _ [ class: IntClass, instanceData: NIL ] ]; Read: PUBLIC PROC [in: IO.STREAM] RETURNS [out: Int] ~ { RETURN[NEW[IntRep _ [IO.GetInt[in] ] ] ]; }; FromRope: PUBLIC PROC [rope: ROPE] RETURNS [Int] = { RETURN[NEW[IntRep _ [Convert.IntFromRope[rope] ] ] ]; }; ToRope: PUBLIC PROC [int: Int] RETURNS [out: ROPE] = { RETURN[ Convert.RopeFromInt[int.val] ]; }; Write: PUBLIC PROC [stream: IO.STREAM, in: Int] = { IO.PutRope[ stream, ToRope[in] ] }; FromINT: PUBLIC PROC [int: INT] RETURNS [Int] = { RETURN[NEW[IntRep _ [int] ] ]; }; ToINT: PUBLIC PROC [int: Int] RETURNS [INT] = { RETURN[int.val]; }; Add: PUBLIC PROC [firstArg, secondArg: Int] RETURNS [result: Int] ~ { RETURN [NEW[IntRep _ [firstArg.val + secondArg.val]]]; }; Negate: PUBLIC PROC [arg: Int] RETURNS [result: Int] ~ { RETURN [NEW[IntRep _ [ - arg.val]]]; }; Subtract: PUBLIC PROC [firstArg, secondArg: Int] RETURNS [result: Int] ~ { RETURN [NEW[IntRep _ [firstArg.val - secondArg.val]]]; }; Multiply: PUBLIC PROC [firstArg, secondArg: Int] RETURNS [result: Int] ~ { RETURN [NEW[IntRep _ [firstArg.val * secondArg.val]]]; }; Remainder: PUBLIC PROC [firstArg, secondArg: Int] RETURNS [result: Int] ~ { RETURN [NEW[IntRep _ [firstArg.val MOD secondArg.val]]]; }; Gcd: PUBLIC PROC [m, n: Int] RETURNS [gcd: Int] ~ { IF Equal[m, IntZero] AND Equal[n, IntZero] THEN gcd _ IntZero ELSE { r: Int; UNTIL Equal[n, IntZero] DO r _ Remainder[m, n]; m _ n; n _ r; ENDLOOP; gcd _ Abs[m]; }; }; Sign: PUBLIC PROC [arg: Int] RETURNS [Basics.Comparison] = { SELECT arg.val FROM < 0 => RETURN[less]; = 0 => RETURN[equal]; ENDCASE => RETURN[greater]; }; Abs: PUBLIC PROC [arg: Int] RETURNS [result: Int] ~ { RETURN [NEW[IntRep _ [ ABS[arg.val] ]]]; }; Compare: PUBLIC PROC [firstArg, secondArg: Int] RETURNS [Basics.Comparison] ~ { SELECT firstArg.val FROM < secondArg.val => RETURN[less]; = secondArg.val => RETURN[equal]; ENDCASE => RETURN[greater]; }; Equal: PUBLIC PROC [firstArg, secondArg: Int] RETURNS [BOOL] ~ { RETURN[ Compare[firstArg, secondArg] = equal ] }; END. ΖIntsImpl.mesa Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT Types and Constants Variables I/O and Conversion Arithmetic Euclidean algorithm, adapted from Mesa manual p. 2-2 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šœ œœ˜BJšœ˜—šž œœ˜Jšœ ˜Jšœ˜—šž œœ ˜Jšœ œœ˜BJšœ˜—šžœœ ˜Jšœ œœ˜CJšœ˜—šžœœ ˜Jšœœœ˜=Jšœ˜—šžœœ˜Jšœ ˜Jšœ˜—šž œœ˜Jšœœœ˜?Jšœ˜—šž œœ˜!Jšœœ˜!Jšœ˜—šžœœ ˜Jšœœ˜ Jšœ˜—šž œœ˜$Jšœ œœ˜AJšœ˜—šžœœœœ˜: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˜Jšœ ˜ K˜—K˜š žœœœ œœ˜3Jšœ˜Jšœ˜K˜——šœ™š žœœœœœœ˜8Kšœœ˜)K˜K˜—š žœœœœœ ˜4Kšœœ+˜5K˜K˜—š žœœœ œœ˜6Kšœ!˜'K˜K˜—š žœœœ œœ˜3Jšœ˜ Jšœ˜J˜—š žœœœœœ ˜1Kšœœ˜K˜K˜—šžœ œ œœ˜/Kšœ ˜K˜——šž ™ šžœœœœ˜EKšœœ+˜6K˜J˜—šžœœœ œ˜8Kšœœ˜$K˜J˜—šžœœœœ˜JKšœœ+˜6K˜J˜—šžœœœœ˜JKšœœ+˜6K˜J˜—šž œœœœ˜KKšœœœ˜8K˜J˜—šžœœœ œ˜3Jšœ4™4Jšœœœ˜=šœ˜J˜šœ˜J˜J˜Jšœ˜—J˜ J˜—K˜——šœ ™ šžœœœ œ˜=šœ ˜Kšœœ˜Kšœœ˜Kšœœ ˜—Jšœ˜J™—šžœœœ œ˜5Kšœœ œ˜(J˜J˜—šžœ œœ˜Ošœ˜Kšœœ˜ Kšœœ˜!Kšœœ ˜—J˜J˜—šžœ œœœ˜@Jšœ(˜.Jšœ˜J˜—J˜J˜—Jšœ˜J˜—…—