"

 COPYRIGHT (c) 1988 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:#Float

       instanceVariableNames:''

       classVariableNames:''

       poolDictionaries:''

       category:'Magnitude-Numbers'

!

Float comment:'

COPYRIGHT (c) 1988 by Claus Gittinger

              All Rights Reserved

!Float class methodsFor:'instance creation'!

basicNew

    "return a new float - here we return 0.0

     - floats are usually NOT created this way ...

     Its implemented here to allow things like binary store & load

     of floats. (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 */

    RETURN ( _MKFLOAT((0.0) COMMA_SND) );

%}

! !

!Float class methodsFor:'constants'!

zero

    "return the neutral element for addition"

    ^ 0.0

!

unity

    "return the neutral element for multiplication"

    ^ 1.0

!

pi

    "return the constant pi"

    ^ 3.1415926535897932384626434

! !

!Float class methodsFor:'queries'!

isBuiltInClass

    "this class is known by the run-time-system"

    ^ self == Float

! !

!Float methodsFor:'arithmetic'!

+ aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    double result;

    if (_isSmallInteger(aNumber)) {

        result = _floatVal(self) + (double)(_intVal(aNumber));

retResult:

        _qMKFLOAT(newFloat, result, SENDER);

        RETURN ( newFloat );

    }

    if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

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

        goto retResult;

    }

%}

.

    ^ aNumber sumFromFloat:self

!

- aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    double result;

    if (_isSmallInteger(aNumber)) {

        result = _floatVal(self) - (double)(_intVal(aNumber));

retResult:

        _qMKFLOAT(newFloat, result, SENDER);

        RETURN ( newFloat );

    }

    if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

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

        goto retResult;

    }

%}

.

    ^ aNumber differenceFromFloat:self

!

* aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    double result;

    if (_isSmallInteger(aNumber)) {

        result = _floatVal(self) * (double)(_intVal(aNumber));

retResult:

        _qMKFLOAT(newFloat, result, SENDER);

        RETURN ( newFloat );

    }

    if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

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

        goto retResult;

    }

%}

.

    ^ aNumber productFromFloat:self

!

/ aNumber

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

%{  /* NOCONTEXT */

    OBJ newFloat;

    double result, val;

    if (_isSmallInteger(aNumber)) {

        if (aNumber != _MKSMALLINT(0)) {

            result = _floatVal(self) / ( (double)_intVal(aNumber)) ;

retResult:

            _qMKFLOAT(newFloat, result, SENDER);

            RETURN ( newFloat );

        }

    } else {

        if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

            val = _floatVal(aNumber);

            if (val != 0.0) {

                result = _floatVal(self) / val;

                goto retResult;

            }

        }

    }

%}

.

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

        DivisionByZeroSignal raise.

        ^ self

    ].

    ^ aNumber quotientFromFloat:self

!

// aNumber

    "return the integer quotient of dividing the receiver by aNumber with

    truncation towards negative infinity."

    ^ (self / aNumber) floor asInteger

!

\\ aNumber

    "return the integer remainder of dividing the receiver by aNumber with

    truncation towards negative infinity."

    ^ (self - ((self / aNumber) floor * aNumber)) floor asInteger

!

negated

    "return myself negated"

%{  /* NOCONTEXT */

    OBJ newFloat;

    _qMKFLOAT(newFloat, - _floatVal(self), SENDER);

    RETURN ( newFloat );

%}

! !

!Float methodsFor:'testing'!

positive

    "return true if the receiver is greater or equal to zero"

%{  /* NOCONTEXT */

    RETURN ( (_floatVal(self) >= 0.0) ? true : false );

%}

!

negative

    "return true if the receiver is less than zero"

%{  /* NOCONTEXT */

    RETURN ( (_floatVal(self) < 0.0) ? true : false );

%}

! !

!Float methodsFor:'comparing'!

< aNumber

    "return true, if the argument is greater"

%{  /* NOCONTEXT */

    if (_isSmallInteger(aNumber)) {

        RETURN ( (_floatVal(self) < (double)(_intVal(aNumber))) ? true : false );

    }

    if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

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

    }

%}

.

    ^ aNumber lessFromFloat:self

!

> aNumber

    "return true, if the argument is less"

