"

 COPYRIGHT (c) 1988 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

Number subclass:#Integer

	instanceVariableNames:''

	classVariableNames:'BCDConversionErrorSignal PrimeCache'

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

Object subclass:#ModuloNumber

	instanceVariableNames:'modulus reciprocal shift'

	classVariableNames:''

	poolDictionaries:''

	privateIn:Integer

!

!Integer class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1988 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    abstract superclass for all integer numbers.

    See details in concrete subclasses LargeInteger and SmallInteger.

    Mixed mode arithmetic:

        int op int         -> int

        int op fix         -> fix; scale is fix's scale

        int op fraction    -> fraction

        int op float       -> float

    [author:]

        Claus Gittinger

    [see also:]

        Number

        LargeInteger SmallInteger

        Float ShortFloat Fraction FixedPoint

"

! !

!Integer class methodsFor:'instance creation'!

byte1:b1 byte2:b2 byte3:b3 byte4:b4

    "Squeak compatibility:

     Return an Integer given four value bytes.

     The returned integer is either a Small- or a LargeInteger 

     (on 32bit systems - on 64bit systems, it will be always a SmallInteger)"

    |t|

    t := b4.

    t := (t bitShift:8) + b3.

    t := (t bitShift:8) + b2.

    ^ (t bitShift:8) + b1.

    "

     (Integer byte1:16r10 byte2:16r32 byte3:16r54 byte4:16r76) hexPrintString

     (Integer byte1:16r00 byte2:16r11 byte3:16r22 byte4:16r33) hexPrintString

    "

    "Created: 19.10.1997 / 18:08:52 / cg"

    "Modified: 19.10.1997 / 18:09:04 / cg"

!

fastFromString:aString at:startIndex

    "return the next unsigned Integer from the string

     as a decimal number, starting at startIndex.

     The number must be in the native machines int range

     (i.e. 63bit on alpha / 31 on all others);

     However, for portability, only use it for 31bit numbers.

     No spaces are skipped.

     This is a specially tuned entry (using a low-level C-call), which

     returns garbage if the argument string is not a small integer number.

     It has been added to allow high speed string decomposition into numbers,

     especially for mass-data."

%{   /* NOCONTEXT */

    if (__isStringLike(aString) && __isSmallInteger(startIndex)) {

        char *cp = (char *)(__stringVal(aString));

        int idx = __intVal(startIndex) - 1;

        unsigned INT val;

        if ((unsigned)idx < __stringSize(aString)) {

            val = atoi(cp + idx);

            if (val <= _MAX_INT) {

                RETURN(__mkSmallInteger(val));

            }

            RETURN (__MKUINT(val));

        }

    }

%}.

    self primitiveFailed.

    "

     Integer fastFromString:'12345' at:1

     Integer fastFromString:'12345' at:2

     Integer fastFromString:'12345' at:3

     Integer fastFromString:'12345' at:4

     Integer fastFromString:'12345' at:5

     Integer fastFromString:'1234512345' at:1

     Integer fastFromString:'2147483647' at:1

     Integer fastFromString:'4294967295' at:1

     Integer fastFromString:'12345' at:6

     Integer fastFromString:'12345' at:0

     Time millisecondsToRun:[

        100000 timesRepeat:[

            Integer readFrom:'12345'

        ]

     ]

    "

    "

     Time millisecondsToRun:[

        100000 timesRepeat:[

            Integer fastFromString:'12345' at:1

        ]

     ]

    "

!

fromBCDBytes:aByteArray

    "given a byteArray in BCD format, return an appropriate integer.

     The byteArray must contain the BCD encoded decimal string,

     starting with the most significant digits.

     This conversion is useful for some communication protocols,

     or control systems, which represent big numbers this way...

    "

    |val|

    val := 0.

    aByteArray do:[:twoDigits |

        |hi lo|

        hi := (twoDigits bitShift:-4) bitAnd:16r0F.

        lo := twoDigits bitAnd:16r0F.

        val := (val * 100) + (hi * 10) + lo

    ].

    ^ val

    "

     Integer fromBCDBytes:#[16r12 16r34 16r56]

     Integer fromBCDBytes:#[16r12 16r34 16r56 16r78]

     Integer fromBCDBytes:#[16r12 16r34 16r56 16r78 16r90]

     Integer fromBCDBytes:#[16r98 16r76 16r54]

     Integer fromBCDBytes:#[16r98 16r76 16r54 16r32]

     Integer fromBCDBytes:#[16r98 16r76 16r54 16r32 16r10]

     Integer fromBCDBytes:#[16r12 16r34 16r56 16r78 16r90 16r12 16r34 16r56 16r78 16r90]

    "

