"

 COPYRIGHT (c) 1999 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:libbasic' }"

LimitedPrecisionReal variableByteSubclass:#LongFloat

	instanceVariableNames:''

	classVariableNames:'DefaultPrintFormat LongFloatZero LongFloatOne Pi E'

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!LongFloat 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 isnanl

#  define isnanl(x)      \

        ((((unsigned int *)(&x))[0] == 0x00000000) && \

         (((unsigned int *)(&x))[1] == 0xC0000000) && \

         (((unsigned short *)(&x))[4] == 0xFFFF))

# endif

# ifndef isnan

#  define isnan(x)      \

        ((((unsigned int *)(&x))[0] == 0x00000000) && \

         (((unsigned int *)(&x))[1] == 0xFFF80000))

# endif

# ifndef isPositiveInfinity

#  define isPositiveInfinity(x) \

        ((((unsigned int *)(&x))[0] == 0x00000000) && \

         (((unsigned int *)(&x))[1] == 0x7FF00000))

# endif

# ifndef isNegativeInfinity

#  define isPositiveInfinity(x) \

        ((((unsigned int *)(&x))[0] == 0x00000000) && \

         (((unsigned int *)(&x))[1] == 0xFFF00000))

# endif

# ifndef isinf

#  define isinf(x) \

        ((((unsigned int *)(&x))[0] == 0x00000000) && \

         ((((unsigned int *)(&x))[1] & 0x7FF00000) == 0x7FF00000))

# endif

# ifndef finite

#  define finite(x) (!isinf(x) && !isnan(x))

# endif

# define NO_ASINH

# define NO_ACOSH

# define NO_ATANH

#endif

#ifdef realIX

/*

 * no finite(x)

 */

# ifndef finite

#  define finite(x)     1

# endif

#endif /* realIX */

#ifdef WIN32

# define LONGFLOAT      long double

# define LONG_isnan     isnanl

#endif

#if defined(__GNUC__)

# define LONGFLOAT      long double

# if defined(linux)

#  define LONG_ceil     ceill

#  define LONG_floor    floorl

#  define LONG_sqrt     sqrtl

#  define LONG_sin      sinl

#  define LONG_cos      cosl

#  define LONG_tan      tanl

#  define LONG_sinh     sinhl

#  define LONG_cosh     coshl

#  define LONG_tanh     tanhl

#  define LONG_asin     asinl

#  define LONG_acos     acosl

#  define LONG_atan     atanl

#  define LONG_asinh    asinhl

#  define LONG_acosh    acoshl

#  define LONG_atanh    atanhl

#  define LONG_exp      expl

#  define LONG_frexp    frexpl

#  define LONG_log      logl

#  define LONG_log10    log10l

#  define LONG_pow      powl

#  define LONG_isnan    isnanl

#  define LONG_isfinite isfinitel

# endif

#endif

/*

 * on systems which do not support long doubles, fall back to Float

 * arithmetic

 */

#ifndef LONGFLOAT

# define LONGFLOAT       double

# define LONGFLOAT_CLASS  Float

# define LONGFLOAT_GLOBAL @global(Float)

#else

# define LONGFLOAT_CLASS LongFloat

# define LONGFLOAT_GLOBAL @global(LongFloat)

#endif

struct __longfloatstruct {

        HEADER

#ifdef __NEED_DOUBLE_ALIGN

        __FILLTYPE_DOUBLE       f_filler;

#endif

        LONGFLOAT               f_longfloatvalue;

};

#define __LongFloatInstPtr(obj)      ((struct __longfloatstruct *)(__objPtr(obj)))

#ifndef __longFloatVal

# define __longFloatVal(o) \

        __LongFloatInstPtr(o)->f_longfloatvalue

#endif

#ifndef __qMKLFLOAT

# define __qMKLFLOAT(__newFloat__, __fVal__) \

    { \

        __qNew(__newFloat__ , sizeof(struct __longfloatstruct)); \

        if (__newFloat__) { \

            __qClass(__newFloat__) = LONGFLOAT_GLOBAL; \

            __LongFloatInstPtr(__newFloat__)->f_longfloatvalue = (LONGFLOAT)(__fVal__); \

        } \

    }

