"

 COPYRIGHT (c) 1994 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' }"

Number subclass:#LimitedPrecisionReal

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!LimitedPrecisionReal class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1994 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 any-precision floating point numbers (i.e. Float and Double).

    Due to historic reasons, ST/X's Floats are what Doubles are in ST-80.

    This may change soon (implementing LPReal is a first step towards this).

    Range and Precision of Storage Formats:

      Format |   Class    | Significant Digits (Binary) | Smallest Pos Number | Largest Pos Number | Significant Digits (Decimal)

      -------+------------+-----------------------------+---------------------+--------------------+------------------------------    

      single | ShortFloat |         24                  |  1.175... 10-38     |  3.402... 10+38    |      6-9

      -------+------------+-----------------------------+---------------------+--------------------+------------------------------    

      double | Float      |         53                  |  2.225... 10-308    |  1.797... 10+308   |     15-17

      -------+------------+-----------------------------+---------------------+--------------------+------------------------------    

      double | LongFloat  |        113                  |  3.362... 10-4932   |  1.189... 10+4932  |     33-36

      ext    |            |                             |                     |                    |

      (SPARC)|            |                             |                     |                    |

      -------+            |-----------------------------+---------------------+--------------------+------------------------------    

      double |            |         64                  |  3.362... 10-4932   |  1.189... 10+4932  |     18-21

      ext    |            |                             |                     |                    |

      (x86)  |            |                             |                     |                    |

      -------+------------+-----------------------------+---------------------+--------------------+------------------------------    

        --   | LargeFloat |         arbitrary           |  arbitrarily small  |  arbitrarily large |     arbitrary

      -------+------------+-----------------------------+---------------------+--------------------+------------------------------    

    [author:]

        Claus Gittinger

    [see also:]

        Fraction FixedPoint

"

! !

!LimitedPrecisionReal class methodsFor:'instance creation'!

