"

 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.

"

"{ Package: 'stx:libbasic' }"

LimitedPrecisionReal variableByteSubclass:#ShortFloat

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!ShortFloat primitiveDefinitions!

%{

#include <errno.h>

#ifndef __OPTIMIZE__

# define __OPTIMIZE__

#endif

#define __USE_ISOC9X 1

#include <math.h>

/*

 * on some systems errno is a macro ... check for it here

 */

#ifndef errno

 extern errno;

#endif

#if defined (_AIX)

# include <float.h>

#endif

#if defined(IRIX)

# include <nan.h>

#endif

#if defined(LINUX)

# ifndef NAN

#  include <bits/nan.h>

# endif

#endif

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

# include <nan.h>

#endif

#ifdef WIN32

/*

 * no finite(x) ?

 * no isnan(x) ?

 */

# ifndef finite 

#  define finite(x)     1

# endif

# ifndef isnan

#  define isnan(x)      0

# endif

#endif

#ifdef realIX

/*

 * no finite(x)

 */

# ifndef finite

#  define finite(x)     1

# endif

#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. 

    They use the C-compilers 'float' format, which is usually the IEE single float format.

    In contrast to Floats (which use the C-compilers 64bit 'double' format),

    ShortFloats give you 32 bit floats.

    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 some of 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.

    Mixed mode arithmetic:

        shortFloat op shortFloat   -> shortFloat

        shortFloat op fix         -> shortFloat

        shortFloat op fraction    -> shortFloat

        shortFloat op integer     -> shortFloat

        shortFloat op longFloat   -> longFloat

        shortFloat op float       -> float

        shortFloat op complex     -> complex

    Representation:

            32bit single precision IEE floats

            23 bit mantissa,

            8 bit exponent,

            6 decimal digits (approx)

    Range and Precision of Storage Formats: see LimitedPrecisionReal >> documentation

    [author:]

        Claus Gittinger

    [see also:]

        Number

        Float LongFloat Fraction FixedPoint Integer Complex

        FloatArray DoubleArray

"

! !

!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);

%}

!

fastFromString:aString at:startIndex

    "return the next ShortFloat from the string starting at startIndex. 

     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 higher speed string decomposition into

     numbers."

%{

     if (__isString(aString) && __isSmallInteger(startIndex)) {

	char *cp = (char *)(__stringVal(aString));

	int idx = __intVal(startIndex) - 1;

	double atof();

	double val;

	if ((unsigned)idx < __stringSize(aString)) {

	    val = atof(cp + idx);

	    RETURN (__MKSFLOAT(val));

	}

     }

%}.

     self primitiveFailed.

    "

     ShortFloat fastFromString:'123.45' at:1  

     ShortFloat fastFromString:'123.45' at:2  

     ShortFloat fastFromString:'123.45E4' at:1  

     ShortFloat fastFromString:'hello123.45E4' at:6  

     ShortFloat fastFromString:'12345' at:1  

     ShortFloat fastFromString:'12345' at:2  

     ShortFloat fastFromString:'12345' at:3  

     ShortFloat fastFromString:'12345' at:4  

     ShortFloat fastFromString:'12345' at:5  

     ShortFloat fastFromString:'12345' at:6  

     ShortFloat fastFromString:'12345' at:0  

     ShortFloat fastFromString:'hello123.45E4' at:1  

     Time millisecondsToRun:[

	100000 timesRepeat:[

	    ShortFloat readFrom:'123.45'

	]

     ]

    "

    "

     Time millisecondsToRun:[

	100000 timesRepeat:[

	    ShortFloat fastFromString:'123.45' at:1  

	]

     ]

    "

!

readFrom:aStringOrStream

    "read a shortFloat from a string"

    |num|

    num := super readFrom:aStringOrStream onError:[self error:'conversion error for: ' , self name].

    num notNil ifTrue:[  

	num := num asShortFloat

    ].

    ^ num 

    "

     ShortFloat readFrom:'0.1'

     ShortFloat readFrom:'0'    

     ShortFloat readFrom:'.123' 

     ShortFloat readFrom:'-.123'   

     ShortFloat readFrom:'1e4'  

    "

    "Modified: / 7.1.1998 / 16:17:59 / cg"

