"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 2018 by eXept Software AG

              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:libbasic2' }"

"{ NameSpace: Smalltalk }"

LimitedPrecisionReal variableByteSubclass:#IEEEFloat

	instanceVariableNames:'exponentSize'

	classVariableNames:''

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!IEEEFloat class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 2018 by eXept Software AG

              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

"

    Unfinished, ongoing work

    soft float emulation for arbitrary IEEE float formats.

    This is very very slow and should only be used when importing 

    funny sized floating point numbers (such as float24 or float8) from

    external sources, or to simulate computations on otherwise unsupported floating pnt numbers.

    Create one by passing the overall number of bits and the number of exponent-bits:

        IEEEFloat size:64 exponentSize:(Float numBitsInExponent)

    or:

        1.0 asIEEEFloat

    will give you a (slow) variant of a regular float.

    And:

        IEEEFloat size:256 exponentSize:19

    will give you a 256 bit ieee float.

"

! !

!IEEEFloat class methodsFor:'instance creation'!

fromFloat:aFloat

    |nB f mantissaInclInt biasedExponent intBitMask matissaMask|

    nB := aFloat byteSize.

    "/ if there are integer bits in the characteristic (extended x86 floats),

    "/ we need one more byte and there is no hidden integer bit;    

    aFloat numBitsInIntegerPart > 0 ifTrue:[

        mantissaInclInt := aFloat mantissaBits.

        biasedExponent := aFloat exponent + aFloat eBias.

        matissaMask := (1 bitShift:aFloat numBitsInMantissa)-1. 

        intBitMask := (1 bitShift:aFloat numBitsInMantissa-1). 

        (mantissaInclInt bitTest:intBitMask) ifTrue:[

            "/ turn it off to make it hidden

            mantissaInclInt := mantissaInclInt bitClear:intBitMask.

            mantissaInclInt := mantissaInclInt bitShift:1.

            biasedExponent := biasedExponent - 1.

        ] ifFalse:[

            ((mantissaInclInt = 0) and:[biasedExponent == aFloat eBias]) ifTrue:[

                biasedExponent := 0.

            ] ifFalse:[

                self halt.

            ].

        ].

        ^ self size:nB*8 exponentSize:aFloat numBitsInExponent 

            fraction:mantissaInclInt exponent:biasedExponent signBit:(aFloat < 0 ifTrue:1 ifFalse:0)

    ].

    f := self basicNew:nB.

    1 to:nB do:[:i |

        f basicAt:i put:(aFloat byteAt:i)

    ].

    f exponentSize:(aFloat numBitsInExponent).

    ^ f

    "

     self fromFloat:1.0

     self fromFloat:2.0

     self fromFloat:1.0 asShortFloat

     self fromFloat:2.0 asShortFloat

     self fromFloat:1.0 asLongFloat

     self fromFloat:2.0 asLongFloat

     self fromFloat:3.0 asLongFloat

     self fromFloat:101.0 asLongFloat

     self fromFloat:0.0 asLongFloat

     self fromFloat:0.5 asLongFloat

    "

!

fromInteger:anInteger

    "convert to one of 64, 128 or 256 bit IEEEFloat"

    |nM nE h l fraction e bias absInt nBytes|

    absInt := anInteger abs.

    h := absInt highBit.

    l := absInt lowBit.

    nM := Float numBitsInMantissa.

    nE := Float numBitsInExponent.

    bias := Float eBias.

    nBytes := 64 / 8.

    (h - l) > nM ifTrue:[

        nM := QuadFloat numBitsInMantissa.

        nE := QuadFloat numBitsInExponent.

        bias := QuadFloat eBias.

        nBytes := 128 / 8.

        (h - l) > nM ifTrue:[

            nM := OctaFloat numBitsInMantissa.

            nE := OctaFloat numBitsInExponent.

            bias := OctaFloat eBias.

            nBytes := 256 / 8.

        ]

    ].

    "/ cut off precision by shifting right (if h > nM) 

    "/ or add zeros by shifting to the left 

    h == 0 ifTrue:[

        fraction := e := 0.

    ] ifFalse:[

        fraction := absInt bitShift:(nM - h + 1). 

        fraction := fraction bitAnd:((1 bitShift:nM)-1).

        e := bias + h - 1.

    ].

    ^ (self basicNew:nBytes) exponentSize:nE;

        setFraction:fraction exponent:e 

        signBit:(anInteger negative ifTrue:[1] ifFalse:[0]);

        yourself

    "

     self fromInteger:1

     self fromInteger:-1

     self fromInteger:2

     self fromInteger:1024 * 1024 * 1024 * 1024 * 1024 * 1024

     self fromInteger:1e20 asInteger

     self fromInteger:1e100 asInteger

     self fromInteger:2r1010101010101010101010101010101

     self fromInteger:2r1010101010101010101010101010101010101010101010101010101010101010

     self fromInteger:1e-100 asInteger

     1 asIEEEFloat

    "

