My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/lang/Double.java (1 of 18352 files). Show all

Unified · Split

@@ -0,0 +1,988 @@
	1	+/*
	2	+ * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package java.lang;
	27	+
	28	+import sun.misc.FloatingDecimal;
	29	+import sun.misc.FpUtils;
	30	+import sun.misc.DoubleConsts;
	31	+
	32	+/**
	33	+ * The {@code Double} class wraps a value of the primitive type
	34	+ * {@code double} in an object. An object of type
	35	+ * {@code Double} contains a single field whose type is
	36	+ * {@code double}.
	37	+ *
	38	+ * <p>In addition, this class provides several methods for converting a
	39	+ * {@code double} to a {@code String} and a
	40	+ * {@code String} to a {@code double}, as well as other
	41	+ * constants and methods useful when dealing with a
	42	+ * {@code double}.
	43	+ *
	44	+ * @author Lee Boynton
	45	+ * @author Arthur van Hoff
	46	+ * @author Joseph D. Darcy
	47	+ * @since JDK1.0
	48	+ */
	49	+public final class Double extends Number implements Comparable<Double> {
	50	+ /**
	51	+ * A constant holding the positive infinity of type
	52	+ * {@code double}. It is equal to the value returned by
	53	+ * {@code Double.longBitsToDouble(0x7ff0000000000000L)}.
	54	+ */
	55	+ public static final double POSITIVE_INFINITY = 1.0 / 0.0;
	56	+
	57	+ /**
	58	+ * A constant holding the negative infinity of type
	59	+ * {@code double}. It is equal to the value returned by
	60	+ * {@code Double.longBitsToDouble(0xfff0000000000000L)}.
	61	+ */
	62	+ public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
	63	+
	64	+ /**
	65	+ * A constant holding a Not-a-Number (NaN) value of type
	66	+ * {@code double}. It is equivalent to the value returned by
	67	+ * {@code Double.longBitsToDouble(0x7ff8000000000000L)}.
	68	+ */
	69	+ public static final double NaN = 0.0d / 0.0;
	70	+
	71	+ /**
	72	+ * A constant holding the largest positive finite value of type
	73	+ * {@code double},
	74	+ * (2-2<sup>-52</sup>)·2<sup>1023</sup>. It is equal to
	75	+ * the hexadecimal floating-point literal
	76	+ * {@code 0x1.fffffffffffffP+1023} and also equal to
	77	+ * {@code Double.longBitsToDouble(0x7fefffffffffffffL)}.
	78	+ */
	79	+ public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308
	80	+
	81	+ /**
	82	+ * A constant holding the smallest positive normal value of type
	83	+ * {@code double}, 2<sup>-1022</sup>. It is equal to the
	84	+ * hexadecimal floating-point literal {@code 0x1.0p-1022} and also
	85	+ * equal to {@code Double.longBitsToDouble(0x0010000000000000L)}.
	86	+ *
	87	+ * @since 1.6
	88	+ */
	89	+ public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308
	90	+
	91	+ /**
	92	+ * A constant holding the smallest positive nonzero value of type
	93	+ * {@code double}, 2<sup>-1074</sup>. It is equal to the
	94	+ * hexadecimal floating-point literal
	95	+ * {@code 0x0.0000000000001P-1022} and also equal to
	96	+ * {@code Double.longBitsToDouble(0x1L)}.
	97	+ */
	98	+ public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324
	99	+
	100	+ /**
	101	+ * Maximum exponent a finite {@code double} variable may have.
	102	+ * It is equal to the value returned by
	103	+ * {@code Math.getExponent(Double.MAX_VALUE)}.
	104	+ *
	105	+ * @since 1.6
	106	+ */
	107	+ public static final int MAX_EXPONENT = 1023;
	108	+
	109	+ /**
	110	+ * Minimum exponent a normalized {@code double} variable may
	111	+ * have. It is equal to the value returned by
	112	+ * {@code Math.getExponent(Double.MIN_NORMAL)}.
	113	+ *
	114	+ * @since 1.6
	115	+ */
	116	+ public static final int MIN_EXPONENT = -1022;
	117	+
	118	+ /**
	119	+ * The number of bits used to represent a {@code double} value.
	120	+ *
	121	+ * @since 1.5
	122	+ */
	123	+ public static final int SIZE = 64;
	124	+
	125	+ /**
	126	+ * The {@code Class} instance representing the primitive type
	127	+ * {@code double}.
	128	+ *
	129	+ * @since JDK1.1
	130	+ */
	131	+ public static final Class<Double> TYPE = (Class<Double>) Class.getPrimitiveClass("double");
	132	+
	133	+ /**
	134	+ * Returns a string representation of the {@code double}
	135	+ * argument. All characters mentioned below are ASCII characters.
	136	+ * <ul>
	137	+ * <li>If the argument is NaN, the result is the string
	138	+ * "{@code NaN}".
	139	+ * <li>Otherwise, the result is a string that represents the sign and
	140	+ * magnitude (absolute value) of the argument. If the sign is negative,
	141	+ * the first character of the result is '{@code -}'
	142	+ * (<code>'\u002D'</code>); if the sign is positive, no sign character
	143	+ * appears in the result. As for the magnitude <i>m</i>:
	144	+ * <ul>
	145	+ * <li>If <i>m</i> is infinity, it is represented by the characters
	146	+ * {@code "Infinity"}; thus, positive infinity produces the result
	147	+ * {@code "Infinity"} and negative infinity produces the result
	148	+ * {@code "-Infinity"}.
	149	+ *
	150	+ * <li>If <i>m</i> is zero, it is represented by the characters
	151	+ * {@code "0.0"}; thus, negative zero produces the result
	152	+ * {@code "-0.0"} and positive zero produces the result
	153	+ * {@code "0.0"}.
	154	+ *
	155	+ * <li>If <i>m</i> is greater than or equal to 10<sup>-3</sup> but less
	156	+ * than 10<sup>7</sup>, then it is represented as the integer part of
	157	+ * <i>m</i>, in decimal form with no leading zeroes, followed by
	158	+ * '{@code .}' (<code>'\u002E'</code>), followed by one or
	159	+ * more decimal digits representing the fractional part of <i>m</i>.
	160	+ *
	161	+ * <li>If <i>m</i> is less than 10<sup>-3</sup> or greater than or
	162	+ * equal to 10<sup>7</sup>, then it is represented in so-called
	163	+ * "computerized scientific notation." Let <i>n</i> be the unique
	164	+ * integer such that 10<sup><i>n</i></sup> ≤ <i>m</i> {@literal <}
	165	+ * 10<sup><i>n</i>+1</sup>; then let <i>a</i> be the
	166	+ * mathematically exact quotient of <i>m</i> and
	167	+ * 10<sup><i>n</i></sup> so that 1 ≤ <i>a</i> {@literal <} 10. The
	168	+ * magnitude is then represented as the integer part of <i>a</i>,
	169	+ * as a single decimal digit, followed by '{@code .}'
	170	+ * (<code>'\u002E'</code>), followed by decimal digits
	171	+ * representing the fractional part of <i>a</i>, followed by the
	172	+ * letter '{@code E}' (<code>'\u0045'</code>), followed
	173	+ * by a representation of <i>n</i> as a decimal integer, as
	174	+ * produced by the method {@link Integer#toString(int)}.
	175	+ * </ul>
	176	+ * </ul>
	177	+ * How many digits must be printed for the fractional part of
	178	+ * <i>m</i> or <i>a</i>? There must be at least one digit to represent
	179	+ * the fractional part, and beyond that as many, but only as many, more
	180	+ * digits as are needed to uniquely distinguish the argument value from
	181	+ * adjacent values of type {@code double}. That is, suppose that
	182	+ * <i>x</i> is the exact mathematical value represented by the decimal
	183	+ * representation produced by this method for a finite nonzero argument
	184	+ * <i>d</i>. Then <i>d</i> must be the {@code double} value nearest
	185	+ * to <i>x</i>; or if two {@code double} values are equally close
	186	+ * to <i>x</i>, then <i>d</i> must be one of them and the least
	187	+ * significant bit of the significand of <i>d</i> must be {@code 0}.
	188	+ *
	189	+ * <p>To create localized string representations of a floating-point
	190	+ * value, use subclasses of {@link java.text.NumberFormat}.
	191	+ *
	192	+ * @param d the {@code double} to be converted.
	193	+ * @return a string representation of the argument.
	194	+ */
	195	+ public static String toString(double d) {
	196	+ return new FloatingDecimal(d).toJavaFormatString();
	197	+ }
	198	+
	199	+ /**
	200	+ * Returns a hexadecimal string representation of the
	201	+ * {@code double} argument. All characters mentioned below
	202	+ * are ASCII characters.
	203	+ *
	204	+ * <ul>
	205	+ * <li>If the argument is NaN, the result is the string
	206	+ * "{@code NaN}".
	207	+ * <li>Otherwise, the result is a string that represents the sign
	208	+ * and magnitude of the argument. If the sign is negative, the
	209	+ * first character of the result is '{@code -}'
	210	+ * (<code>'\u002D'</code>); if the sign is positive, no sign
	211	+ * character appears in the result. As for the magnitude <i>m</i>:
	212	+ *
	213	+ * <ul>
	214	+ * <li>If <i>m</i> is infinity, it is represented by the string
	215	+ * {@code "Infinity"}; thus, positive infinity produces the
	216	+ * result {@code "Infinity"} and negative infinity produces
	217	+ * the result {@code "-Infinity"}.
	218	+ *
	219	+ * <li>If <i>m</i> is zero, it is represented by the string
	220	+ * {@code "0x0.0p0"}; thus, negative zero produces the result
	221	+ * {@code "-0x0.0p0"} and positive zero produces the result
	222	+ * {@code "0x0.0p0"}.
	223	+ *
	224	+ * <li>If <i>m</i> is a {@code double} value with a
	225	+ * normalized representation, substrings are used to represent the
	226	+ * significand and exponent fields. The significand is
	227	+ * represented by the characters {@code "0x1."}
	228	+ * followed by a lowercase hexadecimal representation of the rest
	229	+ * of the significand as a fraction. Trailing zeros in the
	230	+ * hexadecimal representation are removed unless all the digits
	231	+ * are zero, in which case a single zero is used. Next, the
	232	+ * exponent is represented by {@code "p"} followed
	233	+ * by a decimal string of the unbiased exponent as if produced by
	234	+ * a call to {@link Integer#toString(int) Integer.toString} on the
	235	+ * exponent value.
	236	+ *
	237	+ * <li>If <i>m</i> is a {@code double} value with a subnormal
	238	+ * representation, the significand is represented by the
	239	+ * characters {@code "0x0."} followed by a
	240	+ * hexadecimal representation of the rest of the significand as a
	241	+ * fraction. Trailing zeros in the hexadecimal representation are
	242	+ * removed. Next, the exponent is represented by
	243	+ * {@code "p-1022"}. Note that there must be at
	244	+ * least one nonzero digit in a subnormal significand.
	245	+ *
	246	+ * </ul>
	247	+ *
	248	+ * </ul>
	249	+ *
	250	+ * <table border>
	251	+ * <caption><h3>Examples</h3></caption>
	252	+ * <tr><th>Floating-point Value</th><th>Hexadecimal String</th>
	253	+ * <tr><td>{@code 1.0}</td> <td>{@code 0x1.0p0}</td>
	254	+ * <tr><td>{@code -1.0}</td> <td>{@code -0x1.0p0}</td>
	255	+ * <tr><td>{@code 2.0}</td> <td>{@code 0x1.0p1}</td>
	256	+ * <tr><td>{@code 3.0}</td> <td>{@code 0x1.8p1}</td>
	257	+ * <tr><td>{@code 0.5}</td> <td>{@code 0x1.0p-1}</td>
	258	+ * <tr><td>{@code 0.25}</td> <td>{@code 0x1.0p-2}</td>
	259	+ * <tr><td>{@code Double.MAX_VALUE}</td>
	260	+ * <td>{@code 0x1.fffffffffffffp1023}</td>
	261	+ * <tr><td>{@code Minimum Normal Value}</td>
	262	+ * <td>{@code 0x1.0p-1022}</td>
	263	+ * <tr><td>{@code Maximum Subnormal Value}</td>
	264	+ * <td>{@code 0x0.fffffffffffffp-1022}</td>
	265	+ * <tr><td>{@code Double.MIN_VALUE}</td>
	266	+ * <td>{@code 0x0.0000000000001p-1022}</td>
	267	+ * </table>
	268	+ * @param d the {@code double} to be converted.
	269	+ * @return a hex string representation of the argument.
	270	+ * @since 1.5
	271	+ * @author Joseph D. Darcy
	272	+ */
	273	+ public static String toHexString(double d) {
	274	+ /*
	275	+ * Modeled after the "a" conversion specifier in C99, section
	276	+ * 7.19.6.1; however, the output of this method is more
	277	+ * tightly specified.
	278	+ */
	279	+ if (!FpUtils.isFinite(d) )
	280	+ // For infinity and NaN, use the decimal output.
	281	+ return Double.toString(d);
	282	+ else {
	283	+ // Initialized to maximum size of output.
	284	+ StringBuffer answer = new StringBuffer(24);
	285	+
	286	+ if (FpUtils.rawCopySign(1.0, d) == -1.0) // value is negative,
	287	+ answer.append("-"); // so append sign info
	288	+
	289	+ answer.append("0x");
	290	+
	291	+ d = Math.abs(d);
	292	+
	293	+ if(d == 0.0) {
	294	+ answer.append("0.0p0");
	295	+ }
	296	+ else {
	297	+ boolean subnormal = (d < DoubleConsts.MIN_NORMAL);
	298	+
	299	+ // Isolate significand bits and OR in a high-order bit
	300	+ // so that the string representation has a known
	301	+ // length.
	302	+ long signifBits = (Double.doubleToLongBits(d)
	303	+ & DoubleConsts.SIGNIF_BIT_MASK) \|
	304	+ 0x1000000000000000L;
	305	+
	306	+ // Subnormal values have a 0 implicit bit; normal
	307	+ // values have a 1 implicit bit.
	308	+ answer.append(subnormal ? "0." : "1.");
	309	+
	310	+ // Isolate the low-order 13 digits of the hex
	311	+ // representation. If all the digits are zero,
	312	+ // replace with a single 0; otherwise, remove all
	313	+ // trailing zeros.
	314	+ String signif = Long.toHexString(signifBits).substring(3,16);
	315	+ answer.append(signif.equals("0000000000000") ? // 13 zeros
	316	+ "0":
	317	+ signif.replaceFirst("0{1,12}$", ""));
	318	+
	319	+ // If the value is subnormal, use the E_min exponent
	320	+ // value for double; otherwise, extract and report d's
	321	+ // exponent (the representation of a subnormal uses
	322	+ // E_min -1).
	323	+ answer.append("p" + (subnormal ?
	324	+ DoubleConsts.MIN_EXPONENT:
	325	+ FpUtils.getExponent(d) ));
	326	+ }
	327	+ return answer.toString();
	328	+ }
	329	+ }
	330	+
	331	+ /**
	332	+ * Returns a {@code Double} object holding the
	333	+ * {@code double} value represented by the argument string
	334	+ * {@code s}.
	335	+ *
	336	+ * <p>If {@code s} is {@code null}, then a
	337	+ * {@code NullPointerException} is thrown.
	338	+ *
	339	+ * <p>Leading and trailing whitespace characters in {@code s}
	340	+ * are ignored. Whitespace is removed as if by the {@link
	341	+ * String#trim} method; that is, both ASCII space and control
	342	+ * characters are removed. The rest of {@code s} should
	343	+ * constitute a <i>FloatValue</i> as described by the lexical
	344	+ * syntax rules:
	345	+ *
	346	+ * <blockquote>
	347	+ * <dl>
	348	+ * <dt><i>FloatValue:</i>
	349	+ * <dd><i>Sign<sub>opt</sub></i> {@code NaN}
	350	+ * <dd><i>Sign<sub>opt</sub></i> {@code Infinity}
	351	+ * <dd><i>Sign<sub>opt</sub> FloatingPointLiteral</i>
	352	+ * <dd><i>Sign<sub>opt</sub> HexFloatingPointLiteral</i>
	353	+ * <dd><i>SignedInteger</i>
	354	+ * </dl>
	355	+ *
	356	+ * <p>
	357	+ *
	358	+ * <dl>
	359	+ * <dt><i>HexFloatingPointLiteral</i>:
	360	+ * <dd> <i>HexSignificand BinaryExponent FloatTypeSuffix<sub>opt</sub></i>
	361	+ * </dl>
	362	+ *
	363	+ * <p>
	364	+ *
	365	+ * <dl>
	366	+ * <dt><i>HexSignificand:</i>
	367	+ * <dd><i>HexNumeral</i>
	368	+ * <dd><i>HexNumeral</i> {@code .}
	369	+ * <dd>{@code 0x} <i>HexDigits<sub>opt</sub>
	370	+ * </i>{@code .}<i> HexDigits</i>
	371	+ * <dd>{@code 0X}<i> HexDigits<sub>opt</sub>
	372	+ * </i>{@code .} <i>HexDigits</i>
	373	+ * </dl>
	374	+ *
	375	+ * <p>
	376	+ *
	377	+ * <dl>
	378	+ * <dt><i>BinaryExponent:</i>
	379	+ * <dd><i>BinaryExponentIndicator SignedInteger</i>
	380	+ * </dl>
	381	+ *
	382	+ * <p>
	383	+ *
	384	+ * <dl>
	385	+ * <dt><i>BinaryExponentIndicator:</i>
	386	+ * <dd>{@code p}
	387	+ * <dd>{@code P}
	388	+ * </dl>
	389	+ *
	390	+ * </blockquote>
	391	+ *
	392	+ * where <i>Sign</i>, <i>FloatingPointLiteral</i>,
	393	+ * <i>HexNumeral</i>, <i>HexDigits</i>, <i>SignedInteger</i> and
	394	+ * <i>FloatTypeSuffix</i> are as defined in the lexical structure
	395	+ * sections of
	396	+ * <cite>The Java™ Language Specification</cite>,
	397	+ * except that underscores are not accepted between digits.
	398	+ * If {@code s} does not have the form of
	399	+ * a <i>FloatValue</i>, then a {@code NumberFormatException}
	400	+ * is thrown. Otherwise, {@code s} is regarded as
	401	+ * representing an exact decimal value in the usual
	402	+ * "computerized scientific notation" or as an exact
	403	+ * hexadecimal value; this exact numerical value is then
	404	+ * conceptually converted to an "infinitely precise"
	405	+ * binary value that is then rounded to type {@code double}
	406	+ * by the usual round-to-nearest rule of IEEE 754 floating-point
	407	+ * arithmetic, which includes preserving the sign of a zero
	408	+ * value.
	409	+ *
	410	+ * Note that the round-to-nearest rule also implies overflow and
	411	+ * underflow behaviour; if the exact value of {@code s} is large
	412	+ * enough in magnitude (greater than or equal to ({@link
	413	+ * #MAX_VALUE} + {@link Math#ulp(double) ulp(MAX_VALUE)}/2),
	414	+ * rounding to {@code double} will result in an infinity and if the
	415	+ * exact value of {@code s} is small enough in magnitude (less
	416	+ * than or equal to {@link #MIN_VALUE}/2), rounding to float will
	417	+ * result in a zero.
	418	+ *
	419	+ * Finally, after rounding a {@code Double} object representing
	420	+ * this {@code double} value is returned.
	421	+ *
	422	+ * <p> To interpret localized string representations of a
	423	+ * floating-point value, use subclasses of {@link
	424	+ * java.text.NumberFormat}.
	425	+ *
	426	+ * <p>Note that trailing format specifiers, specifiers that
	427	+ * determine the type of a floating-point literal
	428	+ * ({@code 1.0f} is a {@code float} value;
	429	+ * {@code 1.0d} is a {@code double} value), do
	430	+ * <em>not</em> influence the results of this method. In other
	431	+ * words, the numerical value of the input string is converted
	432	+ * directly to the target floating-point type. The two-step
	433	+ * sequence of conversions, string to {@code float} followed
	434	+ * by {@code float} to {@code double}, is <em>not</em>
	435	+ * equivalent to converting a string directly to
	436	+ * {@code double}. For example, the {@code float}
	437	+ * literal {@code 0.1f} is equal to the {@code double}
	438	+ * value {@code 0.10000000149011612}; the {@code float}
	439	+ * literal {@code 0.1f} represents a different numerical
	440	+ * value than the {@code double} literal
	441	+ * {@code 0.1}. (The numerical value 0.1 cannot be exactly
	442	+ * represented in a binary floating-point number.)
	443	+ *
	444	+ * <p>To avoid calling this method on an invalid string and having
	445	+ * a {@code NumberFormatException} be thrown, the regular
	446	+ * expression below can be used to screen the input string:
	447	+ *
	448	+ * <code>
	449	+ * <pre>
	450	+ * final String Digits = "(\\p{Digit}+)";
	451	+ * final String HexDigits = "(\\p{XDigit}+)";
	452	+ * // an exponent is 'e' or 'E' followed by an optionally
	453	+ * // signed decimal integer.
	454	+ * final String Exp = "[eE][+-]?"+Digits;
	455	+ * final String fpRegex =
	456	+ * ("[\\x00-\\x20]*"+ // Optional leading "whitespace"
	457	+ * "[+-]?(" + // Optional sign character
	458	+ * "NaN\|" + // "NaN" string
	459	+ * "Infinity\|" + // "Infinity" string
	460	+ *
	461	+ * // A decimal floating-point string representing a finite positive
	462	+ * // number without a leading sign has at most five basic pieces:
	463	+ * // Digits . Digits ExponentPart FloatTypeSuffix
	464	+ * //
	465	+ * // Since this method allows integer-only strings as input
	466	+ * // in addition to strings of floating-point literals, the
	467	+ * // two sub-patterns below are simplifications of the grammar
	468	+ * // productions from section 3.10.2 of
	469	+ * // <cite>The Java™ Language Specification</cite>.
	470	+ *
	471	+ * // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt
	472	+ * "((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)\|"+
	473	+ *
	474	+ * // . Digits ExponentPart_opt FloatTypeSuffix_opt
	475	+ * "(\\.("+Digits+")("+Exp+")?)\|"+
	476	+ *
	477	+ * // Hexadecimal strings
	478	+ * "((" +
	479	+ * // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt
	480	+ * "(0[xX]" + HexDigits + "(\\.)?)\|" +
	481	+ *
	482	+ * // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt
	483	+ * "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" +
	484	+ *
	485	+ * ")[pP][+-]?" + Digits + "))" +
	486	+ * "[fFdD]?))" +
	487	+ * "[\\x00-\\x20]*");// Optional trailing "whitespace"
	488	+ *
	489	+ * if (Pattern.matches(fpRegex, myString))
	490	+ * Double.valueOf(myString); // Will not throw NumberFormatException
	491	+ * else {
	492	+ * // Perform suitable alternative action
	493	+ * }
	494	+ * </pre>
	495	+ * </code>
	496	+ *
	497	+ * @param s the string to be parsed.
	498	+ * @return a {@code Double} object holding the value
	499	+ * represented by the {@code String} argument.
	500	+ * @throws NumberFormatException if the string does not contain a
	501	+ * parsable number.
	502	+ */
	503	+ public static Double valueOf(String s) throws NumberFormatException {
	504	+ return new Double(FloatingDecimal.readJavaFormatString(s).doubleValue());
	505	+ }
	506	+
	507	+ /**
	508	+ * Returns a {@code Double} instance representing the specified
	509	+ * {@code double} value.
	510	+ * If a new {@code Double} instance is not required, this method
	511	+ * should generally be used in preference to the constructor
	512	+ * {@link #Double(double)}, as this method is likely to yield
	513	+ * significantly better space and time performance by caching
	514	+ * frequently requested values.
	515	+ *
	516	+ * @param d a double value.
	517	+ * @return a {@code Double} instance representing {@code d}.
	518	+ * @since 1.5
	519	+ */
	520	+ public static Double valueOf(double d) {
	521	+ return new Double(d);
	522	+ }
	523	+
	524	+ /**
	525	+ * Returns a new {@code double} initialized to the value
	526	+ * represented by the specified {@code String}, as performed
	527	+ * by the {@code valueOf} method of class
	528	+ * {@code Double}.
	529	+ *
	530	+ * @param s the string to be parsed.
	531	+ * @return the {@code double} value represented by the string
	532	+ * argument.
	533	+ * @throws NullPointerException if the string is null
	534	+ * @throws NumberFormatException if the string does not contain
	535	+ * a parsable {@code double}.
	536	+ * @see java.lang.Double#valueOf(String)
	537	+ * @since 1.2
	538	+ */
	539	+ public static double parseDouble(String s) throws NumberFormatException {
	540	+ return FloatingDecimal.readJavaFormatString(s).doubleValue();
	541	+ }
	542	+
	543	+ /**
	544	+ * Returns {@code true} if the specified number is a
	545	+ * Not-a-Number (NaN) value, {@code false} otherwise.
	546	+ *
	547	+ * @param v the value to be tested.
	548	+ * @return {@code true} if the value of the argument is NaN;
	549	+ * {@code false} otherwise.
	550	+ */
	551	+ static public boolean isNaN(double v) {
	552	+ return (v != v);
	553	+ }
	554	+
	555	+ /**
	556	+ * Returns {@code true} if the specified number is infinitely
	557	+ * large in magnitude, {@code false} otherwise.
	558	+ *
	559	+ * @param v the value to be tested.
	560	+ * @return {@code true} if the value of the argument is positive
	561	+ * infinity or negative infinity; {@code false} otherwise.
	562	+ */
	563	+ static public boolean isInfinite(double v) {
	564	+ return (v == POSITIVE_INFINITY) \|\| (v == NEGATIVE_INFINITY);
	565	+ }
	566	+
	567	+ /**
	568	+ * The value of the Double.
	569	+ *
	570	+ * @serial
	571	+ */
	572	+ private final double value;
	573	+
	574	+ /**
	575	+ * Constructs a newly allocated {@code Double} object that
	576	+ * represents the primitive {@code double} argument.
	577	+ *
	578	+ * @param value the value to be represented by the {@code Double}.
	579	+ */
	580	+ public Double(double value) {
	581	+ this.value = value;
	582	+ }
	583	+
	584	+ /**
	585	+ * Constructs a newly allocated {@code Double} object that
	586	+ * represents the floating-point value of type {@code double}
	587	+ * represented by the string. The string is converted to a
	588	+ * {@code double} value as if by the {@code valueOf} method.
	589	+ *
	590	+ * @param s a string to be converted to a {@code Double}.
	591	+ * @throws NumberFormatException if the string does not contain a
	592	+ * parsable number.
	593	+ * @see java.lang.Double#valueOf(java.lang.String)
	594	+ */
	595	+ public Double(String s) throws NumberFormatException {
	596	+ // REMIND: this is inefficient
	597	+ this(valueOf(s).doubleValue());
	598	+ }
	599	+
	600	+ /**
	601	+ * Returns {@code true} if this {@code Double} value is
	602	+ * a Not-a-Number (NaN), {@code false} otherwise.
	603	+ *
	604	+ * @return {@code true} if the value represented by this object is
	605	+ * NaN; {@code false} otherwise.
	606	+ */
	607	+ public boolean isNaN() {
	608	+ return isNaN(value);
	609	+ }
	610	+
	611	+ /**
	612	+ * Returns {@code true} if this {@code Double} value is
	613	+ * infinitely large in magnitude, {@code false} otherwise.
	614	+ *
	615	+ * @return {@code true} if the value represented by this object is
	616	+ * positive infinity or negative infinity;
	617	+ * {@code false} otherwise.
	618	+ */
	619	+ public boolean isInfinite() {
	620	+ return isInfinite(value);
	621	+ }
	622	+
	623	+ /**
	624	+ * Returns a string representation of this {@code Double} object.
	625	+ * The primitive {@code double} value represented by this
	626	+ * object is converted to a string exactly as if by the method
	627	+ * {@code toString} of one argument.
	628	+ *
	629	+ * @return a {@code String} representation of this object.
	630	+ * @see java.lang.Double#toString(double)
	631	+ */
	632	+ public String toString() {
	633	+ return toString(value);
	634	+ }
	635	+
	636	+ /**
	637	+ * Returns the value of this {@code Double} as a {@code byte} (by
	638	+ * casting to a {@code byte}).
	639	+ *
	640	+ * @return the {@code double} value represented by this object
	641	+ * converted to type {@code byte}
	642	+ * @since JDK1.1
	643	+ */
	644	+ public byte byteValue() {
	645	+ return (byte)value;
	646	+ }
	647	+
	648	+ /**
	649	+ * Returns the value of this {@code Double} as a
	650	+ * {@code short} (by casting to a {@code short}).
	651	+ *
	652	+ * @return the {@code double} value represented by this object
	653	+ * converted to type {@code short}
	654	+ * @since JDK1.1
	655	+ */
	656	+ public short shortValue() {
	657	+ return (short)value;
	658	+ }
	659	+
	660	+ /**
	661	+ * Returns the value of this {@code Double} as an
	662	+ * {@code int} (by casting to type {@code int}).
	663	+ *
	664	+ * @return the {@code double} value represented by this object
	665	+ * converted to type {@code int}
	666	+ */
	667	+ public int intValue() {
	668	+ return (int)value;
	669	+ }
	670	+
	671	+ /**
	672	+ * Returns the value of this {@code Double} as a
	673	+ * {@code long} (by casting to type {@code long}).
	674	+ *
	675	+ * @return the {@code double} value represented by this object
	676	+ * converted to type {@code long}
	677	+ */
	678	+ public long longValue() {
	679	+ return (long)value;
	680	+ }
	681	+
	682	+ /**
	683	+ * Returns the {@code float} value of this
	684	+ * {@code Double} object.
	685	+ *
	686	+ * @return the {@code double} value represented by this object
	687	+ * converted to type {@code float}
	688	+ * @since JDK1.0
	689	+ */
	690	+ public float floatValue() {
	691	+ return (float)value;
	692	+ }
	693	+
	694	+ /**
	695	+ * Returns the {@code double} value of this
	696	+ * {@code Double} object.
	697	+ *
	698	+ * @return the {@code double} value represented by this object
	699	+ */
	700	+ public double doubleValue() {
	701	+ return (double)value;
	702	+ }
	703	+
	704	+ /**
	705	+ * Returns a hash code for this {@code Double} object. The
	706	+ * result is the exclusive OR of the two halves of the
	707	+ * {@code long} integer bit representation, exactly as
	708	+ * produced by the method {@link #doubleToLongBits(double)}, of
	709	+ * the primitive {@code double} value represented by this
	710	+ * {@code Double} object. That is, the hash code is the value
	711	+ * of the expression:
	712	+ *
	713	+ * <blockquote>
	714	+ * {@code (int)(v^(v>>>32))}
	715	+ * </blockquote>
	716	+ *
	717	+ * where {@code v} is defined by:
	718	+ *
	719	+ * <blockquote>
	720	+ * {@code long v = Double.doubleToLongBits(this.doubleValue());}
	721	+ * </blockquote>
	722	+ *
	723	+ * @return a {@code hash code} value for this object.
	724	+ */
	725	+ public int hashCode() {
	726	+ long bits = doubleToLongBits(value);
	727	+ return (int)(bits ^ (bits >>> 32));
	728	+ }
	729	+
	730	+ /**
	731	+ * Compares this object against the specified object. The result
	732	+ * is {@code true} if and only if the argument is not
	733	+ * {@code null} and is a {@code Double} object that
	734	+ * represents a {@code double} that has the same value as the
	735	+ * {@code double} represented by this object. For this
	736	+ * purpose, two {@code double} values are considered to be
	737	+ * the same if and only if the method {@link
	738	+ * #doubleToLongBits(double)} returns the identical
	739	+ * {@code long} value when applied to each.
	740	+ *
	741	+ * <p>Note that in most cases, for two instances of class
	742	+ * {@code Double}, {@code d1} and {@code d2}, the
	743	+ * value of {@code d1.equals(d2)} is {@code true} if and
	744	+ * only if
	745	+ *
	746	+ * <blockquote>
	747	+ * {@code d1.doubleValue() == d2.doubleValue()}
	748	+ * </blockquote>
	749	+ *
	750	+ * <p>also has the value {@code true}. However, there are two
	751	+ * exceptions:
	752	+ * <ul>
	753	+ * <li>If {@code d1} and {@code d2} both represent
	754	+ * {@code Double.NaN}, then the {@code equals} method
	755	+ * returns {@code true}, even though
	756	+ * {@code Double.NaN==Double.NaN} has the value
	757	+ * {@code false}.
	758	+ * <li>If {@code d1} represents {@code +0.0} while
	759	+ * {@code d2} represents {@code -0.0}, or vice versa,
	760	+ * the {@code equal} test has the value {@code false},
	761	+ * even though {@code +0.0==-0.0} has the value {@code true}.
	762	+ * </ul>
	763	+ * This definition allows hash tables to operate properly.
	764	+ * @param obj the object to compare with.
	765	+ * @return {@code true} if the objects are the same;
	766	+ * {@code false} otherwise.
	767	+ * @see java.lang.Double#doubleToLongBits(double)
	768	+ */
	769	+ public boolean equals(Object obj) {
	770	+ return (obj instanceof Double)
	771	+ && (doubleToLongBits(((Double)obj).value) ==
	772	+ doubleToLongBits(value));
	773	+ }
	774	+
	775	+ /**
	776	+ * Returns a representation of the specified floating-point value
	777	+ * according to the IEEE 754 floating-point "double
	778	+ * format" bit layout.
	779	+ *
	780	+ * <p>Bit 63 (the bit that is selected by the mask
	781	+ * {@code 0x8000000000000000L}) represents the sign of the
	782	+ * floating-point number. Bits
	783	+ * 62-52 (the bits that are selected by the mask
	784	+ * {@code 0x7ff0000000000000L}) represent the exponent. Bits 51-0
	785	+ * (the bits that are selected by the mask
	786	+ * {@code 0x000fffffffffffffL}) represent the significand
	787	+ * (sometimes called the mantissa) of the floating-point number.
	788	+ *
	789	+ * <p>If the argument is positive infinity, the result is
	790	+ * {@code 0x7ff0000000000000L}.
	791	+ *
	792	+ * <p>If the argument is negative infinity, the result is
	793	+ * {@code 0xfff0000000000000L}.
	794	+ *
	795	+ * <p>If the argument is NaN, the result is
	796	+ * {@code 0x7ff8000000000000L}.
	797	+ *
	798	+ * <p>In all cases, the result is a {@code long} integer that, when
	799	+ * given to the {@link #longBitsToDouble(long)} method, will produce a
	800	+ * floating-point value the same as the argument to
	801	+ * {@code doubleToLongBits} (except all NaN values are
	802	+ * collapsed to a single "canonical" NaN value).
	803	+ *
	804	+ * @param value a {@code double} precision floating-point number.
	805	+ * @return the bits that represent the floating-point number.
	806	+ */
	807	+ public static long doubleToLongBits(double value) {
	808	+ long result = doubleToRawLongBits(value);
	809	+ // Check for NaN based on values of bit fields, maximum
	810	+ // exponent and nonzero significand.
	811	+ if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
	812	+ DoubleConsts.EXP_BIT_MASK) &&
	813	+ (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
	814	+ result = 0x7ff8000000000000L;
	815	+ return result;
	816	+ }
	817	+
	818	+ /**
	819	+ * Returns a representation of the specified floating-point value
	820	+ * according to the IEEE 754 floating-point "double
	821	+ * format" bit layout, preserving Not-a-Number (NaN) values.
	822	+ *
	823	+ * <p>Bit 63 (the bit that is selected by the mask
	824	+ * {@code 0x8000000000000000L}) represents the sign of the
	825	+ * floating-point number. Bits
	826	+ * 62-52 (the bits that are selected by the mask
	827	+ * {@code 0x7ff0000000000000L}) represent the exponent. Bits 51-0
	828	+ * (the bits that are selected by the mask
	829	+ * {@code 0x000fffffffffffffL}) represent the significand
	830	+ * (sometimes called the mantissa) of the floating-point number.
	831	+ *
	832	+ * <p>If the argument is positive infinity, the result is
	833	+ * {@code 0x7ff0000000000000L}.
	834	+ *
	835	+ * <p>If the argument is negative infinity, the result is
	836	+ * {@code 0xfff0000000000000L}.
	837	+ *
	838	+ * <p>If the argument is NaN, the result is the {@code long}
	839	+ * integer representing the actual NaN value. Unlike the
	840	+ * {@code doubleToLongBits} method,
	841	+ * {@code doubleToRawLongBits} does not collapse all the bit
	842	+ * patterns encoding a NaN to a single "canonical" NaN
	843	+ * value.
	844	+ *
	845	+ * <p>In all cases, the result is a {@code long} integer that,
	846	+ * when given to the {@link #longBitsToDouble(long)} method, will
	847	+ * produce a floating-point value the same as the argument to
	848	+ * {@code doubleToRawLongBits}.
	849	+ *
	850	+ * @param value a {@code double} precision floating-point number.
	851	+ * @return the bits that represent the floating-point number.
	852	+ * @since 1.3
	853	+ */
	854	+ public static native long doubleToRawLongBits(double value);
	855	+
	856	+ /**
	857	+ * Returns the {@code double} value corresponding to a given
	858	+ * bit representation.
	859	+ * The argument is considered to be a representation of a
	860	+ * floating-point value according to the IEEE 754 floating-point
	861	+ * "double format" bit layout.
	862	+ *
	863	+ * <p>If the argument is {@code 0x7ff0000000000000L}, the result
	864	+ * is positive infinity.
	865	+ *
	866	+ * <p>If the argument is {@code 0xfff0000000000000L}, the result
	867	+ * is negative infinity.
	868	+ *
	869	+ * <p>If the argument is any value in the range
	870	+ * {@code 0x7ff0000000000001L} through
	871	+ * {@code 0x7fffffffffffffffL} or in the range
	872	+ * {@code 0xfff0000000000001L} through
	873	+ * {@code 0xffffffffffffffffL}, the result is a NaN. No IEEE
	874	+ * 754 floating-point operation provided by Java can distinguish
	875	+ * between two NaN values of the same type with different bit
	876	+ * patterns. Distinct values of NaN are only distinguishable by
	877	+ * use of the {@code Double.doubleToRawLongBits} method.
	878	+ *
	879	+ * <p>In all other cases, let <i>s</i>, <i>e</i>, and <i>m</i> be three
	880	+ * values that can be computed from the argument:
	881	+ *
	882	+ * <blockquote><pre>
	883	+ * int s = ((bits >> 63) == 0) ? 1 : -1;
	884	+ * int e = (int)((bits >> 52) & 0x7ffL);
	885	+ * long m = (e == 0) ?
	886	+ * (bits & 0xfffffffffffffL) << 1 :
	887	+ * (bits & 0xfffffffffffffL) \| 0x10000000000000L;
	888	+ * </pre></blockquote>
	889	+ *
	890	+ * Then the floating-point result equals the value of the mathematical
	891	+ * expression <i>s</i>·<i>m</i>·2<sup><i>e</i>-1075</sup>.
	892	+ *
	893	+ * <p>Note that this method may not be able to return a
	894	+ * {@code double} NaN with exactly same bit pattern as the
	895	+ * {@code long} argument. IEEE 754 distinguishes between two
	896	+ * kinds of NaNs, quiet NaNs and <i>signaling NaNs</i>. The
	897	+ * differences between the two kinds of NaN are generally not
	898	+ * visible in Java. Arithmetic operations on signaling NaNs turn
	899	+ * them into quiet NaNs with a different, but often similar, bit
	900	+ * pattern. However, on some processors merely copying a
	901	+ * signaling NaN also performs that conversion. In particular,
	902	+ * copying a signaling NaN to return it to the calling method
	903	+ * may perform this conversion. So {@code longBitsToDouble}
	904	+ * may not be able to return a {@code double} with a
	905	+ * signaling NaN bit pattern. Consequently, for some
	906	+ * {@code long} values,
	907	+ * {@code doubleToRawLongBits(longBitsToDouble(start))} may
	908	+ * <i>not</i> equal {@code start}. Moreover, which
	909	+ * particular bit patterns represent signaling NaNs is platform
	910	+ * dependent; although all NaN bit patterns, quiet or signaling,
	911	+ * must be in the NaN range identified above.
	912	+ *
	913	+ * @param bits any {@code long} integer.
	914	+ * @return the {@code double} floating-point value with the same
	915	+ * bit pattern.
	916	+ */
	917	+ public static native double longBitsToDouble(long bits);
	918	+
	919	+ /**
	920	+ * Compares two {@code Double} objects numerically. There
	921	+ * are two ways in which comparisons performed by this method
	922	+ * differ from those performed by the Java language numerical
	923	+ * comparison operators ({@code <, <=, ==, >=, >})
	924	+ * when applied to primitive {@code double} values:
	925	+ * <ul><li>
	926	+ * {@code Double.NaN} is considered by this method
	927	+ * to be equal to itself and greater than all other
	928	+ * {@code double} values (including
	929	+ * {@code Double.POSITIVE_INFINITY}).
	930	+ * <li>
	931	+ * {@code 0.0d} is considered by this method to be greater
	932	+ * than {@code -0.0d}.
	933	+ * </ul>
	934	+ * This ensures that the <i>natural ordering</i> of
	935	+ * {@code Double} objects imposed by this method is <i>consistent
	936	+ * with equals</i>.
	937	+ *
	938	+ * @param anotherDouble the {@code Double} to be compared.
	939	+ * @return the value {@code 0} if {@code anotherDouble} is
	940	+ * numerically equal to this {@code Double}; a value
	941	+ * less than {@code 0} if this {@code Double}
	942	+ * is numerically less than {@code anotherDouble};
	943	+ * and a value greater than {@code 0} if this
	944	+ * {@code Double} is numerically greater than
	945	+ * {@code anotherDouble}.
	946	+ *
	947	+ * @since 1.2
	948	+ */
	949	+ public int compareTo(Double anotherDouble) {
	950	+ return Double.compare(value, anotherDouble.value);
	951	+ }
	952	+
	953	+ /**
	954	+ * Compares the two specified {@code double} values. The sign
	955	+ * of the integer value returned is the same as that of the
	956	+ * integer that would be returned by the call:
	957	+ * <pre>
	958	+ * new Double(d1).compareTo(new Double(d2))
	959	+ * </pre>
	960	+ *
	961	+ * @param d1 the first {@code double} to compare
	962	+ * @param d2 the second {@code double} to compare
	963	+ * @return the value {@code 0} if {@code d1} is
	964	+ * numerically equal to {@code d2}; a value less than
	965	+ * {@code 0} if {@code d1} is numerically less than
	966	+ * {@code d2}; and a value greater than {@code 0}
	967	+ * if {@code d1} is numerically greater than
	968	+ * {@code d2}.
	969	+ * @since 1.4
	970	+ */
	971	+ public static int compare(double d1, double d2) {
	972	+ if (d1 < d2)
	973	+ return -1; // Neither val is NaN, thisVal is smaller
	974	+ if (d1 > d2)
	975	+ return 1; // Neither val is NaN, thisVal is larger
	976	+
	977	+ // Cannot use doubleToRawLongBits because of possibility of NaNs.
	978	+ long thisBits = Double.doubleToLongBits(d1);
	979	+ long anotherBits = Double.doubleToLongBits(d2);
	980	+
	981	+ return (thisBits == anotherBits ? 0 : // Values are equal
	982	+ (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
	983	+ 1)); // (0.0, -0.0) or (NaN, !NaN)
	984	+ }
	985	+
	986	+ /** use serialVersionUID from JDK 1.0.2 for interoperability */
	987	+ private static final long serialVersionUID = -9172774392245257468L;
	988	+}