"

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

	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 <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 /* WIN32 */

#ifdef realIX

/*

 * no finite(x)

 */

# ifndef finite

#  define finite(x)     1

# endif

#endif /* realIX */

#ifdef WIN32

# define LONGFLOAT      long double

#endif

#if defined(__GNUC__) && defined(i386)

# define LONGFLOAT      long double

#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) \

	(__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. In ST/X, Float uses

    the underlying C-compilers double implementation, while LongFloats are

    mapped onto C-long doubles.

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

    double precision float format (64 bits), while LongFloats use 10byte extended IEE format

    (80 bits).

    But there is no guaranty - on systems which do not support long doubles,

    LongFloats are represented as Doubles.

    [author:]

	Claus Gittinger

    [see also:]

	Number

	Float ShortFloat Fraction FixedPoint Integer

"

! !

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

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

    RETURN (newFloat);

%}

!

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

pi

    "return the constant pi as LongFloat"

    ^ 3.14159 asLongFloat

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

!

unity

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

    ^ 1.0 asLongFloat

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

!

zero

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

    ^ 0.0 asLongFloat

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

! !

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

! !

!LongFloat methodsFor:'arithmetic'!

* aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    LONGFLOAT result;

    if (__isSmallInteger(aNumber)) {

	result = __longFloatVal(self) * (LONGFLOAT)(__intVal(aNumber));

retResult:

	__qMKLFLOAT(newFloat, result);

	RETURN ( newFloat );

    } else if (__isLongFloat(aNumber)) {

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

	goto retResult;

    } else if (__isFloatLike(aNumber)) {

	result = __longFloatVal(self) * (LONGFLOAT)(__floatVal(aNumber));

	goto retResult;

    } else if (__isShortFloat(aNumber)) {

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

	goto retResult;

    }

%}.

    ^ aNumber productFromLongFloat:self

!

+ aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    LONGFLOAT result;

    if (__isSmallInteger(aNumber)) {

	result = __longFloatVal(self) + (LONGFLOAT)(__intVal(aNumber));

retResult:

	__qMKLFLOAT(newFloat, result);

	RETURN ( newFloat );

    } else if (__isLongFloat(aNumber)) {

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

	goto retResult;

    } else if (__isShortFloat(aNumber)) {

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

	goto retResult;

    } else if (__isFloatLike(aNumber)) {

	result = __longFloatVal(self) + (LONGFLOAT)(__floatVal(aNumber));

	goto retResult;

    }

%}.

    ^ aNumber sumFromLongFloat:self

!

- aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    LONGFLOAT result;

    if (__isSmallInteger(aNumber)) {

	result = __longFloatVal(self) - (LONGFLOAT)(__intVal(aNumber));

retResult:

	__qMKLFLOAT(newFloat, result);

	RETURN ( newFloat );

    } else if (__isLongFloat(aNumber)) {

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

	goto retResult;

    } else if (__isShortFloat(aNumber)) {

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

	goto retResult;

    } else if (__isFloatLike(aNumber)) {

	result = __longFloatVal(self) - (LONGFLOAT)(__floatVal(aNumber));

	goto retResult;

    }

%}.

    ^ aNumber differenceFromLongFloat:self

!

/ aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    LONGFLOAT result, val;

    if (__isSmallInteger(aNumber)) {

	if (aNumber != __MKSMALLINT(0)) {

	    result = __longFloatVal(self) / (LONGFLOAT)(__intVal(aNumber));

retResult:

	    __qMKLFLOAT(newFloat, result);

	    RETURN ( newFloat );

	}

    } else if (__isLongFloat(aNumber)) {

	val = __longFloatVal(aNumber);

	if (val != 0.0) {

	    result = __longFloatVal(self) / val;

	    goto retResult;

	}

    } else if (__isFloatLike(aNumber)) {

	val = (LONGFLOAT)(__floatVal(aNumber));

	if (val != 0.0) {

	    result = __longFloatVal(self) / val;

	    goto retResult;

	}

    } else if (__isShortFloat(aNumber)) {

	val = (LONGFLOAT)(__shortFloatVal(aNumber));

	if (val != 0.0) {

	    result = __longFloatVal(self) / val;

	    goto retResult;

	}

    }

%}.

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

	"

	 No, you shalt not divide by zero

	"

	^ DivisionByZeroSignal raiseRequest.

    ].

    ^ aNumber quotientFromLongFloat:self

!

negated

    "return myself negated"

%{  /* NOCONTEXT */

    OBJ newFloat;

    LONGFLOAT rslt = - __longFloatVal(self);

    __qMKLFLOAT(newFloat, rslt);

    RETURN ( newFloat );

%}.

    ^ 0.0 - self

!

uncheckedDivide:aNumber

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

     Do not check for divide by zero (return NaN or infinity)"

%{  /* NOCONTEXT */

    OBJ newFloat;

    LONGFLOAT result, val;

    if (__isSmallInteger(aNumber)) {

	result = __longFloatVal(self) / (LONGFLOAT)(__intVal(aNumber));

retResult:

	__qMKLFLOAT(newFloat, result);

	RETURN ( newFloat );

    } else if (__isLongFloat(aNumber)) {

	result = __longFloatVal(self) / __longFloatVal(aNumber);

	goto retResult;

    } else if (__isFloatLike(aNumber)) {

	val = (LONGFLOAT)(__floatVal(aNumber));

	result = __longFloatVal(self) / val;

	goto retResult;

    } else if (__isShortFloat(aNumber)) {

	val = (LONGFLOAT)(__shortFloatVal(aNumber));

	result = __longFloatVal(self) / val;

	goto retResult;

    }

%}.

    ^ aNumber quotientFromLongFloat:self

    "

      0.0 asLongFloat uncheckedDivide:0

      1.0 asLongFloat uncheckedDivide:0.0

    "

! !

!LongFloat methodsFor:'coercing & converting'!

asFloat

    "return a Float with same value as the receiver"

%{  /* NOCONTEXT */

    OBJ newFloat;

    double dVal = (double)__longFloatVal(self);

    __qMKFLOAT(newFloat, dVal);

    RETURN ( newFloat );

%}

    "

     1.0 asLongFloat 

    "

!

asInteger

    "return an integer with same value - might truncate"

%{  /* NOCONTEXT */

    LONGFLOAT fVal;

    fVal = __longFloatVal(self);

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

	RETURN ( __MKSMALLINT( (INT)fVal) );

    }

%}.

    ^ super asInteger

    "

     12345.0 asLongFloat asInteger

     1e15 asLongFloat asInteger

    "

!

asLongFloat

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

    ^ self

!

asShortFloat

    "return a ShortFloat with same value as the receiver"

%{  /* NOCONTEXT */

    OBJ newFloat;

    float fVal = (float)__longFloatVal(self);

    __qMKSFLOAT(newFloat, fVal);

    RETURN ( newFloat );

%}

    "

     1.0 asLongFloat asShortFloat  

    "

!

generality

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

    ^ 90

! !

!LongFloat methodsFor:'comparing'!

< aNumber

    "return true, if the argument is greater"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

	RETURN ( (__longFloatVal(self) < (LONGFLOAT)(__intVal(aNumber))) ? true : false );

    }

    if (__isLongFloat(aNumber)) {

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

    }

    if (__isFloatLike(aNumber)) {

	RETURN ( (__longFloatVal(self) < (LONGFLOAT)(__floatVal(aNumber))) ? true : false );

    }

    if (__isShortFloat(aNumber)) {

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