"

 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.

"

Number subclass:#Integer

	instanceVariableNames:''

	classVariableNames:'DefaultDisplayRadix'

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!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

    [Class variables:]

	DefaultDisplayRadix     the radix in which integers present their 

				displayString (which is used in inspectors)

				If you are to look at many hex numbers, bitmasks

				etc. you may set this to 2 or 16.

				(avoids typing printStringRadix:.. all the time

				 - I know - I am lazy ;-). Default is 10.

    [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"

    |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"

!

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."

    ErrorSignal handle:[:ex |

        ^ exceptionBlock value

    ] do:[

        |str nextChar value 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 onError:[^ exceptionBlock value].

        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 onError:[^ exceptionBlock value]

        ].

        negative ifTrue:[

            ^ value negated

        ].

        ^ value

    ].

    "

     Integer readFrom:'12345'   

     Integer readFrom:'-12345'   

     Integer readFrom:'+12345'   

     Integer readFrom:'16rFFFF'  

     Integer readFrom:'12345.1234' 

     Integer readFrom:'foo'

     Integer readFrom:'foo' onError:[0]

    "

    "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 value|

    str := aStringOrStream readStream.

    nextChar := str peekOrNil.

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

        ^ exceptionBlock value

    ].

    value := nextChar digitValue.

    str next.

    nextChar := str peekOrNil.

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

        value := value * radix + nextChar digitValue.

        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  

    "

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

! !

!Integer class methodsFor:'constants'!

unity

    "return the neutral element for multiplication (1)"

    ^ 1

    "Modified: 18.7.1996 / 12:26:43 / cg"

!

zero

    "return the neutral element for addition (0)"

    ^ 0

    "Modified: 18.7.1996 / 12:26:38 / cg"

! !

!Integer class methodsFor:'misc'!

displayRadix:aNumber

    "being tired of always sending #printStringRadix: in the inspectors,

     this allows you to change the default print radix for the displayString

     method."

    DefaultDisplayRadix := aNumber

    "

     Integer displayRadix:16. 123456 inspect

     Integer displayRadix:10. 123456 inspect

    "

! !

!Integer methodsFor:'VisualAge compatibility'!

<< aNumber

    "left shift"

    ^ self bitShift:aNumber

    "

     1 << 5 

     64 << -5 

    "

!

>> aNumber

    "right shift"

    ^ self bitShift:(aNumber negated)

    "

     1 >> -5  

     64 >> 5  

    "

!

clearBit:index

    "return a new number where the specified bit is off.

     Bits are counted from 1 starting with the least significant."

    ^ self bitAnd:(1 bitShift:index-1) bitInvert

    "

     5 clearBit:3         => 1 

     16rFFFF clearBit:16  => 32767 (16r7FFF)   

     16rFFFF clearBit:1   => 65534 (16rFFFE)  

    "

!

isBitSet:index

    "return true if the index' bit is set; false otherwise.

     Bits are counted from 1 starting with the least significant."

    ^ (self bitAt:index) ~~ 0

    "

     5 isBitSet:3       => true

     2r0101 isBitSet:2  => false

     2r0101 isBitSet:1  => true

     2r0101 isBitSet:0  index error

    "

!

setBit:index

    "return a new number where the specified bit is on.

     Bits are counted from 1 starting with the least significant."

    ^ self bitOr:(1 bitShift:index-1)

    "

     0 setBit:3         => 4 (2r100)

     0 setBit:48        => 140737488355328 (2r1000.....000)

     ((0 setBit:99) setBit:100) printStringRadix:2  

    "

! !

!Integer methodsFor:'bit operators'!

bitAnd:anInteger

    "return the bitwise-and of the receiver and the argument, anInteger.

     This is a general and slow implementation, walking over the bytes of

     the receiver and the argument."

    |n "{ Class: SmallInteger }"

     result byte|

    n := (anInteger digitLength) min:(self digitLength).

    result := self class basicNew numberOfDigits:n.

    1 to:n do:[:index |

	byte := (anInteger digitAt:index) bitAnd:(self digitAt:index).

	result digitAt:index put:byte.

    ].

    (byte == 0 or:[n <= SmallInteger maxBytes]) ifTrue:[

	^ result compressed

    ].

    ^ result

    "

     (16r112233445566778899 bitAnd:16rFF                ) printStringRadix:16 

     (16r112233445566778899 bitAnd:16rFFFFFFFFFFFFFFFF00) printStringRadix:16 

     (16r112233445566778899 bitAnd:16rFF0000000000000000) printStringRadix:16 

     (16r112233445566778899 bitAnd:16r00000000000000FFFF) printStringRadix:16 

    "

    "Modified: 5.11.1996 / 14:06:26 / cg"

!

bitAt:index

    "return the value of the index's bit (index starts at 1).

     Notice: the result of bitShift: on negative receivers is not 

	     defined in the language standard (since the implementation

	     is free to choose any internal representation for integers)"

    |i "{Class: SmallInteger}"|

    i := index - 1.

    ^ (self digitAt:(i // 8 + 1)) bitAt:(i \\ 8 + 1)

    "

     1 bitAt:1                     => 1 

     1 bitAt:2                     => 0

     1 bitAt:0                     index error

     2r1000100010001000100010001000100010001000100010001000 bitAt:48 => 1  

     2r1000100010001000100010001000100010001000100010001000 bitAt:47 => 0  

     (1 bitShift:1000) bitAt:1000  => 0

     (1 bitShift:1000) bitAt:1001  => 1

     (1 bitShift:1000) bitAt:1002  => 0

     (1 bitShift:30) bitAt:30    

     (1 bitShift:30) bitAt:31    

     (1 bitShift:30) bitAt:32     

     (1 bitShift:31) bitAt:31     

     (1 bitShift:31) bitAt:32     

     (1 bitShift:31) bitAt:33    

     (1 bitShift:32) bitAt:32    

     (1 bitShift:32) bitAt:33    

     (1 bitShift:32) bitAt:34    

     (1 bitShift:64) bitAt:64     

     (1 bitShift:64) bitAt:65     

     (1 bitShift:64) bitAt:66     

    "

!

bitClear:anInteger

    "return the bitwise-and of the receiver and the complement of the argument, anInteger,

     returning the receiver with bits of the argument cleared."

    ^self bitAnd:(anInteger bitInvert)

!

bitInvert

    "return a new integer, where all bits are complemented.

     This does not really make sense for negative largeIntegers,

     since the digits are stored as absolute value."

    |n "{ Class: SmallInteger }"

     result byte|

    n := self digitLength.

    result := self class basicNew numberOfDigits:n.

    1 to:n do:[:index |

        byte := self digitAt:index.

        result digitAt:index put:(byte bitInvert bitAnd:16rFF).

    ].

    (byte == 255 or:[n <= SmallInteger maxBytes]) ifTrue:[

        ^ result compressed

    ].

    ^ result

!

bitOr:anInteger

    "return the bitwise-or of the receiver and the argument, anInteger.

     This is a general and slow implementation, walking over the bytes of

     the receiver and the argument."

    |n "{ Class: SmallInteger }"

     result byte|

    n := (anInteger digitLength) max:(self digitLength).

    result := self class basicNew numberOfDigits:n.

    1 to:n do:[:index |

	byte := (anInteger digitAt:index) bitOr:(self digitAt:index).

	result digitAt:index put:byte.

    ].

"/ no need to normalize - if the operands were correct

"/    byte == 0 ifTrue:[

"/        ^ result normalize

"/    ].

    ^ result

!

bitShift:shiftCount

    "return the value of the receiver shifted by shiftCount bits;

     leftShift if shiftCount > 0; rightShift otherwise.

     Notice: the result of bitShift: on negative receivers is not 

	     defined in the language standard (since the implementation

	     is free to choose any internal representation for integers)"

    |result 

     prev       "{ Class: SmallInteger }"

     next       "{ Class: SmallInteger }"

     byte       "{ Class: SmallInteger }"

     byte2      "{ Class: SmallInteger }"

     bitShift   "{ Class: SmallInteger }"

     revShift   "{ Class: SmallInteger }"

     digitShift "{ Class: SmallInteger }"

     n          "{ Class: SmallInteger }" 

     nn         "{ Class: SmallInteger }"

     nDigits    "{ Class: SmallInteger }" |

    shiftCount > 0 ifTrue:[

	"left shift"

	digitShift := shiftCount // 8.

	bitShift := shiftCount \\ 8.

	n := self digitLength.

	"

	 modulo 8 shifts can be done faster ...

	"

	bitShift == 0 ifTrue:[

	    result := self class basicNew numberOfDigits:n + digitShift.

	    result sign:self sign.

	    result digits replaceFrom:(digitShift + 1) with:self digits.

	    "

	     no normalize needed, since receiver was already normalized

	    "

	    ^ result

	].

	"

	 less-than-8 shifts can be done faster ...

	"

	digitShift == 0 ifTrue:[