!

size:numBits exponentSize:exponentSize

    ^ (self basicNew:(numBits // 8)) exponentSize:exponentSize

    "

     self size:256 exponentSize:19

     self size:16 exponentSize:5

     self size:(1.0 basicSize * 8) exponentSize:(1.0 numBitsInExponent)

    "

!

size:numBits exponentSize:exponentSize fraction:normalizedFraction exponent:biasedExponent signBit:signBit

    ^ ((self basicNew:(numBits // 8)) exponentSize:exponentSize) 

            setFraction:normalizedFraction exponent:biasedExponent signBit:signBit

    "

     self size:256 exponentSize:19 fromInteger:1

     self size:256 exponentSize:19 fromInteger:2

     self size:64 exponentSize:11 fraction:0 exponent:(0 + Float eBias) signBit:0

     self size:64 exponentSize:11 fraction:0 exponent:0 signBit:0

    "

!

size:numBits exponentSize:exponentSize fromFloat:aFloat

    ^ ((self basicNew:(numBits // 8)) exponentSize:exponentSize) setValueFromFloat:aFloat

    "

     self size:256 exponentSize:19 fromFloat:1.0

     self size:256 exponentSize:19 fromFloat:2.0

    "

!

size:numBits exponentSize:exponentSize fromInteger:anInteger

    ^ ((self basicNew:(numBits // 8)) exponentSize:exponentSize) setValueFromInteger:anInteger

    "

     self size:256 exponentSize:19 fromInteger:1

     self size:256 exponentSize:19 fromInteger:2

    "

! !

!IEEEFloat class methodsFor:'coercing & converting'!

coerce:aNumber

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

    ^ aNumber asIEEEFloat

! !

!IEEEFloat class methodsFor:'constants'!

pi

    ^ Float pi

!

unity

    ^ 1.0

!

zero

    ^ 0.0

! !

!IEEEFloat methodsFor:'accessing'!

exponentBits

    "return the bits of my exponent.

     These might be biased.

     My bytes are stored LSB first; thus we have to fetch the high exponent bytes."

    |nBytes nExpBytes e|

    nBytes := self basicSize.

    nExpBytes := (exponentSize + 1 + 7) // 8.

    "/ seee eeee eeee mmmm mmmm ....

    "/ BAD: assumes LSB

    e := (self basicAt:nBytes) bitAnd:16r7F.

    2 to:nExpBytes do:[:eI |

         e := (e bitShift:8) bitOr:(self basicAt:nBytes + 1 - eI)

    ].

    "/ 0eee eeee eeee mmmm

    e := e rightShift:(nExpBytes * 8) - 1 "sign" - exponentSize.

    "/ 0000 0eee eeee eeee 

    ^ e

    "

     1.0 asShortFloat asIEEEFloat

     (1 to:4) conform:[:i | (1.0 asShortFloat basicAt:i) = (1.0 asShortFloat asIEEEFloat basicAt:i)]

     1.0 asShortFloat exponentBits 

     1.0 asShortFloat asIEEEFloat exponentBits

     -1.0 asShortFloat exponentBits  

     -1.0 asShortFloat asIEEEFloat exponentBits   

     (self size:32 exponentSize:8) inspect.

     (self size:64 exponentSize:11) inspect.

     (self size:128 exponentSize:16) inspect.

     (self size:256 exponentSize:16) inspect.

    "

    "construct a soft-shortFloat

     |f sf|

     sf := 1.0 asShortFloat.

     f := self size:(sf basicSize * 8) exponentSize:(sf numBitsInExponent).

     1 to:sf basicSize do:[:i | f basicAt:i put:(sf basicAt:i)].

     f inspect

    "

    "Modified: 12.2.1997 / 16:45:27 / cg"

!

exponentSize

    ^ exponentSize

!

exponentSize:something

    exponentSize := something.

!

mantissaBits

    "return the bits of my mantissa (incl. the hidden bit).

     My bytes are stored LSB first."

    |bits hiddenBit mask c|

    bits := self digitBytes asIntegerMSB:false.

    bits == 0 ifTrue:[^ 0].

    hiddenBit := (1 bitShift:self numBitsInMantissa).

    mask := hiddenBit-1.

    c := bits bitAnd:mask.

    "/ TODO: care for subnormals (exponent = 0)!!

    ^ c bitOr:hiddenBit.

    " 

     (self size:32 exponentSize:8) inspect.

    "

   "construct a soft-shortFloat

    |f sf|

    sf := 1.0 asShortFloat.

    f := self size:(sf basicSize * 8) exponentSize:(sf numBitsInExponent).

    1 to:sf basicSize do:[:i | f basicAt:i put:(sf basicAt:i)].

    f inspect

   "

    "Modified: 12.2.1997 / 16:45:27 / cg"

!

setFraction:normalizedFraction exponent:biasedExponent signBit:signBit

    |bits|

    bits := (normalizedFraction 

            bitOr:(biasedExponent bitShift:self numBitsInMantissa))

            bitOr:(signBit bitShift:(self basicSize * 8) - 1). 

    1 to:self basicSize do:[:i | self basicAt:i put:(bits digitAt:i)].

    "

     (self size:64 exponentSize:11) setFraction:0 exponent:1024 signBit:0

    "

!

setValueFromInteger:intValue

    "/ how many bits are there, in this int

    |absValue myNumBits numBitsInNumber shift|

    absValue := intValue abs. 

    numBitsInNumber := absValue highBit.

    myNumBits := (self basicSize * 8) - 1 "sign" - exponentSize.

    shift := myNumBits - numBitsInNumber. 

    numBitsInNumber > myNumBits ifTrue:[

        self halt.

    ] ifFalse:[

        "/ number:

        "/    1xxxxxxx...xxxxx

        "/ myRep:

        "/    seee...eeexxxxxxxxxx

        absValue digitLength to:1 by:-1 do:[:byteIndex |

        ].

    ].

    "/ cut off some bits

    "Float numBitsInExponent

     self size:16 exponentSize:4 fromInteger:1

     self size:32 exponentSize:11 fromInteger:1

     self size:256 exponentSize:19 fromInteger:1

     self size:256 exponentSize:19 fromInteger:2

    "

! !

!IEEEFloat methodsFor:'arithmetic'!

* aNumber

    "/ thisContext isRecursive ifTrue:[self halt].

    ^ aNumber productFromIEEEFloat:self

!

+ aNumber

    "/ thisContext isRecursive ifTrue:[self halt].

    ^ aNumber sumFromIEEEFloat:self

    "

     (-2.0 asIEEEFloat)

     (2.0 asIEEEFloat)

     self assert:((4.0 asIEEEFloat) + (2.0 asIEEEFloat)) = (6.0 asIEEEFloat)   

     self assert:((4.0 asIEEEFloat) + (-2.0 asIEEEFloat)) = (2.0 asIEEEFloat)  

     self assert:((-4.0 asIEEEFloat) + (-2.0 asIEEEFloat)) = (-6.0 asIEEEFloat)  

     self assert:((-4.0 asIEEEFloat) + (2.0 asIEEEFloat)) = (-2.0 asIEEEFloat)  

     self assert:((2.0 asIEEEFloat) + (4.0 asIEEEFloat)) = (6.0 asIEEEFloat)   

     self assert:((2.0 asIEEEFloat) + (-4.0 asIEEEFloat)) = (-2.0 asIEEEFloat)  

     self assert:((-2.0 asIEEEFloat) + (-4.0 asIEEEFloat)) = (-6.0 asIEEEFloat)  

     self assert:((-2.0 asIEEEFloat) + (4.0 asIEEEFloat)) = (2.0 asIEEEFloat)  

     self assert:((IEEEFloat fromFloat:0.1) + (IEEEFloat fromFloat:-0.1)) = (IEEEFloat fromFloat:0.0)  

     self assert:((IEEEFloat fromFloat:-0.1) + (IEEEFloat fromFloat:0.1)) = (IEEEFloat fromFloat:0.0)  

    "

!

- aNumber

    "/ thisContext isRecursive ifTrue:[self halt].

    ^ aNumber differenceFromIEEEFloat:self

    "

     self assert:((4.0 asIEEEFloat) - (2.0 asIEEEFloat)) = (2.0 asIEEEFloat)   

     self assert:((4.0 asIEEEFloat) - (-2.0 asIEEEFloat)) = (6.0 asIEEEFloat)  

     self assert:((-4.0 asIEEEFloat) - (-2.0 asIEEEFloat)) = (-2.0 asIEEEFloat)  

     self assert:((-4.0 asIEEEFloat) - (2.0 asIEEEFloat)) = (-6.0 asIEEEFloat)  

     self assert:((2.0 asIEEEFloat) - (4.0 asIEEEFloat)) = (-2.0 asIEEEFloat)   

     self assert:((2.0 asIEEEFloat) - (-4.0 asIEEEFloat)) = (6.0 asIEEEFloat)  

     self assert:((-2.0 asIEEEFloat) - (-4.0 asIEEEFloat)) = (2.0 asIEEEFloat)  

     self assert:((-2.0 asIEEEFloat) - (4.0 asIEEEFloat)) = (-6.0 asIEEEFloat)  

     self assert:((IEEEFloat fromFloat:0.1) - (IEEEFloat fromFloat:0.1)) = (IEEEFloat fromFloat:0.0)  

     self assert:((IEEEFloat fromFloat:0.1) - (IEEEFloat fromFloat:-0.1)) = (IEEEFloat fromFloat:0.2)  

     self assert:((IEEEFloat fromFloat:-0.1) - (IEEEFloat fromFloat:-0.1)) = (IEEEFloat fromFloat:0.0)  

    "

!

/ aNumber

    "/ thisContext isRecursive ifTrue:[self halt].

    ^ aNumber quotientFromIEEEFloat:self

!

negated

    |f highByte|

    f := self copy.

    highByte := self basicAt:(self basicSize).

    f basicAt:(self basicSize) put:(highByte bitXor:16r80).

    ^ f.

    "

     self assert:(IEEEFloat fromFloat:2.0) negated = (IEEEFloat fromFloat:-2.0) 

     self assert:(IEEEFloat fromFloat:2.0) negated negated = (IEEEFloat fromFloat:2.0) 

     self assert:(IEEEFloat fromFloat:-2.0) negated = (IEEEFloat fromFloat:2.0) 

    "

! !

!IEEEFloat methodsFor:'coercing & converting'!

asIEEEFloat

    ^ self

!

coerce:aNumber

    "convert the argument aNumber into an instance of the receiver's class and return it.

     Redefined to preserve the size and exponentSize"

    |fraction e h nM|

    aNumber isInteger ifTrue:[

        nM := self numBitsInMantissa.

        "/ cut off precision by shifting right (if h > nM) 

        "/ or add zeros by shifting to the left 

        h := aNumber highBit.

        h == 0 ifTrue:[

            fraction := e := 0.

        ] ifFalse:[

            fraction := aNumber bitShift:(nM - h + 1). 

            fraction := fraction bitAnd:((1 bitShift:nM)-1).

            e := self eBias + h - 1.

        ].

        ^ (self class basicNew:self basicSize) exponentSize:exponentSize;

            setFraction:fraction exponent:e 

            signBit:(aNumber negative ifTrue:[1] ifFalse:[0]);

            yourself

    ].

    ^ self class coerce:aNumber

    "Modified: / 15-06-2017 / 10:27:03 / cg"

!

generality

    ^ 97   "/ between OctaFloat and LargeFloat

    "

     1 asShortFloat generality 70

     1 asFloat generality      80

     1 asLongFloat generality  90

     1 asQuadFloat generality

     1 asQDouble generality    95

     1 asLargeFloat generality 100

    "

! !

!IEEEFloat methodsFor:'comparing'!

< aNumber

    "/ thisContext isRecursive ifTrue:[self halt].

    ^ aNumber lessFromIEEEFloat:self

!

= aNumber

    ^ aNumber equalFromIEEEFloat:self

! !

!IEEEFloat methodsFor:'double dispatching'!

differenceFromIEEEFloat:anIEEEFloat

    "/ anIEEEFloat - self

    self isZero ifTrue:[^ anIEEEFloat]. "/ otherwise, we might get a negative zero

    ^ self negated sumFromIEEEFloat:anIEEEFloat

    "

     0.0 + (0.0 negated)