%{  /* NOCONTEXT */

    if (_isSmallInteger(aNumber)) {

        RETURN ( (_floatVal(self) > (double)(_intVal(aNumber))) ? true : false );

    }

    if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

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

    }

%}

.

    ^ self retry:#> coercing:aNumber

!

<= aNumber

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

%{  /* NOCONTEXT */

    if (_isSmallInteger(aNumber)) {

        RETURN ( (_floatVal(self) <= (double)(_intVal(aNumber))) ? true : false );

    }

    if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

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

    }

%}

.

    ^ self retry:#<= coercing:aNumber

!

>= aNumber

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

%{  /* NOCONTEXT */

    if (_isSmallInteger(aNumber)) {

        RETURN ( (_floatVal(self) >= (double)(_intVal(aNumber))) ? true : false );

    }

    if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

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

    }

%}

.

    ^ self retry:#>= coercing:aNumber

!

= aNumber

    "return true, if the arguments value are equal"

%{  /* NOCONTEXT */

    if (_isSmallInteger(aNumber)) {

        RETURN ( (_floatVal(self) == (double)(_intVal(aNumber))) ? true : false );

    }

    if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

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

    }

%}

.

    ^ self retry:#= coercing:aNumber

!

~= aNumber

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

%{  /* NOCONTEXT */

    if (_isSmallInteger(aNumber)) {

        RETURN ( (_floatVal(self) != (double)(_intVal(aNumber))) ? true : false );

    }

    if ((aNumber != nil) && (_qClass(aNumber) == Float)) {

        RETURN ( (_floatVal(self) != _floatVal(aNumber)) ? true : false );

    }

%}

.

    ^ self retry:#~= coercing:aNumber

! !

!Float methodsFor:'coercion and converting'!

coerce:aNumber

    "return aNumber converted into receivers type"

    ^ aNumber asFloat

!

generality

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

    ^ 80

!

asFloat

    "return a float with same value - thats me"

    ^ self

!

asInteger

    "return an integer with same value - might truncate"

    |l v sign|

%{  /* NOCONTEXT */

    if ((_floatVal(self) >= (double)_MIN_INT)

     && (_floatVal(self) <= (double)_MAX_INT)) {

        RETURN ( _MKSMALLINT( (INT)_floatVal(self)) );

    }

%}

.

    ^ super asInteger

    "12345.0 asInteger"

    "1e15 asInteger"

! !

!Float methodsFor:'truncation and rounding'!

truncated

    |val|

%{

    double floor(), ceil();

    double dVal;

    dVal = _floatVal(self);

    if (dVal < 0.0) {

        dVal = ceil(dVal);

    } else {

        dVal = floor(dVal);

    }

    /*

     */

    if ((dVal >= (double)_MIN_INT) && (dVal <= (double)_MAX_INT)) {

        RETURN ( _MKSMALLINT( (INT) dVal ) );

    }

    val = _MKFLOAT(dVal COMMA_CON);

    ^ val asInteger

!

rounded

    |val|

%{

    double floor();

    double dVal;

    /*

     */

    dVal = floor(_floatVal(self) + 0.5);

    if ((dVal >= (double)_MIN_INT) && (dVal <= (double)_MAX_INT)) {

        RETURN ( _MKSMALLINT( (INT) dVal ) );

    }

    val = _MKFLOAT(dVal COMMA_CON);

    ^ val asInteger

!

floor

    RETURN ( _MKFLOAT(floor(_floatVal(self)) COMMA_SND) );

!

ceiling

    "return the smallest integer-valued float greater or equal to the receiver"

    double ceil();

    RETURN ( _MKFLOAT(ceil(_floatVal(self)) COMMA_SND) );

! !

!Float methodsFor:'mathematical functions'!

ln

    "return the natural logarithm of myself"

%{  /* NOCONTEXT */

    double log();

    double result;

    extern errno;

    extern OBJ ErrorNumber;

    errno = 0;

    result = log(_floatVal(self));

    if (errno == 0)

        RETURN ( _MKFLOAT(result COMMA_SND) );

    ErrorNumber = _MKSMALLINT(errno);

%}

.

    DomainErrorSignal raise

!

raisedTo:aNumber

    "return self raised to the power of aNumber"

    |n|

    n := aNumber asFloat.

%{

    double pow();

    double result;