Changeset 8784


Ignore:
Timestamp:
03/17/05 15:05:09 (16 years ago)
Author:
piso
Message:

SINGLE-FLOAT support.

Location:
trunk/j/src/org/armedbear/lisp
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/Autoload.java

    r8783 r8784  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Autoload.java,v 1.219 2005-03-15 17:34:30 piso Exp $
     5 * $Id: Autoload.java,v 1.220 2005-03-17 14:44:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    498498        autoload(PACKAGE_SYS, "class-direct-slots", "SlotClass");
    499499        autoload(PACKAGE_SYS, "class-slots", "SlotClass");
    500         autoload(PACKAGE_SYS, "coerce-to-float", "FloatFunctions");
     500        autoload(PACKAGE_SYS, "coerce-to-double-float", "FloatFunctions");
     501        autoload(PACKAGE_SYS, "coerce-to-single-float", "FloatFunctions");
    501502        autoload(PACKAGE_SYS, "condition-report", "Condition");
    502503        autoload(PACKAGE_SYS, "create-new-file", "create_new_file");
     
    506507        autoload(PACKAGE_SYS, "float-infinity-p", "FloatFunctions");
    507508        autoload(PACKAGE_SYS, "float-nan-p", "FloatFunctions");
     509        autoload(PACKAGE_SYS, "float-string", "FloatFunctions", true);
    508510        autoload(PACKAGE_SYS, "function-info", "function_info");
    509511        autoload(PACKAGE_SYS, "generic-function-discriminating-function", "GenericFunction");
  • trunk/j/src/org/armedbear/lisp/Bignum.java

    r8767 r8784  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Bignum.java,v 1.63 2005-03-14 14:23:00 piso Exp $
     5 * $Id: Bignum.java,v 1.64 2005-03-17 14:47:39 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    131131        if (obj instanceof Bignum)
    132132            return value.equals(((Bignum)obj).value);
    133         if (obj instanceof LispFloat)
    134             return floatValue() == ((LispFloat)obj).value;
     133        if (obj instanceof SingleFloat)
     134            return floatValue() == ((SingleFloat)obj).value;
     135        if (obj instanceof DoubleFloat)
     136            return doubleValue() == ((DoubleFloat)obj).value;
    135137        return false;
    136138    }
     
    178180    }
    179181
    180     public double floatValue() throws ConditionThrowable
     182    public float floatValue() throws ConditionThrowable
     183    {
     184        float f = value.floatValue();
     185        if (Float.isInfinite(f))
     186            signal(new TypeError("The value " + writeToString() +
     187                                 " is too large to be converted to a single float."));
     188        return f;
     189    }
     190
     191    public double doubleValue() throws ConditionThrowable
    181192    {
    182193        double d = value.doubleValue();
    183194        if (Double.isInfinite(d))
    184             signal(new TypeError(writeToString() +
    185                                  " is too large to be converted to a float"));
     195            signal(new TypeError("The value " + writeToString() +
     196                                 " is too large to be converted to a double float."));
    186197        return d;
    187198    }
     
    193204        }
    194205        catch (ClassCastException e) {
    195             signal(new TypeError(obj, "bignum"));
     206            signal(new TypeError(obj, Symbol.BIGNUM));
    196207            // Not reached.
    197208            return null;
     
    231242                denominator);
    232243        }
    233         if (obj instanceof LispFloat)
    234             return new LispFloat(floatValue() + ((LispFloat)obj).value);
     244        if (obj instanceof SingleFloat)
     245            return new SingleFloat(floatValue() + ((SingleFloat)obj).value);
     246        if (obj instanceof DoubleFloat)
     247            return new DoubleFloat(doubleValue() + ((DoubleFloat)obj).value);
    235248        if (obj instanceof Complex) {
    236249            Complex c = (Complex) obj;
     
    252265                denominator);
    253266        }
    254         if (obj instanceof LispFloat)
    255             return new LispFloat(floatValue() - ((LispFloat)obj).value);
     267        if (obj instanceof SingleFloat)
     268            return new SingleFloat(floatValue() - ((SingleFloat)obj).value);
     269        if (obj instanceof DoubleFloat)
     270            return new DoubleFloat(doubleValue() - ((DoubleFloat)obj).value);
    256271        if (obj instanceof Complex) {
    257272            Complex c = (Complex) obj;
     
    287302            return number(n.multiply(value), ((Ratio)obj).denominator());
    288303        }
    289         if (obj instanceof LispFloat)
    290             return new LispFloat(floatValue() * ((LispFloat)obj).value);
     304        if (obj instanceof SingleFloat)
     305            return new SingleFloat(floatValue() * ((SingleFloat)obj).value);
     306        if (obj instanceof DoubleFloat)
     307            return new DoubleFloat(doubleValue() * ((DoubleFloat)obj).value);
    291308        if (obj instanceof Complex) {
    292309            Complex c = (Complex) obj;
     
    307324            return number(d.multiply(value), ((Ratio)obj).numerator());
    308325        }
    309         if (obj instanceof LispFloat)
    310             return new LispFloat(floatValue() / ((LispFloat)obj).value);
     326        if (obj instanceof SingleFloat)
     327            return new SingleFloat(floatValue() / ((SingleFloat)obj).value);
     328        if (obj instanceof DoubleFloat)
     329            return new DoubleFloat(doubleValue() / ((DoubleFloat)obj).value);
    311330        if (obj instanceof Complex) {
    312331            Complex c = (Complex) obj;
     
    325344        if (obj instanceof Bignum)
    326345            return value.equals(((Bignum)obj).value);
    327         if (obj instanceof LispFloat)
    328             return isEqualTo(((LispFloat)obj).rational());
     346        if (obj instanceof SingleFloat)
     347            return isEqualTo(((SingleFloat)obj).rational());
     348        if (obj instanceof DoubleFloat)
     349            return isEqualTo(((DoubleFloat)obj).rational());
    329350        if (obj.numberp())
    330351            return false;
     
    338359        if (obj instanceof Bignum)
    339360            return !value.equals(((Bignum)obj).value);
    340         if (obj instanceof LispFloat)
    341             return isNotEqualTo(((LispFloat)obj).rational());
     361        if (obj instanceof SingleFloat)
     362            return isNotEqualTo(((SingleFloat)obj).rational());
     363        if (obj instanceof DoubleFloat)
     364            return isNotEqualTo(((DoubleFloat)obj).rational());
    342365        if (obj.numberp())
    343366            return true;
     
    357380            return n.compareTo(((Ratio)obj).numerator()) < 0;
    358381        }
    359         if (obj instanceof LispFloat)
    360             return isLessThan(((LispFloat)obj).rational());
     382        if (obj instanceof SingleFloat)
     383            return isLessThan(((SingleFloat)obj).rational());
     384        if (obj instanceof DoubleFloat)
     385            return isLessThan(((DoubleFloat)obj).rational());
    361386        signal(new TypeError(obj, Symbol.REAL));
    362387        // Not reached.
     
    374399            return n.compareTo(((Ratio)obj).numerator()) > 0;
    375400        }
    376         if (obj instanceof LispFloat)
    377             return isGreaterThan(((LispFloat)obj).rational());
     401        if (obj instanceof SingleFloat)
     402            return isGreaterThan(((SingleFloat)obj).rational());
     403        if (obj instanceof DoubleFloat)
     404            return isGreaterThan(((DoubleFloat)obj).rational());
    378405        signal(new TypeError(obj, Symbol.REAL));
    379406        // Not reached.
     
    391418            return n.compareTo(((Ratio)obj).numerator()) <= 0;
    392419        }
    393         if (obj instanceof LispFloat)
    394             return isLessThanOrEqualTo(((LispFloat)obj).rational());
     420        if (obj instanceof SingleFloat)
     421            return isLessThanOrEqualTo(((SingleFloat)obj).rational());
     422        if (obj instanceof DoubleFloat)
     423            return isLessThanOrEqualTo(((DoubleFloat)obj).rational());
    395424        signal(new TypeError(obj, Symbol.REAL));
    396425        // Not reached.
     
    408437            return n.compareTo(((Ratio)obj).numerator()) >= 0;
    409438        }
    410         if (obj instanceof LispFloat)
    411             return isGreaterThanOrEqualTo(((LispFloat)obj).rational());
     439        if (obj instanceof SingleFloat)
     440            return isGreaterThanOrEqualTo(((SingleFloat)obj).rational());
     441        if (obj instanceof DoubleFloat)
     442            return isGreaterThanOrEqualTo(((DoubleFloat)obj).rational());
    412443        signal(new TypeError(obj, Symbol.REAL));
    413444        // Not reached.
     
    442473                value1 = quotient;
    443474                value2 = remainder;
    444             } else if (obj instanceof LispFloat) {
     475            } else if (obj instanceof SingleFloat) {
    445476                // "When rationals and floats are combined by a numerical
    446477                // function, the rational is first converted to a float of the
    447478                // same format." 12.1.4.1
    448                 return new LispFloat(floatValue()).truncate(obj);
     479                return new SingleFloat(floatValue()).truncate(obj);
     480            } else if (obj instanceof DoubleFloat) {
     481                // "When rationals and floats are combined by a numerical
     482                // function, the rational is first converted to a float of the
     483                // same format." 12.1.4.1
     484                return new DoubleFloat(doubleValue()).truncate(obj);
    449485            } else
    450486                return signal(new TypeError(obj, Symbol.REAL));
  • trunk/j/src/org/armedbear/lisp/BuiltInClass.java

    r8655 r8784  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: BuiltInClass.java,v 1.36 2005-02-28 00:56:26 piso Exp $
     5 * $Id: BuiltInClass.java,v 1.37 2005-03-17 14:48:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8383    public static final BuiltInClass CONS                             = addClass(Symbol.CONS);
    8484    public static final BuiltInClass DIVISION_BY_ZERO                 = addClass(Symbol.DIVISION_BY_ZERO);
     85    public static final BuiltInClass DOUBLE_FLOAT                     = addClass(Symbol.DOUBLE_FLOAT);
    8586    public static final BuiltInClass ECHO_STREAM                      = addClass(Symbol.ECHO_STREAM);
    8687    public static final BuiltInClass END_OF_FILE                      = addClass(Symbol.END_OF_FILE);
     
    118119    public static final BuiltInClass SIMPLE_ERROR                     = addClass(Symbol.SIMPLE_ERROR);
    119120    public static final BuiltInClass SIMPLE_STRING                    = addClass(Symbol.SIMPLE_STRING);
     121    public static final BuiltInClass SIMPLE_TYPE_ERROR                = addClass(Symbol.SIMPLE_TYPE_ERROR);
    120122    public static final BuiltInClass SIMPLE_VECTOR                    = addClass(Symbol.SIMPLE_VECTOR);
    121     public static final BuiltInClass SIMPLE_TYPE_ERROR                = addClass(Symbol.SIMPLE_TYPE_ERROR);
     123    public static final BuiltInClass SINGLE_FLOAT                     = addClass(Symbol.SINGLE_FLOAT);
    122124    public static final BuiltInClass SLIME_INPUT_STREAM               = addClass(Symbol.SLIME_INPUT_STREAM);
    123125    public static final BuiltInClass SLIME_OUTPUT_STREAM              = addClass(Symbol.SLIME_OUTPUT_STREAM);
     
    317319                                SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
    318320                                CLASS_T);
     321        DOUBLE_FLOAT.setDirectSuperclass(FLOAT);
     322        DOUBLE_FLOAT.setCPL(DOUBLE_FLOAT, FLOAT, REAL, NUMBER, CLASS_T);
    319323        ECHO_STREAM.setDirectSuperclass(STREAM);
    320324        ECHO_STREAM.setCPL(ECHO_STREAM, STREAM, CLASS_T);
     
    435439        SIMPLE_WARNING.setCPL(SIMPLE_WARNING, SIMPLE_CONDITION, WARNING,
    436440                              CONDITION, STANDARD_OBJECT, CLASS_T);
     441        SINGLE_FLOAT.setDirectSuperclass(FLOAT);
     442        SINGLE_FLOAT.setCPL(SINGLE_FLOAT, FLOAT, REAL, NUMBER, CLASS_T);
    437443        SLIME_INPUT_STREAM.setDirectSuperclass(STRING_STREAM);
    438444        SLIME_INPUT_STREAM.setCPL(SLIME_INPUT_STREAM, STRING_STREAM, STREAM,
  • trunk/j/src/org/armedbear/lisp/Complex.java

    r8766 r8784  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Complex.java,v 1.32 2005-03-14 13:50:37 piso Exp $
     5 * $Id: Complex.java,v 1.33 2005-03-17 14:48:59 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4141        if (!imagpart.realp())
    4242            return signal(new TypeError(imagpart, Symbol.REAL));
    43         if (realpart instanceof LispFloat)
    44             imagpart = LispFloat.coerceToFloat(imagpart);
    45         else if (imagpart instanceof LispFloat)
    46             realpart = LispFloat.coerceToFloat(realpart);
     43        if (realpart instanceof DoubleFloat)
     44            imagpart = DoubleFloat.coerceToFloat(imagpart);
     45        else if (imagpart instanceof DoubleFloat)
     46            realpart = DoubleFloat.coerceToFloat(realpart);
     47        else if (realpart instanceof SingleFloat)
     48            imagpart = SingleFloat.coerceToFloat(imagpart);
     49        else if (imagpart instanceof SingleFloat)
     50            realpart = SingleFloat.coerceToFloat(realpart);
    4751        if (imagpart instanceof Fixnum) {
    4852            if (((Fixnum)imagpart).value == 0)
     
    122126        if (obj.numberp()) {
    123127            // obj is a number, but not complex.
    124             if (imagpart instanceof LispFloat) {
    125                 if (((LispFloat)imagpart).value == 0) {
    126                     if (obj instanceof Fixnum)
    127                         return ((Fixnum)obj).value == ((LispFloat)realpart).value;
    128                     if (obj instanceof LispFloat)
    129                         return ((LispFloat)obj).value == ((LispFloat)realpart).value;
     128            if (imagpart instanceof SingleFloat) {
     129                if (((SingleFloat)imagpart).value == 0) {
     130                    if (obj instanceof Fixnum)
     131                        return ((Fixnum)obj).value == ((SingleFloat)realpart).value;
     132                    if (obj instanceof SingleFloat)
     133                        return ((SingleFloat)obj).value == ((SingleFloat)realpart).value;
     134                }
     135            }
     136            if (imagpart instanceof DoubleFloat) {
     137                if (((DoubleFloat)imagpart).value == 0) {
     138                    if (obj instanceof Fixnum)
     139                        return ((Fixnum)obj).value == ((DoubleFloat)realpart).value;
     140                    if (obj instanceof DoubleFloat)
     141                        return ((DoubleFloat)obj).value == ((DoubleFloat)realpart).value;
    130142                }
    131143            }
     
    209221        if (obj.numberp()) {
    210222            // obj is a number, but not complex.
    211             if (imagpart instanceof LispFloat) {
    212                 if (((LispFloat)imagpart).value == 0) {
    213                     if (obj instanceof Fixnum)
    214                         return ((Fixnum)obj).value == ((LispFloat)realpart).value;
    215                     if (obj instanceof LispFloat)
    216                         return ((LispFloat)obj).value == ((LispFloat)realpart).value;
     223            if (imagpart instanceof SingleFloat) {
     224                if (((SingleFloat)imagpart).value == 0) {
     225                    if (obj instanceof Fixnum)
     226                        return ((Fixnum)obj).value == ((SingleFloat)realpart).value;
     227                    if (obj instanceof SingleFloat)
     228                        return ((SingleFloat)obj).value == ((SingleFloat)realpart).value;
     229                    if (obj instanceof DoubleFloat)
     230                        return ((DoubleFloat)obj).value == ((SingleFloat)realpart).value;
     231                }
     232            }
     233            if (imagpart instanceof DoubleFloat) {
     234                if (((DoubleFloat)imagpart).value == 0) {
     235                    if (obj instanceof Fixnum)
     236                        return ((Fixnum)obj).value == ((DoubleFloat)realpart).value;
     237                    if (obj instanceof SingleFloat)
     238                        return ((SingleFloat)obj).value == ((DoubleFloat)realpart).value;
     239                    if (obj instanceof DoubleFloat)
     240                        return ((DoubleFloat)obj).value == ((DoubleFloat)realpart).value;
    217241                }
    218242            }
     
    231255    public LispObject ABS() throws ConditionThrowable
    232256    {
    233         double real = LispFloat.coerceToFloat(realpart).value;
    234         double imag = LispFloat.coerceToFloat(imagpart).value;
    235         return new LispFloat(Math.sqrt(real * real + imag * imag));
     257        if (realpart instanceof DoubleFloat) {
     258            double real = DoubleFloat.coerceToFloat(realpart).value;
     259            double imag = DoubleFloat.coerceToFloat(imagpart).value;
     260            return new DoubleFloat(Math.sqrt(real * real + imag * imag));
     261        } else {
     262            float real = SingleFloat.coerceToFloat(realpart).value;
     263            float imag = SingleFloat.coerceToFloat(imagpart).value;
     264            return new SingleFloat((float)Math.sqrt(real * real + imag * imag));
     265        }
    236266    }
    237267
  • trunk/j/src/org/armedbear/lisp/Fixnum.java

    r8757 r8784  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Fixnum.java,v 1.111 2005-03-12 17:54:30 piso Exp $
     5 * $Id: Fixnum.java,v 1.112 2005-03-17 14:50:07 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    179179        if (obj instanceof Fixnum)
    180180            return value == ((Fixnum)obj).value;
    181         if (obj instanceof LispFloat)
    182             return (float) value == ((LispFloat)obj).getValue();
     181        if (obj instanceof SingleFloat)
     182            return value == ((SingleFloat)obj).value;
     183        if (obj instanceof DoubleFloat)
     184            return value == ((DoubleFloat)obj).value;
    183185        return false;
    184186    }
     
    259261            // Not reached.
    260262            return null;
    261         }
    262     }
    263 
    264     public static float getFloat(LispObject obj) throws ConditionThrowable
    265     {
    266         try {
    267             return (float) ((Fixnum)obj).value;
    268         }
    269         catch (ClassCastException e) {
    270             signal(new TypeError(obj, Symbol.FIXNUM));
    271             return 0;
    272263        }
    273264    }
     
    323314                          denominator);
    324315        }
    325         if (obj instanceof LispFloat)
    326             return new LispFloat(value + LispFloat.getValue(obj));
     316        if (obj instanceof SingleFloat)
     317            return new SingleFloat(value + ((SingleFloat)obj).value);
     318        if (obj instanceof DoubleFloat)
     319            return new DoubleFloat(value + ((DoubleFloat)obj).value);
    327320        if (obj instanceof Complex) {
    328321            Complex c = (Complex) obj;
     
    354347                denominator);
    355348        }
    356         if (obj instanceof LispFloat)
    357             return new LispFloat(value - LispFloat.getValue(obj));
     349        if (obj instanceof SingleFloat)
     350            return new SingleFloat(value - ((SingleFloat)obj).value);
     351        if (obj instanceof DoubleFloat)
     352            return new DoubleFloat(value - ((DoubleFloat)obj).value);
    358353        if (obj instanceof Complex) {
    359354            Complex c = (Complex) obj;
     
    391386                denominator);
    392387        }
    393         if (obj instanceof LispFloat)
    394             return new LispFloat(value * LispFloat.getValue(obj));
     388        if (obj instanceof SingleFloat)
     389            return new SingleFloat(value * ((SingleFloat)obj).value);
     390        if (obj instanceof DoubleFloat)
     391            return new DoubleFloat(value * ((DoubleFloat)obj).value);
    395392        if (obj instanceof Complex) {
    396393            Complex c = (Complex) obj;
     
    419416                              numerator);
    420417            }
    421             if (obj instanceof LispFloat)
    422                 return new LispFloat(value / LispFloat.getValue(obj));
     418            if (obj instanceof SingleFloat)
     419                return new SingleFloat(value / ((SingleFloat)obj).value);
     420            if (obj instanceof DoubleFloat)
     421                return new DoubleFloat(value / ((DoubleFloat)obj).value);
    423422            if (obj instanceof Complex) {
    424423                Complex c = (Complex) obj;
     
    448447        if (obj instanceof Fixnum)
    449448            return value == ((Fixnum)obj).value;
    450         if (obj instanceof LispFloat)
    451             return (float) value == LispFloat.getValue(obj);
     449        if (obj instanceof SingleFloat)
     450            return isEqualTo(((SingleFloat)obj).rational());
     451        if (obj instanceof DoubleFloat)
     452            return value == ((DoubleFloat)obj).value;
    452453        if (obj instanceof Complex)
    453454            return obj.isEqualTo(this);
     
    469470            return value != ((Fixnum)obj).value;
    470471            // obj is not a fixnum.
    471         if (obj instanceof LispFloat)
    472             return (float) value != LispFloat.getValue(obj);
     472        if (obj instanceof SingleFloat)
     473            return isNotEqualTo(((SingleFloat)obj).rational());
     474        if (obj instanceof DoubleFloat)
     475            return value != ((DoubleFloat)obj).value;
    473476        if (obj instanceof Complex)
    474477            return obj.isNotEqualTo(this);
     
    496499            return n.compareTo(((Ratio)obj).numerator()) < 0;
    497500        }
    498         if (obj instanceof LispFloat)
    499             return isLessThan(((LispFloat)obj).rational());
     501        if (obj instanceof SingleFloat)
     502            return isLessThan(((SingleFloat)obj).rational());
     503        if (obj instanceof DoubleFloat)
     504            return isLessThan(((DoubleFloat)obj).rational());
    500505        signal(new TypeError(obj, Symbol.REAL));
    501506        // Not reached.
     
    519524            return n.compareTo(((Ratio)obj).numerator()) > 0;
    520525        }
    521         if (obj instanceof LispFloat)
    522             return isGreaterThan(((LispFloat)obj).rational());
     526        if (obj instanceof SingleFloat)
     527            return isGreaterThan(((SingleFloat)obj).rational());
     528        if (obj instanceof DoubleFloat)
     529            return isGreaterThan(((DoubleFloat)obj).rational());
    523530        signal(new TypeError(obj, Symbol.REAL));
    524531        // Not reached.
     
    542549            return n.compareTo(((Ratio)obj).numerator()) <= 0;
    543550        }
    544         if (obj instanceof LispFloat)
    545             return isLessThanOrEqualTo(((LispFloat)obj).rational());
     551        if (obj instanceof SingleFloat)
     552            return isLessThanOrEqualTo(((SingleFloat)obj).rational());
     553        if (obj instanceof DoubleFloat)
     554            return isLessThanOrEqualTo(((DoubleFloat)obj).rational());
    546555        signal(new TypeError(obj, Symbol.REAL));
    547556        // Not reached.
     
    565574            return n.compareTo(((Ratio)obj).numerator()) >= 0;
    566575        }
    567         if (obj instanceof LispFloat)
    568             return isGreaterThanOrEqualTo(((LispFloat)obj).rational());
     576        if (obj instanceof SingleFloat)
     577            return isGreaterThanOrEqualTo(((SingleFloat)obj).rational());
     578        if (obj instanceof DoubleFloat)
     579            return isGreaterThanOrEqualTo(((DoubleFloat)obj).rational());
    569580        signal(new TypeError(obj, Symbol.REAL));
    570581        // Not reached.
     
    599610                value1 = quotient;
    600611                value2 = remainder;
    601             } else if (obj instanceof LispFloat) {
     612            } else if (obj instanceof SingleFloat) {
    602613                // "When rationals and floats are combined by a numerical
    603614                // function, the rational is first converted to a float of the
    604615                // same format." 12.1.4.1
    605                 return new LispFloat(value).truncate(obj);
     616                return new SingleFloat(value).truncate(obj);
     617            } else if (obj instanceof DoubleFloat) {
     618                // "When rationals and floats are combined by a numerical
     619                // function, the rational is first converted to a float of the
     620                // same format." 12.1.4.1
     621                return new DoubleFloat(value).truncate(obj);
    606622            } else
    607623                return signal(new TypeError(obj, Symbol.REAL));
  • trunk/j/src/org/armedbear/lisp/FloatFunctions.java

    r8780 r8784  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: FloatFunctions.java,v 1.1 2005-03-15 17:32:04 piso Exp $
     5 * $Id: FloatFunctions.java,v 1.2 2005-03-17 14:45:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3131        public LispObject execute(LispObject arg) throws ConditionThrowable
    3232        {
    33             if (arg instanceof LispFloat) {
     33            if (arg instanceof SingleFloat) {
     34                LispObject[] values = new LispObject[3];
     35                int bits =
     36                    Float.floatToRawIntBits(((SingleFloat)arg).value);
     37                int s = ((bits >> 31) == 0) ? 1 : -1;
     38                int e = (int) ((bits >> 23) & 0xffL);
     39                int m;
     40                if (e == 0)
     41                    m = (bits & 0x7fffff) << 1;
     42                else
     43                    m = (bits & 0x7fffff) | 0x800000;
     44                LispObject significand = number(m);
     45                Fixnum exponent = new Fixnum(e - 150);
     46                Fixnum sign = new Fixnum(s);
     47                return LispThread.currentThread().setValues(significand,
     48                                                            exponent,
     49                                                            sign);
     50            }
     51            if (arg instanceof DoubleFloat) {
    3452                LispObject[] values = new LispObject[3];
    3553                long bits =
    36                     Double.doubleToRawLongBits((double)((LispFloat)arg).value);
     54                    Double.doubleToRawLongBits((double)((DoubleFloat)arg).value);
    3755                int s = ((bits >> 63) == 0) ? 1 : -1;
    3856                int e = (int) ((bits >> 52) & 0x7ffL);
     
    5977        public LispObject execute(LispObject arg) throws ConditionThrowable
    6078        {
    61             if (arg instanceof LispFloat)
    62                 return ((LispFloat)arg).rational();
     79            if (arg instanceof SingleFloat)
     80                return ((SingleFloat)arg).rational();
     81            if (arg instanceof DoubleFloat)
     82                return ((DoubleFloat)arg).rational();
    6383            if (arg.rationalp())
    6484                return arg;
     
    7494        public LispObject execute(LispObject arg) throws ConditionThrowable
    7595        {
    76             if (arg instanceof LispFloat)
     96            if (arg instanceof SingleFloat || arg instanceof DoubleFloat)
    7797                return Fixnum.TWO;
    7898            return signal(new TypeError(arg, Symbol.FLOAT));
     
    80100    };
    81101
     102    private static final Fixnum FIXNUM_24 = new Fixnum(24);
    82103    private static final Fixnum FIXNUM_53 = new Fixnum(53);
    83104
     
    89110        public LispObject execute(LispObject arg) throws ConditionThrowable
    90111        {
    91             if (arg instanceof LispFloat)
     112            if (arg instanceof SingleFloat)
     113                return FIXNUM_24;
     114            if (arg instanceof DoubleFloat)
    92115                return FIXNUM_53;
    93116            return signal(new TypeError(arg, Symbol.FLOAT));
     
    102125            throws ConditionThrowable
    103126        {
    104             double f = LispFloat.getValue(first);
    105             int n = Fixnum.getValue(second);
    106             return new LispFloat(f * Math.pow(2, n));
    107         }
    108     };
    109 
    110     // ### coerce-to-float
    111     private static final Primitive COERCE_TO_FLOAT =
    112         new Primitive("coerce-to-float", PACKAGE_SYS, false)
    113     {
    114         public LispObject execute(LispObject arg) throws ConditionThrowable
    115         {
    116             return LispFloat.coerceToFloat(arg);
     127            if (first instanceof SingleFloat) {
     128                float f = ((SingleFloat)first).value;
     129                int n = Fixnum.getValue(second);
     130                return new SingleFloat(f * (float) Math.pow(2, n));
     131            }
     132            if (first instanceof DoubleFloat) {
     133                double d = ((DoubleFloat)first).value;
     134                int n = Fixnum.getValue(second);
     135                return new DoubleFloat(d * Math.pow(2, n));
     136            }
     137            return signal(new TypeError(first, Symbol.FLOAT));
     138        }
     139    };
     140
     141    // ### coerce-to-single-float
     142    private static final Primitive COERCE_TO_SINGLE_FLOAT =
     143        new Primitive("coerce-to-single-float", PACKAGE_SYS, false)
     144    {
     145        public LispObject execute(LispObject arg) throws ConditionThrowable
     146        {
     147            return SingleFloat.coerceToFloat(arg);
     148        }
     149    };
     150
     151    // ### coerce-to-double-float
     152    private static final Primitive COERCE_TO_DOUBLE_FLOAT =
     153        new Primitive("coerce-to-double-float", PACKAGE_SYS, false)
     154    {
     155        public LispObject execute(LispObject arg) throws ConditionThrowable
     156        {
     157            return DoubleFloat.coerceToFloat(arg);
    117158        }
    118159    };
     
    125166        public LispObject execute(LispObject arg) throws ConditionThrowable
    126167        {
    127             return LispFloat.coerceToFloat(arg);
     168            if (arg instanceof SingleFloat || arg instanceof DoubleFloat)
     169                return arg;
     170            return SingleFloat.coerceToFloat(arg);
    128171        }
    129172        public LispObject execute(LispObject first, LispObject second)
    130173            throws ConditionThrowable
    131174        {
    132             // FIXME Ignore prototype.
    133             return LispFloat.coerceToFloat(first);
     175            if (second instanceof SingleFloat)
     176                return SingleFloat.coerceToFloat(first);
     177            if (second instanceof DoubleFloat)
     178                return DoubleFloat.coerceToFloat(first);
     179            return signal(new TypeError(second, Symbol.FLOAT));
    134180        }
    135181    };
     
    141187        public LispObject execute(LispObject arg) throws ConditionThrowable
    142188        {
    143             return arg instanceof LispFloat ? T : NIL;
     189            if (arg instanceof SingleFloat)
     190                return T;
     191            if (arg instanceof DoubleFloat)
     192                return T;
     193            return NIL;
    144194        }
    145195    };
     
    151201        public LispObject execute(LispObject arg) throws ConditionThrowable
    152202        {
    153             if (arg instanceof LispFloat) {
    154                 LispFloat f = (LispFloat) arg;
     203            if (arg instanceof DoubleFloat) {
     204                DoubleFloat f = (DoubleFloat) arg;
    155205                return number(Double.doubleToLongBits(f.value) >>> 32);
    156206            }
     
    165215        public LispObject execute(LispObject arg) throws ConditionThrowable
    166216        {
    167             if (arg instanceof LispFloat) {
    168                 LispFloat f = (LispFloat) arg;
     217            if (arg instanceof DoubleFloat) {
     218                DoubleFloat f = (DoubleFloat) arg;
    169219                return number(Double.doubleToLongBits(f.value) & 0xffffffffL);
    170220            }
     
    182232            if (arg instanceof Fixnum) {
    183233                long bits = (long) ((Fixnum)arg).value;
    184                 return new LispFloat(Double.longBitsToDouble(bits));
     234                return new DoubleFloat(Double.longBitsToDouble(bits));
    185235            }
    186236            if (arg instanceof Bignum) {
    187237                long bits = ((Bignum)arg).value.longValue();
    188                 return new LispFloat(Double.longBitsToDouble(bits));
     238                return new DoubleFloat(Double.longBitsToDouble(bits));
    189239            }
    190240            return signal(new TypeError());
     
    198248            throws ConditionThrowable
    199249        {
    200             if (arg instanceof LispFloat)
    201                 return Double.isInfinite(((LispFloat)arg).value) ? T : NIL;
     250            if (arg instanceof SingleFloat)
     251                return Float.isInfinite(((SingleFloat)arg).value) ? T : NIL;
     252            if (arg instanceof DoubleFloat)
     253                return Double.isInfinite(((DoubleFloat)arg).value) ? T : NIL;
    202254            return signal(new TypeError(arg, Symbol.FLOAT));
    203255        }
     
    210262            throws ConditionThrowable
    211263        {
    212             if (arg instanceof LispFloat)
    213                 return Double.isNaN(((LispFloat)arg).value) ? T : NIL;
     264            if (arg instanceof SingleFloat)
     265                return Float.isNaN(((SingleFloat)arg).value) ? T : NIL;
     266            if (arg instanceof DoubleFloat)
     267                return Double.isNaN(((DoubleFloat)arg).value) ? T : NIL;
     268            return signal(new TypeError(arg, Symbol.FLOAT));
     269        }
     270    };
     271
     272    private static final Primitive FLOAT_STRING =
     273        new Primitive("float-string", PACKAGE_SYS, true)
     274    {
     275        public LispObject execute(LispObject arg) throws ConditionThrowable
     276        {
     277            if (arg instanceof SingleFloat) {
     278                String s1 = String.valueOf(((SingleFloat)arg).value);
     279                String s2 = s1.replace('E', 'f');
     280                if (s1 != s2 || _PRINT_READABLY_.symbolValue() == NIL)
     281                    return new SimpleString(s2);
     282                return new SimpleString(s2.concat("f0"));
     283            }
     284            if (arg instanceof DoubleFloat) {
     285                String s1 = String.valueOf(((DoubleFloat)arg).value);
     286                String s2 = s1.replace('E', 'd');
     287                if (s1 != s2 || _PRINT_READABLY_.symbolValue() == NIL)
     288                    return new SimpleString(s2);
     289                return new SimpleString(s2.concat("d0"));
     290            }
    214291            return signal(new TypeError(arg, Symbol.FLOAT));
    215292        }
  • trunk/j/src/org/armedbear/lisp/Java.java

    r8671 r8784  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Java.java,v 1.49 2005-03-01 13:09:18 asimon Exp $
     5 * $Id: Java.java,v 1.50 2005-03-17 14:50:59 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    664664            return new Bignum(((Long)obj).longValue());
    665665        if (obj instanceof Double || obj instanceof Float)
    666             return new LispFloat(((Number)obj).doubleValue());
     666            return new DoubleFloat(((Number)obj).doubleValue());
    667667        if (obj instanceof String)
    668668            return new SimpleString((String)obj);
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r8773 r8784  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Lisp.java,v 1.326 2005-03-14 20:23:24 piso Exp $
     5 * $Id: Lisp.java,v 1.327 2005-03-17 14:51:59 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    16391639    // ### *read-default-float-format*
    16401640    public static final Symbol _READ_DEFAULT_FLOAT_FORMAT_ =
    1641         exportSpecial("*READ-DEFAULT-FLOAT-FORMAT*", PACKAGE_CL, Symbol.DOUBLE_FLOAT);
     1641        exportSpecial("*READ-DEFAULT-FLOAT-FORMAT*", PACKAGE_CL, Symbol.SINGLE_FLOAT);
    16421642
    16431643    // Printer control variables.
     
    17251725
    17261726    public static final Symbol PI =
    1727         exportConstant("PI", PACKAGE_CL, LispFloat.PI);
     1727        exportConstant("PI", PACKAGE_CL, DoubleFloat.PI);
    17281728
    17291729    public static final Symbol SHORT_FLOAT_EPSILON =
    17301730        exportConstant("SHORT-FLOAT-EPSILON", PACKAGE_CL,
    1731                        new LispFloat((double)1.1102230246251568E-16));
     1731                       new SingleFloat((float)5.960465E-8));
    17321732
    17331733    public static final Symbol SINGLE_FLOAT_EPSILON =
    17341734        exportConstant("SINGLE-FLOAT-EPSILON", PACKAGE_CL,
    1735                        new LispFloat((double)1.1102230246251568E-16));
     1735                       new SingleFloat((float)5.960465E-8));
    17361736
    17371737    public static final Symbol DOUBLE_FLOAT_EPSILON =
    17381738        exportConstant("DOUBLE-FLOAT-EPSILON", PACKAGE_CL,
    1739                        new LispFloat((double)1.1102230246251568E-16));
     1739                       new DoubleFloat((double)1.1102230246251568E-16));
    17401740
    17411741    public static final Symbol LONG_FLOAT_EPSILON =
    17421742        exportConstant("LONG-FLOAT-EPSILON", PACKAGE_CL,
    1743                        new LispFloat((double)1.1102230246251568E-16));
     1743                       new DoubleFloat((double)1.1102230246251568E-16));
    17441744
    17451745    public static final Symbol SHORT_FLOAT_NEGATIVE_EPSILON =
    17461746        exportConstant("SHORT-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL,
    1747                        new LispFloat((double)5.551115123125784E-17));
     1747                       new SingleFloat(2.9802326e-8f));
    17481748
    17491749    public static final Symbol SINGLE_FLOAT_NEGATIVE_EPSILON =
    17501750        exportConstant("SINGLE-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL,
    1751                        new LispFloat((double)5.551115123125784E-17));
     1751                       new SingleFloat(2.9802326e-8f));
    17521752
    17531753    public static final Symbol DOUBLE_FLOAT_NEGATIVE_EPSILON =
    17541754        exportConstant("DOUBLE-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL,
    1755                        new LispFloat((double)5.551115123125784E-17));
     1755                       new DoubleFloat((double)5.551115123125784E-17));
    17561756
    17571757    public static final Symbol LONG_FLOAT_NEGATIVE_EPSILON =
    17581758        exportConstant("LONG-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL,
    1759                        new LispFloat((double)5.551115123125784E-17));
     1759                       new DoubleFloat((double)5.551115123125784E-17));
    17601760
    17611761    public static final Symbol MOST_POSITIVE_SHORT_FLOAT =
    17621762        exportConstant("MOST-POSITIVE-SHORT-FLOAT", PACKAGE_CL,
    1763                        new LispFloat(Double.MAX_VALUE));
     1763                       new SingleFloat(Float.MAX_VALUE));
    17641764
    17651765    public static final Symbol MOST_POSITIVE_SINGLE_FLOAT =
    17661766        exportConstant("MOST-POSITIVE-SINGLE-FLOAT", PACKAGE_CL,
    1767                        new LispFloat(Double.MAX_VALUE));
     1767                       new SingleFloat(Float.MAX_VALUE));
    17681768
    17691769    public static final Symbol MOST_POSITIVE_DOUBLE_FLOAT =
    17701770        exportConstant("MOST-POSITIVE-DOUBLE-FLOAT", PACKAGE_CL,
    1771                        new LispFloat(Double.MAX_VALUE));
     1771                       new DoubleFloat(Double.MAX_VALUE));
    17721772
    17731773    public static final Symbol MOST_POSITIVE_LONG_FLOAT =
    17741774        exportConstant("MOST-POSITIVE-LONG-FLOAT", PACKAGE_CL,
    1775                        new LispFloat(Double.MAX_VALUE));
     1775                       new DoubleFloat(Double.MAX_VALUE));
    17761776
    17771777    public static final Symbol LEAST_POSITIVE_SHORT_FLOAT =
    17781778        exportConstant("LEAST-POSITIVE-SHORT-FLOAT", PACKAGE_CL,
    1779                        new LispFloat(Double.MIN_VALUE));
     1779                       new SingleFloat(Float.MIN_VALUE));
    17801780
    17811781    public static final Symbol LEAST_POSITIVE_SINGLE_FLOAT =
    17821782        exportConstant("LEAST-POSITIVE-SINGLE-FLOAT", PACKAGE_CL,
    1783                        new LispFloat(Double.MIN_VALUE));
     1783                       new SingleFloat(Float.MIN_VALUE));
    17841784
    17851785    public static final Symbol LEAST_POSITIVE_DOUBLE_FLOAT =
    17861786        exportConstant("LEAST-POSITIVE-DOUBLE-FLOAT", PACKAGE_CL,
    1787                        new LispFloat(Double.MIN_VALUE));
     1787                       new DoubleFloat(Double.MIN_VALUE));
    17881788
    17891789    public static final Symbol LEAST_POSITIVE_LONG_FLOAT =
    17901790        exportConstant("LEAST-POSITIVE-LONG-FLOAT", PACKAGE_CL,
    1791                        new LispFloat(Double.MIN_VALUE));
     1791                       new DoubleFloat(Double.MIN_VALUE));
    17921792
    17931793    public static final Symbol LEAST_POSITIVE_NORMALIZED_SHORT_FLOAT =
    17941794        exportConstant("LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT", PACKAGE_CL,
    1795                        new LispFloat(Double.MIN_VALUE));
     1795                       new SingleFloat(1.17549435e-38f));
    17961796
    17971797    public static final Symbol LEAST_POSITIVE_NORMALIZED_SINGLE_FLOAT =
    17981798        exportConstant("LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT", PACKAGE_CL,
    1799                        new LispFloat(Double.MIN_VALUE));
     1799                       new SingleFloat(1.17549435e-38f));
    18001800
    18011801    public static final Symbol LEAST_POSITIVE_NORMALIZED_DOUBLE_FLOAT =
    18021802        exportConstant("LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT", PACKAGE_CL,
    1803                        new LispFloat(Double.MIN_VALUE));
     1803                       new DoubleFloat(2.2250738585072014e-308d));
    18041804
    18051805    public static final Symbol LEAST_POSITIVE_NORMALIZED_LONG_FLOAT =
    18061806        exportConstant("LEAST-POSITIVE-NORMALIZED-LONG-FLOAT", PACKAGE_CL,
    1807                        new LispFloat(Double.MIN_VALUE));
     1807                       new DoubleFloat(2.2250738585072014e-308d));
    18081808
    18091809    public static final Symbol MOST_NEGATIVE_SHORT_FLOAT =
    18101810        exportConstant("MOST-NEGATIVE-SHORT-FLOAT", PACKAGE_CL,
    1811                        new LispFloat(- Double.MAX_VALUE));
     1811                       new SingleFloat(- Float.MAX_VALUE));
    18121812
    18131813    public static final Symbol MOST_NEGATIVE_SINGLE_FLOAT =
    18141814        exportConstant("MOST-NEGATIVE-SINGLE-FLOAT", PACKAGE_CL,
    1815                        new LispFloat(- Double.MAX_VALUE));
     1815                       new SingleFloat(- Float.MAX_VALUE));
    18161816
    18171817    public static final Symbol MOST_NEGATIVE_DOUBLE_FLOAT =
    18181818        exportConstant("MOST-NEGATIVE-DOUBLE-FLOAT", PACKAGE_CL,
    1819                        new LispFloat(- Double.MAX_VALUE));
     1819                       new DoubleFloat(- Double.MAX_VALUE));
    18201820
    18211821    public static final Symbol MOST_NEGATIVE_LONG_FLOAT =
    18221822        exportConstant("MOST-NEGATIVE-LONG-FLOAT", PACKAGE_CL,
    1823                        new LispFloat(- Double.MAX_VALUE));
     1823                       new DoubleFloat(- Double.MAX_VALUE));
    18241824
    18251825    public static final Symbol LEAST_NEGATIVE_SHORT_FLOAT =
    18261826        exportConstant("LEAST-NEGATIVE-SHORT-FLOAT", PACKAGE_CL,
    1827                        new LispFloat(- Double.MIN_VALUE));
     1827                       new SingleFloat(- Float.MIN_VALUE));
    18281828
    18291829    public static final Symbol LEAST_NEGATIVE_SINGLE_FLOAT =
    18301830        exportConstant("LEAST-NEGATIVE-SINGLE-FLOAT", PACKAGE_CL,
    1831                        new LispFloat(- Double.MIN_VALUE));
     1831                       new SingleFloat(- Float.MIN_VALUE));
    18321832
    18331833    public static final Symbol LEAST_NEGATIVE_DOUBLE_FLOAT =
    18341834        exportConstant("LEAST-NEGATIVE-DOUBLE-FLOAT", PACKAGE_CL,
    1835                        new LispFloat(- Double.MIN_VALUE));
     1835                       new DoubleFloat(- Double.MIN_VALUE));
    18361836
    18371837    public static final Symbol LEAST_NEGATIVE_LONG_FLOAT =
    18381838        exportConstant("LEAST-NEGATIVE-LONG-FLOAT", PACKAGE_CL,
    1839                        new LispFloat(- Double.MIN_VALUE));
     1839                       new DoubleFloat(- Double.MIN_VALUE));
    18401840
    18411841    public static final Symbol LEAST_NEGATIVE_NORMALIZED_SHORT_FLOAT =
    18421842        exportConstant("LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT", PACKAGE_CL,
    1843                        new LispFloat(- Double.MIN_VALUE));
     1843                       new SingleFloat(-1.17549435e-38f));
    18441844
    18451845    public static final Symbol LEAST_NEGATIVE_NORMALIZED_SINGLE_FLOAT =
    18461846        exportConstant("LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT", PACKAGE_CL,
    1847                        new LispFloat(- Double.MIN_VALUE));
     1847                       new SingleFloat(-1.17549435e-38f));
    18481848
    18491849    public static final Symbol LEAST_NEGATIVE_NORMALIZED_DOUBLE_FLOAT =
    18501850        exportConstant("LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT", PACKAGE_CL,
    1851                        new LispFloat(- Double.MIN_VALUE));
     1851                       new DoubleFloat(-2.2250738585072014e-308d));
    18521852
    18531853    public static final Symbol LEAST_NEGATIVE_NORMALIZED_LONG_FLOAT =
    18541854        exportConstant("LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT", PACKAGE_CL,
    1855                        new LispFloat(- Double.MIN_VALUE));
     1855                       new DoubleFloat(-2.2250738585072014e-308d));
    18561856
    18571857    public static final Symbol BOOLE_CLR =
  • trunk/j/src/org/armedbear/lisp/LispThread.java

    r8660 r8784  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: LispThread.java,v 1.76 2005-02-28 02:50:03 piso Exp $
     5 * $Id: LispThread.java,v 1.77 2005-03-17 14:52:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    870870        {
    871871            double d =
    872                 ((LispFloat)arg.multiplyBy(new LispFloat(1000))).getValue();
     872                ((DoubleFloat)arg.multiplyBy(new DoubleFloat(1000))).getValue();
    873873            if (d < 0)
    874874                return signal(new TypeError(arg, "non-negative real"));
  • trunk/j/src/org/armedbear/lisp/Makefile.in

    r8781 r8784  
    22
    33# Copyright (C) 2003-2005 Peter Graves
    4 # $Id: Makefile.in,v 1.199 2005-03-15 17:33:22 piso Exp $
     4# $Id: Makefile.in,v 1.200 2005-03-17 14:53:14 piso Exp $
    55
    66# This program is free software; you can redistribute it and/or
     
    6363    DivisionByZero.class \
    6464    Do.class \
     65    DoubleFloat.class \
    6566    DowncaseStream.class \
    6667    EchoStream.class \
     
    102103    LispClass.class \
    103104    LispError.class \
    104     LispFloat.class \
    105105    LispObject.class \
    106106    LispReader.class \
     
    145145    SimpleVector.class \
    146146    SimpleWarning.class \
     147    SingleFloat.class \
    147148    Site.class \
    148149    SiteName.class \
  • trunk/j/src/org/armedbear/lisp/MathFunctions.java

    r8087 r8784  
    22 * Math.java
    33 *
    4  * Copyright (C) 2004 Peter Graves
    5  * $Id: MathFunctions.java,v 1.16 2004-11-03 15:39:01 piso Exp $
     4 * Copyright (C) 2004-2005 Peter Graves
     5 * $Id: MathFunctions.java,v 1.17 2005-03-17 14:54:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4343    private static LispObject sin(LispObject arg) throws ConditionThrowable
    4444    {
     45        if (arg instanceof DoubleFloat)
     46            return new DoubleFloat(Math.sin(((DoubleFloat)arg).value));
    4547        if (arg.realp())
    46             return new LispFloat(Math.sin(LispFloat.coerceToFloat(arg).getValue()));
     48            return new SingleFloat((float)Math.sin(SingleFloat.coerceToFloat(arg).value));
    4749        if (arg instanceof Complex) {
    4850            LispObject n = arg.multiplyBy(Complex.getInstance(Fixnum.ZERO,
     
    6769    private static LispObject cos(LispObject arg) throws ConditionThrowable
    6870    {
     71        if (arg instanceof DoubleFloat)
     72            return new DoubleFloat(Math.cos(((DoubleFloat)arg).value));
    6973        if (arg.realp())
    70             return new LispFloat(Math.cos(LispFloat.coerceToFloat(arg).getValue()));
     74            return new SingleFloat((float)Math.cos(SingleFloat.coerceToFloat(arg).value));
    7175        if (arg instanceof Complex) {
    7276            LispObject n = arg.multiplyBy(Complex.getInstance(Fixnum.ZERO,
     
    8488        public LispObject execute(LispObject arg) throws ConditionThrowable
    8589        {
     90            if (arg instanceof DoubleFloat)
     91                return new DoubleFloat(Math.tan(((DoubleFloat)arg).value));
    8692            if (arg.realp())
    87                 return new LispFloat(Math.tan(LispFloat.coerceToFloat(arg).value));
     93                return new SingleFloat((float)Math.tan(SingleFloat.coerceToFloat(arg).value));
    8894            return sin(arg).divideBy(cos(arg));
    8995        }
     
    101107    private static LispObject asin(LispObject arg) throws ConditionThrowable
    102108    {
    103         if (arg instanceof LispFloat) {
    104             double d = ((LispFloat)arg).value;
    105             if (Math.abs(d) < 1)
    106                 return new LispFloat(Math.asin(d));
     109        if (arg instanceof SingleFloat) {
     110            float f = ((SingleFloat)arg).value;
     111            if (Math.abs(f) <= 1)
     112                return new SingleFloat((float)Math.asin(f));
     113        }
     114        if (arg instanceof DoubleFloat) {
     115            double d = ((DoubleFloat)arg).value;
     116            if (Math.abs(d) <= 1)
     117                return new DoubleFloat(Math.asin(d));
    107118        }
    108119        LispObject result = arg.multiplyBy(arg);
     
    136147    private static LispObject acos(LispObject arg) throws ConditionThrowable
    137148    {
    138         if (arg instanceof LispFloat) {
    139             double d = ((LispFloat)arg).value;
    140             if (Math.abs(d) < 1)
    141                 return new LispFloat(Math.acos(d));
    142         }
    143         LispObject result = LispFloat.PI.divideBy(Fixnum.TWO);
     149        if (arg instanceof DoubleFloat) {
     150            double d = ((DoubleFloat)arg).value;
     151            if (Math.abs(d) <= 1)
     152                return new DoubleFloat(Math.acos(d));
     153        }
     154        if (arg instanceof SingleFloat) {
     155            float f = ((SingleFloat)arg).value;
     156            if (Math.abs(f) <= 1)
     157                return new SingleFloat((float)Math.acos(f));
     158        }
     159        LispObject result = DoubleFloat.PI.divideBy(Fixnum.TWO);
     160        if (!(arg instanceof DoubleFloat))
     161            result = new SingleFloat((float)((DoubleFloat)result).value);
    144162        result = result.subtract(asin(arg));
    145163        if (result instanceof Complex) {
     
    188206            return result;
    189207        }
    190         return new LispFloat(Math.atan(LispFloat.coerceToFloat(arg).getValue()));
     208        if (arg instanceof DoubleFloat)
     209            return new DoubleFloat(Math.atan(((DoubleFloat)arg).value));
     210        return new SingleFloat((float)Math.atan(SingleFloat.coerceToFloat(arg).value));
    191211    }
    192212
     
    210230                                           im);
    211231        }
    212         if (isJava15 && arg instanceof LispFloat) {
    213             try {
    214                 if (sinhMethod == null) {
    215                     Class c = Class.forName("java.lang.Math");
    216                     Class[] parameterTypes = new Class[1];
    217                     parameterTypes[0] = Double.TYPE;
    218                     sinhMethod = c.getMethod("sinh", parameterTypes);
    219                 }
    220                 if (sinhMethod != null) {
    221                     Object[] args;
    222                     args = new Object[1];
    223                     args[0] = new Double(((LispFloat)arg).value);
    224                     Double d = (Double) sinhMethod.invoke(null, args);
    225                     return new LispFloat(d.doubleValue());
    226                 }
    227             }
    228             catch (Throwable t) {
    229                 Debug.trace(t);
    230                 // Fall through...
     232        if (isJava15) {
     233            if (arg instanceof SingleFloat) {
     234                try {
     235                    if (sinhMethod == null) {
     236                        Class c = Class.forName("java.lang.Math");
     237                        Class[] parameterTypes = new Class[1];
     238                        parameterTypes[0] = Double.TYPE;
     239                        sinhMethod = c.getMethod("sinh", parameterTypes);
     240                    }
     241                    if (sinhMethod != null) {
     242                        Object[] args;
     243                        args = new Object[1];
     244                        args[0] = new Double(((DoubleFloat)arg).value);
     245                        Double d = (Double) sinhMethod.invoke(null, args);
     246                        return new SingleFloat((float)d.doubleValue());
     247                    }
     248                }
     249                catch (Throwable t) {
     250                    Debug.trace(t);
     251                    // Fall through...
     252                }
     253            } else if (arg instanceof DoubleFloat) {
     254                try {
     255                    if (sinhMethod == null) {
     256                        Class c = Class.forName("java.lang.Math");
     257                        Class[] parameterTypes = new Class[1];
     258                        parameterTypes[0] = Double.TYPE;
     259                        sinhMethod = c.getMethod("sinh", parameterTypes);
     260                    }
     261                    if (sinhMethod != null) {
     262                        Object[] args;
     263                        args = new Object[1];
     264                        args[0] = new Double(((DoubleFloat)arg).value);
     265                        Double d = (Double) sinhMethod.invoke(null, args);
     266                        return new DoubleFloat(d.doubleValue());
     267                    }
     268                }
     269                catch (Throwable t) {
     270                    Debug.trace(t);
     271                    // Fall through...
     272                }
    231273            }
    232274        }
     
    263305                                           im);
    264306        }
    265         if (isJava15 && arg instanceof LispFloat) {
    266             try {
    267                 if (coshMethod == null) {
    268                     Class c = Class.forName("java.lang.Math");
    269                     Class[] parameterTypes = new Class[1];
    270                     parameterTypes[0] = Double.TYPE;
    271                     coshMethod = c.getMethod("cosh", parameterTypes);
    272                 }
    273                 if (coshMethod != null) {
    274                     Object[] args;
    275                     args = new Object[1];
    276                     args[0] = new Double(((LispFloat)arg).value);
    277                     Double d = (Double) coshMethod.invoke(null, args);
    278                     return new LispFloat(d.doubleValue());
    279                 }
    280             }
    281             catch (Throwable t) {
    282                 Debug.trace(t);
    283                 // Fall through...
     307        if (isJava15) {
     308            if (arg instanceof SingleFloat) {
     309                try {
     310                    if (coshMethod == null) {
     311                        Class c = Class.forName("java.lang.Math");
     312                        Class[] parameterTypes = new Class[1];
     313                        parameterTypes[0] = Double.TYPE;
     314                        coshMethod = c.getMethod("cosh", parameterTypes);
     315                    }
     316                    if (coshMethod != null) {
     317                        Object[] args;
     318                        args = new Object[1];
     319                        args[0] = new Double(((DoubleFloat)arg).value);
     320                        Double d = (Double) coshMethod.invoke(null, args);
     321                        return new SingleFloat((float)d.doubleValue());
     322                    }
     323                }
     324                catch (Throwable t) {
     325                    Debug.trace(t);
     326                    // Fall through...
     327                }
     328            } else if (arg instanceof DoubleFloat) {
     329                try {
     330                    if (coshMethod == null) {
     331                        Class c = Class.forName("java.lang.Math");
     332                        Class[] parameterTypes = new Class[1];
     333                        parameterTypes[0] = Double.TYPE;
     334                        coshMethod = c.getMethod("cosh", parameterTypes);
     335                    }
     336                    if (coshMethod != null) {
     337                        Object[] args;
     338                        args = new Object[1];
     339                        args[0] = new Double(((DoubleFloat)arg).value);
     340                        Double d = (Double) coshMethod.invoke(null, args);
     341                        return new DoubleFloat(d.doubleValue());
     342                    }
     343                }
     344                catch (Throwable t) {
     345                    Debug.trace(t);
     346                    // Fall through...
     347                }
    284348            }
    285349        }
     
    304368        public LispObject execute(LispObject arg) throws ConditionThrowable
    305369        {
    306             if (isJava15 && arg instanceof LispFloat) {
    307                 try {
    308                     if (tanhMethod == null) {
    309                         Class c = Class.forName("java.lang.Math");
    310                         Class[] parameterTypes = new Class[1];
    311                         parameterTypes[0] = Double.TYPE;
    312                         tanhMethod = c.getMethod("tanh", parameterTypes);
    313                     }
    314                     if (tanhMethod != null) {
    315                         Object[] args;
    316                         args = new Object[1];
    317                         args[0] = new Double(((LispFloat)arg).value);
    318                         Double d = (Double) tanhMethod.invoke(null, args);
    319                         return new LispFloat(d.doubleValue());
    320                     }
    321                 }
    322                 catch (Throwable t) {
    323                     Debug.trace(t);
    324                     // Fall through...
     370            if (isJava15) {
     371                if (arg instanceof SingleFloat) {
     372                    try {
     373                        if (tanhMethod == null) {
     374                            Class c = Class.forName("java.lang.Math");
     375                            Class[] parameterTypes = new Class[1];
     376                            parameterTypes[0] = Double.TYPE;
     377                            tanhMethod = c.getMethod("tanh", parameterTypes);
     378                        }
     379                        if (tanhMethod != null) {
     380                            Object[] args;
     381                            args = new Object[1];
     382                            args[0] = new Double(((DoubleFloat)arg).value);
     383                            Double d = (Double) tanhMethod.invoke(null, args);
     384                            return new SingleFloat((float)d.doubleValue());
     385                        }
     386                    }
     387                    catch (Throwable t) {
     388                        Debug.trace(t);
     389                        // Fall through...
     390                    }
     391                } else if (arg instanceof DoubleFloat) {
     392                    try {
     393                        if (tanhMethod == null) {
     394                            Class c = Class.forName("java.lang.Math");
     395                            Class[] parameterTypes = new Class[1];
     396                            parameterTypes[0] = Double.TYPE;
     397                            tanhMethod = c.getMethod("tanh", parameterTypes);
     398                        }
     399                        if (tanhMethod != null) {
     400                            Object[] args;
     401                            args = new Object[1];
     402                            args[0] = new Double(((DoubleFloat)arg).value);
     403                            Double d = (Double) tanhMethod.invoke(null, args);
     404                            return new DoubleFloat(d.doubleValue());
     405                        }
     406                    }
     407                    catch (Throwable t) {
     408                        Debug.trace(t);
     409                        // Fall through...
     410                    }
    325411                }
    326412            }
     
    455541    private static LispObject exp(LispObject arg) throws ConditionThrowable
    456542    {
    457         if (arg instanceof LispFloat) {
    458             return new LispFloat(Math.pow(Math.E, ((LispFloat)arg).value));
    459         }
     543        if (arg instanceof DoubleFloat)
     544            return new DoubleFloat(Math.pow(Math.E, ((DoubleFloat)arg).value));
    460545        if (arg.realp())
    461             return new LispFloat(Math.pow(Math.E, LispFloat.coerceToFloat(arg).value));
     546            return new SingleFloat((float)Math.pow(Math.E, SingleFloat.coerceToFloat(arg).value));
    462547        if (arg instanceof Complex) {
    463548            Complex c = (Complex) arg;
     
    478563    private static final LispObject sqrt(LispObject obj) throws ConditionThrowable
    479564    {
     565        if (obj instanceof DoubleFloat) {
     566            if (obj.minusp())
     567                return Complex.getInstance(new DoubleFloat(0),
     568                                           sqrt(Fixnum.ZERO.subtract(obj)));
     569            return new DoubleFloat(Math.sqrt(DoubleFloat.coerceToFloat(obj).value));
     570        }
    480571        if (obj.realp()) {
    481572            if (obj.minusp())
    482                 return Complex.getInstance(new LispFloat(0),
     573                return Complex.getInstance(new SingleFloat(0),
    483574                                           sqrt(Fixnum.ZERO.subtract(obj)));
    484             return new LispFloat(Math.sqrt(LispFloat.coerceToFloat(obj).getValue()));
     575            return new SingleFloat((float)Math.sqrt(SingleFloat.coerceToFloat(obj).value));
    485576        }
    486577        if (obj instanceof Complex)
     
    490581
    491582    // ### log
    492     private static final Primitive LOG = new Primitive("log", "number &optional base")
     583    private static final Primitive LOG =
     584        new Primitive("log", "number &optional base")
    493585    {
    494586        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    507599        if (obj.realp() && !obj.minusp()) {  // real value
    508600            if (obj instanceof Fixnum)
    509                 return new LispFloat(Math.log(((Fixnum)obj).getValue()));
     601                return new SingleFloat((float)Math.log(((Fixnum)obj).value));
    510602            if (obj instanceof Bignum)
    511                 return new LispFloat(Math.log(((Bignum)obj).floatValue()));
     603                return new SingleFloat((float)Math.log(((Bignum)obj).doubleValue()));
    512604            if (obj instanceof Ratio)
    513                 return new LispFloat(Math.log(((Ratio)obj).floatValue()));
    514             if (obj instanceof LispFloat)
    515                 return new LispFloat(Math.log(((LispFloat)obj).getValue()));
     605                return new SingleFloat((float)Math.log(((Ratio)obj).doubleValue()));
     606            if (obj instanceof SingleFloat)
     607                return new SingleFloat((float)Math.log(((SingleFloat)obj).value));
     608            if (obj instanceof DoubleFloat)
     609                return new DoubleFloat(Math.log(((DoubleFloat)obj).value));
    516610        } else { // returning Complex
    517             LispFloat re, im, phase, abs;
    518611            if (obj.realp() && obj.minusp()) {
    519                 re = LispFloat.coerceToFloat(obj);
    520                 abs = new LispFloat(Math.abs(re.getValue()));
    521                 phase = new LispFloat(Math.PI);
    522                 return Complex.getInstance(new LispFloat(Math.log(abs.getValue())), phase);
     612                if (obj instanceof DoubleFloat) {
     613                    DoubleFloat re = DoubleFloat.coerceToFloat(obj);
     614                    DoubleFloat abs = new DoubleFloat(Math.abs(re.value));
     615                    DoubleFloat phase = new DoubleFloat(Math.PI);
     616                    return Complex.getInstance(new DoubleFloat(Math.log(abs.getValue())), phase);
     617                } else {
     618                    SingleFloat re = SingleFloat.coerceToFloat(obj);
     619                    SingleFloat abs = new SingleFloat(Math.abs(re.value));
     620                    SingleFloat phase = new SingleFloat((float)Math.PI);
     621                    return Complex.getInstance(new SingleFloat((float)Math.log(abs.value)), phase);
     622                }
    523623            } else if (obj instanceof Complex) {
    524                 re = LispFloat.coerceToFloat(((Complex)obj).getRealPart());
    525                 im = LispFloat.coerceToFloat(((Complex)obj).getImaginaryPart());
    526                 phase = new LispFloat(Math.atan2(im.getValue(), re.getValue()));  // atan(y/x)
    527                 abs = (LispFloat)((Complex)obj).ABS();
    528                 return Complex.getInstance(new LispFloat(Math.log(abs.getValue())), phase);
    529             }
    530         }
    531         signal(new TypeError(obj, "number"));
     624                if (((Complex)obj).getRealPart() instanceof DoubleFloat) {
     625                    DoubleFloat re = DoubleFloat.coerceToFloat(((Complex)obj).getRealPart());
     626                    DoubleFloat im = DoubleFloat.coerceToFloat(((Complex)obj).getImaginaryPart());
     627                    DoubleFloat phase =
     628                        new DoubleFloat(Math.atan2(im.getValue(), re.getValue()));  // atan(y/x)
     629                    DoubleFloat abs = (DoubleFloat)((Complex)obj).ABS();
     630                    return Complex.getInstance(new DoubleFloat(Math.log(abs.getValue())), phase);
     631                } else {
     632                    SingleFloat re = SingleFloat.coerceToFloat(((Complex)obj).getRealPart());
     633                    SingleFloat im = SingleFloat.coerceToFloat(((Complex)obj).getImaginaryPart());
     634                    SingleFloat phase =
     635                        new SingleFloat((float)Math.atan2(im.value, re.value));  // atan(y/x)
     636                    SingleFloat abs = (SingleFloat)((Complex)obj).ABS();
     637                    return Complex.getInstance(new SingleFloat((float)Math.log(abs.value)), phase);
     638                }
     639            }
     640        }
     641        signal(new TypeError(obj, Symbol.NUMBER));
    532642        return NIL;
    533643    }
     
    543653            if (power.zerop()) {
    544654                if (power instanceof Fixnum) {
    545                     if (base instanceof LispFloat)
    546                         return LispFloat.ONE;
     655                    if (base instanceof SingleFloat)
     656                        return SingleFloat.ONE;
     657                    if (base instanceof DoubleFloat)
     658                        return DoubleFloat.ONE;
    547659                    if (base instanceof Complex) {
    548                         if (((Complex)base).getRealPart() instanceof LispFloat)
    549                             return Complex.getInstance(LispFloat.ONE,
    550                                                        LispFloat.ZERO);
     660                        if (((Complex)base).getRealPart() instanceof SingleFloat)
     661                            return Complex.getInstance(SingleFloat.ONE,
     662                                                       SingleFloat.ZERO);
     663                        if (((Complex)base).getRealPart() instanceof DoubleFloat)
     664                            return Complex.getInstance(DoubleFloat.ONE,
     665                                                       DoubleFloat.ZERO);
    551666                    }
    552667                    return Fixnum.ONE;
    553668                }
    554                 if (power instanceof LispFloat) {
    555                     return LispFloat.ONE;
    556                 }
     669                if (power instanceof DoubleFloat)
     670                    return DoubleFloat.ONE;
     671                if (base instanceof DoubleFloat)
     672                    return DoubleFloat.ONE;
     673                return SingleFloat.ONE;
    557674            }
    558675            if (power instanceof Fixnum) {
     
    560677                    return intexp(base, power);
    561678                LispObject result;
    562                 if (base instanceof LispFloat)
    563                     result = LispFloat.ONE;
     679                if (base instanceof SingleFloat)
     680                    result = SingleFloat.ONE;
     681                else if (base instanceof DoubleFloat)
     682                    result = DoubleFloat.ONE;
    564683                else
    565684                    result = Fixnum.ONE;
     
    585704                x = ((Fixnum)base).value;
    586705            else if (base instanceof Ratio)
    587                 x = ((Ratio)base).floatValue();
    588             else if (base instanceof LispFloat)
    589                 x = ((LispFloat)base).value;
     706                x = ((Ratio)base).doubleValue();
     707            else if (base instanceof SingleFloat)
     708                x = ((SingleFloat)base).value;
     709            else if (base instanceof DoubleFloat)
     710                x = ((DoubleFloat)base).value;
    590711            else
    591712                return signal(new LispError("EXPT: unsupported case"));
    592713            if (power instanceof Ratio)
    593                 y = ((Ratio)power).floatValue();
    594             else if (power instanceof LispFloat)
    595                 y = ((LispFloat)power).value;
     714                y = ((Ratio)power).doubleValue();
     715            else if (power instanceof SingleFloat)
     716                y = ((SingleFloat)power).value;
     717            else if (power instanceof DoubleFloat)
     718                y = ((DoubleFloat)power).value;
    596719            else
    597720                return signal(new LispError("EXPT: unsupported case"));
    598721            double r = Math.pow(x, y);
    599             if (!Double.isNaN(r))
    600                 return new LispFloat(r);
     722            if (!Double.isNaN(r)) {
     723                if (base instanceof DoubleFloat || power instanceof DoubleFloat)
     724                    return new DoubleFloat(r);
     725                else
     726                    return new SingleFloat((float)r);
     727            }
    601728            if (x < 0) {
    602729                r = Math.pow(-x, y);
    603730                double realPart = r * Math.cos(y * Math.PI);
    604731                double imagPart = r * Math.sin(y * Math.PI);
    605                 return Complex.getInstance(new LispFloat(realPart),
    606                                            new LispFloat(imagPart));
     732                if (base instanceof DoubleFloat || power instanceof DoubleFloat)
     733                    return Complex.getInstance(new DoubleFloat(realPart),
     734                                               new DoubleFloat(imagPart));
     735                else
     736                    return Complex.getInstance(new SingleFloat((float)realPart),
     737                                               new SingleFloat((float)imagPart));
    607738            }
    608739            return signal(new LispError("EXPT: unsupported case"));
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r8774 r8784  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Primitives.java,v 1.742 2005-03-14 20:24:37 piso Exp $
     5 * $Id: Primitives.java,v 1.743 2005-03-17 14:55:00 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    45794579        public LispObject execute(LispObject arg) throws ConditionThrowable
    45804580        {
    4581             if (arg instanceof LispFloat)
    4582                 return Complex.getInstance(arg, LispFloat.ZERO);
     4581            if (arg instanceof SingleFloat)
     4582                return Complex.getInstance(arg, SingleFloat.ZERO);
     4583            if (arg instanceof DoubleFloat)
     4584                return Complex.getInstance(arg, DoubleFloat.ZERO);
    45834585            if (arg.realp())
    45844586                return arg;
  • trunk/j/src/org/armedbear/lisp/RandomState.java

    r8087 r8784  
    22 * RandomState.java
    33 *
    4  * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: RandomState.java,v 1.4 2004-11-03 15:39:01 piso Exp $
     4 * Copyright (C) 2003-2005 Peter Graves
     5 * $Id: RandomState.java,v 1.5 2005-03-17 14:55:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9898                return number(remainder);
    9999            }
    100         } else if (arg instanceof LispFloat) {
    101             double limit = ((LispFloat)arg).getValue();
     100        } else if (arg instanceof SingleFloat) {
     101            float limit = ((SingleFloat)arg).value;
     102            if (limit > 0) {
     103                float rand = random.nextFloat();
     104                return new SingleFloat(rand * limit);
     105            }
     106        } else if (arg instanceof DoubleFloat) {
     107            double limit = ((DoubleFloat)arg).value;
    102108            if (limit > 0) {
    103109                double rand = random.nextDouble();
    104                 return new LispFloat(rand * limit);
     110                return new DoubleFloat(rand * limit);
    105111            }
    106112        }
  • trunk/j/src/org/armedbear/lisp/Ratio.java

    r8755 r8784  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Ratio.java,v 1.49 2005-03-12 17:06:56 piso Exp $
     5 * $Id: Ratio.java,v 1.50 2005-03-17 14:56:43 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    122122                denominator.equals(((Ratio)obj).denominator);
    123123        }
    124         if (obj instanceof LispFloat) {
    125             return floatValue() == ((LispFloat)obj).getValue();
     124        if (obj instanceof SingleFloat) {
     125            return floatValue() == ((SingleFloat)obj).value;
     126        }
     127        if (obj instanceof DoubleFloat) {
     128            return doubleValue() == ((DoubleFloat)obj).value;
    126129        }
    127130        return false;
     
    152155    }
    153156
    154     public double floatValue()
     157    public float floatValue()
     158    {
     159        return (float) doubleValue();
     160    }
     161
     162    public double doubleValue()
    155163    {
    156164        double result = numerator.doubleValue() / denominator.doubleValue();
     
    218226                common);
    219227        }
    220         if (obj instanceof LispFloat) {
    221             return new LispFloat(floatValue() + ((LispFloat)obj).getValue());
     228        if (obj instanceof SingleFloat) {
     229            return new SingleFloat(floatValue() + ((SingleFloat)obj).value);
     230        }
     231        if (obj instanceof DoubleFloat) {
     232            return new DoubleFloat(doubleValue() + ((DoubleFloat)obj).value);
    222233        }
    223234        if (obj instanceof Complex) {
     
    249260                common);
    250261        }
    251         if (obj instanceof LispFloat) {
    252             return new LispFloat(floatValue() - ((LispFloat)obj).getValue());
     262        if (obj instanceof SingleFloat) {
     263            return new SingleFloat(floatValue() - ((SingleFloat)obj).value);
     264        }
     265        if (obj instanceof DoubleFloat) {
     266            return new DoubleFloat(doubleValue() - ((DoubleFloat)obj).value);
    253267        }
    254268        if (obj instanceof Complex) {
     
    275289            return number(numerator.multiply(n), denominator.multiply(d));
    276290        }
    277         if (obj instanceof LispFloat) {
    278             return new LispFloat(floatValue() * ((LispFloat)obj).getValue());
     291        if (obj instanceof SingleFloat) {
     292            return new SingleFloat(floatValue() * ((SingleFloat)obj).value);
     293        }
     294        if (obj instanceof DoubleFloat) {
     295            return new DoubleFloat(doubleValue() * ((DoubleFloat)obj).value);
    279296        }
    280297        if (obj instanceof Complex) {
     
    301318            return number(numerator.multiply(d), denominator.multiply(n));
    302319        }
    303         if (obj instanceof LispFloat) {
     320        if (obj instanceof SingleFloat) {
    304321            if (obj.zerop())
    305322                return signal(new DivisionByZero());
    306             return new LispFloat(floatValue() / ((LispFloat)obj).getValue());
     323            return new SingleFloat(floatValue() / ((SingleFloat)obj).value);
     324        }
     325        if (obj instanceof DoubleFloat) {
     326            if (obj.zerop())
     327                return signal(new DivisionByZero());
     328            return new DoubleFloat(doubleValue() / ((DoubleFloat)obj).value);
    307329        }
    308330        if (obj instanceof Complex) {
     
    327349            return (numerator.equals(((Ratio)obj).numerator) &&
    328350                    denominator.equals(((Ratio)obj).denominator));
    329         if (obj instanceof LispFloat)
    330             return isEqualTo(((LispFloat)obj).rational());
     351        if (obj instanceof SingleFloat)
     352            return isEqualTo(((SingleFloat)obj).rational());
     353        if (obj instanceof DoubleFloat)
     354            return isEqualTo(((DoubleFloat)obj).rational());
    331355        if (obj.numberp())
    332356            return false;
     
    356380            return n1.compareTo(n2) < 0;
    357381        }
    358         if (obj instanceof LispFloat)
    359             return isLessThan(((LispFloat)obj).rational());
     382        if (obj instanceof SingleFloat)
     383            return isLessThan(((SingleFloat)obj).rational());
     384        if (obj instanceof DoubleFloat)
     385            return isLessThan(((DoubleFloat)obj).rational());
    360386        signal(new TypeError(obj, Symbol.REAL));
    361387        // Not reached.
     
    378404            return n1.compareTo(n2) > 0;
    379405        }
    380         if (obj instanceof LispFloat)
    381             return isGreaterThan(((LispFloat)obj).rational());
     406        if (obj instanceof SingleFloat)
     407            return isGreaterThan(((SingleFloat)obj).rational());
     408        if (obj instanceof DoubleFloat)
     409            return isGreaterThan(((DoubleFloat)obj).rational());
    382410        signal(new TypeError(obj, Symbol.REAL));
    383411        // Not reached.
     
    400428            return n1.compareTo(n2) <= 0;
    401429        }
    402         if (obj instanceof LispFloat)
    403             return isLessThanOrEqualTo(((LispFloat)obj).rational());
     430        if (obj instanceof SingleFloat)
     431            return isLessThanOrEqualTo(((SingleFloat)obj).rational());
     432        if (obj instanceof DoubleFloat)
     433            return isLessThanOrEqualTo(((DoubleFloat)obj).rational());
    404434        signal(new TypeError(obj, Symbol.REAL));
    405435        // Not reached.
     
    422452            return n1.compareTo(n2) >= 0;
    423453        }
    424         if (obj instanceof LispFloat)
    425             return isGreaterThanOrEqualTo(((LispFloat)obj).rational());
     454        if (obj instanceof SingleFloat)
     455            return isGreaterThanOrEqualTo(((SingleFloat)obj).rational());
     456        if (obj instanceof DoubleFloat)
     457            return isGreaterThanOrEqualTo(((DoubleFloat)obj).rational());
    426458        signal(new TypeError(obj, Symbol.REAL));
    427459        // Not reached.
     
    431463    public LispObject truncate(LispObject obj) throws ConditionThrowable
    432464    {
    433         if (obj instanceof LispFloat) {
    434             // "When rationals and floats are combined by a numerical function,
    435             // the rational is first converted to a float of the same format."
    436             // 12.1.4.1
    437             return new LispFloat(floatValue()).truncate(obj);
    438         }
     465        // "When rationals and floats are combined by a numerical function,
     466        // the rational is first converted to a float of the same format."
     467        // 12.1.4.1
     468        if (obj instanceof SingleFloat)
     469            return new SingleFloat(floatValue()).truncate(obj);
     470        if (obj instanceof DoubleFloat)
     471            return new DoubleFloat(doubleValue()).truncate(obj);
    439472        BigInteger n, d;
    440473  try {
  • trunk/j/src/org/armedbear/lisp/RuntimeClass.java

    r8084 r8784  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: RuntimeClass.java,v 1.9 2004-11-03 15:27:23 piso Exp $
     5 * $Id: RuntimeClass.java,v 1.10 2005-03-17 14:57:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    151151    }
    152152
    153     public static final LispFloat makeLispObject(float i) throws ConditionThrowable
     153    public static final DoubleFloat makeLispObject(float i) throws ConditionThrowable
    154154    {
    155         return new LispFloat(i);
     155        return new DoubleFloat(i);
    156156    }
    157157
    158     public static final LispFloat makeLispObject(double i) throws ConditionThrowable
     158    public static final DoubleFloat makeLispObject(double i) throws ConditionThrowable
    159159    {
    160         return new LispFloat(i);
     160        return new DoubleFloat(i);
    161161    }
    162162
  • trunk/j/src/org/armedbear/lisp/Stream.java

    r8741 r8784  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Stream.java,v 1.116 2005-03-07 19:08:01 piso Exp $
     5 * $Id: Stream.java,v 1.117 2005-03-17 14:57:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    935935        int i = 0;
    936936        boolean maybe = false;
     937        char marker = 0;
    937938        char c = token.charAt(i);
    938939        if (c == '-' || c == '+') {
     
    951952        }
    952953        if (i < length) {
    953             if ("esfdlESFDL".indexOf(token.charAt(i)) >= 0) {
     954            c = token.charAt(i);
     955            if ("esfdlESFDL".indexOf(c) >= 0) {
    954956                // Exponent marker.
    955957                maybe = true;
     958                marker = Utilities.toUpperCase(c);
     959                if (marker == 'S')
     960                    marker = 'F';
     961                else if (marker == 'L')
     962                    marker = 'D';
     963                else if (marker == 'E') {
     964                    LispObject format = _READ_DEFAULT_FLOAT_FORMAT_.symbolValue();
     965                    if (format == Symbol.SINGLE_FLOAT || format == Symbol.SHORT_FLOAT)
     966                        marker = 'F';
     967                    else
     968                        marker = 'D';
     969                }
    956970                sb.append('E');
    957971                ++i;
     
    963977        sb.append(token.substring(i));
    964978        try {
    965             return new LispFloat(Double.parseDouble(sb.toString()));
     979            if (marker == 0) {
     980                LispObject format = _READ_DEFAULT_FLOAT_FORMAT_.symbolValue();
     981                if (format == Symbol.SINGLE_FLOAT || format == Symbol.SHORT_FLOAT)
     982                    marker = 'F';
     983                else
     984                    marker = 'D';
     985            }
     986            if (marker == 'D')
     987                return new DoubleFloat(Double.parseDouble(sb.toString()));
     988            else
     989                return new SingleFloat(Float.parseFloat(sb.toString()));
    966990        }
    967991        catch (NumberFormatException e) {
  • trunk/j/src/org/armedbear/lisp/Symbol.java

    r8663 r8784  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Symbol.java,v 1.175 2005-02-28 17:18:02 piso Exp $
     5 * $Id: Symbol.java,v 1.176 2005-03-17 14:58:18 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    187187    public static final Symbol _SOURCE                            = PACKAGE_SYS.addInternalSymbol("%SOURCE");
    188188
     189    public static final Symbol SINGLE_FLOAT_POSITIVE_INFINITY     = PACKAGE_EXT.addExternalSymbol("SINGLE-FLOAT-POSITIVE-INFINITY");
     190    public static final Symbol SINGLE_FLOAT_NEGATIVE_INFINITY     = PACKAGE_EXT.addExternalSymbol("SINGLE-FLOAT-NEGATIVE-INFINITY");
    189191    public static final Symbol DOUBLE_FLOAT_POSITIVE_INFINITY     = PACKAGE_EXT.addExternalSymbol("DOUBLE-FLOAT-POSITIVE-INFINITY");
    190192    public static final Symbol DOUBLE_FLOAT_NEGATIVE_INFINITY     = PACKAGE_EXT.addExternalSymbol("DOUBLE-FLOAT-NEGATIVE-INFINITY");
  • trunk/j/src/org/armedbear/lisp/coerce.lisp

    r8641 r8784  
    22;;;
    33;;; Copyright (C) 2004-2005 Peter Graves
    4 ;;; $Id: coerce.lisp,v 1.6 2005-02-26 17:38:11 piso Exp $
     4;;; $Id: coerce.lisp,v 1.7 2005-03-17 14:59:03 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    4747               (t
    4848                (coerce-error object result-type))))
    49         ((memq result-type '(float single-float double-float short-float long-float))
    50          (coerce-to-float object))
     49        ((memq result-type '(float single-float short-float))
     50         (coerce-to-single-float object))
     51        ((memq result-type '(double-float long-float))
     52         (coerce-to-double-float object))
    5153        ((eq result-type 'complex)
    5254         (cond ((floatp object)
  • trunk/j/src/org/armedbear/lisp/early-defuns.lisp

    r8642 r8784  
    22;;;
    33;;; Copyright (C) 2003-2005 Peter Graves
    4 ;;; $Id: early-defuns.lisp,v 1.20 2005-02-26 17:41:38 piso Exp $
     4;;; $Id: early-defuns.lisp,v 1.21 2005-03-17 14:59:57 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    4242           (BASE-CHAR
    4343            (return-from normalize-type 'character))
    44            ((SHORT-FLOAT SINGLE-FLOAT DOUBLE-FLOAT LONG-FLOAT)
    45             (return-from normalize-type 'float))
     44           (SHORT-FLOAT
     45            (return-from normalize-type 'single-float))
     46           (LONG-FLOAT
     47            (return-from normalize-type 'double-float))
    4648           (COMPLEX
    4749            (return-from normalize-type '(complex *)))
     
    154156           (return-from normalize-type (list 'simple-array 'base-char (list (car i))))
    155157           (return-from normalize-type '(simple-array base-char (*)))))
    156       ((SHORT-FLOAT SINGLE-FLOAT DOUBLE-FLOAT LONG-FLOAT)
    157        (setf tp 'float))
     158      (SHORT-FLOAT
     159       (setf tp 'single-float))
     160      (LONG-FLOAT
     161       (setf tp 'double-float))
    158162      (COMPLEX
    159163        (cond ((null i)
    160164               (setf i '(*)))
    161               ((memq i '(short-float single-float double-float long-float))
    162                (setf i 'float)))))
     165              ((eq i 'short-float)
     166               (setf i 'single-float))
     167              ((eq i 'long-float)
     168               (setf i 'double-float)))))
    163169    (if i (cons tp i) tp)))
    164170
  • trunk/j/src/org/armedbear/lisp/float_sign.java

    r7020 r8784  
    22 * float_sign.java
    33 *
    4  * Copyright (C) 2004 Peter Graves
    5  * $Id: float_sign.java,v 1.1 2004-06-06 19:31:53 piso Exp $
     4 * Copyright (C) 2004-2005 Peter Graves
     5 * $Id: float_sign.java,v 1.2 2005-03-17 15:01:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
     24// ### float-sign
    2425public final class float_sign extends Primitive
    2526{
     
    3132    public LispObject execute(LispObject arg) throws ConditionThrowable
    3233    {
    33         try {
    34             double d = ((LispFloat)arg).value;
     34        if (arg instanceof SingleFloat) {
     35            float f = ((SingleFloat)arg).value;
     36            int bits = Float.floatToRawIntBits(f);
     37            return bits < 0 ? SingleFloat.MINUS_ONE : SingleFloat.ONE;
     38        }
     39        if (arg instanceof DoubleFloat) {
     40            double d = ((DoubleFloat)arg).value;
    3541            long bits = Double.doubleToRawLongBits(d);
    36             return bits < 0 ? LispFloat.MINUS_ONE : LispFloat.ONE;
     42            return bits < 0 ? DoubleFloat.MINUS_ONE : DoubleFloat.ONE;
    3743        }
    38         catch (ClassCastException e) {
    39             return signal(new TypeError(arg, Symbol.FLOAT));
    40         }
     44        return signal(new TypeError(arg, Symbol.FLOAT));
    4145    }
    4246
     
    4448        throws ConditionThrowable
    4549    {
    46         double d1, d2;
    47         try {
    48             d1 = ((LispFloat)first).value;
    49         }
    50         catch (ClassCastException e) {
     50        if (!first.floatp())
    5151            return signal(new TypeError(first, Symbol.FLOAT));
    52         }
    53         try {
    54             d2 = Math.abs(((LispFloat)second).value);
    55         }
    56         catch (ClassCastException e) {
     52        if (!second.floatp())
    5753            return signal(new TypeError(second, Symbol.FLOAT));
    58         }
    59         long bits = Double.doubleToRawLongBits(d1);
    60         return bits < 0 ? new LispFloat(-d2) : new LispFloat(d2);
     54        if (first.minusp()) {
     55            if (second.minusp())
     56                return second;
     57            else
     58                return Fixnum.ZERO.subtract(second);
     59        } else
     60            return second.ABS();
    6161    }
    6262
  • trunk/j/src/org/armedbear/lisp/format.lisp

    r8214 r8784  
    11;;; format.lisp
    22;;;
    3 ;;; Copyright (C) 2004 Peter Graves
    4 ;;; $Id: format.lisp,v 1.24 2004-12-06 17:48:28 piso Exp $
     3;;; Copyright (C) 2004-2005 Peter Graves
     4;;; $Id: format.lisp,v 1.25 2005-03-17 15:03:06 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    195195         (when scale
    196196           (setf x (* x (expt 10 scale))))
    197          (let* ((s (sys::%write-to-string x))
     197         (let* ((s (sys:float-string x))
    198198                (length (length s))
    199199                (index (position #\. s)))
  • trunk/j/src/org/armedbear/lisp/ftruncate.java

    r8754 r8784  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: ftruncate.java,v 1.4 2005-03-12 15:57:48 piso Exp $
     5 * $Id: ftruncate.java,v 1.5 2005-03-17 15:03:56 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626//  (multiple-value-bind (tru rem) (truncate number divisor)
    2727//   (values (float tru) rem)))
     28
     29// "FFLOOR, FCEILING, FTRUNCATE, and FROUND handle arguments of different types
     30// in the following way: If number is a float, and divisor is not a float of
     31// longer format, then the first result is a float of the same type as number.
     32// Otherwise, the first result is of the type determined by contagion rules."
    2833public final class ftruncate extends Primitive
    2934{
     
    3641    {
    3742        LispObject q = arg.truncate(Fixnum.ONE); // an integer
    38         if (q instanceof Fixnum)
    39             q = new LispFloat(((Fixnum)q).value);
    40         else
    41             q = new LispFloat(((Bignum)q).floatValue());
     43        if (arg instanceof DoubleFloat) {
     44            if (q instanceof Fixnum)
     45                q = new DoubleFloat(((Fixnum)q).value);
     46            else
     47                q = new DoubleFloat(((Bignum)q).doubleValue());
     48        } else {
     49            if (q instanceof Fixnum)
     50                q = new SingleFloat(((Fixnum)q).value);
     51            else
     52                q = new SingleFloat(((Bignum)q).floatValue());
     53        }
    4254        LispThread.currentThread()._values[0] = q;
    4355        return q;
     
    4860    {
    4961        LispObject q = first.truncate(second); // an integer
    50         if (q instanceof Fixnum)
    51             q = new LispFloat(((Fixnum)q).value);
    52         else
    53             q = new LispFloat(((Bignum)q).floatValue());
     62        if (first instanceof DoubleFloat || second instanceof DoubleFloat) {
     63            if (q instanceof Fixnum)
     64                q = new DoubleFloat(((Fixnum)q).value);
     65            else
     66                q = new DoubleFloat(((Bignum)q).doubleValue());
     67        } else {
     68            if (q instanceof Fixnum)
     69                q = new SingleFloat(((Fixnum)q).value);
     70            else
     71                q = new SingleFloat(((Bignum)q).floatValue());
     72        }
    5473        LispThread.currentThread()._values[0] = q;
    5574        return q;
  • trunk/j/src/org/armedbear/lisp/numbers.lisp

    r7962 r8784  
    11;;; numbers.lisp
    22;;;
    3 ;;; Copyright (C) 2003-2004 Peter Graves
    4 ;;; $Id: numbers.lisp,v 1.34 2004-10-12 17:03:00 piso Exp $
     3;;; Copyright (C) 2003-2005 Peter Graves
     4;;; $Id: numbers.lisp,v 1.35 2005-03-17 15:04:23 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    158158             (complex
    159159              (if (zerop (realpart number))
    160                   (* (/ pi 2) (signum (imagpart number)))
     160                  (coerce (* (/ pi 2) (signum (imagpart number)))
     161                          (if (typep (imagpart number) 'double-float)
     162                              'double-float 'single-float))
    161163                  (atan (imagpart number) (realpart number))))))
  • trunk/j/src/org/armedbear/lisp/subtypep.lisp

    r8762 r8784  
    22;;;
    33;;; Copyright (C) 2003-2005 Peter Graves
    4 ;;; $Id: subtypep.lisp,v 1.60 2005-03-13 01:50:18 piso Exp $
     4;;; $Id: subtypep.lisp,v 1.61 2005-03-17 15:04:50 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    2222(in-package #:system)
    2323
    24 (defparameter *known-types* (make-hash-table))
     24(defparameter *known-types* (make-hash-table :test 'eq))
    2525
    2626(dolist (i '((ARITHMETIC-ERROR ERROR)
     
    4141             (CONTROL-ERROR ERROR)
    4242             (DIVISION-BY-ZERO ARITHMETIC-ERROR)
     43             (DOUBLE-FLOAT FLOAT)
    4344             (END-OF-FILE STREAM-ERROR)
    4445             (ERROR SERIOUS-CONDITION)
     
    5758             (KEYWORD SYMBOL)
    5859             (LIST SEQUENCE)
     60             (LONG-FLOAT FLOAT)
    5961             (NIL-VECTOR SIMPLE-STRING)
    6062             (NULL BOOLEAN LIST)
     
    7476             (RESTART)
    7577             (SERIOUS-CONDITION CONDITION)
     78             (SHORT-FLOAT FLOAT)
    7679             (SIMPLE-ARRAY ARRAY)
    7780             (SIMPLE-BASE-STRING SIMPLE-STRING BASE-STRING)
     
    8386             (SIMPLE-VECTOR VECTOR SIMPLE-ARRAY)
    8487             (SIMPLE-WARNING SIMPLE-CONDITION WARNING)
     88             (SINGLE-FLOAT FLOAT)
    8589             (STANDARD-CHAR CHARACTER)
    8690             (STANDARD-CLASS CLASS)
     
    570574               (values (sub-interval-p i1 i2) t)
    571575               (values nil (known-type-p t2))))
     576          ((memq t1 '(single-float short-float))
     577           (if (memq t2 '(single-float short-float float real number))
     578               (values (sub-interval-p i1 i2) t)
     579               (values nil (known-type-p t2))))
     580          ((memq t1 '(double-float long-float))
     581           (if (memq t2 '(double-float long-float float real number))
     582               (values (sub-interval-p i1 i2) t)
     583               (values nil (known-type-p t2))))
    572584          ((eq t1 'integer)
    573585           (cond ((memq t2 '(integer rational real number))
  • trunk/j/src/org/armedbear/lisp/typep.lisp

    r8772 r8784  
    22;;;
    33;;; Copyright (C) 2003-2005 Peter Graves
    4 ;;; $Id: typep.lisp,v 1.24 2005-03-14 18:55:46 piso Exp $
     4;;; $Id: typep.lisp,v 1.25 2005-03-17 15:05:09 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    7878            (or (null (car i)) (eq (car i) '*) (%typep (car object) (car i)))
    7979            (or (null (cadr i)) (eq (cadr i) '*) (%typep (cdr object) (cadr i)))))
    80       (FLOAT
     80      ((FLOAT SINGLE-FLOAT DOUBLE-FLOAT SHORT-FLOAT LONG-FLOAT)
    8181       (and (floatp object) (in-interval-p object i)))
    8282      (INTEGER
Note: See TracChangeset for help on using the changeset viewer.