"

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

ArithmeticValue subclass:#Number

	instanceVariableNames:''

	classVariableNames:'DecimalPointCharacterForPrinting DecimalPointCharactersForReading

		DefaultDisplayRadix'

	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

    [class variables:]

	DecimalPointCharacterForPrinting          <Character>                     used when printing

	DecimalPointCharactersForReading          <Collection of Character>       accepted as decimalPointChars when reading

	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:]

	Integer LargeInteger SmallInteger

	LimitedPrecisionReal Float ShortFloat

	Fraction FixedPoint

"

! !

!Number class methodsFor:'instance creation'!

coerce:aNumber

    "convert the argument aNumber into an instance of the receiver (class) and return it."

    self == Number ifTrue:[

        self assert:(aNumber isNumber).

        ^ aNumber

    ].

    ^ super coerce:aNumber

    "Created: / 21-06-2017 / 08:58:38 / cg"

!

fastFromString:aString

    "return the next Float, Integer or ShortFloat from the string.

     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 valid float number.

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

     especially for mass-data."

    ^ self fastFromString:aString at:1

    "

     Float fromString:'12345.0'

     Float fastFromString:'12345.0'

     Integer fromString:'12345'

     Integer fastFromString:'12345'

     should be roughly 10times faster than the general method:

     Time millisecondsToRun:[

	100000 timesRepeat:[ Float fromString:'12345.0' ]

     ].

     Time millisecondsToRun:[

	100000 timesRepeat:[ Float fastFromString:'12345.0' ]

     ].

     Time millisecondsToRun:[

	100000 timesRepeat:[ Integer fromString:'12345' ]

     ].

     Time millisecondsToRun:[

	100000 timesRepeat:[ Integer fastFromString:'12345' ]

     ].

    "

!

fromNumber:aNumber

    "return aNumber coerced to myself"

    self isAbstract ifTrue:[^ aNumber]. 

    ^ self coerce:aNumber

    "Created: / 21-06-2017 / 08:57:00 / cg"

!

fromString:aString

    "return a number by reading from aString.

     In contrast to readFrom:, no garbage is allowed after the number.

     I.e. the string must contain exactly one valid number (with optional separators around)"

    ^ self

	fromString:aString

	decimalPointCharacters:(self decimalPointCharactersForReading)

    "

     Number fromString:'12345'

     Number fromString:'abc'

     Number fromString:'1abc'   -> raises an error

     Number readFrom:'1abc'     -> reads a 1

     Number readFrom:'10/2'     -> reads a 10

     Number fromString:'10/2'   -> raises an error

     Number fromString:'(1/2)'  -> reads a fraction

     Number readFrom:'(1/2)'    -> reads a fraction

     Number readFrom:'(10/2)'   -> reads a 5

     '12345' asNumber

    "

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

!

fromString:aString decimalPointCharacters:decimalPointCharacters

    "return a number by reading from aString.

     In contrast to readFrom:, no garbage is allowed after the number.

     I.e. the string must contain exactly one valid number (with optional separators around)"

    |s num|

    s := aString readStream.

    num := self readFrom:s decimalPointCharacters:decimalPointCharacters onError:[^ ConversionError raiseRequestErrorString:' - invalid number'].

    s atEnd ifFalse:[

	s skipSeparators.

	s atEnd ifFalse:[

	    ^ ConversionError raiseRequestErrorString:' - garbage at end of number'

	].

    ].

    ^ num.

    "

     Number fromString:'12345'

     Number fromString:'abc'

     Number fromString:'1abc'

     '12345' asNumber

    "

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

!

fromString:aString decimalPointCharacters:decimalPointCharacters onError:exceptionBlock

    "return a number by reading from aString.

     In contrast to readFrom:, no garbage is allowed after the number.

     I.e. the string must contain exactly one valid number (with optional separators around)"

    |s num|

    s := aString readStream.

    num := self readFrom:s decimalPointCharacters:decimalPointCharacters onError:[^ exceptionBlock value].

    s atEnd ifFalse:[

        s skipSeparators.

        s atEnd ifFalse:[

            ^ exceptionBlock value "/ - garbage at end of number'

        ].

    ].

    ^ num.

    "

     Number fromString:'12345' onError:0

     Number fromString:'12,345' decimalPointCharacters:',' onError:0

     Number fromString:'12,345' decimalPointCharacters:',' onError:0

     Number fromString:'fooBarBaz' onError:0

     Number fromString:'123fooBarBaz' onError:0

     Number fromString:'123,fooBarBaz' decimalPointCharacters:',' onError:0

    "

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

!

fromString:aString onError:exceptionBlock

    "return a number by reading from aString.

     In contrast to readFrom:, no garbage is allowed after the number.

     I.e. the string must contain exactly one valid number (with optional separators around)"

    ^ self fromString:aString decimalPointCharacters:(self decimalPointCharactersForReading) onError:exceptionBlock

    "

     Number fromString:'12345' onError:0

     Number fromString:'fooBarBaz' onError:0

     Number fromString:'123fooBarBaz' onError:0

    "

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

