"{ Package: 'stx:libbasic2' }"

"{ NameSpace: Smalltalk }"

LimitedPrecisionReal variableByteSubclass:#IEEEFloat

	instanceVariableNames:'exponentSize'

	classVariableNames:''

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!IEEEFloat class methodsFor:'documentation'!

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|

    nB := aFloat byteSize.

    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

    "

!

fromInteger:anInteger

    ^ self fromFloat:anInteger asFloat

    "

     self fromInteger:1

     self fromInteger:2

     self fromInteger:1e20 asInteger

     self fromInteger:1e100 asInteger

    "

!

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:anInteger exponent:exp signBit:signBit

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

            setFraction:anInteger exponent:exp signBit:signBit

    "

     self size:256 exponentSize:19 fromInteger:1

     self size:256 exponentSize:19 fromInteger:2

    "

!

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'!

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'!

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)         

     (0.0 negated) + 0.0 

     0.0 asIEEEFloat + (0.0 negated)         

     (0.0 asIEEEFloat negated) + 0.0 

     0.0 asIEEEFloat + (0.0 asIEEEFloat negated)         

     (0.0 asIEEEFloat negated) + 0.0 asIEEEFloat

    "

!

equalFromIEEEFloat:anIEEEFloat

    |nBytes m1 m2 nM1 nM2 e1 e2|

    nBytes := self basicSize.

    anIEEEFloat basicSize == nBytes ifTrue:[

        anIEEEFloat exponentSize == exponentSize ifTrue:[

            1 to:nBytes-1 do:[:i |

                (self basicAt:i) = (anIEEEFloat basicAt:i) ifFalse:[^ false].

            ].

            (self basicAt:nBytes) = (anIEEEFloat basicAt:nBytes) ifFalse:[

                ((self basicAt:nBytes) bitAnd:16r7F) == 0 ifTrue:[

                    ((anIEEEFloat basicAt:nBytes) bitAnd:16r7F) == 0 ifTrue:[

                        ^ true.

                    ].

                ].

                ^ false

            ].

            ^ true.

        ].

    ].

    "/ more complicated compare

    self negative = anIEEEFloat negative ifFalse:[

        ^ self isZero and:[anIEEEFloat isZero]

    ].

    "/ bring to same exponent, add m1 + m2, normalize

    m1 := anIEEEFloat mantissaBits. 

    m2 := self mantissaBits.        

    nM1 := anIEEEFloat numBitsInMantissa.

    nM2 := self numBitsInMantissa.

    nM1 ~= nM2 ifTrue:[

        nM1 > nM2 ifTrue:[

            m2 := m2 bitShift:(nM1-nM2).

        ] ifFalse:[

            m1 := m1 bitShift:(nM2-nM1).

        ].

    ].

    m1 = m2 ifFalse:[^ false].

    e1 := anIEEEFloat exponentBits - anIEEEFloat eBias.

    e2 := self exponentBits - self eBias.

    e1 = e2 ifFalse:[^ false].

    ^ true.

!

lessFromIEEEFloat:anIEEEFloat

        ^ anIEEEFloat negative

    ].

        anIEEEFloat exponentSize == exponentSize ifTrue:[

            ].

            ^ false.

        ].

    ].

    "/ more complicated compare

    "/ bring to same exponent, add m1 + m2, normalize

    m1 := anIEEEFloat mantissaBits. 

    m2 := self mantissaBits.        

    nM1 := anIEEEFloat numBitsInMantissa.