"

 COPYRIGHT (c) 1996 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.

"

LimitedPrecisionReal variableByteSubclass:#ShortFloat

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!ShortFloat primitiveDefinitions!

%{

/*

 * includes, defines, structure definitions

 * and typedefs come here.

 */

#if defined (_AIX)

# include <float.h>

#endif

#if defined(IRIX)

# include <nan.h>

#endif

#if defined(LINUX)

# include <nan.h>

#endif

#if defined(solaris) || defined(sunos)

# include <nan.h>

#endif

%}

! !

!ShortFloat class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1996 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

"

    ShortFloats represent rational numbers with limited precision. In ST/X, Float uses

    the underlying C-compilers double implementation, while ShortFloats are

    mapped onto C-floats.

    Therefore instances of Float are usually represented by the 8-byte IEE 

    double precision float format, while ShortFloats use 4byte IEE format.

    (but there is no guaranty).

    Notice, that ST/X Floats are what Doubles are in ST-80 and ShortFloats are

    ST-80's Floats respectively.

    This may change in one of the next versions (at least on machines, which 

    provide different float and double types in their C-compiler.

    WARNING:

    The layout of shortFloat instances is known by the runtime system and the compiler;

    you may not add instance variables here. 

    Also, subclassing is complicated by the fact, that the VM creates floats/shortFloats, 

    and does its float-checks by an identity compare with the ShortFloat-class. 

    (i.e. your subclasses instances may not be recognized as float-like objects, 

     thus mixed mode arithmetic will always coerce them, effectively slowing things down).

    This may be changed, to use a flag bit in the class.

    [author:]

        Claus Gittinger

    [see also:]

        Number

        Float Fraction FixedPoint Integer

"

! !

!ShortFloat class methodsFor:'instance creation'!

basicNew

    "return a new shortFloat - here we return 0.0

     - shortFloats are usually NOT created this way ...

     Its implemented here to allow things like binary store & load

     of shortFloats. (but even this support will go away eventually, its not

     a good idea to store the bits of a float - the reader might have a

     totally different representation - so floats will eventually be 

     binary stored in a device independent format."

%{  /* NOCONTEXT */

    OBJ newFloat;

    __qMKSFLOAT(newFloat, 0.0);

    RETURN (newFloat);

%}

! !

!ShortFloat class methodsFor:'constants'!

pi

    "return the constant pi as ShortFloat"

    ^ 3.14159 asShortFloat

    "Modified: 23.4.1996 / 09:26:31 / cg"

!

unity

    "return the neutral element for multiplication (1.0) as ShortFloat"

    ^ 1.0 asShortFloat

    "Modified: 23.4.1996 / 09:26:51 / cg"

!

zero

    "return the neutral element for addition (0.0) as ShortFloat"

    ^ 0.0 asShortFloat

    "Modified: 23.4.1996 / 09:26:45 / cg"

! !

!ShortFloat class methodsFor:'queries'!

isBuiltInClass

    "return true if this class is known by the run-time-system.

     Here, true is returned for myself, false for subclasses."

    ^ self == ShortFloat

    "Modified: 23.4.1996 / 16:00:23 / cg"

! !

!ShortFloat methodsFor:'arithmetic'!

* aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    float result;

    double dResult;

    if (__isSmallInteger(aNumber)) {

        result = __shortFloatVal(self) * (float)(__intVal(aNumber));

retResult:

        __qMKSFLOAT(newFloat, result);

        RETURN ( newFloat );

    }

    if (__isShortFloat(aNumber)) {

        result = __shortFloatVal(self) * __shortFloatVal(aNumber);

        goto retResult;

    }

    if (__isFloatLike(aNumber)) {

        dResult = (double) __shortFloatVal(self)* __floatVal(aNumber);

        __qMKFLOAT(newFloat, dResult);

        RETURN ( newFloat );

    }

%}.

    ^ aNumber productFromShortFloat:self

!

+ aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    float result;

    double dResult;

    if (__isSmallInteger(aNumber)) {

        result = __shortFloatVal(self) + (float)(__intVal(aNumber));

retResult:

        __qMKSFLOAT(newFloat, result);

        RETURN ( newFloat );

    }

    if (__isShortFloat(aNumber)) {

        result = __shortFloatVal(self) + __shortFloatVal(aNumber);

        goto retResult;

    }

    if (__isFloatLike(aNumber)) {

        dResult = (double) __shortFloatVal(self) + __floatVal(aNumber);

        __qMKFLOAT(newFloat, dResult);

        RETURN ( newFloat );

    }

%}.

    ^ aNumber sumFromShortFloat:self

!

- aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    float result;

    double dResult;

    if (__isSmallInteger(aNumber)) {

        result = __shortFloatVal(self) - (float)(__intVal(aNumber));

retResult:

        __qMKSFLOAT(newFloat, result);

        RETURN ( newFloat );

    }

    if (__isShortFloat(aNumber)) {

        result = __shortFloatVal(self) - __shortFloatVal(aNumber);

        goto retResult;

    }

    if (__isFloatLike(aNumber)) {

        dResult = (double) __shortFloatVal(self) - __floatVal(aNumber);

        __qMKFLOAT(newFloat, dResult);

        RETURN ( newFloat );

    }

%}.

    ^ aNumber differenceFromShortFloat:self

!

/ aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    float result, val;

    double dResult, dVal;

    if (__isSmallInteger(aNumber)) {

        if (aNumber != __MKSMALLINT(0)) {

            result = __shortFloatVal(self) / (float)(__intVal(aNumber));

retResult:

            __qMKSFLOAT(newFloat, result);

            RETURN ( newFloat );

        }

    }

    if (__isShortFloat(aNumber)) {

        val = __shortFloatVal(aNumber);

        if (val != 0.0) {

            result = __shortFloatVal(self) / val;

            goto retResult;

        }

    }

    if (__isFloatLike(aNumber)) {

        dVal = __floatVal(aNumber);

        if (dVal != 0.0) {

            dResult = (double) __shortFloatVal(self) / dVal;

            __qMKFLOAT(newFloat, dResult);

        }

        RETURN ( newFloat );

    }

%}.

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

        "

         No, you shalt not divide by zero

        "

        ^ DivisionByZeroSignal raise.

    ].

    ^ aNumber quotientFromFloat:self

!

negated

    "return myself negated"

%{  /* NOCONTEXT */

    OBJ newFloat;

    float rslt = - __shortFloatVal(self);

    __qMKSFLOAT(newFloat, rslt);

    RETURN ( newFloat );

%}

! !

!ShortFloat methodsFor:'coercion and converting'!

asDouble

    "ST80 compatibility - return a Float with same value as the receiver"

    ^ self asFloat

!

asFloat

    "return a Float with same value as the receiver"

%{  /* NOCONTEXT */

    OBJ newFloat;

    double dVal = (double)__shortFloatVal(self);

    __qMKFLOAT(newFloat, dVal);

    RETURN ( newFloat );

%}

    "

     1.0 asShortFloat asFloat 

    "

!

asInteger

    "return an integer with same value - might truncate"

%{  /* NOCONTEXT */

    float fVal;

    fVal = __shortFloatVal(self);

    if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {

        RETURN ( __MKSMALLINT( (INT)fVal) );

    }

%}.

    ^ super asInteger

    "

     12345.0 asShortFloat asInteger

     1e15 asShortFloat asInteger

    "

!

asShortFloat

    "return a ShortFloat with same value as the receiver - thats me"

    ^ self

!

generality

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

    ^ 70

! !

!ShortFloat methodsFor:'comparing'!

< aNumber

    "return true, if the argument is greater"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

        RETURN ( (__shortFloatVal(self) < (float)(__intVal(aNumber))) ? true : false );

    }

    if (__isFloatLike(aNumber)) {

        RETURN ( (double)(__shortFloatVal(self) < __floatVal(aNumber)) ? true : false );

    }

    if (__isShortFloat(aNumber)) {

        RETURN ( (__shortFloatVal(self) < __shortFloatVal(aNumber)) ? true : false );

    }

%}.

    ^ aNumber lessFromShortFloat:self

    "

     1.0 asShortFloat > (1/3)

    "

!

<= aNumber

    "return true, if the argument is greater or equal"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

        RETURN ( (__shortFloatVal(self) <= (float)(__intVal(aNumber))) ? true : false );

    }

    if (__isFloatLike(aNumber)) {

        RETURN ( (double)(__shortFloatVal(self) <= __floatVal(aNumber)) ? true : false );

    }

    if (__isShortFloat(aNumber)) {

        RETURN ( (__shortFloatVal(self) <= __shortFloatVal(aNumber)) ? true : false );

    }

%}.

    ^ self retry:#<= coercing:aNumber

!

= aNumber

    "return true, if the arguments value are equal by value"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

        RETURN ( (__shortFloatVal(self) == (float)(__intVal(aNumber))) ? true : false );

    }

    if (__isFloatLike(aNumber)) {

        RETURN ( (double)(__shortFloatVal(self) == __floatVal(aNumber)) ? true : false );

    }

    if (__isShortFloat(aNumber)) {

        RETURN ( (__shortFloatVal(self) == __shortFloatVal(aNumber)) ? true : false );

    }

%}.

    ^ self retry:#= coercing:aNumber

!

> aNumber

    "return true, if the argument is less"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

        RETURN ( (__shortFloatVal(self) > (float)(__intVal(aNumber))) ? true : false );

    }

    if (__isFloatLike(aNumber)) {

        RETURN ( (double)(__shortFloatVal(self) > __floatVal(aNumber)) ? true : false );

    }

    if (__isShortFloat(aNumber)) {

        RETURN ( (__shortFloatVal(self) > __shortFloatVal(aNumber)) ? true : false );

    }

%}.

    ^ self retry:#> coercing:aNumber

!

>= aNumber

    "return true, if the argument is less or equal"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

        RETURN ( (__shortFloatVal(self) >= (float)(__intVal(aNumber))) ? true : false );

    }

    if (__isFloatLike(aNumber)) {

        RETURN ( (double)(__shortFloatVal(self) >= __floatVal(aNumber)) ? true : false );

    }

    if (__isShortFloat(aNumber)) {

        RETURN ( (__shortFloatVal(self) >= __shortFloatVal(aNumber)) ? true : false );

    }

%}.

    ^ self retry:#>= coercing:aNumber

!

hash

    "return a number for hashing; redefined, since floats compare

     by numeric value (i.e. 3.0 = 3), therefore 3.0 hash must be the same

     as 3 hash."

    |i|

    (self >= SmallInteger minVal and:[self <= SmallInteger maxVal]) ifTrue:[

        i := self asInteger.

        self = i ifTrue:[

            ^ i hash

        ].

    ].

    "

     mhmh take some of my value-bits to hash on

    "

    ^ (((self basicAt:4) bitAnd:16r3F) bitShift:24) +

      ((self basicAt:3) bitShift:16) +

      ((self basicAt:2) bitShift:8) +

      (self basicAt:1)

    "