!

readFrom:aStringOrStream decimalPointCharacters:decimalPointCharacters

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

     skipping all whitespace first.

     Return the value of exceptionBlock, if no number can be read.

     This method is less strict than the smalltalk number reader; it

     allows for prefixed + and also allows missing fractional part after eE.

     It also allows garbage after the number - i.e. it reads what it can.

     See #fromString: , which is more strict and does not allow garbage at the end."

    ^ self

	readFrom:aStringOrStream

	decimalPointCharacters:decimalPointCharacters

	onError:[self error:'conversion error for: ' , self name]

    "

     Number readFrom:'123.456' decimalPointCharacters:'.'

     Number readFrom:'123,456' decimalPointCharacters:'.,'

     Number readFrom:'123,456' decimalPointCharacters:'.'

    "

!

readFrom:aStringOrStream decimalPointCharacters:decimalPointCharacters 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.

     This method is less strict than the smalltalk number reader; it

     allows for prefixed + and also allows missing fractional part after eE.

     It also allows garbage after the number - i.e. it reads what it can.

     See #fromString: , which is more strict and does not allow garbage at the end.

     Notice (see examples below): 

        if sent to Number, it will decide which type of number to return (depending on the exponent character);

        if sent to a concrete number-class, an instance of that class will be returned (independent of the exponent character)

    "

    ^ [

        |value intValue mantissaAndScale scale decimalMantissa str

         nextChar radix sign signExp exp numerator denom expChar|

        str := aStringOrStream readStream.

        nextChar := str skipSeparators.

        nextChar isNil ifTrue:[^ exceptionBlock value].

        (nextChar == $-) ifTrue:[

            sign := -1.

            str next.

            nextChar := str peekOrNil

        ] ifFalse:[

            sign := 1.

            (nextChar == $+) ifTrue:[

                str next.

                nextChar := str peekOrNil

            ]

        ].

        nextChar == $( ifTrue:[

            "maybe a Fraction e.g. (1/3)"

            str next.

            numerator := Integer readFrom:str onError:[^ exceptionBlock value].

            str skipSeparators.

            nextChar := str peekOrNil.

            nextChar == $/ ifTrue:[

                str next.

                denom := Integer readFrom:str onError:[^ exceptionBlock value].

                str skipSeparators.

                nextChar := str peekOrNil.

            ].

            nextChar == $) ifFalse:[^ exceptionBlock value].

            str next.

            value := Fraction numerator:numerator denominator:denom.

            value := value * sign.

            (self ~~ Number and:[self ~~ Fraction]) ifTrue:[

                value := self coerce:value.

            ].    

            ^ value

        ].

        nextChar isNil ifTrue:[^ exceptionBlock value].

        (nextChar isDigit or:[(decimalPointCharacters includes:nextChar)]) ifFalse:[

            ^ exceptionBlock value.

"/          value := super readFrom:str.

"/          sign == -1 ifTrue:[value := value negated].

"/          ^ value

        ].

        (decimalPointCharacters includes:nextChar) ifTrue:[

            radix := 10.

            value := 0.0.

            intValue := 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.

                nextChar := str peekOrNil.

            ] ifFalse:[

                radix := 10

            ].

            intValue := value.

        ].

        (self == Integer or:[self inheritsFrom:Integer]) ifFalse:[

            (decimalPointCharacters includes:nextChar) ifTrue:[

                str next.

                nextChar := str peekOrNil.

                decimalMantissa := 0.

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

                    |mantissa|

                    mantissaAndScale := self readMantissaAndScaleFrom:str radix:radix.

                    mantissa := mantissaAndScale first.

                    value := (mantissa coerce:value) + mantissa.

                    nextChar := str peekOrNil.

                ]

            ].

            ('eEdDqQfF' includes:nextChar) ifTrue:[

                expChar := nextChar.

                str next.

                nextChar := str peekOrNil.

                signExp := 1.

                (nextChar == $+) ifTrue:[

                    str next.

                    nextChar := str peekOrNil.

                ] ifFalse:[

                    (nextChar == $-) ifTrue:[

                        str next.

                        nextChar := str peekOrNil.

                        signExp := -1

                    ]

                ].

                "/ if I am abstract (i.e. I am Number or LPReal),

                "/ let the exponent-character decide what kind of float we get:

                "/      qQ   -> LongFloat

                "/      eEdD -> Float      (which is iee-double)

                "/      fF   -> ShortFloat (which is iee-float)

                self isAbstract ifTrue:[

                    ('qQ' includes:expChar) ifTrue:[

                        value := value asLongFloat.

                    ] ifFalse:[

                        ('fF' includes:expChar) ifTrue:[

                            value := value asShortFloat.

                        ] ifFalse:[    

                            "/ maybe in the far future we might create shortfloats when seeing eE,

                            "/ and only produce doubles on dD.

                            "/ (for now, always create Doubles for Dolphin, Squeak etc. compatibility)

                            false "('eE' includes:expChar)" ifTrue:[

                                value := value asShortFloat

                            ] ifFalse:[

                                value := value asFloat.

                            ].    

                        ].    

                    ].

                ] ifFalse:[

                    value := self coerce:value.

                ].

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

                    exp := (Integer readFrom:str radix:radix) * signExp.

                    value := value * ((value class unity * 10.0) raisedToInteger:exp)

                ]

            ] ifFalse:[

                ('sS' includes:nextChar) ifTrue:[

                    str next.

                    nextChar := str peekOrNil.

                    (nextChar notNil and:[ nextChar isDigit]) ifTrue:[

                        scale := (Integer readFrom:str).

                    ].

                    mantissaAndScale isNil ifTrue:[

                        value := intValue asFixedPoint:(scale ? 0).

                    ] ifFalse:[

                        denom := 10 raisedTo:mantissaAndScale last.

                        value := FixedPoint

                                    numerator:(intValue * denom) + (mantissaAndScale second)

                                    denominator:denom

                                    scale:(scale ? mantissaAndScale third).

                    ].

                ] ifFalse:[

                    (self inheritsFrom:LimitedPrecisionReal) ifTrue:[

                        "when requesting a specific Float instance, coerce it.

                         otherwise return a value without loosing precision"

                        value := self coerce:value.

                    ].

                ].

            ].

        ].

        sign == -1 ifTrue:[

            value := value negated

        ].

        value.

    ] on:Error do:exceptionBlock

    "

     Number readFrom:(ReadStream on:'54.32e-01') decimalPointCharacters:'.' onError:[self halt].

     Number readFrom:(ReadStream on:'12345') decimalPointCharacters:'.' onError:[self halt].

     Number readFrom:(ReadStream on:'12345.0') decimalPointCharacters:'.' onError:[self halt].

     Number readFrom:(ReadStream on:'12345.0f') decimalPointCharacters:'.' onError:[self halt].

     Number readFrom:(ReadStream on:'12345.0e') decimalPointCharacters:'.' onError:[self halt].

     Number readFrom:(ReadStream on:'12345.0q') decimalPointCharacters:'.' onError:[self halt].

     Number readFrom:(ReadStream on:'12345.0d') decimalPointCharacters:'.' onError:[self halt].

     Number readFrom:(ReadStream on:'12345.0s') decimalPointCharacters:'.' onError:[self halt].

     Number readFrom:(ReadStream on:'12345.01s') decimalPointCharacters:'.' onError:[self halt].

     Float readFrom:(ReadStream on:'12345') decimalPointCharacters:'.' onError:[self halt].

     Number readFrom:(ReadStream on:'12345678901234567890')

     Number readFrom:(ReadStream on:'12345678901234567890.0')

     Number readFrom:(ReadStream on:'12345678901234567890.012345678901234567890')

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

     Number readFrom:'16rAAAAFFFFAAAAFFFF'

     Number readFrom:'0.000001'

     '+00000123.45' asNumber

     Number readFrom:'(1/3)'

     Number readFrom:'(-1/3)'

     Number readFrom:'(1/-3)'

     Number readFrom:'-(1/3)'

     Number readFrom:'-(-1/3)'

     Number readFrom:'(-1/3'

     Number readFrom:'99s'

     Number readFrom:'99.00s'

     Number readFrom:'99.0000000s'

     Number readFrom:'.0000000s'

     Number readFrom:'.0000000q'

     Number readFrom:'.0000000f'

     Number readFrom:'.0000000e'

     Number readFrom:'.0000000s1'

     Number readFrom:'.0000000q1'

     Number readFrom:'.0000000f1'

     Number readFrom:'.0000000e1'

     LongFloat readFrom:'.00000001'

     Number readFrom:'.00000000000001'

     Number readFrom:'.001'

     ShortFloat readFrom:'.001'

     Number readFrom:'123garbage'      -> returns 123

     Number fromString:'123garbage'    -> raises an error

     DecimalPointCharactersForReading := #( $. $, ).

     Number readFrom:'99,00'

     DecimalPointCharactersForReading := #( $. ).

     Number readFrom:'99,00'

    "

    "Modified: / 21-06-2017 / 09:00:10 / 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.

     This method is less strict than the smalltalk number reader; it

     allows for prefixed + and also allows missing fractional part after eE.

     It also allows garbage after the number - i.e. it reads what it can.

     See #fromString: , which is more strict and does not allow garbage at the end."

    ^ self

	readFrom:aStringOrStream

	decimalPointCharacters:(self decimalPointCharactersForReading)

	onError:exceptionBlock