!

readFrom:aStringOrStream onError:exceptionBlock

    "read a shortFloat from a string"

    |num|

    num := super readFrom:aStringOrStream onError:nil.

    num isNil ifTrue:[  

	^ exceptionBlock value

    ].

    ^ num asShortFloat

    "

     ShortFloat readFrom:'0.1'

     ShortFloat readFrom:'0'

     ShortFloat readFrom:'.123'

    "

    "Modified: / 7.1.1998 / 16:17:59 / cg"

! !

!ShortFloat class methodsFor:'binary storage'!

readBinaryIEEESingleFrom:aStream

    "read a float value from the binary stream, aStream,

     interpreting the next bytes as an IEEE formatted 4-byte float"

    |f|

    f := ShortFloat basicNew.

    self readBinaryIEEESingleFrom:aStream into:f.

    ^ f

    "Created: 16.4.1996 / 21:00:35 / cg"

!

readBinaryIEEESingleFrom:aStream into:aFloat

    "read a float value from the binary stream, aStream,

     interpreting the next bytes as an IEEE formatted 4-byte float"

    aFloat isShortFloat ifFalse:[self error].

    "

     this implementation is wrong: does not work on non-IEEE machines

     (to date all machines where ST/X is running on use

      IEEE float format. Need more here, when porting ST/X to 370's)

    "

    self isIEEEFormat ifFalse:[self error:'unsupported operation'].

    UninterpretedBytes isBigEndian ifFalse:[

        "swap the bytes"

        8 to:4 by:-1 do:[:i |

            aFloat basicAt:i put:(aStream next)

        ].

        ^ self

    ].

    1 to:4 do:[:i |

        aFloat basicAt:i put:aStream next

    ]

!

storeBinaryIEEESingle:aFloat on:aStream

    "store aFloat as an IEEE formatted 4-byte float

     onto the binary stream, aStream"

    aFloat isShortFloat ifFalse:[self error].

    "

     this implementation is wrong: does not work on non-IEEE machines

     (to date all machines where ST/X is running on use

      IEEE float format. Need more here, when porting ST/X to 370's)

    "

    self isIEEEFormat ifFalse:[self error:'unsupported operation'].

    UninterpretedBytes isBigEndian ifFalse:[

        "swap the bytes"

        8 to:4 by:-1 do:[:i |

            aStream nextPut:(aFloat basicAt:i).

        ].

        ^ self

    ].

    1 to:4 do:[:i |

        aStream nextPut:(aFloat basicAt:i).

    ]

! !

!ShortFloat class methodsFor:'constants'!

e

    "return the constant e as ShortFloat"

    ^ Float e asShortFloat

!

pi

    "return the constant pi as ShortFloat"

    ^ Float pi asShortFloat

!

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

exponentCharacter

    ^ $e

!

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"

!

isIEEEFormat

    "return true, if this machine represents floats in IEEE format.

     Currently, no support is provided for non-ieee machines

     to convert their floats into this (which is only relevant,

     if such a machine wants to send floats as binary to some other

     machine).

     Machines with non-IEEE format are VAXed and IBM370-type systems

     (among others). Today, most systems use IEEE format floats."

    ^ true "/ this may be a lie

!

numBitsInExponent

    "answer the number of bits in the exponent

     This is an IEEE float, where 8 bits are available:

        seeeeeee emmmmmmm mmmmmmmm mmmmmmmm

    "

    ^ 8

!

numBitsInMantissa

    "answer the number of bits in the mantissa.

     This is an IEEE float, where 23 bits (the hidden one is not counted here) are available:

        seeeeeee emmmmmmm mmmmmmmm mmmmmmmm

    "

    ^ 23

!

precision

    "answer the precision of a ShortFloat (in bits)

     This is an IEEE float, only the fraction from the normalized mantissa is stored 

     and so there is a hidden bit and the mantissa is actually represented by 24 binary digits"

    ^  24

!

radix

    "answer the radix of a ShortFloats exponent

     This is an IEEE float, which is represented as binary"

    ^  2        "must be careful here, whenever ST/X is used on VAX or a 370"

! !

!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 );