*             parsable number.     */    public static Double valueOf(String s) throws NumberFormatException {        return new Double(FloatingDecimal.readJavaFormatString(s).doubleValue());    }     /**     * Returns a {@code Double} instance representing the specified     * {@code double} value.     * If a new {@code Double} instance is not required, this method     * should generally be used in preference to the constructor     * {@link #Double(double)}, as this method is likely to yield     * significantly better space and time performance by caching     * frequently requested values.     *     * @param  d a double value.     * @return a {@code Double} instance representing {@code d}.     * @since  1.5     */    public static Double valueOf(double d) {        return new Double(d);    }     /**     * Returns a new {@code double} initialized to the value     * represented by the specified {@code String}, as performed     * by the {@code valueOf} method of class     * {@code Double}.     *     * @param  s   the string to be parsed.     * @return the {@code double} value represented by the string     *         argument.     * @throws NullPointerException  if the string is null     * @throws NumberFormatException if the string does not contain     *         a parsable {@code double}.     * @see    java.lang.Double#valueOf(String)     * @since 1.2     */    public static double parseDouble(String s) throws NumberFormatException {        return FloatingDecimal.readJavaFormatString(s).doubleValue();    }     /**     * Returns {@code true} if the specified number is a     * Not-a-Number (NaN) value, {@code false} otherwise.     *     * @param   v   the value to be tested.     * @return  {@code true} if the value of the argument is NaN;     *          {@code false} otherwise.     */    static public boolean isNaN(double v) {        return (v != v);    }     /**     * Returns {@code true} if the specified number is infinitely     * large in magnitude, {@code false} otherwise.     *     * @param   v   the value to be tested.     * @return  {@code true} if the value of the argument is positive     *          infinity or negative infinity; {@code false} otherwise.     */    static public boolean isInfinite(double v) {        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);    }     /**     * The value of the Double.     *     * @serial     */    private final double value;     /**     * Constructs a newly allocated {@code Double} object that     * represents the primitive {@code double} argument.     *     * @param   value   the value to be represented by the {@code Double}.     */    public Double(double value) {        this.value = value;    }     /**     * Constructs a newly allocated {@code Double} object that     * represents the floating-point value of type {@code double}     * represented by the string. The string is converted to a     * {@code double} value as if by the {@code valueOf} method.     *     * @param  s  a string to be converted to a {@code Double}.     * @throws    NumberFormatException  if the string does not contain a     *            parsable number.     * @see       java.lang.Double#valueOf(java.lang.String)     */    public Double(String s) throws NumberFormatException {        // REMIND: this is inefficient        this(valueOf(s).doubleValue());    }     /**     * Returns {@code true} if this {@code Double} value is     * a Not-a-Number (NaN), {@code false} otherwise.     *     * @return  {@code true} if the value represented by this object is     *          NaN; {@code false} otherwise.     */    public boolean isNaN() {        return isNaN(value);    }     /**     * Returns {@code true} if this {@code Double} value is     * infinitely large in magnitude, {@code false} otherwise.     *     * @return  {@code true} if the value represented by this object is     *          positive infinity or negative infinity;     *          {@code false} otherwise.     */    public boolean isInfinite() {        return isInfinite(value);    }     /**     * Returns a string representation of this {@code Double} object.     * The primitive {@code double} value represented by this     * object is converted to a string exactly as if by the method     * {@code toString} of one argument.     *     * @return  a {@code String} representation of this object.     * @see java.lang.Double#toString(double)     */    public String toString() {        return toString(value);    }     /**     * Returns the value of this {@code Double} as a {@code byte} (by     * casting to a {@code byte}).     *     * @return  the {@code double} value represented by this object     *          converted to type {@code byte}     * @since JDK1.1     */    public byte byteValue() {        return (byte)value;    }     /**     * Returns the value of this {@code Double} as a     * {@code short} (by casting to a {@code short}).     *     * @return  the {@code double} value represented by this object     *          converted to type {@code short}     * @since JDK1.1     */    public short shortValue() {        return (short)value;    }     /**     * Returns the value of this {@code Double} as an     * {@code int} (by casting to type {@code int}).     *     * @return  the {@code double} value represented by this object     *          converted to type {@code int}     */    public int intValue() {        return (int)value;    }     /**     * Returns the value of this {@code Double} as a     * {@code long} (by casting to type {@code long}).     *     * @return  the {@code double} value represented by this object     *          converted to type {@code long}     */    public long longValue() {        return (long)value;    }     /**     * Returns the {@code float} value of this     * {@code Double} object.     *     * @return  the {@code double} value represented by this object     *          converted to type {@code float}     * @since JDK1.0     */    public float floatValue() {        return (float)value;    }     /**     * Returns the {@code double} value of this     * {@code Double} object.     *     * @return the {@code double} value represented by this object     */    public double doubleValue() {        return (double)value;    }     /**     * Returns a hash code for this {@code Double} object. The     * result is the exclusive OR of the two halves of the     * {@code long} integer bit representation, exactly as     * produced by the method {@link #doubleToLongBits(double)}, of     * the primitive {@code double} value represented by this     * {@code Double} object. That is, the hash code is the value     * of the expression:     *     * <blockquote>     *  {@code (int)(v^(v>>>32))}     * </blockquote>     *     * where {@code v} is defined by:     *     * <blockquote>     *  {@code long v = Double.doubleToLongBits(this.doubleValue());}     * </blockquote>     *     * @return  a {@code hash code} value for this object.     */    public int hashCode() {        long bits = doubleToLongBits(value);        return (int)(bits ^ (bits >>> 32));    }     /**     * Compares this object against the specified object.  The result     * is {@code true} if and only if the argument is not     * {@code null} and is a {@code Double} object that     * represents a {@code double} that has the same value as the     * {@code double} represented by this object. For this     * purpose, two {@code double} values are considered to be     * the same if and only if the method {@link     * #doubleToLongBits(double)} returns the identical     * {@code long} value when applied to each.     *     * <p>Note that in most cases, for two instances of class     * {@code Double}, {@code d1} and {@code d2}, the     * value of {@code d1.equals(d2)} is {@code true} if and     * only if     *     * <blockquote>     *  {@code d1.doubleValue() == d2.doubleValue()}     * </blockquote>     *     * <p>also has the value {@code true}. However, there are two     * exceptions:     * <ul>     * <li>If {@code d1} and {@code d2} both represent     *     {@code Double.NaN}, then the {@code equals} method     *     returns {@code true}, even though     *     {@code Double.NaN==Double.NaN} has the value     *     {@code false}.     * <li>If {@code d1} represents {@code +0.0} while     *     {@code d2} represents {@code -0.0}, or vice versa,     *     the {@code equal} test has the value {@code false},     *     even though {@code +0.0==-0.0} has the value {@code true}.     * </ul>     * This definition allows hash tables to operate properly.     * @param   obj   the object to compare with.     * @return  {@code true} if the objects are the same;     *          {@code false} otherwise.     * @see java.lang.Double#doubleToLongBits(double)     */    public boolean equals(Object obj) {        return (obj instanceof Double)               && (doubleToLongBits(((Double)obj).value) ==                      doubleToLongBits(value));    }     /**     * Returns a representation of the specified floating-point value     * according to the IEEE 754 floating-point "double     * format" bit layout.     *     * <p>Bit 63 (the bit that is selected by the mask     * {@code 0x8000000000000000L}) represents the sign of the     * floating-point number. Bits     * 62-52 (the bits that are selected by the mask     * {@code 0x7ff0000000000000L}) represent the exponent. Bits 51-0     * (the bits that are selected by the mask     * {@code 0x000fffffffffffffL}) represent the significand     * (sometimes called the mantissa) of the floating-point number.     *     * <p>If the argument is positive infinity, the result is     * {@code 0x7ff0000000000000L}.     *     * <p>If the argument is negative infinity, the result is     * {@code 0xfff0000000000000L}.     *     * <p>If the argument is NaN, the result is     * {@code 0x7ff8000000000000L}.     *     * <p>In all cases, the result is a {@code long} integer that, when     * given to the {@link #longBitsToDouble(long)} method, will produce a     * floating-point value the same as the argument to     * {@code doubleToLongBits} (except all NaN values are     * collapsed to a single "canonical" NaN value).     *     * @param   value   a {@code double} precision floating-point number.     * @return the bits that represent the floating-point number.     */    public static long doubleToLongBits(double value) {        long result = doubleToRawLongBits(value);        // Check for NaN based on values of bit fields, maximum        // exponent and nonzero significand.        if ( ((result & DoubleConsts.EXP_BIT_MASK) ==              DoubleConsts.EXP_BIT_MASK) &&             (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)            result = 0x7ff8000000000000L;        return result;    }     /**     * Returns a representation of the specified floating-point value     * according to the IEEE 754 floating-point "double     * format" bit layout, preserving Not-a-Number (NaN) values.     *     * <p>Bit 63 (the bit that is selected by the mask     * {@code 0x8000000000000000L}) represents the sign of the     * floating-point number. Bits     * 62-52 (the bits that are selected by the mask     * {@code 0x7ff0000000000000L}) represent the exponent. Bits 51-0     * (the bits that are selected by the mask     * {@code 0x000fffffffffffffL}) represent the significand     * (sometimes called the mantissa) of the floating-point number.     *     * <p>If the argument is positive infinity, the result is     * {@code 0x7ff0000000000000L}.     *     * <p>If the argument is negative infinity, the result is     * {@code 0xfff0000000000000L}.     *     * <p>If the argument is NaN, the result is the {@code long}     * integer representing the actual NaN value.  Unlike the     * {@code doubleToLongBits} method,     * {@code doubleToRawLongBits} does not collapse all the bit     * patterns encoding a NaN to a single "canonical" NaN     * value.     *     * <p>In all cases, the result is a {@code long} integer that,     * when given to the {@link #longBitsToDouble(long)} method, will     * produce a floating-point value the same as the argument to     * {@code doubleToRawLongBits}.     *     * @param   value   a {@code double} precision floating-point number.     * @return the bits that represent the floating-point number.     * @since 1.3     */    public static native long doubleToRawLongBits(double value);     /**     * Returns the {@code double} value corresponding to a given     * bit representation.     * The argument is considered to be a representation of a     * floating-point value according to the IEEE 754 floating-point     * "double format" bit layout.     *     * <p>If the argument is {@code 0x7ff0000000000000L}, the result     * is positive infinity.     *     * <p>If the argument is {@code 0xfff0000000000000L}, the result     * is negative infinity.     *     * <p>If the argument is any value in the range     * {@code 0x7ff0000000000001L} through     * {@code 0x7fffffffffffffffL} or in the range     * {@code 0xfff0000000000001L} through     * {@code 0xffffffffffffffffL}, the result is a NaN.  No IEEE     * 754 floating-point operation provided by Java can distinguish     * between two NaN values of the same type with different bit     * patterns.  Distinct values of NaN are only distinguishable by     * use of the {@code Double.doubleToRawLongBits} method.     *     * <p>In all other cases, let <i>s</i>, <i>e</i>, and <i>m</i> be three     * values that can be computed from the argument:     *     * <blockquote><pre>     * int s = ((bits &gt;&gt; 63) == 0) ? 1 : -1;     * int e = (int)((bits &gt;&gt; 52) & 0x7ffL);     * long m = (e == 0) ?     *                 (bits & 0xfffffffffffffL) &lt;&lt; 1 :     *                 (bits & 0xfffffffffffffL) | 0x10000000000000L;     * </pre></blockquote>     *     * Then the floating-point result equals the value of the mathematical     * expression <i>s</i>&middot;<i>m</i>&middot;2<sup><i>e</i>-1075</sup>.     *     * <p>Note that this method may not be able to return a     * {@code double} NaN with exactly same bit pattern as the     * {@code long} argument.  IEEE 754 distinguishes between two     * kinds of NaNs, quiet NaNs and <i>signaling NaNs</i>.  The     * differences between the two kinds of NaN are generally not     * visible in Java.  Arithmetic operations on signaling NaNs turn     * them into quiet NaNs with a different, but often similar, bit     * pattern.  However, on some processors merely copying a     * signaling NaN also performs that conversion.  In particular,     * copying a signaling NaN to return it to the calling method     * may perform this conversion.  So {@code longBitsToDouble}     * may not be able to return a {@code double} with a     * signaling NaN bit pattern.  Consequently, for some     * {@code long} values,     * {@code doubleToRawLongBits(longBitsToDouble(start))} may     * <i>not</i> equal {@code start}.  Moreover, which     * particular bit patterns represent signaling NaNs is platform     * dependent; although all NaN bit patterns, quiet or signaling,     * must be in the NaN range identified above.     *     * @param   bits   any {@code long} integer.     * @return  the {@code double} floating-point value with the same     *          bit pattern.     */    public static native double longBitsToDouble(long bits);     /**     * Compares two {@code Double} objects numerically.  There     * are two ways in which comparisons performed by this method     * differ from those performed by the Java language numerical     * comparison operators ({@code <, <=, ==, >=, >})     * when applied to primitive {@code double} values:     * <ul><li>     *          {@code Double.NaN} is considered by this method     *          to be equal to itself and greater than all other     *          {@code double} values (including     *          {@code Double.POSITIVE_INFINITY}).     * <li>     *          {@code 0.0d} is considered by this method to be greater     *          than {@code -0.0d}.     * </ul>     * This ensures that the <i>natural ordering</i> of     * {@code Double} objects imposed by this method is <i>consistent     * with equals</i>.     *     * @param   anotherDouble   the {@code Double} to be compared.     * @return  the value {@code 0} if {@code anotherDouble} is     *          numerically equal to this {@code Double}; a value     *          less than {@code 0} if this {@code Double}     *          is numerically less than {@code anotherDouble};     *          and a value greater than {@code 0} if this     *          {@code Double} is numerically greater than     *          {@code anotherDouble}.     *     * @since   1.2     */    public int compareTo(Double anotherDouble) {        return Double.compare(value, anotherDouble.value);    }     /**     * Compares the two specified {@code double} values. The sign     * of the integer value returned is the same as that of the     * integer that would be returned by the call:     * <pre>     *    new Double(d1).compareTo(new Double(d2))     * </pre>     *     * @param   d1        the first {@code double} to compare     * @param   d2        the second {@code double} to compare     * @return  the value {@code 0} if {@code d1} is     *          numerically equal to {@code d2}; a value less than     *          {@code 0} if {@code d1} is numerically less than     *          {@code d2}; and a value greater than {@code 0}     *          if {@code d1} is numerically greater than     *          {@code d2}.     * @since 1.4     */    public static int compare(double d1, double d2) {        if (d1 < d2)            return -1;           // Neither val is NaN, thisVal is smaller        if (d1 > d2)            return 1;            // Neither val is NaN, thisVal is larger         // Cannot use doubleToRawLongBits because of possibility of NaNs.        long thisBits    = Double.doubleToLongBits(d1);        long anotherBits = Double.doubleToLongBits(d2);         return (thisBits == anotherBits ?  0 : // Values are equal                (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)                 1));                          // (0.0, -0.0) or (NaN, !NaN)    }     /** use serialVersionUID from JDK 1.0.2 for interoperability */    private static final long serialVersionUID = -9172774392245257468L;}

Lines 501–988 of 988. Previous lines