
<<IntsImpl.mesa>>
<<Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT>>
<<>>
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;
<<Types and Constants>>
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];
<<Variables>>
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
    ] ];
<<I/O and Conversion>>
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];
        };
<<Arithmetic>>
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] ~ {
<<Euclidean algorithm, adapted from Mesa manual p. 2-2>>
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];
};
    };
<<Comparison>>
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.