fromInteger:anInteger

    "return a float with anInteger's value.

     Since floats have a limited precision, you usually loose bits when doing this

     (see Float decimalPrecision, LongFloat decimalPrecision."

    |newFloat sign absVal|

    newFloat := self zero.

    sign := anInteger sign.

    absVal := anInteger abs.

    (sign ~~ 0) ifTrue:[

        absVal digitLength to:1 by:-1 do:[:i |

            newFloat := (newFloat * 256.0) + (absVal digitByteAt:i) asFloat

        ].

        (sign < 0) ifTrue:[

            newFloat := newFloat negated

        ]

    ].

    ^ newFloat

    "

     1234567890 asFloat                     

     1234567890 asFloat asInteger                    

     -1234567890 asFloat asInteger                    

     12345678901234567890 asFloat             

     12345678901234567890 asFloat asInteger   

     -12345678901234567890 asFloat asInteger   

     12345678901234567890 asLongFloat           

     12345678901234567890 asLongFloat asInteger 

     -12345678901234567890 asLongFloat asInteger 

     123456789012345678901234567890 asLongFloat           

     123456789012345678901234567890 asLongFloat asInteger  

     -123456789012345678901234567890 asLongFloat asInteger  

     1234567890123456789012345678901234567890 asLongFloat           

     1234567890123456789012345678901234567890 asLongFloat asInteger  

     -1234567890123456789012345678901234567890 asLongFloat asInteger  

    "

!

fromLimitedPrecisionReal:anLPReal

    "return a float with anLPReals value.

     You might loose bits when doing this.

     Slow fallback."

    |fract|

    anLPReal isFinite ifFalse:[

        anLPReal isNaN ifTrue:[^ self NaN].

        anLPReal negative ifTrue:[^ self negativeInfinity].

        ^ self infinity

    ].

    fract := anLPReal asTrueFraction.

    ^ (self fromInteger:fract numerator) / (self fromInteger:fract denominator)

!

new:aNumber

    "catch this message - not allowed for floats/doubles"

    self error:'Floats/Doubles cannot be created with new:'

! !

!LimitedPrecisionReal class methodsFor:'class initialization'!

initialize

    "initialize ANSI compliant float globals"

    Smalltalk at:#FloatE put:ShortFloat.

    Smalltalk at:#FloatD put:Float.

    Smalltalk at:#FloatQ put:LongFloat.

    "

     self initialize

    "

    "Created: / 7.9.2001 / 14:02:45 / cg"

    "Modified: / 7.9.2001 / 14:02:54 / cg"

! !

!LimitedPrecisionReal class methodsFor:'constants & defaults'!

NaN

    "return the constant NaN (not a Number)."

    ^ self zero uncheckedDivide:self zero

    "

      ShortFloat NaN  

      Float NaN       

      LongFloat NaN   

      LargeFloat NaN   

    "

!

e

    "return the closest approximation of the irrational number e"

    self subclassResponsibility

    "Modified: / 7.9.2001 / 14:05:02 / cg"

!

emax

    "return the largest exponent"

    self subclassResponsibility

    "Created: / 7.9.2001 / 14:05:28 / cg"

!

emin

    "return the smallest exponent"

    self subclassResponsibility

    "Created: / 7.9.2001 / 14:05:35 / cg"

!

epsilon

    "return the maximum relative spacing"

    ^ self radix asFloat raisedTo:(1 - self precision)

    "

      ShortFloat epsilon  

      Float epsilon       

      LongFloat epsilon   

    "

!

fmax

    "return the largest value allowed"

    self subclassResponsibility

    "Created: / 7.9.2001 / 14:06:56 / cg"

!

fmin

    "return the minimum value allowed"

    self subclassResponsibility

    "Created: / 7.9.2001 / 14:07:06 / cg"

!

infinity

    "return a float representing infinity"

    ^ self unity uncheckedDivide:self zero

    "

      ShortFloat infinity  

      Float infinity       

      LongFloat infinity   

      LargeFloat infinity   

    "

!

negativeInfinity

    "return a float representing negative infinity"

    ^ self unity negated uncheckedDivide:self zero

    "

      ShortFloat negativeInfinity   

      Float negativeInfinity       

      LongFloat negativeInfinity   

      LargeFloat negativeInfinity   

    "

!

pi

    "return the closest approximation of the irrational number pi"

    self subclassResponsibility

    "Created: / 7.9.2001 / 14:07:35 / cg"

! !

!LimitedPrecisionReal class methodsFor:'queries'!

decimalPrecision

    "return the number of valid decimal digits"

    ^ (self precision / (10.0 log:self radix)) floor

    "

     ShortFloat decimalPrecision 

     Float decimalPrecision      

     LongFloat decimalPrecision  

    "

!

numBitsInExponent

    "return the number of bits in the exponent"

    ^ self subclassResponsibility

!

numBitsInIntegerPart

    ^ 0

!

numBitsInMantissa

    "return the number of bits in the mantissa

     (typically 1 less than the precision due to the hidden bit)"

    ^ self subclassResponsibility

!

precision

    "return the number of valid mantissa bits"

    ^ self numBitsInMantissa + 1 - self numBitsInIntegerPart 

!

radix

    "return the radix (base)"

    self subclassResponsibility

    "Created: / 7.9.2001 / 14:08:20 / cg"

! !

!LimitedPrecisionReal methodsFor:'accessing'!

at:index

    "redefined to prevent access to individual bytes in a real."

    self error:'not allowed for floats/doubles'

!

at:index put:aValue

    "redefined to prevent access to individual bytes in a real"

    self error:'not allowed for floats/doubles'

! !

!LimitedPrecisionReal methodsFor:'arithmetic'!

* aNumber

    "return the product of the receiver and the argument, aNumber"

"/ as soon as Float are float & Double are doubles,

"/ use:

"/    ^ aNumber productFromDouble:self asDouble

    ^ aNumber productFromFloat:self asFloat

    "Modified: 17.4.1996 / 12:35:36 / cg"

!

+ aNumber

    "return the sum of the receiver and the argument, aNumber"

"/ as soon as Float are float & Double are doubles,

"/ use:

"/    ^ aNumber sumFromDouble:self asDouble

    ^ aNumber sumFromFloat:self asFloat

    "Modified: 17.4.1996 / 12:35:55 / cg"

!

- aNumber

    "return the difference of the receiver and the argument, aNumber"

"/ as soon as Float are float & Double are doubles,

"/ use:

"/    ^ aNumber differenceFromDouble:self asDouble

    ^ aNumber differenceFromFloat:self asFloat

    "Modified: 17.4.1996 / 12:36:07 / cg"

!

/ aNumber

    "return the quotient of the receiver and the argument, aNumber"

    ((aNumber == 0) or:[aNumber = 0.0]) ifTrue:[

        ^ ZeroDivide raiseRequestWith:thisContext.

    ].

"/ as soon as Float are float & Double are doubles,

"/ use:

"/    ^ aNumber quotientFromDouble:self asDouble

    ^ aNumber quotientFromFloat:self asFloat

    "Modified: / 17.4.1996 / 12:36:21 / cg"

    "Modified: / 26.7.1999 / 10:46:11 / stefan"

!

// aNumber

    "return the integer quotient of dividing the receiver by aNumber with

     truncation towards negative infinity."

    ^ (self / aNumber) floor asInteger

    "Modified: 5.11.1996 / 11:45:37 / cg"

!

ceiling

    ^ self asTrueFraction ceiling

!

floor

    ^ self asTrueFraction floor

! !

!LimitedPrecisionReal methodsFor:'coercing & converting'!

asFloat

    ^ Float fromLimitedPrecisionReal:self

!

asFraction

    "Answer a rational number (Integer or Fraction) representing the receiver.

     This conversion uses the continued fraction method to approximate 

     a floating point number.

     In contrast to #asTrueFraction, which returns exactly the value of the float,

     this rounds in the last significant bit of the floating point number.

    "

    |num1 denom1 num2 denom2 int frac newD temp limit|

    self isFinite ifFalse:[

"/        ^ self asMetaNumber.

        ^ self class

            raise:#domainErrorSignal

            receiver:self

            selector:#asFraction

            arguments:#()

            errorString:'Cannot represent non-finite number as fraction'

    ].

    limit := 10 raisedToInteger:self defaultNumberOfDigits.

    num1 := self truncated. 

    denom1 := 1.            "The first of two alternating denominators"

    num2 := 1.              "The second numerator"

    denom2 := 0.            "The second denominator--will update"

    int := num1.            "The integer part of self"

    frac := self fractionPart.             

    [frac = 0] whileFalse:[                

        newD := 1.0 / frac.                   

        int := newD truncated.        

        frac := newD fractionPart.      "save the fractional part for next time"

        temp := num2.                   "old numerator and save it"

        num2 := num1.                         

        num1 := num1 * int + temp.      "Update first numerator"

        temp := denom2.                 "old denominator and save it"

        denom2 := denom1.                    

        denom1 := int * denom1 + temp.  "Update first denominator"

        limit < denom1 ifTrue:[

            "Is ratio past float precision?  If so, pick which of the two ratios to use"

            num2 = 0.0 ifTrue:[

                "Is second denominator 0?"

                ^ Fraction numerator:num1 denominator:denom1

            ].

            ^ Fraction numerator:num2 denominator:denom2

        ]

    ].

    "If fractional part is zero, return the first ratio"

    denom1 = 1 ifTrue:[

        "Am i really an Integer?"

        ^ num1 "Yes, return Integer result"

    ].

    "Otherwise return Fraction result"

    ^ Fraction numerator:num1 denominator:denom1

    "

     1.1 asFraction      

     1.2 asFraction      

     0.3 asFraction   

     0.5 asFraction  

     (1/5) asFloat asFraction  

     (1/8) asFloat asFraction  

     (1/13) asFloat asFraction 

     3.14159 asFraction        

     3.14159 asFraction asFloat       

     1.3 asFraction            

     1.0 asFraction            

     1E6 asFraction            

     1E-6 asFraction            

    "

    "Modified: / 25.10.1997 / 16:41:19 / cg"

!

asInteger

    "return an integer with same value - might truncate"

    |max maxF|

    self isFinite ifFalse:[

"/        ^ self asMetaNumber.

        ^ self class

            raise:#domainErrorSignal

            receiver:self

            selector:#asInteger

            arguments:#()

            errorString:'Cannot represent non-finite number as integer'

    ].

    self abs < 2e16 ifTrue:[

        "/ NOTICE: this must be redefined in float

        "/ subclasses to handle the smallinteger range;

        "/ i.e. this may only be invoked for reals

        "/ which are NOT within the smallInt range.

        "/ otherwise, endless recursion is the consequence.

        max := SmallInteger maxVal // 2 + 1.

        maxF := max asFloat.