!

fromSwappedBCDBytes:aByteArray

    "given a byteArray in BCD format, return an appropriate integer.

     The byteArray must contain the BCD encoded decimal string,

     starting with the LEAST significant digits.

     This conversion is useful for some communication protocols,

     or control systems (e.g. SMC), which represent big numbers this way...

    "

    |val|

    val := 0.

    aByteArray do:[:twoDigits |

        |hi lo|

        lo := (twoDigits bitShift:-4) bitAnd:16r0F.

        hi := twoDigits bitAnd:16r0F.

        lo <= 9 ifTrue:[

            val := (val * 100) + (hi * 10) + lo

        ] ifFalse:[

            "16rF is used to encode an odd number of digits"

            val := (val * 10) + hi.

        ].

    ].

    ^ val

    "

     Integer fromSwappedBCDBytes:#[16r12 16r34 16r56]

     Integer fromSwappedBCDBytes:#[16r12 16r34 16rF6]

     Integer fromSwappedBCDBytes:#[16r12 16r34 16r56 16r78]

     Integer fromSwappedBCDBytes:#[16r12 16r34 16r56 16r78 16r90]

     Integer fromSwappedBCDBytes:#[16r98 16r76 16r54]

     Integer fromSwappedBCDBytes:#[16r98 16r76 16r54 16r32]

     Integer fromSwappedBCDBytes:#[16r98 16r76 16r54 16r32 16r10]

     Integer fromSwappedBCDBytes:#[16r12 16r34 16r56 16r78 16r90 16r12 16r34 16r56 16r78 16r90]

    "

!

new:numberOfBytes neg:negative

    "for ST-80 compatibility:

     Return an empty Integer (uninitialized value) with space for

     numberOfBytes bytes (= digitLength). The additional argument

     negative specifies if the result should be a negative number.

     The digits can be stored byte-wise into the result, using digitAt:put:"

    ^ LargeInteger basicNew 

            numberOfDigits:numberOfBytes

            sign:(negative ifTrue:[-1] ifFalse:[1])

!

readFrom:aStringOrStream

    "return the next unsigned Integer from the (character-)stream aStream

     as decimal number.

     NOTICE:

       This behaves different from the default readFrom:, in returning

       0 (instead of raising an error) in case no number can be read.

       It is unclear, if this is the correct behavior (ST-80 does this)

       - depending on the upcoming ANSI standard, this may change."

    ^ self readFrom:aStringOrStream onError:0

    "

     Integer readFrom:(ReadStream on:'foobar')

     Integer readFrom:(ReadStream on:'foobar') onError:nil

    "

!

readFrom:aStringOrStream onError:exceptionBlock

    "return the next Integer from the (character-)stream aStream,

     handling initial XXr for arbitrary radix numbers and initial sign.

     Also, all initial whitespace is skipped.

     If the string does not represent a valid integer number,

     return the value of exceptionBlock."

    |value|

    Error handle:[:ex |

        ^ exceptionBlock value

    ] do:[

        |str nextChar negative|

        str := aStringOrStream readStream.

        nextChar := str skipSeparators.

        (nextChar == $-) ifTrue:[

            negative := true.

            str next.

            nextChar := str peekOrNil

        ] ifFalse:[

            negative := false

        ].

        (nextChar isNil or:[nextChar isDigit not]) ifTrue:[

            "

             the string does not represent an integer

            "

            ^ exceptionBlock value

        ].

        value := self readFrom:str radix:10.

        nextChar := str peekOrNil.

        ((nextChar == $r) or:[ nextChar == $R]) ifTrue:[

            "-xxr<number> is invalid; should be xxr-<val>"

            negative ifTrue:[

                'Integer [warning]: invalid (negative) radix ignored' errorPrintCR.

                negative := false

            ].

            str next.

            value := self readFrom:str radix:value

        ].

        negative ifTrue:[

            value := value negated

        ].

    ].

    ^ value

    "

     Integer readFrom:'12345'      onError:['wrong']

     Integer readFrom:'-12345'     onError:['wrong']

     Integer readFrom:'+12345'     onError:['wrong']

     Integer readFrom:'16rFFFF'    onError:['wrong']

     Integer readFrom:'12345.1234' onError:['wrong']

     Integer readFrom:'foo'        onError:['wrong']

     Integer readFrom:'foo'

    "

    "Created: / 16.11.1995 / 22:48:59 / cg"

    "Modified: / 14.4.1998 / 19:17:28 / cg"

!

readFrom:aStringOrStream radix:radix

    "return the next unsigned Integer from the (character-)stream aStream

     in radix; (assumes that the initial XXr has already been read).

     No whitespace-skipping is done.

     Returns 0 if no number available.

     NOTICE:

       This behaves different from the default readFrom:, in returning

       0 (instead of raising an error) in case no number can be read.

       It is unclear, if this is the correct behavior (ST-80 does this)

       - depending on the upcoming ANSI standard, this may change."

    ^ self readFrom:aStringOrStream radix:radix onError:0

!

readFrom:aStringOrStream radix:radix onError:exceptionBlock

    "return the next unsigned Integer from the (character-)stream aStream

     in radix; (assumes that the initial XXr has already been read).

     No whitespace-skipping is done.

     Returns the value of exceptionBlock, if no number is available."

    |str nextChar nextChar2 nextChar3 nextChar4 value

     r     "{ Class: SmallInteger }"

     r2    "{ Class: SmallInteger }"

     r3    "{ Class: SmallInteger }"

     r4    "{ Class: SmallInteger }"

     digit1 digit2 digit3 digit4 |

    str := aStringOrStream readStream.

    nextChar := str peekOrNil.

    (nextChar notNil and:[nextChar isDigitRadix:radix]) ifFalse:[

        ^ exceptionBlock value

    ].

    value := nextChar digitValue.

    str next.

    nextChar := str peekOrNil.

"/ OLD code

"/    [nextChar notNil and:[nextChar isDigitRadix:radix]] whileTrue:[

"/        str next.

"/        value := value * radix + nextChar digitValue.

"/        nextChar := str peekOrNil.

"/    ].

"/    ^ value.

    "/ the code below does the same, but is much faster, if the

    "/ converted number is large

    "/ (requires only half as many LargeInt multiplications and additions)

    "/ It should not be slower for smallIntegers.

    r := radix.

    r2 := r * r.

    r3 := r2 * r.

    r4 := r2 * r2.

    [nextChar notNil and:[ (digit1 := nextChar digitValueRadix:r) notNil]] whileTrue:[

        "/ read 4 chars and pre-compute their value to avoid largeInt operations.

        str next.

        nextChar2 := str peekOrNil.

        (nextChar2 isNil or:[ (digit2 := nextChar2 digitValueRadix:r) isNil]) ifTrue:[

            ^ (value * r) + digit1.

        ].

        str next.

        nextChar3 := str peekOrNil.

        (nextChar3 isNil or:[ (digit3 := nextChar3 digitValueRadix:r) isNil]) ifTrue:[

            ^ (value * r2) + ((digit1*r) + digit2).

        ].

        str next.

        nextChar4 := str peekOrNil.

        (nextChar4 isNil or:[ (digit4 := nextChar4 digitValueRadix:r) isNil]) ifTrue:[

            ^ (value * r3) + ((((digit1*r) + digit2)*r) + digit3).

        ].

        value := (value * r4) + ((((((digit1*r) + digit2)*r) + digit3)*r) + digit4).

        str next.

        nextChar := str peekOrNil.

    ].

    ^ value

    "

     Integer readFrom:(ReadStream on:'12345') radix:10

     Integer readFrom:(ReadStream on:'FFFF') radix:16

     Integer readFrom:(ReadStream on:'1010') radix:2

     Integer readFrom:(ReadStream on:'foobar') radix:10

     Integer readFrom:(ReadStream on:'foobar') radix:10 onError:nil

     Integer readFrom:'gg' radix:10 onError:0

     Time millisecondsToRun:[

        1000 timesRepeat:[

            (String new:1000 withAll:$1) asInteger

        ]

     ]

    "

    "Modified: / 14.4.1998 / 19:16:46 / cg"