#endif

#ifndef __isLongFloat

# define __isLongFloat(o) \

        (__Class(o) == @global(LongFloat))

#endif

#ifndef __qIsLongFloat

# define __qIsLongFloat(o) \

        (__qClass(o) == @global(LongFloat))

#endif

%}

! !

!LongFloat class methodsFor:'documentation'!

copyright

"

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

"

    LongFloats represent rational numbers with limited precision.

    They use the C-compilers 'long double' format, which is usually

    mapped to the IEE extended float or IEE quad float format.

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

    LongFloats give you 80 bit floats (extended) or 128 bit floats (quad).

    The actual number of bits depends on the underlying CPU

    (thus, longFloat code is not quaranteed to be portable).

    NO GUARANTY:

        on systems which do not support 'long doubles', LongFloats are (silently)

        represented as 'doubles'.

    Representation:

        gcc-i386:

            80bit extended IEE floats stored in in 96bits (12bytes);

            64 bit mantissa,

            16 bit exponent,

            19 decimal digits (approx)

        borland-i386 (WIN32):

            80bit extended IEE floats stored in in 80bits (10bytes);

            64 bit mantissa,

            16 bit exponent,

            19 decimal digits (approx)

        gcc-sparc:

            128bit quad IEE floats (16bytes);

            112 bit mantissa,

            16 bit exponent,

            34 decimal digits (approx)

    Mixed mode arithmetic:

        longFloat op longFloat   -> longFloat

        longFloat op fix         -> longFloat

        longFloat op fraction    -> longFloat

        longFloat op integer     -> longFloat

        longFloat op shortFloat  -> longFloat

        longFloat op float       -> longFloat

        longFloat op complex     -> complex

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

    [author:]

        Claus Gittinger

    [see also:]

        Number

        Float ShortFloat Fraction FixedPoint Integer Complex

        FloatArray DoubleArray                                                                         

"

! !

!LongFloat class methodsFor:'initialization'!

initialize

    "do not write a literal constant here - we cannot depend on the underlying C-compiler here..."

    DefaultPrintFormat := '.9'.  "/ 9 valid digits

    "/ enough digits for 128bit IEEE quads

    Pi := self readFrom:'3.1415926535897932384626433832795029'. "/ '3.14159265358979323846264338327950288419716939937510582097494459'.

    E := self readFrom:'2.7182818284590452353602874713526625'.

    "

     self initialize

    "      

    "      

     DefaultPrintFormat := '.19'. 

     LongFloat pi printString.     

     DefaultPrintFormat := '.9'. 

     LongFloat pi printString.     

     DefaultPrintFormat := '.6'. 

     LongFloat pi printString.     

    "

! !

!LongFloat class methodsFor:'instance creation'!

basicNew

    "return a new longFloat - here we return 0.0

     - LongFloats are usually NOT created this way ...

     Its implemented here to allow things like binary store & load

     of longFloats. (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;

    if (sizeof(LONGFLOAT) == sizeof(double)) {

        __qMKFLOAT(newFloat, 0.0);   /* OBJECT ALLOCATION */

    } else {

        __qMKLFLOAT(newFloat, 0.0);   /* OBJECT ALLOCATION */

    }

    RETURN (newFloat);

%}

!

fromFloat:aFloat

    "return a new longFloat, given a float value"

