/* * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code 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 General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.lang; import sun.misc.FloatingDecimal;import sun.misc.FpUtils;import sun.misc.DoubleConsts; /** * The {@code Double} class wraps a value of the primitive type * {@code double} in an object. An object of type * {@code Double} contains a single field whose type is * {@code double}. * * <p>In addition, this class provides several methods for converting a * {@code double} to a {@code String} and a * {@code String} to a {@code double}, as well as other * constants and methods useful when dealing with a * {@code double}. * * @author  Lee Boynton * @author  Arthur van Hoff * @author  Joseph D. Darcy * @since JDK1.0 */public final class Double extends Number implements Comparable<Double> {    /**     * A constant holding the positive infinity of type     * {@code double}. It is equal to the value returned by     * {@code Double.longBitsToDouble(0x7ff0000000000000L)}.     */    public static final double POSITIVE_INFINITY = 1.0 / 0.0;     /**     * A constant holding the negative infinity of type     * {@code double}. It is equal to the value returned by     * {@code Double.longBitsToDouble(0xfff0000000000000L)}.     */    public static final double NEGATIVE_INFINITY = -1.0 / 0.0;     /**     * A constant holding a Not-a-Number (NaN) value of type     * {@code double}. It is equivalent to the value returned by     * {@code Double.longBitsToDouble(0x7ff8000000000000L)}.     */    public static final double NaN = 0.0d / 0.0;     /**     * A constant holding the largest positive finite value of type     * {@code double},     * (2-2<sup>-52</sup>)&middot;2<sup>1023</sup>.  It is equal to     * the hexadecimal floating-point literal     * {@code 0x1.fffffffffffffP+1023} and also equal to     * {@code Double.longBitsToDouble(0x7fefffffffffffffL)}.     */    public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308     /**     * A constant holding the smallest positive normal value of type     * {@code double}, 2<sup>-1022</sup>.  It is equal to the     * hexadecimal floating-point literal {@code 0x1.0p-1022} and also     * equal to {@code Double.longBitsToDouble(0x0010000000000000L)}.     *     * @since 1.6     */    public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308     /**     * A constant holding the smallest positive nonzero value of type     * {@code double}, 2<sup>-1074</sup>. It is equal to the     * hexadecimal floating-point literal     * {@code 0x0.0000000000001P-1022} and also equal to     * {@code Double.longBitsToDouble(0x1L)}.     */    public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324     /**     * Maximum exponent a finite {@code double} variable may have.     * It is equal to the value returned by     * {@code Math.getExponent(Double.MAX_VALUE)}.     *     * @since 1.6     */    public static final int MAX_EXPONENT = 1023;     /**     * Minimum exponent a normalized {@code double} variable may     * have.  It is equal to the value returned by     * {@code Math.getExponent(Double.MIN_NORMAL)}.     *     * @since 1.6     */    public static final int MIN_EXPONENT = -1022;     /**     * The number of bits used to represent a {@code double} value.     *     * @since 1.5     */    public static final int SIZE = 64;     /**     * The {@code Class} instance representing the primitive type     * {@code double}.     *     * @since JDK1.1     */    public static final Class<Double>   TYPE = (Class<Double>) Class.getPrimitiveClass("double");     /**     * Returns a string representation of the {@code double}     * argument. All characters mentioned below are ASCII characters.     * <ul>     * <li>If the argument is NaN, the result is the string     *     "{@code NaN}".     * <li>Otherwise, the result is a string that represents the sign and     * magnitude (absolute value) of the argument. If the sign is negative,     * the first character of the result is '{@code -}'     * (<code>'&#92;u002D'</code>); if the sign is positive, no sign character     * appears in the result. As for the magnitude <i>m</i>:     * <ul>     * <li>If <i>m</i> is infinity, it is represented by the characters     * {@code "Infinity"}; thus, positive infinity produces the result     * {@code "Infinity"} and negative infinity produces the result     * {@code "-Infinity"}.     *     * <li>If <i>m</i> is zero, it is represented by the characters     * {@code "0.0"}; thus, negative zero produces the result     * {@code "-0.0"} and positive zero produces the result     * {@code "0.0"}.     *     * <li>If <i>m</i> is greater than or equal to 10<sup>-3</sup> but less     * than 10<sup>7</sup>, then it is represented as the integer part of     * <i>m</i>, in decimal form with no leading zeroes, followed by     * '{@code .}' (<code>'&#92;u002E'</code>), followed by one or     * more decimal digits representing the fractional part of <i>m</i>.     *     * <li>If <i>m</i> is less than 10<sup>-3</sup> or greater than or     * equal to 10<sup>7</sup>, then it is represented in so-called     * "computerized scientific notation." Let <i>n</i> be the unique     * integer such that 10<sup><i>n</i></sup> &le; <i>m</i> {@literal <}     * 10<sup><i>n</i>+1</sup>; then let <i>a</i> be the     * mathematically exact quotient of <i>m</i> and     * 10<sup><i>n</i></sup> so that 1 &le; <i>a</i> {@literal <} 10. The     * magnitude is then represented as the integer part of <i>a</i>,     * as a single decimal digit, followed by '{@code .}'     * (<code>'&#92;u002E'</code>), followed by decimal digits     * representing the fractional part of <i>a</i>, followed by the     * letter '{@code E}' (<code>'&#92;u0045'</code>), followed     * by a representation of <i>n</i> as a decimal integer, as     * produced by the method {@link Integer#toString(int)}.     * </ul>     * </ul>     * How many digits must be printed for the fractional part of     * <i>m</i> or <i>a</i>? There must be at least one digit to represent     * the fractional part, and beyond that as many, but only as many, more     * digits as are needed to uniquely distinguish the argument value from     * adjacent values of type {@code double}. That is, suppose that     * <i>x</i> is the exact mathematical value represented by the decimal     * representation produced by this method for a finite nonzero argument     * <i>d</i>. Then <i>d</i> must be the {@code double} value nearest     * to <i>x</i>; or if two {@code double} values are equally close     * to <i>x</i>, then <i>d</i> must be one of them and the least     * significant bit of the significand of <i>d</i> must be {@code 0}.     *     * <p>To create localized string representations of a floating-point     * value, use subclasses of {@link java.text.NumberFormat}.     *     * @param   d   the {@code double} to be converted.     * @return a string representation of the argument.     */    public static String toString(double d) {        return new FloatingDecimal(d).toJavaFormatString();    }     /**     * Returns a hexadecimal string representation of the     * {@code double} argument. All characters mentioned below     * are ASCII characters.     *     * <ul>     * <li>If the argument is NaN, the result is the string     *     "{@code NaN}".     * <li>Otherwise, the result is a string that represents the sign     * and magnitude of the argument. If the sign is negative, the     * first character of the result is '{@code -}'     * (<code>'&#92;u002D'</code>); if the sign is positive, no sign     * character appears in the result. As for the magnitude <i>m</i>:     *     * <ul>     * <li>If <i>m</i> is infinity, it is represented by the string     * {@code "Infinity"}; thus, positive infinity produces the     * result {@code "Infinity"} and negative infinity produces     * the result {@code "-Infinity"}.     *     * <li>If <i>m</i> is zero, it is represented by the string     * {@code "0x0.0p0"}; thus, negative zero produces the result     * {@code "-0x0.0p0"} and positive zero produces the result     * {@code "0x0.0p0"}.     *     * <li>If <i>m</i> is a {@code double} value with a     * normalized representation, substrings are used to represent the     * significand and exponent fields.  The significand is     * represented by the characters {@code "0x1."}     * followed by a lowercase hexadecimal representation of the rest     * of the significand as a fraction.  Trailing zeros in the     * hexadecimal representation are removed unless all the digits     * are zero, in which case a single zero is used. Next, the     * exponent is represented by {@code "p"} followed     * by a decimal string of the unbiased exponent as if produced by     * a call to {@link Integer#toString(int) Integer.toString} on the     * exponent value.     *     * <li>If <i>m</i> is a {@code double} value with a subnormal     * representation, the significand is represented by the     * characters {@code "0x0."} followed by a     * hexadecimal representation of the rest of the significand as a     * fraction.  Trailing zeros in the hexadecimal representation are     * removed. Next, the exponent is represented by     * {@code "p-1022"}.  Note that there must be at     * least one nonzero digit in a subnormal significand.     *     * </ul>     *     * </ul>     *     * <table border>     * <caption><h3>Examples</h3></caption>     * <tr><th>Floating-point Value</th><th>Hexadecimal String</th>     * <tr><td>{@code 1.0}</td> <td>{@code 0x1.0p0}</td>     * <tr><td>{@code -1.0}</td>        <td>{@code -0x1.0p0}</td>     * <tr><td>{@code 2.0}</td> <td>{@code 0x1.0p1}</td>     * <tr><td>{@code 3.0}</td> <td>{@code 0x1.8p1}</td>     * <tr><td>{@code 0.5}</td> <td>{@code 0x1.0p-1}</td>     * <tr><td>{@code 0.25}</td>        <td>{@code 0x1.0p-2}</td>     * <tr><td>{@code Double.MAX_VALUE}</td>     *     <td>{@code 0x1.fffffffffffffp1023}</td>     * <tr><td>{@code Minimum Normal Value}</td>     *     <td>{@code 0x1.0p-1022}</td>     * <tr><td>{@code Maximum Subnormal Value}</td>     *     <td>{@code 0x0.fffffffffffffp-1022}</td>     * <tr><td>{@code Double.MIN_VALUE}</td>     *     <td>{@code 0x0.0000000000001p-1022}</td>     * </table>     * @param   d   the {@code double} to be converted.     * @return a hex string representation of the argument.     * @since 1.5     * @author Joseph D. Darcy     */    public static String toHexString(double d) {        /*         * Modeled after the "a" conversion specifier in C99, section         * 7.19.6.1; however, the output of this method is more         * tightly specified.         */        if (!FpUtils.isFinite(d) )            // For infinity and NaN, use the decimal output.            return Double.toString(d);        else {            // Initialized to maximum size of output.            StringBuffer answer = new StringBuffer(24);             if (FpUtils.rawCopySign(1.0, d) == -1.0) // value is negative,                answer.append("-");                  // so append sign info             answer.append("0x");             d = Math.abs(d);             if(d == 0.0) {                answer.append("0.0p0");            }            else {                boolean subnormal = (d < DoubleConsts.MIN_NORMAL);                 // Isolate significand bits and OR in a high-order bit                // so that the string representation has a known                // length.                long signifBits = (Double.doubleToLongBits(d)                                   & DoubleConsts.SIGNIF_BIT_MASK) |                    0x1000000000000000L;                 // Subnormal values have a 0 implicit bit; normal                // values have a 1 implicit bit.                answer.append(subnormal ? "0." : "1.");                 // Isolate the low-order 13 digits of the hex                // representation.  If all the digits are zero,                // replace with a single 0; otherwise, remove all                // trailing zeros.                String signif = Long.toHexString(signifBits).substring(3,16);                answer.append(signif.equals("0000000000000") ? // 13 zeros                              "0":                              signif.replaceFirst("0{1,12}$", ""));                 // If the value is subnormal, use the E_min exponent                // value for double; otherwise, extract and report d's                // exponent (the representation of a subnormal uses                // E_min -1).                answer.append("p" + (subnormal ?                               DoubleConsts.MIN_EXPONENT:                               FpUtils.getExponent(d) ));            }            return answer.toString();        }    }     /**     * Returns a {@code Double} object holding the     * {@code double} value represented by the argument string     * {@code s}.     *     * <p>If {@code s} is {@code null}, then a     * {@code NullPointerException} is thrown.     *     * <p>Leading and trailing whitespace characters in {@code s}     * are ignored.  Whitespace is removed as if by the {@link     * String#trim} method; that is, both ASCII space and control     * characters are removed. The rest of {@code s} should     * constitute a <i>FloatValue</i> as described by the lexical     * syntax rules:     *     * <blockquote>     * <dl>     * <dt><i>FloatValue:</i>     * <dd><i>Sign<sub>opt</sub></i> {@code NaN}     * <dd><i>Sign<sub>opt</sub></i> {@code Infinity}     * <dd><i>Sign<sub>opt</sub> FloatingPointLiteral</i>     * <dd><i>Sign<sub>opt</sub> HexFloatingPointLiteral</i>     * <dd><i>SignedInteger</i>     * </dl>     *     * <p>     *     * <dl>     * <dt><i>HexFloatingPointLiteral</i>:     * <dd> <i>HexSignificand BinaryExponent FloatTypeSuffix<sub>opt</sub></i>     * </dl>     *     * <p>     *     * <dl>     * <dt><i>HexSignificand:</i>     * <dd><i>HexNumeral</i>     * <dd><i>HexNumeral</i> {@code .}     * <dd>{@code 0x} <i>HexDigits<sub>opt</sub>     *     </i>{@code .}<i> HexDigits</i>     * <dd>{@code 0X}<i> HexDigits<sub>opt</sub>     *     </i>{@code .} <i>HexDigits</i>     * </dl>     *     * <p>     *     * <dl>     * <dt><i>BinaryExponent:</i>     * <dd><i>BinaryExponentIndicator SignedInteger</i>     * </dl>     *     * <p>     *     * <dl>     * <dt><i>BinaryExponentIndicator:</i>     * <dd>{@code p}     * <dd>{@code P}     * </dl>     *     * </blockquote>     *     * where <i>Sign</i>, <i>FloatingPointLiteral</i>,     * <i>HexNumeral</i>, <i>HexDigits</i>, <i>SignedInteger</i> and     * <i>FloatTypeSuffix</i> are as defined in the lexical structure     * sections of     * <cite>The Java&trade; Language Specification</cite>,     * except that underscores are not accepted between digits.     * If {@code s} does not have the form of     * a <i>FloatValue</i>, then a {@code NumberFormatException}     * is thrown. Otherwise, {@code s} is regarded as     * representing an exact decimal value in the usual     * "computerized scientific notation" or as an exact     * hexadecimal value; this exact numerical value is then     * conceptually converted to an "infinitely precise"     * binary value that is then rounded to type {@code double}     * by the usual round-to-nearest rule of IEEE 754 floating-point     * arithmetic, which includes preserving the sign of a zero     * value.     *     * Note that the round-to-nearest rule also implies overflow and     * underflow behaviour; if the exact value of {@code s} is large     * enough in magnitude (greater than or equal to ({@link     * #MAX_VALUE} + {@link Math#ulp(double) ulp(MAX_VALUE)}/2),     * rounding to {@code double} will result in an infinity and if the     * exact value of {@code s} is small enough in magnitude (less     * than or equal to {@link #MIN_VALUE}/2), rounding to float will     * result in a zero.     *     * Finally, after rounding a {@code Double} object representing     * this {@code double} value is returned.     *     * <p> To interpret localized string representations of a     * floating-point value, use subclasses of {@link     * java.text.NumberFormat}.     *     * <p>Note that trailing format specifiers, specifiers that     * determine the type of a floating-point literal     * ({@code 1.0f} is a {@code float} value;     * {@code 1.0d} is a {@code double} value), do     * <em>not</em> influence the results of this method.  In other     * words, the numerical value of the input string is converted     * directly to the target floating-point type.  The two-step     * sequence of conversions, string to {@code float} followed     * by {@code float} to {@code double}, is <em>not</em>     * equivalent to converting a string directly to     * {@code double}. For example, the {@code float}     * literal {@code 0.1f} is equal to the {@code double}     * value {@code 0.10000000149011612}; the {@code float}     * literal {@code 0.1f} represents a different numerical     * value than the {@code double} literal     * {@code 0.1}. (The numerical value 0.1 cannot be exactly     * represented in a binary floating-point number.)     *     * <p>To avoid calling this method on an invalid string and having     * a {@code NumberFormatException} be thrown, the regular     * expression below can be used to screen the input string:     *     * <code>     * <pre>     *  final String Digits     = "(\\p{Digit}+)";     *  final String HexDigits  = "(\\p{XDigit}+)";     *  // an exponent is 'e' or 'E' followed by an optionally     *  // signed decimal integer.     *  final String Exp        = "[eE][+-]?"+Digits;     *  final String fpRegex    =     *      ("[\\x00-\\x20]*"+  // Optional leading "whitespace"     *       "[+-]?(" + // Optional sign character     *       "NaN|" +           // "NaN" string     *       "Infinity|" +      // "Infinity" string     *     *       // A decimal floating-point string representing a finite positive     *       // number without a leading sign has at most five basic pieces:     *       // Digits . Digits ExponentPart FloatTypeSuffix     *       //     *       // Since this method allows integer-only strings as input     *       // in addition to strings of floating-point literals, the     *       // two sub-patterns below are simplifications of the grammar     *       // productions from section 3.10.2 of     *       // <cite>The Java&trade; Language Specification</cite>.     *     *       // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt     *       "((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+     *     *       // . Digits ExponentPart_opt FloatTypeSuffix_opt     *       "(\\.("+Digits+")("+Exp+")?)|"+     *     *       // Hexadecimal strings     *       "((" +     *        // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt     *        "(0[xX]" + HexDigits + "(\\.)?)|" +     *     *        // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt     *        "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" +     *     *        ")[pP][+-]?" + Digits + "))" +     *       "[fFdD]?))" +     *       "[\\x00-\\x20]*");// Optional trailing "whitespace"     *     *  if (Pattern.matches(fpRegex, myString))     *      Double.valueOf(myString); // Will not throw NumberFormatException     *  else {     *      // Perform suitable alternative action     *  }     * </pre>     * </code>     *     * @param      s   the string to be parsed.     * @return     a {@code Double} object holding the value     *             represented by the {@code String} argument.     * @throws     NumberFormatException  if the string does not contain a

Lines 1–500 of 988. Load more