!

readFromRomanString:aStringOrStream

    "convert a string or stream containing a roman representation into an integer.

     Raises a RomanNumberFormatError, if the inputs format is completely wrong.

     Raises BadRomanNumberFormatError if its wrong, but could be parsed.

     Notifies via NaiveRomanNumberFormatNotification, if its a bit wrong (naive format).

     Will read both real and naive roman numbers (see printRomanOn: vs. printRomanOn:naive:),

     however, a notification is raised for for naive numbers (catch it if you are interested in it)."

    |romanValues s c val digitVal prevDigitVal countSame delta

     stopOnSeparator finish|

    romanValues := Dictionary

                    withKeys:'MDCLXVI' "/ #($M $D $C $L $X $V $I)

                    andValues:#(1000 500 100 50 10 5 1).

    (stopOnSeparator := aStringOrStream isStream) ifFalse:[

        s := aStringOrStream readStream.

    ].

    s atEnd ifTrue:[

        ^ RomanNumberFormatError raiseErrorString:'empty string'

    ].

    val := 0.

    prevDigitVal := 99999.

    countSame := 1.

    finish := false.

    [s atEnd or:[finish]] whileFalse:[

        c := s next asUppercase.

        c isSeparator ifTrue:[

            stopOnSeparator ifFalse:[

                ^ RomanNumberFormatError raiseErrorString:'garbage at the end'

            ].

            finish := true.

        ] ifFalse:[

            digitVal := romanValues at:c ifAbsent:nil.

            digitVal isNil ifTrue:[

                ^ RomanNumberFormatError raiseErrorString:'invalid character'

            ].

            digitVal = prevDigitVal ifTrue:[

                ( #( 1 10 100 1000) includes:digitVal) ifFalse:[

                    ^ RomanNumberFormatError raiseErrorString:'character may not be repeated'

                ].

                val := val + digitVal.

                countSame := countSame + 1.

                countSame >= 4 ifTrue:[

                    digitVal ~= 1000 ifTrue:[

                        countSame > 4 ifTrue:[

                            "/ this is a bad roman number (such as MCCCCCCCCXXXXXXII);

                            "/ Its not correct, but sometimes encountered on buildings.

                            "/ If you do not want to be too picky,

                            "/ provide a proceeding handler in order to proceed the conversion.

                            BadRomanNumberFormatError raiseRequestErrorString:'more than 4 occurrences of same character'

                        ] ifFalse:[

                            "/ this is a naive roman number (such as VIIII);

                            "/ Its not correct, but very often encountered (especially as page numbers).

                            "/ The notification below normally goes unnoticed, unless some input validator

                            "/ wants to be very picky, and treat this as an error.

                            "/ To do so, provide a handler for NaiveRomanNumberFormatNotification.

                            NaiveRomanNumberFormatNotification raiseRequestErrorString:'more than 3 occurrences of same character'.

                        ]

                    ]

                ].

            ] ifFalse:[

                digitVal < prevDigitVal ifTrue:[

                    val := val + digitVal.

                ] ifFalse:[

                    countSame == 1 ifFalse:[

                        ^ RomanNumberFormatError raiseErrorString:'invalid character combination'

                    ].

                    delta := digitVal - prevDigitVal.

                    ( #( 4 9 40 90 400 900) includes:delta) ifFalse:[

                        ^ RomanNumberFormatError raiseErrorString:'invalid character combination'

                    ].

                    val := val - prevDigitVal.

                    val := val + delta.

                    digitVal := prevDigitVal - 0.1.  "/ trick: prevent prevDigit from arriving again.