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/Float.java | 576 ++++++++++++++++++++++--------------------- 1 file changed, 289 insertions(+), 287 deletions(-) (limited to 'libjava/java/lang/Float.java') diff --git a/libjava/java/lang/Float.java b/libjava/java/lang/Float.java index 7c0d19914e2..930b8415076 100644 --- a/libjava/java/lang/Float.java +++ b/libjava/java/lang/Float.java @@ -1,4 +1,4 @@ -/* java.lang.Float +/* Float.java -- object wrapper for float 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 Float represent primitive * float values. @@ -55,10 +49,17 @@ 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 Float extends Number implements Comparable { + /** + * Compatible with JDK 1.0+. + */ + private static final long serialVersionUID = -2671257302660747028L; + /** * The maximum positive value a double may represent * is 3.4028235e+38f. @@ -74,46 +75,50 @@ public final class Float extends Number implements Comparable /** * The value of a float representation -1.0/0.0, negative infinity. */ - public static final float NEGATIVE_INFINITY = -1.0f/0.0f; + public static final float NEGATIVE_INFINITY = -1.0f / 0.0f; /** * The value of a float representation 1.0/0.0, positive infinity. */ - public static final float POSITIVE_INFINITY = 1.0f/0.0f; + public static final float POSITIVE_INFINITY = 1.0f / 0.0f; /** * All IEEE 754 values of NaN have the same value in Java. */ - public static final float NaN = 0.0f/0.0f; + public static final float NaN = 0.0f / 0.0f; /** - * The primitive type float is represented by this + * The primitive type float is represented by this * Class object. + * @since 1.1 */ public static final Class TYPE = VMClassLoader.getPrimitiveClass('F'); /** * The immutable value of this Float. + * + * @serial the wrapped float */ private final float value; - private static final long serialVersionUID = -2671257302660747028L; - + /** + * Load native routines necessary for this class. + */ static { if (Configuration.INIT_LOAD_LIBRARY) { - System.loadLibrary ("javalang"); + System.loadLibrary("javalang"); } } /** - * Create a float from the primitive Float + * Create a Float from the primitive float * specified. * - * @param value the Float argument + * @param value the float argument */ - public Float (float value) + public Float(float value) { this.value = value; } @@ -124,379 +129,395 @@ public final class Float extends Number implements Comparable * * @param value the double argument */ - public Float (double value) + public Float(double value) { - this.value = (float)value; + this.value = (float) value; } /** * Create a Float from the specified String. - * * This method calls Float.parseFloat(). * - * @exception NumberFormatException when the String cannot - * be parsed into a Float. * @param s the String to convert - * @see #parseFloat(java.lang.String) + * @throws NumberFormatException if s cannot be parsed as a + * float + * @throws NullPointerException if s is null + * @see #parseFloat(String) + */ + public Float(String s) + { + value = parseFloat(s); + } + + /** + * Convert the float 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').
+ * + * + * + * + * + * + * + * + * + * + *
Value of FloatString 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 float. + * + *

To create other output formats, use {@link java.text.NumberFormat}. + * + * @XXX specify where we are not in accord with the spec. + * + * @param f the float to convert + * @return the String representing the float + */ + public static String toString(float f) + { + return Double.toString(f, true); + } + + /** + * Creates a new Float object using the String. + * + * @param s the String to convert + * @return the new Float + * @throws NumberFormatException if s cannot be parsed as a + * float + * @throws NullPointerException if s is null + * @see #parseFloat(String) */ - public Float (String s) throws NumberFormatException + public static Float valueOf(String s) { - this.value = parseFloat (s); + return new Float(parseFloat(s)); } /** - * Parse the specified String as a float. - * - * 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 float has a limited range. If the - * number you specify is greater than Float.MAX_VALUE or less - * than -Float.MAX_VALUE, it will be set at - * Float.POSITIVE_INFINITY or - * Float.NEGATIVE_INFINITY, respectively. - *

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

- * If an unexpected character is found in the String, a - * NumberFormatException will be thrown. Spaces are not - * allowed and will cause this exception to be thrown. + * Parse the specified String as a float. 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 float. 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 value of the String as a float. - * @exception NumberFormatException when the string cannot be parsed to a - * float. - * @since JDK 1.2 + * @return the float value of s + * @throws NumberFormatException if s cannot be parsed as a + * float + * @throws NullPointerException if s is null * @see #MIN_VALUE * @see #MAX_VALUE * @see #POSITIVE_INFINITY * @see #NEGATIVE_INFINITY + * @since 1.2 */ - public static float parseFloat (String s) throws NumberFormatException + public static float parseFloat(String s) { - // The spec says that parseFloat() should work like - // Double.valueOf(). This is equivalent, in our implementation, - // but more efficient. - return (float) Double.parseDouble (s); + // XXX Rounding parseDouble() causes some errors greater than 1 ulp from + // the infinitely precise decimal. + return (float) Double.parseDouble(s); } /** - * Convert the float value of this Float - * to a String. This method calls - * Float.toString(float) to do its dirty work. + * Return true if the float has the same + * value as NaN, otherwise return false. * - * @return the String representation of this Float. - * @see #toString(float) + * @param v the float to compare + * @return whether the argument is NaN */ - public String toString () + public static boolean isNaN(float v) { - return toString (value); + // This works since NaN != NaN is the only reflexive inequality + // comparison which returns true. + return v != v; } /** - * If the Object is not null, is an - * instanceof Float, and represents - * the same primitive float value return - * true. Otherwise false is returned. - *

- * Note that there are two differences between == and - * equals(). 0.0f == -0.0f returns true - * but new Float(0.0f).equals(new Float(-0.0f)) returns - * false. And Float.NaN == Float.NaN returns - * false, but - * new Float(Float.NaN).equals(new Float(Float.NaN)) returns - * true. + * Return true if the float has a value + * equal to either NEGATIVE_INFINITY or + * POSITIVE_INFINITY, otherwise return false. * - * @param obj the object to compare to - * @return whether the objects are semantically equal. + * @param v the float to compare + * @return whether the argument is (-/+) infinity */ - public boolean equals (Object obj) + public static boolean isInfinite(float v) { - if (!(obj instanceof Float)) - return false; - - float f = ((Float) obj).value; - - // GCJ LOCAL: this implementation is probably faster than - // Classpath's, especially once we inline floatToIntBits. - return floatToIntBits (value) == floatToIntBits (f); - // END GCJ LOCAL + return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY; } /** - * Return a hashcode representing this Object. - * Float's hash code is calculated by calling the - * floatToIntBits() function. - * @return this Object's hash code. - * @see java.lang.Float.floatToIntBits(float) + * Return true if the value of this Float + * is the same as NaN, otherwise return false. + * + * @return whether this Float is NaN */ - public int hashCode () + public boolean isNaN() { - return floatToIntBits (value); + return isNaN(value); } /** - * Return the value of this Double when cast to an - * int. + * Return true if the value of this Float + * is the same as NEGATIVE_INFINITY or + * POSITIVE_INFINITY, otherwise return false. + * + * @return whether this Float is (-/+) infinity */ - public int intValue () + public boolean isInfinite() { - return (int) value; + return isInfinite(value); } /** - * Return the value of this Double when cast to a - * long. + * Convert the float value of this Float + * to a String. This method calls + * Float.toString(float) to do its dirty work. + * + * @return the String representation + * @see #toString(float) */ - public long longValue () + public String toString() { - return (long) value; + return toString(value); } /** - * Return the value of this Double when cast to a - * float. + * Return the value of this Float as a byte. + * + * @return the byte value + * @since 1.1 */ - public float floatValue () + public byte byteValue() { - return (float) value; + return (byte) value; } /** - * Return the primitive double value represented by this - * Double. + * Return the value of this Float as a short. + * + * @return the short value + * @since 1.1 */ - public double doubleValue () + public short shortValue() { - return (double) value; + return (short) value; } /** - * Convert the float to a String. - *

+ * Return the value of this Integer as an int. * - * 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. - * - * @XXX specify where we are not in accord with the spec. - * - * @param f the float to convert - * @return the String representing the float. + * @return the int value */ - public static String toString (float f) + public int intValue() { - return Double.toString ((double) f, true); + return (int) value; } /** - * Return the result of calling new Float(java.lang.String). - * - * @param s the String to convert to a Float. - * @return a new Float representing the String's - * numeric value. + * Return the value of this Integer as a long. * - * @exception NumberFormatException thrown if String cannot - * be parsed as a double. - * @see #Float(java.lang.String) - * @see #parseFloat(java.lang.String) + * @return the long value */ - public static Float valueOf (String s) throws NumberFormatException + public long longValue() { - return new Float (s); + return (long) value; } /** - * Return true if the value of this Float - * is the same as NaN, otherwise return false. - * @return whether this Float is NaN. + * Return the value of this Float. + * + * @return the float value */ - public boolean isNaN () + public float floatValue() { - return isNaN (value); + return value; } /** - * Return true if the float has the same - * value as NaN, otherwise return false. + * Return the value of this Float as a double * - * @param v the float to compare - * @return whether the argument is NaN. + * @return the double value */ - public static boolean isNaN (float v) + public double doubleValue() { - // This works since NaN != NaN is the only reflexive inequality - // comparison which returns true. - return v != v; + return value; } /** - * Return true if the value of this Float - * is the same as NEGATIVE_INFINITY or - * POSITIVE_INFINITY, otherwise return false. + * Return a hashcode representing this Object. Float's hash + * code is calculated by calling floatToIntBits(floatValue()). * - * @return whether this Float is (-/+) infinity. + * @return this Object's hash code + * @see #floatToIntBits(float) */ - public boolean isInfinite () + public int hashCode() { - return isInfinite (value); + return floatToIntBits(value); } /** - * Return true if the float has a value - * equal to either NEGATIVE_INFINITY or - * POSITIVE_INFINITY, otherwise return false. + * Returns true if obj is an instance of + * Float and represents the same float value. Unlike comparing + * two floats with ==, this treats two instances of + * Float.NaN as equal, but treats 0.0 and + * -0.0 as unequal. * - * @param v the float to compare - * @return whether the argument is (-/+) infinity. + *

Note that f1.equals(f2) is identical to + * floatToIntBits(f1.floatValue()) == + * floatToIntBits(f2.floatValue()). + * + * @param obj the object to compare + * @return whether the objects are semantically equal */ - public static boolean isInfinite (float v) + public boolean equals(Object obj) { - return (v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY); + if (! (obj instanceof Float)) + return false; + + float f = ((Float) 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 == f) + return (value != 0) || (1 / value == 1 / f); + return isNaN(value) && isNaN(f); } /** - * Return the int bits of the specified float. - * The result of this function can be used as the argument to - * Float.intBitsToFloat(long) to obtain the + * Convert the float to the IEEE 754 floating-point "single format" bit + * layout. Bit 31 (the most significant) is the sign bit, bits 30-23 + * (masked by 0x7f800000) represent the exponent, and bits 22-0 + * (masked by 0x007fffff) are the mantissa. This function collapses all + * versions of NaN to 0x7fc00000. The result of this function can be used + * as the argument to Float.intBitsToFloat(int) to obtain the * original float value. * * @param value the float to convert - * @return the bits of the float. + * @return the bits of the float + * @see #intBitsToFloat(int) */ - public static native int floatToIntBits (float value); + public static native int floatToIntBits(float value); /** - * Return the int bits of the specified float. - * The result of this function can be used as the argument to - * Float.intBitsToFloat(long) to obtain the - * original float value. The difference between - * this function and floatToIntBits is that this - * function does not collapse NaN values. + * Convert the float to the IEEE 754 floating-point "single format" bit + * layout. Bit 31 (the most significant) is the sign bit, bits 30-23 + * (masked by 0x7f800000) represent the exponent, and bits 22-0 + * (masked by 0x007fffff) 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 Float.intBitsToFloat(int) to + * obtain the original float value. * * @param value the float to convert - * @return the bits of the float. + * @return the bits of the float + * @see #intBitsToFloat(int) */ - public static native int floatToRawIntBits (float value); + public static native int floatToRawIntBits(float value); /** - * Return the float represented by the long - * bits specified. + * Convert the argument in IEEE 754 floating-point "single format" bit + * layout to the corresponding float. Bit 31 (the most significant) is the + * sign bit, bits 30-23 (masked by 0x7f800000) represent the exponent, and + * bits 22-0 (masked by 0x007fffff) are the mantissa. This function leaves + * NaN alone, so that you can recover the bit pattern with + * Float.floatToRawIntBits(float). * - * @param bits the long bits representing a double - * @return the float represented by the bits. + * @param bits the bits to convert + * @return the float represented by the bits + * @see #floatToIntBits(float) + * @see #floatToRawIntBits(float) */ - public static native float intBitsToFloat (int bits); + public static native float intBitsToFloat(int bits); /** - * Returns 0 if the float value of the argument is - * equal to the value of this Float. Returns a number - * less than zero if the value of this Float is less - * than the Float value of the argument, and returns a - * number greater than zero if the value of this Float - * is greater than the float value of the argument. - *
- * Float.NaN is greater than any number other than itself, - * even Float.POSITIVE_INFINITY. - *
- * 0.0 is greater than -0.0. + * Compare two Floats numerically by comparing their float + * 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 floats, including POSITIVE_INFINITY, and positive + * zero is considered greater than negative zero. * - * @param f the Float to compare to. - * @return 0 if the Floats are the same, < 0 if this - * Float is less than the Float in - * in question, or > 0 if it is greater. + * @param f the Float to compare + * @return the comparison + * @since 1.2 + */ + public int compareTo(Float f) + { + return compare(value, f.value); + } + + /** + * Behaves like compareTo(Float) unless the Object + * is not an Float. * + * @param o the object to compare + * @return the comparison + * @throws ClassCastException if the argument is not a Float + * @see #compareTo(Float) + * @see Comparable * @since 1.2 */ - public int compareTo (Float f) + public int compareTo(Object o) { - return compare (value, f.value); + return compare(value, ((Float) o).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. - *
- * Float.NaN is greater than any number other than itself, - * even Float.POSITIVE_INFINITY. - *
- * 0.0 is greater than -0.0. - * - * @param x the first float to compare. - * @param y the second float 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. + * Behaves like new Float(x).compareTo(new Float(y)); in + * other words this compares two floats, special casing NaN and zero, + * without the overhead of objects. + * + * @param x the first float to compare + * @param y the second float to compare + * @return the comparison * @since 1.4 */ - public static int compare (float x, float y) + public static int compare(float x, float y) { - if (isNaN (x)) - return isNaN (y) ? 0 : 1; - if (isNaN (y)) + if (isNaN(x)) + return isNaN(y) ? 0 : 1; + if (isNaN(y)) return -1; // recall that 0.0 == -0.0, so we convert to infinities and try again if (x == 0 && y == 0) @@ -506,23 +527,4 @@ public final class Float extends Number implements Comparable return x > y ? 1 : -1; } - - /** - * Compares the specified Object to this Float - * if and only if the Object is an instanceof - * Float. - * Otherwise it throws a ClassCastException - * - * @param o the Object to compare to. - * @return 0 if the Floats are the same, < 0 if this - * Float is less than the Float in - * in question, or > 0 if it is greater. - * @throws ClassCastException if the argument is not a Float - * - * @since 1.2 - */ - public int compareTo (Object o) - { - return compareTo ((Float) o); - } } -- cgit v1.2.1