From f1cc2b1b4911cb97fd6ee9107cfbf59d446c6c9c Mon Sep 17 00:00:00 2001 From: tromey Date: Thu, 13 Jun 2002 18:16:26 +0000 Subject: * java/lang/natString.cc (init): Handle case where DONT_COPY is true and OFFSET!=0. * java/lang/String.java (String(char[],int,int,boolean): New constructor. * java/lang/Long.java: Imported new version from Classpath. * java/lang/Number.java: Likewise. * java/lang/Integer.java: Likewise. * java/lang/Long.java: Likewise. * java/lang/Float.java: Likewise. * java/lang/Boolean.java: Likewise. * java/lang/Double.java: Likewise. * java/lang/Void.java: Likewise. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@54595 138bc75d-0d04-0410-961f-82ee72b054a4 --- libjava/java/lang/Double.java | 638 +++++++++++++++++++++--------------------- 1 file changed, 325 insertions(+), 313 deletions(-) (limited to 'libjava/java/lang/Double.java') diff --git a/libjava/java/lang/Double.java b/libjava/java/lang/Double.java index c98d987a987..22f2b5f524a 100644 --- a/libjava/java/lang/Double.java +++ b/libjava/java/lang/Double.java @@ -1,4 +1,4 @@ -/* Double.java -- object wrapper for double primitive +/* Double.java -- object wrapper for double Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. - + GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU @@ -40,12 +40,6 @@ package java.lang; import gnu.classpath.Configuration; -/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 - * "The Java Language Specification", ISBN 0-201-63451-1 - * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. - * Status: Believed complete and correct. - */ - /** * Instances of class Double represent primitive * double values. @@ -55,15 +49,16 @@ import gnu.classpath.Configuration; * * @author Paul Fisher * @author Andrew Haley - * @since JDK 1.0 + * @author Eric Blake + * @since 1.0 + * @status updated to 1.4 */ public final class Double extends Number implements Comparable { /** - * The minimum positive value a double may represent - * is 5e-324. + * Compatible with JDK 1.0+. */ - public static final double MIN_VALUE = 5e-324; + private static final long serialVersionUID = -9172774392245257468L; /** * The maximum positive value a double may represent @@ -71,44 +66,51 @@ public final class Double extends Number implements Comparable */ public static final double MAX_VALUE = 1.7976931348623157e+308; + /** + * The minimum positive value a double may represent + * is 5e-324. + */ + public static final double MIN_VALUE = 5e-324; + /** * The value of a double representation -1.0/0.0, negative - * infinity. + * infinity. */ - public static final double NEGATIVE_INFINITY = -1.0d/0.0d; + public static final double NEGATIVE_INFINITY = -1.0 / 0.0; /** * The value of a double representing 1.0/0.0, positive infinity. */ - public static final double POSITIVE_INFINITY = 1.0d/0.0d; + public static final double POSITIVE_INFINITY = 1.0 / 0.0; /** * All IEEE 754 values of NaN have the same value in Java. */ - public static final double NaN = 0.0d/0.0d; + public static final double NaN = 0.0 / 0.0; /** * The primitive type double is represented by this * Class object. + * @since 1.1 */ public static final Class TYPE = VMClassLoader.getPrimitiveClass('D'); /** * The immutable value of this Double. + * + * @serial the wrapped double */ private final double value; - private static final long serialVersionUID = -9172774392245257468L; - /** - * Load native routines necessary for this class. + * Load native routines necessary for this class. */ static { if (Configuration.INIT_LOAD_LIBRARY) { - System.loadLibrary ("javalang"); - initIDs (); + System.loadLibrary("javalang"); + initIDs(); } } @@ -118,411 +120,421 @@ public final class Double extends Number implements Comparable * * @param value the double argument */ - public Double (double value) + public Double(double value) { this.value = value; } /** - * Create a Double from the specified - * String. - * + * Create a Double from the specified String. * This method calls Double.parseDouble(). * - * @exception NumberFormatException when the String cannot - * be parsed into a Float. * @param s the String to convert - * @see #parseDouble(java.lang.String) + * @throws NumberFormatException if s cannot be parsed as a + * double + * @throws NullPointerException if s is null + * @see #parseDouble(String) */ - public Double (String s) throws NumberFormatException + public Double(String s) { - value = parseDouble (s); + value = parseDouble(s); } /** - * Convert the double value of this Double - * to a String. This method calls - * Double.toString(double) to do its dirty work. + * Convert the double to a String. + * Floating-point string representation is fairly complex: here is a + * rundown of the possible values. "[-]" indicates that a + * negative sign will be printed if the value (or exponent) is negative. + * "<number>" means a string of digits ('0' to '9'). + * "<digit>" means a single digit ('0' to '9').
* - * @return the String representation of this Double. - * @see #toString(double) + * + * + * + * + * + * + * + * + * + *
Value of DoubleString Representation
[+-] 0 [-]0.0
Between [+-] 10-3 and 107, exclusive[-]number.number
Other numeric value[-]<digit>.<number> + * E[-]<number>
[+-] infinity [-]Infinity
NaN NaN
+ * + * Yes, negative zero is a possible value. Note that there is + * always a . and at least one digit printed after + * it: even if the number is 3, it will be printed as 3.0. + * After the ".", all digits will be printed except trailing zeros. The + * result is rounded to the shortest decimal number which will parse back + * to the same double. + * + *

To create other output formats, use {@link java.text.NumberFormat}. + * + * @XXX specify where we are not in accord with the spec. + * + * @param d the double to convert + * @return the String representing the double */ - public String toString () + public static String toString(double d) { - return toString (value); + return toString(d, false); } /** - * If the Object is not null, is an - * instanceof Double, and represents - * the same primitive double value return - * true. Otherwise false is returned. - *

- * Note that there are two differences between == and - * equals(). 0.0d == -0.0d returns true - * but new Double(0.0d).equals(new Double(-0.0d)) returns - * false. And Double.NaN == Double.NaN returns - * false, but - * new Double(Double.NaN).equals(new Double(Double.NaN)) returns - * true. + * Create a new Double object using the String. * - * @param obj the object to compare to - * @return whether the objects are semantically equal. + * @param s the String to convert + * @return the new Double + * @throws NumberFormatException if s cannot be parsed as a + * double + * @throws NullPointerException if s is null. + * @see #parseDouble(String) */ - public boolean equals (Object obj) + public static Double valueOf(String s) { - if (!(obj instanceof Double)) - return false; - - double d = ((Double) obj).value; - - // GCJ LOCAL: this implementation is probably faster than - // Classpath's, especially once we inline doubleToLongBits. - return doubleToLongBits (value) == doubleToLongBits (d); - // END GCJ LOCAL + // XXX just call new Double(parseDouble(s)); + if (s == null) + throw new NullPointerException(); + return new Double(s); } /** - * The hashcode is the value of the expression:
- *
- * (int)(v^(v>>>32))
- *
- * where v is defined by:
- * long v = Double.doubleToLongBits(this.longValue());
+ * Parse the specified String as a double. The + * extended BNF grammar is as follows:
+ * 

+   * DecodableString:
+   *      ( [ - | + ] NaN )
+   *    | ( [ - | + ] Infinity )
+   *    | ( [ - | + ] FloatingPoint
+   *              [ f | F | d
+   *                | D] )
+   * FloatingPoint:
+   *      ( { Digit }+ [ . { Digit } ]
+   *              [ Exponent ] )
+   *    | ( . { Digit }+ [ Exponent ] )
+   * Exponent:
+   *      ( ( e | E )
+   *              [ - | + ] { Digit }+ )
+   * Digit: '0' through '9'
+   *
+ * + *

NaN and infinity are special cases, to allow parsing of the output + * of toString. Otherwise, the result is determined by calculating + * n * 10exponent to infinite precision, then rounding + * to the nearest double. Remember that many numbers cannot be precisely + * represented in floating point. In case of overflow, infinity is used, + * and in case of underflow, signed zero is used. Unlike Integer.parseInt, + * this does not accept Unicode digits outside the ASCII range. + * + *

If an unexpected character is found in the String, a + * NumberFormatException will be thrown. Leading and trailing + * 'whitespace' is ignored via String.trim(), but spaces + * internal to the actual number are not allowed. + * + *

To parse numbers according to another format, consider using + * {@link java.text.NumberFormat}. + * + * @XXX specify where/how we are not in accord with the spec. + * + * @param str the String to convert + * @return the double value of s + * @throws NumberFormatException if s cannot be parsed as a + * double + * @throws NullPointerException if s is null + * @see #MIN_VALUE + * @see #MAX_VALUE + * @see #POSITIVE_INFINITY + * @see #NEGATIVE_INFINITY + * @since 1.2 */ - public int hashCode () - { - long v = doubleToLongBits (value); - return (int) (v ^ (v >>> 32)); - } + public static native double parseDouble(String s); /** - * Return the value of this Double when cast to an - * int. + * Return true if the double has the same + * value as NaN, otherwise return false. + * + * @param v the double to compare + * @return whether the argument is NaN. */ - public int intValue () + public static boolean isNaN(double v) { - return (int) value; + // This works since NaN != NaN is the only reflexive inequality + // comparison which returns true. + return v != v; } /** - * Return the value of this Double when cast to a - * long. + * Return true if the double has a value + * equal to either NEGATIVE_INFINITY or + * POSITIVE_INFINITY, otherwise return false. + * + * @param v the double to compare + * @return whether the argument is (-/+) infinity. */ - public long longValue () + public static boolean isInfinite(double v) { - return (long) value; + return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY; } /** - * Return the value of this Double when cast to a - * float. + * Return true if the value of this Double + * is the same as NaN, otherwise return false. + * + * @return whether this Double is NaN */ - public float floatValue () + public boolean isNaN() { - return (float) value; + return isNaN(value); } /** - * Return the primitive double value represented by this - * Double. + * Return true if the value of this Double + * is the same as NEGATIVE_INFINITY or + * POSITIVE_INFINITY, otherwise return false. + * + * @return whether this Double is (-/+) infinity */ - public double doubleValue () + public boolean isInfinite() { - return value; + return isInfinite(value); } /** - * Return the result of calling new Double(java.lang.String). - * - * @param s the String to convert to a Double. - * @return a new Double representing the String's - * numeric value. + * Convert the double value of this Double + * to a String. This method calls + * Double.toString(double) to do its dirty work. * - * @exception NullPointerException thrown if String is - * null. - * @exception NumberFormatException thrown if String cannot - * be parsed as a double. - * @see #Double(java.lang.String) - * @see #parseDouble(java.lang.String) + * @return the String representation + * @see #toString(double) */ - public static Double valueOf (String s) throws NumberFormatException + public String toString() { - return new Double (s); + return toString(value); } /** - * Return true if the value of this Double - * is the same as NaN, otherwise return false. - * @return whether this Double is NaN. + * Return the value of this Double as a byte. + * + * @return the byte value + * @since 1.1 */ - public boolean isNaN () + public byte byteValue() { - return isNaN (value); + return (byte) value; } /** - * Return true if the double has the same - * value as NaN, otherwise return false. + * Return the value of this Double as a short. * - * @param v the double to compare - * @return whether the argument is NaN. + * @return the short value + * @since 1.1 */ - public static boolean isNaN (double v) + public short shortValue() { - // This works since NaN != NaN is the only reflexive inequality - // comparison which returns true. - return v != v; + return (short) value; } /** - * Return true if the value of this Double - * is the same as NEGATIVE_INFINITY or - * POSITIVE_INFINITY, otherwise return false. + * Return the value of this Double as an int. * - * @return whether this Double is (-/+) infinity. + * @return the int value */ - public boolean isInfinite () + public int intValue() { - return isInfinite (value); + return (int) value; } /** - * Return true if the double has a value - * equal to either NEGATIVE_INFINITY or - * POSITIVE_INFINITY, otherwise return false. + * Return the value of this Double as a long. * - * @param v the double to compare - * @return whether the argument is (-/+) infinity. + * @return the long value */ - public static boolean isInfinite (double v) + public long longValue() { - return (v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY); + return (long) value; } /** - * Returns 0 if the double value of the argument is - * equal to the value of this Double. Returns a number - * less than zero if the value of this Double is less - * than the double value of the argument, and returns a - * number greater than zero if the value of this Double - * is greater than the double value of the argument. - *
- * Double.NaN is greater than any number other than itself, - * even Double.POSITIVE_INFINITY. - *
- * 0.0d is greater than -0.0d. - * - * @param d the Double to compare to. - * @return 0 if the Doubles are the same, < 0 if this - * Double is less than the Double in - * in question, or > 0 if it is greater. - * @since 1.2 + * Return the value of this Double as a float. + * + * @return the float value */ - public int compareTo (Double d) + public float floatValue() { - return compare (value, d.value); + return (float) value; } /** - * Returns 0 if the first argument is equal to the second argument. - * Returns a number less than zero if the first argument is less than the - * second argument, and returns a number greater than zero if the first - * argument is greater than the second argument. - *
- * Double.NaN is greater than any number other than itself, - * even Double.POSITIVE_INFINITY. - *
- * 0.0d is greater than -0.0d. - * - * @param x the first double to compare. - * @param y the second double to compare. - * @return 0 if the arguments are the same, < 0 if the - * first argument is less than the second argument in - * in question, or > 0 if it is greater. - * @since 1.4 + * Return the value of this Double. + * + * @return the double value */ - public static int compare (double x, double y) + public double doubleValue() { - if (isNaN (x)) - return isNaN (y) ? 0 : 1; - if (isNaN (y)) - return -1; - // recall that 0.0 == -0.0, so we convert to infinites and try again - if (x == 0 && y == 0) - return (int) (1 / x - 1 / y); - if (x == y) - return 0; - - return x > y ? 1 : -1; + return value; } /** - * Compares the specified Object to this Double - * if and only if the Object is an instanceof - * Double. + * Return a hashcode representing this Object. Double's hash + * code is calculated by:
+ * long v = Double.doubleToLongBits(doubleValue());
+ * int hash = (int)(v^(v>>32)). * - * @param o the Object to compare to. - * @return 0 if the Doubles are the same, < 0 if this - * Double is less than the Double in - * in question, or > 0 if it is greater. - * @throws ClassCastException if the argument is not a Double + * @return this Object's hash code + * @see #doubleToLongBits(double) */ - public int compareTo (Object o) + public int hashCode() { - return compareTo ((Double) o); + long v = doubleToLongBits(value); + return (int) (v ^ (v >>> 32)); } /** - * Convert the double to a String. - *

- * - * Floating-point string representation is fairly complex: here is a - * rundown of the possible values. "[-]" indicates that a - * negative sign will be printed if the value (or exponent) is negative. - * "<number>" means a string of digits (0-9). - * "<digit>" means a single digit (0-9). - *

- * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - *
Value of FloatString Representation
[+-] 0[-]0.0
Between [+-] 10-3 and 107[-]number.number
Other numeric value[-]<digit>.<number>E[-]<number>
[+-] infinity[-]Infinity
NaNNaN
- * - * Yes, negative zero is a possible value. Note that there is - * always a . and at least one digit printed after - * it: even if the number is 3, it will be printed as 3.0. - * After the ".", all digits will be printed except trailing zeros. No - * truncation or rounding is done by this function. - * + * Returns true if obj is an instance of + * Double and represents the same double value. Unlike comparing + * two doubles with ==, this treats two instances of + * Double.NaN as equal, but treats 0.0 and + * -0.0 as unequal. * - * @XXX specify where we are not in accord with the spec. + *

Note that d1.equals(d2) is identical to + * doubleToLongBits(d1.doubleValue()) == + * doubleToLongBits(d2.doubleValue()). * - * @param d the double to convert - * @return the String representing the double. + * @param obj the object to compare + * @return whether the objects are semantically equal */ - public static String toString (double d) + public boolean equals(Object obj) { - return toString (d, false); - } + if (! (obj instanceof Double)) + return false; - static native String toString (double d, boolean isFloat); + double d = ((Double) obj).value; + + // Avoid call to native method. However, some implementations, like gcj, + // are better off using floatToIntBits(value) == floatToIntBits(f). + // Check common case first, then check NaN and 0. + if (value == d) + return (value != 0) || (1 / value == 1 / d); + return isNaN(value) && isNaN(d); + } /** - * Return the long bits of the specified double. - * The result of this function can be used as the argument to - * Double.longBitsToDouble(long) to obtain the - * original double value. + * Convert the double to the IEEE 754 floating-point "double format" bit + * layout. Bit 63 (the most significant) is the sign bit, bits 62-52 + * (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0 + * (masked by 0x000fffffffffffffL) are the mantissa. This function + * collapses all versions of NaN to 0x7ff8000000000000L. The result of this + * function can be used as the argument to + * Double.longBitsToDouble(long) to obtain the original + * double value. * * @param value the double to convert - * @return the bits of the double. + * @return the bits of the double + * @see #longBitsToDouble(long) */ - public static native long doubleToLongBits (double value); + public static native long doubleToLongBits(double value); /** - * Return the long bits of the specified double. - * The result of this function can be used as the argument to - * Double.longBitsToDouble(long) to obtain the - * original double value. This method differs from - * doubleToLongBits in that it does not collapse - * NaN values. + * Convert the double to the IEEE 754 floating-point "double format" bit + * layout. Bit 63 (the most significant) is the sign bit, bits 62-52 + * (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0 + * (masked by 0x000fffffffffffffL) are the mantissa. This function + * leaves NaN alone, rather than collapsing to a canonical value. The + * result of this function can be used as the argument to + * Double.longBitsToDouble(long) to obtain the original + * double value. * * @param value the double to convert - * @return the bits of the double. - */ - public static native long doubleToRawLongBits (double value); - - /** - * Return the double represented by the long - * bits specified. - * - * @param bits the long bits representing a double - * @return the double represented by the bits. - */ - public static native double longBitsToDouble (long bits); - - /** - * Parse the specified String as a double. - * - * The number is really read as n * 10exponent. The - * first number is n, and if there is an "E" - * ("e" is also acceptable), then the integer after that is - * the exponent. - *

- * Here are the possible forms the number can take: - *
- * - * - * - * - * - * - *
FormExamples
[+-]<number>[.]345., -10, 12
[+-]<number>.<number>40.2, 80.00, -12.30
[+-]<number>[.]E[+-]<number>80E12, -12e+7, 4.E-123
[+-]<number>.<number>E[+-]<number>6.02e-22, -40.2E+6, 12.3e9
- * - * "[+-]" means either a plus or minus sign may go there, or - * neither, in which case + is assumed. - *
- * "[.]" means a dot may be placed here, but is optional. - *
- * "<number>" means a string of digits (0-9), basically - * an integer. "<number>.<number>" is basically - * a real number, a floating-point value. - *

- * - * Remember that a double has a limited range. If the - * number you specify is greater than Double.MAX_VALUE or less - * than -Double.MAX_VALUE, it will be set at - * Double.POSITIVE_INFINITY or - * Double.NEGATIVE_INFINITY, respectively. - *

- * Note also that double does not have perfect precision. Many - * numbers cannot be precisely represented. The number you specify - * will be rounded to the nearest representable value. - * Double.MIN_VALUE is the margin of error for - * double values. - *

- * If an unexpected character is found in the String, a - * NumberFormatException will be thrown. Spaces are not - * allowed, and will cause the same exception. + * @return the bits of the double + * @see #longBitsToDouble(long) + */ + public static native long doubleToRawLongBits(double value); + + /** + * Convert the argument in IEEE 754 floating-point "double format" bit + * layout to the corresponding float. Bit 63 (the most significant) is the + * sign bit, bits 62-52 (masked by 0x7ff0000000000000L) represent the + * exponent, and bits 51-0 (masked by 0x000fffffffffffffL) are the mantissa. + * This function leaves NaN alone, so that you can recover the bit pattern + * with Double.doubleToRawLongBits(double). * - * @XXX specify where/how we are not in accord with the spec. + * @param bits the bits to convert + * @return the double represented by the bits + * @see #doubleToLongBits(double) + * @see #doubleToRawLongBits(double) + */ + public static native double longBitsToDouble(long bits); + + /** + * Compare two Doubles numerically by comparing their double + * values. The result is positive if the first is greater, negative if the + * second is greater, and 0 if the two are equal. However, this special + * cases NaN and signed zero as follows: NaN is considered greater than + * all other doubles, including POSITIVE_INFINITY, and positive + * zero is considered greater than negative zero. * - * @param str the String to convert - * @return the value of the String as a double. - * @exception NumberFormatException when the string cannot be parsed to a - * double. - * @exception NullPointerException when the string is null. - * @see #MIN_VALUE - * @see #MAX_VALUE - * @see #POSITIVE_INFINITY - * @see #NEGATIVE_INFINITY + * @param d the Double to compare + * @return the comparison + * @since 1.2 + */ + public int compareTo(Double d) + { + return compare(value, d.value); + } + + /** + * Behaves like compareTo(Double) unless the Object + * is not an Double. + * + * @param o the object to compare + * @return the comparison + * @throws ClassCastException if the argument is not a Double + * @see #compareTo(Double) + * @see Comparable * @since 1.2 */ - public static native double parseDouble (String s) - throws NumberFormatException; + public int compareTo(Object o) + { + return compare(value, ((Double) o).value); + } + + /** + * Behaves like new Double(x).compareTo(new Double(y)); in + * other words this compares two doubles, special casing NaN and zero, + * without the overhead of objects. + * + * @param x the first double to compare + * @param y the second double to compare + * @return the comparison + * @since 1.4 + */ + public static int compare(double x, double y) + { + if (isNaN(x)) + return isNaN(y) ? 0 : 1; + if (isNaN(y)) + return -1; + // recall that 0.0 == -0.0, so we convert to infinites and try again + if (x == 0 && y == 0) + return (int) (1 / x - 1 / y); + if (x == y) + return 0; + + return x > y ? 1 : -1; + } + + /** + * Helper method to convert to string. + * + * @param d the double to convert + * @param isFloat true if the conversion is requested by Float (results in + * fewer digits) + */ + // Package visible for use by Float. + static native String toString(double d, boolean isFloat); /** - * Initialize JNI cache. This method is called only by the + * Initialize JNI cache. This method is called only by the * static initializer when using JNI. */ - private static native void initIDs (); + private static native void initIDs(); } -- cgit v1.2.3