Changeset 3565


Ignore:
Timestamp:
09/03/03 23:48:44 (19 years ago)
Author:
piso
Message:

Lisp floats are now Java doubles.

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

Legend:

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

    r3563 r3565  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Bignum.java,v 1.33 2003-09-02 23:32:54 piso Exp $
     5 * $Id: Bignum.java,v 1.34 2003-09-03 23:47:39 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    138138    }
    139139
    140     public float floatValue() throws TypeError
    141     {
    142         float f = value.floatValue();
    143         if (Float.isInfinite(f))
    144             throw new TypeError(toString() + " is too large to be converted to a single float");
    145         return value.floatValue();
     140    public double floatValue() throws TypeError
     141    {
     142        double d = value.doubleValue();
     143        if (Double.isInfinite(d))
     144            throw new TypeError(toString() +
     145                                " is too large to be converted to a float");
     146        return d;
    146147    }
    147148
  • trunk/j/src/org/armedbear/lisp/CharacterInputStream.java

    r3340 r3565  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: CharacterInputStream.java,v 1.43 2003-08-12 01:36:08 piso Exp $
     5 * $Id: CharacterInputStream.java,v 1.44 2003-09-03 23:46:27 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    722722        sb.append(token.substring(i));
    723723        try {
    724             return new LispFloat(Float.parseFloat(sb.toString()));
     724            return new LispFloat(Double.parseDouble(sb.toString()));
    725725        }
    726726        catch (NumberFormatException e) {
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r3538 r3565  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Lisp.java,v 1.123 2003-08-27 17:28:27 piso Exp $
     5 * $Id: Lisp.java,v 1.124 2003-09-03 23:40:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    11371137    public static final Symbol PI =
    11381138        exportConstant("PI", PACKAGE_CL,
    1139                        new LispFloat((float)3.141592653589793));
     1139                       new LispFloat((double)3.141592653589793));
    11401140
    11411141    public static final Symbol SHORT_FLOAT_EPSILON =
    11421142        exportConstant("SHORT-FLOAT-EPSILON", PACKAGE_CL,
    1143                        new LispFloat((float)5.960465E-8));
     1143                       new LispFloat((double)1.1102230246251568E-16));
    11441144
    11451145    public static final Symbol SINGLE_FLOAT_EPSILON =
    11461146        exportConstant("SINGLE-FLOAT-EPSILON", PACKAGE_CL,
    1147                        new LispFloat((float)5.960465E-8));
     1147                       new LispFloat((double)1.1102230246251568E-16));
    11481148
    11491149    public static final Symbol DOUBLE_FLOAT_EPSILON =
    11501150        exportConstant("DOUBLE-FLOAT-EPSILON", PACKAGE_CL,
    1151                        new LispFloat((float)5.960465E-8));
     1151                       new LispFloat((double)1.1102230246251568E-16));
    11521152
    11531153    public static final Symbol LONG_FLOAT_EPSILON =
    11541154        exportConstant("LONG-FLOAT-EPSILON", PACKAGE_CL,
    1155                        new LispFloat((float)5.960465E-8));
     1155                       new LispFloat((double)1.1102230246251568E-16));
    11561156
    11571157    public static final Symbol SHORT_FLOAT_NEGATIVE_EPSILON =
    11581158        exportConstant("SHORT-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL,
    1159                        new LispFloat((float)2.9802325E-8));
     1159                       new LispFloat((double)5.551115123125784E-17));
    11601160
    11611161    public static final Symbol SINGLE_FLOAT_NEGATIVE_EPSILON =
    11621162        exportConstant("SINGLE-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL,
    1163                        new LispFloat((float)2.9802325E-8));
     1163                       new LispFloat((double)5.551115123125784E-17));
    11641164
    11651165    public static final Symbol DOUBLE_FLOAT_NEGATIVE_EPSILON =
    11661166        exportConstant("DOUBLE-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL,
    1167                        new LispFloat((float)2.9802325E-8));
     1167                       new LispFloat((double)5.551115123125784E-17));
    11681168
    11691169    public static final Symbol LONG_FLOAT_NEGATIVE_EPSILON =
    11701170        exportConstant("LONG-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL,
    1171                        new LispFloat((float)2.9802325E-8));
     1171                       new LispFloat((double)5.551115123125784E-17));
    11721172
    11731173    public static final Symbol MOST_POSITIVE_SHORT_FLOAT =
    11741174        exportConstant("MOST-POSITIVE-SHORT-FLOAT", PACKAGE_CL,
    1175                        new LispFloat(Float.MAX_VALUE));
     1175                       new LispFloat(Double.MAX_VALUE));
    11761176
    11771177    public static final Symbol MOST_POSITIVE_SINGLE_FLOAT =
    11781178        exportConstant("MOST-POSITIVE-SINGLE-FLOAT", PACKAGE_CL,
    1179                        new LispFloat(Float.MAX_VALUE));
     1179                       new LispFloat(Double.MAX_VALUE));
    11801180
    11811181    public static final Symbol MOST_POSITIVE_DOUBLE_FLOAT =
    11821182        exportConstant("MOST-POSITIVE-DOUBLE-FLOAT", PACKAGE_CL,
    1183                        new LispFloat(Float.MAX_VALUE));
     1183                       new LispFloat(Double.MAX_VALUE));
    11841184
    11851185    public static final Symbol MOST_POSITIVE_LONG_FLOAT =
    11861186        exportConstant("MOST-POSITIVE-LONG-FLOAT", PACKAGE_CL,
    1187                        new LispFloat(Float.MAX_VALUE));
     1187                       new LispFloat(Double.MAX_VALUE));
    11881188
    11891189    public static final Symbol LEAST_POSITIVE_SHORT_FLOAT =
    11901190        exportConstant("LEAST-POSITIVE-SHORT-FLOAT", PACKAGE_CL,
    1191                        new LispFloat(Float.MIN_VALUE));
     1191                       new LispFloat(Double.MIN_VALUE));
    11921192
    11931193    public static final Symbol LEAST_POSITIVE_SINGLE_FLOAT =
    11941194        exportConstant("LEAST-POSITIVE-SINGLE-FLOAT", PACKAGE_CL,
    1195                        new LispFloat(Float.MIN_VALUE));
     1195                       new LispFloat(Double.MIN_VALUE));
    11961196
    11971197    public static final Symbol LEAST_POSITIVE_DOUBLE_FLOAT =
    11981198        exportConstant("LEAST-POSITIVE-DOUBLE-FLOAT", PACKAGE_CL,
    1199                        new LispFloat(Float.MIN_VALUE));
     1199                       new LispFloat(Double.MIN_VALUE));
    12001200
    12011201    public static final Symbol LEAST_POSITIVE_LONG_FLOAT =
    12021202        exportConstant("LEAST-POSITIVE-LONG-FLOAT", PACKAGE_CL,
    1203                        new LispFloat(Float.MIN_VALUE));
     1203                       new LispFloat(Double.MIN_VALUE));
    12041204
    12051205    public static final Symbol LEAST_POSITIVE_NORMALIZED_SHORT_FLOAT =
    12061206        exportConstant("LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT", PACKAGE_CL,
    1207                        new LispFloat(Float.MIN_VALUE));
     1207                       new LispFloat(Double.MIN_VALUE));
    12081208
    12091209    public static final Symbol LEAST_POSITIVE_NORMALIZED_SINGLE_FLOAT =
    12101210        exportConstant("LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT", PACKAGE_CL,
    1211                        new LispFloat(Float.MIN_VALUE));
     1211                       new LispFloat(Double.MIN_VALUE));
    12121212
    12131213    public static final Symbol LEAST_POSITIVE_NORMALIZED_DOUBLE_FLOAT =
    12141214        exportConstant("LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT", PACKAGE_CL,
    1215                        new LispFloat(Float.MIN_VALUE));
     1215                       new LispFloat(Double.MIN_VALUE));
    12161216
    12171217    public static final Symbol LEAST_POSITIVE_NORMALIZED_LONG_FLOAT =
    12181218        exportConstant("LEAST-POSITIVE-NORMALIZED-LONG-FLOAT", PACKAGE_CL,
    1219                        new LispFloat(Float.MIN_VALUE));
     1219                       new LispFloat(Double.MIN_VALUE));
    12201220
    12211221    public static final Symbol MOST_NEGATIVE_SHORT_FLOAT =
    12221222        exportConstant("MOST-NEGATIVE-SHORT-FLOAT", PACKAGE_CL,
    1223                        new LispFloat(- Float.MAX_VALUE));
     1223                       new LispFloat(- Double.MAX_VALUE));
    12241224
    12251225    public static final Symbol MOST_NEGATIVE_SINGLE_FLOAT =
    12261226        exportConstant("MOST-NEGATIVE-SINGLE-FLOAT", PACKAGE_CL,
    1227                        new LispFloat(- Float.MAX_VALUE));
     1227                       new LispFloat(- Double.MAX_VALUE));
    12281228
    12291229    public static final Symbol MOST_NEGATIVE_DOUBLE_FLOAT =
    12301230        exportConstant("MOST-NEGATIVE-DOUBLE-FLOAT", PACKAGE_CL,
    1231                        new LispFloat(- Float.MAX_VALUE));
     1231                       new LispFloat(- Double.MAX_VALUE));
    12321232
    12331233    public static final Symbol MOST_NEGATIVE_LONG_FLOAT =
    12341234        exportConstant("MOST-NEGATIVE-LONG-FLOAT", PACKAGE_CL,
    1235                        new LispFloat(- Float.MAX_VALUE));
     1235                       new LispFloat(- Double.MAX_VALUE));
    12361236
    12371237    public static final Symbol LEAST_NEGATIVE_SHORT_FLOAT =
    12381238        exportConstant("LEAST-NEGATIVE-SHORT-FLOAT", PACKAGE_CL,
    1239                        new LispFloat(- Float.MIN_VALUE));
     1239                       new LispFloat(- Double.MIN_VALUE));
    12401240
    12411241    public static final Symbol LEAST_NEGATIVE_SINGLE_FLOAT =
    12421242        exportConstant("LEAST-NEGATIVE-SINGLE-FLOAT", PACKAGE_CL,
    1243                        new LispFloat(- Float.MIN_VALUE));
     1243                       new LispFloat(- Double.MIN_VALUE));
    12441244
    12451245    public static final Symbol LEAST_NEGATIVE_DOUBLE_FLOAT =
    12461246        exportConstant("LEAST-NEGATIVE-DOUBLE-FLOAT", PACKAGE_CL,
    1247                        new LispFloat(- Float.MIN_VALUE));
     1247                       new LispFloat(- Double.MIN_VALUE));
    12481248
    12491249    public static final Symbol LEAST_NEGATIVE_LONG_FLOAT =
    12501250        exportConstant("LEAST-NEGATIVE-LONG-FLOAT", PACKAGE_CL,
    1251                        new LispFloat(- Float.MIN_VALUE));
     1251                       new LispFloat(- Double.MIN_VALUE));
    12521252
    12531253    public static final Symbol LEAST_NEGATIVE_NORMALIZED_SHORT_FLOAT =
    12541254        exportConstant("LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT", PACKAGE_CL,
    1255                        new LispFloat(- Float.MIN_VALUE));
     1255                       new LispFloat(- Double.MIN_VALUE));
    12561256
    12571257    public static final Symbol LEAST_NEGATIVE_NORMALIZED_SINGLE_FLOAT =
    12581258        exportConstant("LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT", PACKAGE_CL,
    1259                        new LispFloat(- Float.MIN_VALUE));
     1259                       new LispFloat(- Double.MIN_VALUE));
    12601260
    12611261    public static final Symbol LEAST_NEGATIVE_NORMALIZED_DOUBLE_FLOAT =
    12621262        exportConstant("LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT", PACKAGE_CL,
    1263                        new LispFloat(- Float.MIN_VALUE));
     1263                       new LispFloat(- Double.MIN_VALUE));
    12641264
    12651265    public static final Symbol LEAST_NEGATIVE_NORMALIZED_LONG_FLOAT =
    12661266        exportConstant("LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT", PACKAGE_CL,
    1267                        new LispFloat(- Float.MIN_VALUE));
     1267                       new LispFloat(- Double.MIN_VALUE));
    12681268
    12691269    static {
  • trunk/j/src/org/armedbear/lisp/LispFloat.java

    r3558 r3565  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispFloat.java,v 1.34 2003-09-02 18:28:16 piso Exp $
     5 * $Id: LispFloat.java,v 1.35 2003-09-03 23:38:30 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626    public static final LispFloat ZERO = new LispFloat(0);
    2727
    28     private final float value;
    29 
    30     public LispFloat(float value)
     28    private final double value;
     29
     30    public LispFloat(double value)
    3131    {
    3232        this.value = value;
     
    134134    }
    135135
    136     public static float getValue(LispObject obj) throws LispError
     136    public static double getValue(LispObject obj) throws LispError
    137137    {
    138138        try {
     
    144144    }
    145145
    146     public final float getValue()
     146    public final double getValue()
    147147    {
    148148        return value;
     
    298298        if (obj instanceof Fixnum) {
    299299            long divisor = ((Fixnum)obj).getValue();
    300             float quotient = value / divisor;
    301             float remainder = value % divisor;
     300            double quotient = value / divisor;
     301            double remainder = value % divisor;
    302302            if (quotient >= Integer.MIN_VALUE && quotient <= Integer.MAX_VALUE) {
    303303                values[0] = new Fixnum((int)quotient);
     
    308308        }
    309309        if (obj instanceof LispFloat) {
    310             float divisor = ((LispFloat)obj).getValue();
    311             float quotient = value / divisor;
     310            double divisor = ((LispFloat)obj).getValue();
     311            double quotient = value / divisor;
    312312            if (quotient >= Integer.MIN_VALUE && quotient <= Integer.MAX_VALUE) {
    313313                int q = (int) quotient;
     
    318318            }
    319319            // We need to convert the quotient to a bignum.
    320             int bits = Float.floatToRawIntBits(quotient);
    321             Fixnum significand = new Fixnum((bits & 0x007fffff) | 0x800000);
    322             Fixnum exponent = new Fixnum(((bits >> 23) & 0xff) - 150);
    323             Fixnum sign = ((bits & 0x80000000) != 0) ? new Fixnum(-1) : Fixnum.ONE;
     320            long bits = Double.doubleToRawLongBits((double)quotient);
     321            int s = ((bits >> 63) == 0) ? 1 : -1;
     322            int e = (int) ((bits >> 52) & 0x7ffL);
     323            long m;
     324            if (e == 0)
     325                m = (bits & 0xfffffffffffffL) << 1;
     326            else
     327                m = (bits & 0xfffffffffffffL) | 0x10000000000000L;
     328            LispObject significand = number(m);
     329            Fixnum exponent = new Fixnum(e - 1075);
     330            Fixnum sign = new Fixnum(s);
    324331            LispObject result = significand;
    325332            result =
    326                 result.multiplyBy(Primitives.EXPT.execute(new Fixnum(2), exponent));
     333                result.multiplyBy(Primitives.EXPT.execute(Fixnum.TWO, exponent));
    327334            result = result.multiplyBy(sign);
    328335            // Calculate remainder.
     
    339346    public int hashCode()
    340347    {
    341         return Float.floatToIntBits(value);
     348        long bits = Double.doubleToLongBits(value);
     349        return (int) (bits ^ (bits >>> 32));
    342350    }
    343351
     
    354362        {
    355363            if (arg instanceof LispFloat) {
    356                 int bits = Float.floatToRawIntBits(((LispFloat)arg).getValue());
    357                 Fixnum significand = new Fixnum((bits & 0x007fffff) | 0x800000);
    358                 Fixnum exponent = new Fixnum(((bits >> 23) & 0xff) - 150);
    359                 Fixnum sign = ((bits & 0x80000000) != 0) ? new Fixnum(-1) : Fixnum.ONE;
    360364                LispObject[] values = new LispObject[3];
     365                long bits =
     366                    Double.doubleToRawLongBits((double)((LispFloat)arg).getValue());
     367                int s = ((bits >> 63) == 0) ? 1 : -1;
     368                int e = (int) ((bits >> 52) & 0x7ffL);
     369                long m;
     370                if (e == 0)
     371                    m = (bits & 0xfffffffffffffL) << 1;
     372                else
     373                    m = (bits & 0xfffffffffffffL) | 0x10000000000000L;
     374                LispObject significand = number(m);
     375                Fixnum exponent = new Fixnum(e - 1075);
     376                Fixnum sign = new Fixnum(s);
    361377                values[0] = significand;
    362378                values[1] = exponent;
     
    388404        {
    389405            if (arg instanceof LispFloat)
    390                 return new Fixnum(32);
     406                return new Fixnum(52);
    391407            throw new TypeError(arg, "float");
    392408        }
  • trunk/j/src/org/armedbear/lisp/LispThread.java

    r2726 r3565  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispThread.java,v 1.8 2003-07-02 18:16:46 piso Exp $
     5 * $Id: LispThread.java,v 1.9 2003-09-03 23:45:26 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    337337        public LispObject execute(LispObject arg) throws LispError
    338338        {
    339             float f =
    340                 ((LispFloat)arg.multiplyBy(new LispFloat((float)1000))).getValue();
    341             if (f < 0)
     339            double d =
     340                ((LispFloat)arg.multiplyBy(new LispFloat(1000))).getValue();
     341            if (d < 0)
    342342                throw new TypeError(arg, "non-negative real");
    343             long millis = f < Long.MAX_VALUE ? (long) f : Long.MAX_VALUE;
     343            long millis = d < Long.MAX_VALUE ? (long) d : Long.MAX_VALUE;
    344344            try {
    345345                Thread.currentThread().sleep(millis);
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r3559 r3565  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitives.java,v 1.366 2003-09-02 18:29:02 piso Exp $
     5 * $Id: Primitives.java,v 1.367 2003-09-03 23:44:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    42014201            }
    42024202            if (args[0] instanceof LispFloat) {
    4203                 float limit = ((LispFloat)args[0]).getValue();
    4204                 float rand = random.nextFloat();
     4203                double limit = ((LispFloat)args[0]).getValue();
     4204                double rand = random.nextDouble();
    42054205                return new LispFloat(rand * limit);
    42064206            }
     
    42864286                    result = new Fixnum(1);
    42874287                else
    4288                     result = new LispFloat((float)1);
     4288                    result = new LispFloat(1);
    42894289                int count = Fixnum.getInt(power);
    42904290                if (count > 0) {
     
    43004300                if (n instanceof Fixnum) {
    43014301                    double d = Math.pow(((Fixnum)n).getValue(),
    4302                         ((LispFloat)power).getValue());
    4303                     return new LispFloat(new Float(d).floatValue());
     4302                                        ((LispFloat)power).getValue());
     4303                    return new LispFloat(d);
    43044304                }
    43054305            }
     
    48054805    {
    48064806        if (obj instanceof Fixnum)
    4807             return new LispFloat((float)Math.sqrt(((Fixnum)obj).getValue()));
     4807            return new LispFloat(Math.sqrt(((Fixnum)obj).getValue()));
    48084808        if (obj instanceof Bignum)
    4809             return new LispFloat((float)Math.sqrt(((Bignum)obj).floatValue()));
     4809            return new LispFloat(Math.sqrt(((Bignum)obj).floatValue()));
    48104810        if (obj instanceof Ratio)
    4811             return new LispFloat((float)Math.sqrt(((Ratio)obj).floatValue()));
     4811            return new LispFloat(Math.sqrt(((Ratio)obj).floatValue()));
    48124812        if (obj instanceof LispFloat)
    4813             return new LispFloat((float)Math.sqrt(((LispFloat)obj).getValue()));
     4813            return new LispFloat(Math.sqrt(((LispFloat)obj).getValue()));
    48144814        throw new TypeError(obj, "number");
    48154815    }
  • trunk/j/src/org/armedbear/lisp/Ratio.java

    r3558 r3565  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Ratio.java,v 1.23 2003-09-02 18:27:37 piso Exp $
     5 * $Id: Ratio.java,v 1.24 2003-09-03 23:48:44 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    130130    }
    131131
    132     public float floatValue()
     132    public double floatValue()
    133133    {
    134134        return numerator.floatValue() / denominator.floatValue();
Note: See TracChangeset for help on using the changeset viewer.