%{  /* NOCONTEXT */

    OBJ newFloat;

    LONGFLOAT f;

    if (sizeof(LONGFLOAT) == sizeof(double)) {

        RETURN (aFloat);

    }

    if (aFloat != nil) {

        if (__qIsFloatLike(aFloat)) {

            f = (LONGFLOAT)(__floatVal(aFloat));

            __qMKLFLOAT(newFloat, f);   /* OBJECT ALLOCATION */

            RETURN (newFloat);

        }

        if (__qIsShortFloat(aFloat)) {

            f = (LONGFLOAT)(__shortFloatVal(aFloat));

            __qMKLFLOAT(newFloat, f);   /* OBJECT ALLOCATION */

            RETURN (newFloat);

        }

        if (__isSmallInteger(aFloat)) {

            f = (LONGFLOAT)(__smallIntegerVal(aFloat));

            __qMKLFLOAT(newFloat, f);   /* OBJECT ALLOCATION */

            RETURN (newFloat);

        }

    }

%}.

    self error:'invalid argumnet'

    "

     LongFloat fromFloat:123.0   

     123.0 asLongFloat    

     123 asLongFloat    

    "

!

readFrom:aStringOrStream onError:exceptionBlock

    "read a longFloat from a string"

    |num|

    num := super readFrom:aStringOrStream onError:nil.

    num isNil ifTrue:[  

	^ exceptionBlock value

    ].

    ^ num asLongFloat

    "

     LongFloat readFrom:'0.1'

     LongFloat readFrom:'0'

    "

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

! !

!LongFloat class methodsFor:'constants'!

e

    "return the constant e as LongFloat"

    ^ E

!

pi

    "return the constant pi as LongFloat"

    ^ Pi

!

unity

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

    LongFloatOne isNil ifTrue:[

	LongFloatOne := 1.0 asLongFloat.

    ].

    ^ LongFloatOne

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

!

zero

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

    LongFloatZero isNil ifTrue:[

	LongFloatZero := 0.0 asLongFloat

    ].

    ^ LongFloatZero

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

! !

!LongFloat class methodsFor:'queries'!

exponentCharacter

    ^ $q

!

isBuiltInClass

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

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

    ^ self == LongFloat

    "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

     i386: This is an 80bit longfloat stored in 96 bits (upper 16 bits are unused), 

           where 15 bits are available in the exponent (i bit is ignored):

        00000000 00000000 seeeeeee eeeeeeee immmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm

    "

%{

    if (sizeof(LONGFLOAT) == 10) { /* i386 - WIN32 */

        RETURN (__MKSMALLINT(15));

    }

    if (sizeof(LONGFLOAT) == 12) { /* i386 */

        RETURN (__MKSMALLINT(15));

    }

    if (sizeof(LONGFLOAT) == 16) { /* sparc */

        RETURN (__MKSMALLINT(15));

    }

%}.

    "systems without longFloat support use doubles instead"

    self basicNew basicSize == Float basicNew basicSize ifTrue:[

        ^ Float numBitsInExponent

    ].

    self error:'missing definition'  "ifdef missing in above primitive code for this architecture"

    "

     1.0 asLongFloat class numBitsInExponent

    "

!

numBitsInIntegerPart

    "answer the number of bits in the integer part of the mantissa

     i386: This is an 80bit longfloat stored in 96 bits (upper 16 bits are unused), 

           where 1 bit is used for the integer part in the mantissa:

        00000000 00000000 seeeeeee eeeeeeee immmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm

    "

%{

    if (sizeof(LONGFLOAT) == 10) { /* i386 - WIN32 */

        RETURN (__MKSMALLINT(1));

    }

    if (sizeof(LONGFLOAT) == 12) { /* i386 */

        RETURN (__MKSMALLINT(1));

    }

    if (sizeof(LONGFLOAT) == 16) { /* sparc */

        RETURN (__MKSMALLINT(0));

    }

%}.

    "systems without longFloat support use doubles instead"

    self basicNew basicSize == Float basicNew basicSize ifTrue:[

        ^ Float numBitsInIntegerPart

    ].

    self error:'missing definition'  "ifdef missing in above primitive code for this architecture"

    "

     1.0 asLongFloat class numBitsInIntegerPart

    "

!

numBitsInMantissa

    "answer the number of bits in the mantissa

     i386: This is an 80bit longfloat stored in 96 bits (upper 16 bits are unused), 

           where 1+63 bits are available in the mantissa: