"

 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.

"

ArithmeticValue subclass:#Number

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!Number 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 kinds of numbers

    [author:]

        Claus Gittinger

    [see also:]

        Integer LargeInteger SmallInteger

        LimitedPrecisionReal Float ShortFloat

        Fraction FixedPoint

"

! !

!Number class methodsFor:'instance creation'!

fromString:aString

    "for compatibility with other smalltalks - same as #readFrom:"

    ^ self readFrom:aString

    "

     Number fromString:'12345'

     '12345' asNumber

    "

    "Modified: / 3.8.1998 / 20:05:11 / cg"

!

fromString:aString onError:exceptionBlock

    "for compatibility with other smalltalks - same as #readFrom:"

    ^ self readFrom:aString onError:exceptionBlock

    "

     Number fromString:'12345' onError:0

     Number fromString:'fooBarBaz' onError:0

    "

    "Modified: / 3.8.1998 / 20:05:34 / cg"

!

readFrom:aStringOrStream onError:exceptionBlock

    "return the next Number from the (character-)stream aStream;

     skipping all whitespace first; return the value of exceptionBlock,

     if no number can be read."

    |value|

    ErrorSignal handle:[:ex |

        ^ exceptionBlock value

    ] do:[

        |str nextChar radix negative signExp|

        str := aStringOrStream readStream.

        nextChar := str skipSeparators.

        nextChar isNil ifTrue:[^ exceptionBlock value].

        (nextChar == $-) ifTrue:[

            negative := true.

            str next.

            nextChar := str peekOrNil

        ] ifFalse:[

            negative := false.

            (nextChar == $+) ifTrue:[

                str next.

                nextChar := str peekOrNil

            ]

        ].

        (nextChar isDigit or:[nextChar == $.]) ifFalse:[

            ^ exceptionBlock value.

"/          value := super readFrom:str.

"/          negative ifTrue:[value := value negated].

"/          ^ value

        ].

        nextChar == $. ifTrue:[

            radix := 10.

            value := 0.0.

        ] ifFalse:[

            value := Integer readFrom:str radix:10.

            nextChar := str peekOrNil.

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

                str next.

                radix := value.

                value := Integer readFrom:str radix:radix.

            ] ifFalse:[

                radix := 10

            ].

        ].

        (nextChar == $.) ifTrue:[

            str next.

            nextChar := str peekOrNil.

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

                value := value asFloat 

                         + (Number readMantissaFrom:str radix:radix).

                nextChar := str peekOrNil

            ]

        ].

        ((nextChar == $e) or:[nextChar == $E]) ifTrue:[

            str next.

            nextChar := str peekOrNil.

            signExp := 1.

            (nextChar == $+) ifTrue:[

                str next.

                nextChar := str peekOrNil.

            ] ifFalse:[

                (nextChar == $-) ifTrue:[

                    str next.

                    nextChar := str peekOrNil.

                    signExp := -1

                ]

            ].

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

                value := value asFloat 

                         * (10.0 raisedToInteger:

                                    ((Integer readFrom:str radix:radix) * signExp))

            ]

        ].

        negative ifTrue:[

            value := value negated

        ].

    ].

    ^ value.

    "

     Number readFrom:(ReadStream on:'54.32e-01')      

     Number readFrom:(ReadStream on:'12345678901234567890') 

     Number readFrom:(ReadStream on:'16rAAAAFFFFAAAAFFFF') 

     Number readFrom:'16rAAAAFFFFAAAAFFFF' 

     Number readFrom:'0.000001'  

     '+00000123.45' asNumber  

    "

    "Modified: / 14.4.1998 / 19:22:50 / cg"

!

readSmalltalkSyntaxFrom:aStream

    "ST-80 compatibility (thanks to a note from alpha testers)

     read and return the next Number in smalltalk syntax from the 

     (character-)stream aStream."

    ^ Scanner scanNumberFrom:aStream

"/    ^ Compiler evaluate:aStream compile:false "/ self readFrom:aStream.

    "

     Number readSmalltalkSyntaxFrom:(ReadStream on:'54.32e-01')    

     Number readSmalltalkSyntaxFrom:(ReadStream on:'12345678901234567890')

     Number readSmalltalkSyntaxFrom:(ReadStream on:'16rAAAAFFFFAAAAFFFF')

     Number readSmalltalkSyntaxFrom:(ReadStream on:'(1/10)') 

     Number readFrom:(ReadStream on:'(1/10)') 

     Number readSmalltalkSyntaxFrom:(ReadStream on:'+00000123.45')  

     Number readFrom:(ReadStream on:'+00000123.45')  

     |s|

     s := ReadStream on:'2.'.

     Number readSmalltalkSyntaxFrom:s.

     s next    

     |s|

     s := ReadStream on:'2.0.'.

     Number readSmalltalkSyntaxFrom:s.

     s next    

    "

    "Modified: / 19.11.1999 / 18:26:47 / cg"

! !

!Number class methodsFor:'error reporting'!

raise:aSignalSymbol receiver:someNumber selector:sel arg:arg errorString:text 

    "ST-80 compatible signal raising. Provided for PD numeric classes"

    <context: #return>

    |msg|

    msg := MessageSend

                receiver:someNumber

                selector:sel

                arguments:(Array with:arg).

    ^ (self perform:aSignalSymbol)

         raiseRequestWith:msg 

         errorString:text 

         in:thisContext sender

    "

     Number 

        raise:#domainErrorSignal

        receiver:1.0

        selector:#sin

        arg:nil

        errorString:'foo bar test'

    "

!

raise:aSignalSymbol receiver:someNumber selector:sel arguments:argArray errorString:text 

    "ST-80 compatible signal raising. Provided for PD numeric classes"

    <context: #return>

    |msg|

    msg := MessageSend

                receiver:someNumber

                selector:sel

                arguments:argArray.

    ^ (self perform:aSignalSymbol)

         raiseRequestWith:msg 

         errorString:text 

         in:thisContext sender

    "

     Number 

        raise:#domainErrorSignal

        receiver:1.0

        selector:#sin

        arg:nil

        errorString:'foo bar test'

    "

!

raise:aSignalSymbol receiver:someNumber selector:sel errorString:text 

    "ST-80 compatible signal raising. Provided for PD numeric classes"

    <context: #return>

    |msg|

    msg := MessageSend

                receiver:someNumber

                selector:sel

                arguments:#().

    ^ (self perform:aSignalSymbol)

         raiseRequestWith:msg 

         errorString:text 

         in:thisContext sender

    "

     Number 

        raise:#domainErrorSignal

        receiver:1.0

        selector:#foo 

        errorString:'foo bar test'

    "

! !

!Number class methodsFor:'private'!

readMantissaFrom:aStream radix:radix

    "helper for readFrom: -

     return the mantissa from the (character-)stream aStream;

     no whitespace-skipping; error if no number available"

    |nextChar value factor|

    value := 0.0.

    factor := 1.0 / radix.

    nextChar := aStream peekOrNil.

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

        value := value + (nextChar digitValue * factor).

        factor := factor / radix.

        aStream next.

        nextChar := aStream peekOrNil

    ].

    ^ value

    "Modified: / 14.4.1998 / 18:47:47 / cg"

! !

!Number methodsFor:'Compatibility - Squeak'!

asSmallAngleDegrees

	"Return the receiver normalized to lie within the range (-180, 180)"

	| pos |

	pos _ self \\ 360.

	pos > 180 ifTrue: [pos _ pos - 360].

	^ pos

"#(-500 -300 -150 -5 0 5 150 300 500 1200) collect: [:n | n asSmallAngleDegrees]"!

newTileMorphRepresentative

	^ TileMorph new addArrows; setLiteral: self; addSuffixIfCan

!

stringForReadout

    ^ self rounded printString

! !

coerce:aNumber

    "return aNumber converted into receivers type"

    ^ self subclassResponsibility

!

generality

    "return the generality value - see ArithmeticValue>>retry:coercing:"

    ^ 40

! !

!Number methodsFor:'converting'!

% aNumber 

    "Return a complex number with the receiver as the real part and 

     aNumber as the imaginary part"

    ^ Complex real:self imaginary:aNumber

    "Modified: / 9.7.1998 / 10:18:12 / cg"

!

@ aNumber

    "return a Point with the receiver as x-coordinate and the argument

     as y-coordinate"

%{  /* NOCONTEXT */

    /*

     * I cannot tell if this special code is worth anything

     */

    if (__CanDoQuickNew(sizeof(struct __point))) {      /* OBJECT ALLOCATION */

        OBJ newPoint;

        int spc;

        __qCheckedAlignedNew(newPoint, sizeof(struct __point));

        __InstPtr(newPoint)->o_class = @global(Point);

        __PointInstPtr(newPoint)->p_x = self;

        __PointInstPtr(newPoint)->p_y = aNumber;

        if (! __bothSmallInteger(self, aNumber)) {

            spc = __qSpace(newPoint);

            __STORE_SPC(newPoint, aNumber, spc);

            __STORE_SPC(newPoint, self, spc);

        }

        RETURN ( newPoint );

    }

%}

.

    ^ Point x:self y:aNumber

!

asComplex

    "Return a complex number with the receiver as the real part and 

     zero as the imaginary part"

    ^ Complex fromReal:self

    "Modified: / 9.7.1998 / 10:18:16 / cg"

!

asPoint

    "return a new Point with the receiver as all coordinates;  

     often used to supply the same value in two dimensions, as with 

     symmetrical gridding or scaling."

%{  /* NOCONTEXT */

    if (__CanDoQuickNew(sizeof(struct __point))) {      /* OBJECT ALLOCATION */

        OBJ newPoint;

        __qCheckedAlignedNew(newPoint, sizeof(struct __point));

        __InstPtr(newPoint)->o_class = @global(Point);

        __PointInstPtr(newPoint)->p_x = self;

        __PointInstPtr(newPoint)->p_y = self;

        __STORE(newPoint, self);

        RETURN ( newPoint );

    }

%}.

    ^ Point x:self y:self

!

decodeAsLiteralArray

    "given a literalEncoding in the receiver,

     create & return the corresponding object.

     The inverse operation to #literalArrayEncoding."

    ^ self

    "Created: 25.2.1997 / 19:17:06 / cg"

    "Modified: 25.2.1997 / 19:17:42 / cg"

!

degreesToRadians

    "interpreting the receiver as radians, return the degrees"

    ^ (self * (Float pi)) / 180.0

!

literalArrayEncoding

    "encode myself as an array literal, from which a copy of the receiver

     can be reconstructed with #decodeAsLiteralArray."

    ^ self

    "Modified: 1.9.1995 / 02:25:26 / claus"

    "Modified: 22.4.1996 / 13:00:27 / cg"

!

radiansToDegrees

    "interpreting the receiver as degrees, return the radians"

    ^ (self * 180.0) / (Float pi)

! !

!Number methodsFor:'intervals'!

to:stop

    "return an interval from receiver up to the argument, incrementing by 1"

    ^ Interval from:self to:stop

!

to:stop by:step

    "return an interval from receiver up to the argument, incrementing by step"

    ^ Interval from:self to:stop by:step

! !

!Number methodsFor:'iteration'!

timesRepeat:aBlock

    "evaluate the argument, aBlock self times"

    |count|

    count := self.

    [count > 0] whileTrue:[

        aBlock value.

        count := count - 1

    ]

!

to:stop by:incr do:aBlock

    "For each element of the interval from the receiver up to the argument stop, incrementing

     by step, evaluate aBlock passing the element as argument."

    |tmp|

    tmp := self.

    (incr > 0) ifTrue:[

        [tmp <= stop] whileTrue:[

            aBlock value:tmp.

            tmp := tmp+incr

        ]

    ] ifFalse:[

        [tmp >= stop] whileTrue:[