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/sun/misc/FormattedFloatingDecimal.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/misc/FormattedFloatingDecimal.java+1767−0

@@ -0,0 +1,1767 @@
	1	+/*
	2	+ * Copyright (c) 2003, 2011, 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 sun.misc;
	27	+
	28	+import sun.misc.FpUtils;
	29	+import sun.misc.DoubleConsts;
	30	+import sun.misc.FloatConsts;
	31	+import java.util.regex.*;
	32	+
	33	+public class FormattedFloatingDecimal{
	34	+ boolean isExceptional;
	35	+ boolean isNegative;
	36	+ int decExponent; // value set at construction, then immutable
	37	+ int decExponentRounded;
	38	+ char digits[];
	39	+ int nDigits;
	40	+ int bigIntExp;
	41	+ int bigIntNBits;
	42	+ boolean mustSetRoundDir = false;
	43	+ boolean fromHex = false;
	44	+ int roundDir = 0; // set by doubleValue
	45	+ int precision; // number of digits to the right of decimal
	46	+
	47	+ public enum Form { SCIENTIFIC, COMPATIBLE, DECIMAL_FLOAT, GENERAL };
	48	+
	49	+ private Form form;
	50	+
	51	+ private FormattedFloatingDecimal( boolean negSign, int decExponent, char []digits, int n, boolean e, int precision, Form form )
	52	+ {
	53	+ isNegative = negSign;
	54	+ isExceptional = e;
	55	+ this.decExponent = decExponent;
	56	+ this.digits = digits;
	57	+ this.nDigits = n;
	58	+ this.precision = precision;
	59	+ this.form = form;
	60	+ }
	61	+
	62	+ /*
	63	+ * Constants of the implementation
	64	+ * Most are IEEE-754 related.
	65	+ * (There are more really boring constants at the end.)
	66	+ */
	67	+ static final long signMask = 0x8000000000000000L;
	68	+ static final long expMask = 0x7ff0000000000000L;
	69	+ static final long fractMask= ~(signMask\|expMask);
	70	+ static final int expShift = 52;
	71	+ static final int expBias = 1023;
	72	+ static final long fractHOB = ( 1L<<expShift ); // assumed High-Order bit
	73	+ static final long expOne = ((long)expBias)<<expShift; // exponent of 1.0
	74	+ static final int maxSmallBinExp = 62;
	75	+ static final int minSmallBinExp = -( 63 / 3 );
	76	+ static final int maxDecimalDigits = 15;
	77	+ static final int maxDecimalExponent = 308;
	78	+ static final int minDecimalExponent = -324;
	79	+ static final int bigDecimalExponent = 324; // i.e. abs(minDecimalExponent)
	80	+
	81	+ static final long highbyte = 0xff00000000000000L;
	82	+ static final long highbit = 0x8000000000000000L;
	83	+ static final long lowbytes = ~highbyte;
	84	+
	85	+ static final int singleSignMask = 0x80000000;
	86	+ static final int singleExpMask = 0x7f800000;
	87	+ static final int singleFractMask = ~(singleSignMask\|singleExpMask);
	88	+ static final int singleExpShift = 23;
	89	+ static final int singleFractHOB = 1<<singleExpShift;
	90	+ static final int singleExpBias = 127;
	91	+ static final int singleMaxDecimalDigits = 7;
	92	+ static final int singleMaxDecimalExponent = 38;
	93	+ static final int singleMinDecimalExponent = -45;
	94	+
	95	+ static final int intDecimalDigits = 9;
	96	+
	97	+
	98	+ /*
	99	+ * count number of bits from high-order 1 bit to low-order 1 bit,
	100	+ * inclusive.
	101	+ */
	102	+ private static int
	103	+ countBits( long v ){
	104	+ //
	105	+ // the strategy is to shift until we get a non-zero sign bit
	106	+ // then shift until we have no bits left, counting the difference.
	107	+ // we do byte shifting as a hack. Hope it helps.
	108	+ //
	109	+ if ( v == 0L ) return 0;
	110	+
	111	+ while ( ( v & highbyte ) == 0L ){
	112	+ v <<= 8;
	113	+ }
	114	+ while ( v > 0L ) { // i.e. while ((v&highbit) == 0L )
	115	+ v <<= 1;
	116	+ }
	117	+
	118	+ int n = 0;
	119	+ while (( v & lowbytes ) != 0L ){
	120	+ v <<= 8;
	121	+ n += 8;
	122	+ }
	123	+ while ( v != 0L ){
	124	+ v <<= 1;
	125	+ n += 1;
	126	+ }
	127	+ return n;
	128	+ }
	129	+
	130	+ /*
	131	+ * Keep big powers of 5 handy for future reference.
	132	+ */
	133	+ private static FDBigInt b5p[];
	134	+
	135	+ private static synchronized FDBigInt
	136	+ big5pow( int p ){
	137	+ assert p >= 0 : p; // negative power of 5
	138	+ if ( b5p == null ){
	139	+ b5p = new FDBigInt[ p+1 ];
	140	+ }else if (b5p.length <= p ){
	141	+ FDBigInt t[] = new FDBigInt[ p+1 ];
	142	+ System.arraycopy( b5p, 0, t, 0, b5p.length );
	143	+ b5p = t;
	144	+ }
	145	+ if ( b5p[p] != null )
	146	+ return b5p[p];
	147	+ else if ( p < small5pow.length )
	148	+ return b5p[p] = new FDBigInt( small5pow[p] );
	149	+ else if ( p < long5pow.length )
	150	+ return b5p[p] = new FDBigInt( long5pow[p] );
	151	+ else {
	152	+ // construct the value.
	153	+ // recursively.
	154	+ int q, r;
	155	+ // in order to compute 5^p,
	156	+ // compute its square root, 5^(p/2) and square.
	157	+ // or, let q = p / 2, r = p -q, then
	158	+ // 5^p = 5^(q+r) = 5^q * 5^r
	159	+ q = p >> 1;
	160	+ r = p - q;
	161	+ FDBigInt bigq = b5p[q];
	162	+ if ( bigq == null )
	163	+ bigq = big5pow ( q );
	164	+ if ( r < small5pow.length ){
	165	+ return (b5p[p] = bigq.mult( small5pow[r] ) );
	166	+ }else{
	167	+ FDBigInt bigr = b5p[ r ];
	168	+ if ( bigr == null )
	169	+ bigr = big5pow( r );
	170	+ return (b5p[p] = bigq.mult( bigr ) );
	171	+ }
	172	+ }
	173	+ }
	174	+
	175	+ //
	176	+ // a common operation
	177	+ //
	178	+ private static FDBigInt
	179	+ multPow52( FDBigInt v, int p5, int p2 ){
	180	+ if ( p5 != 0 ){
	181	+ if ( p5 < small5pow.length ){
	182	+ v = v.mult( small5pow[p5] );
	183	+ } else {
	184	+ v = v.mult( big5pow( p5 ) );
	185	+ }
	186	+ }
	187	+ if ( p2 != 0 ){
	188	+ v.lshiftMe( p2 );
	189	+ }
	190	+ return v;
	191	+ }
	192	+
	193	+ //
	194	+ // another common operation
	195	+ //
	196	+ private static FDBigInt
	197	+ constructPow52( int p5, int p2 ){
	198	+ FDBigInt v = new FDBigInt( big5pow( p5 ) );
	199	+ if ( p2 != 0 ){
	200	+ v.lshiftMe( p2 );
	201	+ }
	202	+ return v;
	203	+ }
	204	+
	205	+ /*
	206	+ * Make a floating double into a FDBigInt.
	207	+ * This could also be structured as a FDBigInt
	208	+ * constructor, but we'd have to build a lot of knowledge
	209	+ * about floating-point representation into it, and we don't want to.
	210	+ *
	211	+ * AS A SIDE EFFECT, THIS METHOD WILL SET THE INSTANCE VARIABLES
	212	+ * bigIntExp and bigIntNBits
	213	+ *
	214	+ */
	215	+ private FDBigInt
	216	+ doubleToBigInt( double dval ){
	217	+ long lbits = Double.doubleToLongBits( dval ) & ~signMask;
	218	+ int binexp = (int)(lbits >>> expShift);
	219	+ lbits &= fractMask;
	220	+ if ( binexp > 0 ){
	221	+ lbits \|= fractHOB;
	222	+ } else {
	223	+ assert lbits != 0L : lbits; // doubleToBigInt(0.0)
	224	+ binexp +=1;
	225	+ while ( (lbits & fractHOB ) == 0L){
	226	+ lbits <<= 1;
	227	+ binexp -= 1;
	228	+ }
	229	+ }
	230	+ binexp -= expBias;
	231	+ int nbits = countBits( lbits );
	232	+ /*
	233	+ * We now know where the high-order 1 bit is,
	234	+ * and we know how many there are.
	235	+ */
	236	+ int lowOrderZeros = expShift+1-nbits;
	237	+ lbits >>>= lowOrderZeros;
	238	+
	239	+ bigIntExp = binexp+1-nbits;
	240	+ bigIntNBits = nbits;
	241	+ return new FDBigInt( lbits );
	242	+ }
	243	+
	244	+ /*
	245	+ * Compute a number that is the ULP of the given value,
	246	+ * for purposes of addition/subtraction. Generally easy.
	247	+ * More difficult if subtracting and the argument
	248	+ * is a normalized a power of 2, as the ULP changes at these points.
	249	+ */
	250	+ private static double ulp( double dval, boolean subtracting ){
	251	+ long lbits = Double.doubleToLongBits( dval ) & ~signMask;
	252	+ int binexp = (int)(lbits >>> expShift);
	253	+ double ulpval;
	254	+ if ( subtracting && ( binexp >= expShift ) && ((lbits&fractMask) == 0L) ){
	255	+ // for subtraction from normalized, powers of 2,
	256	+ // use next-smaller exponent
	257	+ binexp -= 1;
	258	+ }
	259	+ if ( binexp > expShift ){
	260	+ ulpval = Double.longBitsToDouble( ((long)(binexp-expShift))<<expShift );
	261	+ } else if ( binexp == 0 ){
	262	+ ulpval = Double.MIN_VALUE;
	263	+ } else {
	264	+ ulpval = Double.longBitsToDouble( 1L<<(binexp-1) );
	265	+ }
	266	+ if ( subtracting ) ulpval = - ulpval;
	267	+
	268	+ return ulpval;
	269	+ }
	270	+
	271	+ /*
	272	+ * Round a double to a float.
	273	+ * In addition to the fraction bits of the double,
	274	+ * look at the class instance variable roundDir,
	275	+ * which should help us avoid double-rounding error.
	276	+ * roundDir was set in hardValueOf if the estimate was
	277	+ * close enough, but not exact. It tells us which direction
	278	+ * of rounding is preferred.
	279	+ */
	280	+ float
	281	+ stickyRound( double dval ){
	282	+ long lbits = Double.doubleToLongBits( dval );
	283	+ long binexp = lbits & expMask;
	284	+ if ( binexp == 0L \|\| binexp == expMask ){
	285	+ // what we have here is special.
	286	+ // don't worry, the right thing will happen.
	287	+ return (float) dval;
	288	+ }
	289	+ lbits += (long)roundDir; // hack-o-matic.
	290	+ return (float)Double.longBitsToDouble( lbits );
	291	+ }
	292	+
	293	+
	294	+ /*
	295	+ * This is the easy subcase --
	296	+ * all the significant bits, after scaling, are held in lvalue.
	297	+ * negSign and decExponent tell us what processing and scaling
	298	+ * has already been done. Exceptional cases have already been
	299	+ * stripped out.
	300	+ * In particular:
	301	+ * lvalue is a finite number (not Inf, nor NaN)
	302	+ * lvalue > 0L (not zero, nor negative).
	303	+ *
	304	+ * The only reason that we develop the digits here, rather than
	305	+ * calling on Long.toString() is that we can do it a little faster,
	306	+ * and besides want to treat trailing 0s specially. If Long.toString
	307	+ * changes, we should re-evaluate this strategy!
	308	+ */
	309	+ private void
	310	+ developLongDigits( int decExponent, long lvalue, long insignificant ){
	311	+ char digits[];
	312	+ int ndigits;
	313	+ int digitno;
	314	+ int c;
	315	+ //
	316	+ // Discard non-significant low-order bits, while rounding,
	317	+ // up to insignificant value.
	318	+ int i;
	319	+ for ( i = 0; insignificant >= 10L; i++ )
	320	+ insignificant /= 10L;
	321	+ if ( i != 0 ){
	322	+ long pow10 = long5pow[i] << i; // 10^i == 5^i * 2^i;
	323	+ long residue = lvalue % pow10;
	324	+ lvalue /= pow10;
	325	+ decExponent += i;
	326	+ if ( residue >= (pow10>>1) ){
	327	+ // round up based on the low-order bits we're discarding
	328	+ lvalue++;
	329	+ }
	330	+ }
	331	+ if ( lvalue <= Integer.MAX_VALUE ){
	332	+ assert lvalue > 0L : lvalue; // lvalue <= 0
	333	+ // even easier subcase!
	334	+ // can do int arithmetic rather than long!
	335	+ int ivalue = (int)lvalue;
	336	+ ndigits = 10;
	337	+ digits = (char[])(perThreadBuffer.get());
	338	+ digitno = ndigits-1;
	339	+ c = ivalue%10;
	340	+ ivalue /= 10;
	341	+ while ( c == 0 ){
	342	+ decExponent++;
	343	+ c = ivalue%10;
	344	+ ivalue /= 10;
	345	+ }
	346	+ while ( ivalue != 0){
	347	+ digits[digitno--] = (char)(c+'0');
	348	+ decExponent++;
	349	+ c = ivalue%10;
	350	+ ivalue /= 10;
	351	+ }
	352	+ digits[digitno] = (char)(c+'0');
	353	+ } else {
	354	+ // same algorithm as above (same bugs, too )
	355	+ // but using long arithmetic.
	356	+ ndigits = 20;
	357	+ digits = (char[])(perThreadBuffer.get());
	358	+ digitno = ndigits-1;
	359	+ c = (int)(lvalue%10L);
	360	+ lvalue /= 10L;
	361	+ while ( c == 0 ){
	362	+ decExponent++;
	363	+ c = (int)(lvalue%10L);
	364	+ lvalue /= 10L;
	365	+ }
	366	+ while ( lvalue != 0L ){
	367	+ digits[digitno--] = (char)(c+'0');
	368	+ decExponent++;
	369	+ c = (int)(lvalue%10L);
	370	+ lvalue /= 10;
	371	+ }
	372	+ digits[digitno] = (char)(c+'0');
	373	+ }
	374	+ char result [];
	375	+ ndigits -= digitno;
	376	+ result = new char[ ndigits ];
	377	+ System.arraycopy( digits, digitno, result, 0, ndigits );
	378	+ this.digits = result;
	379	+ this.decExponent = decExponent+1;
	380	+ this.nDigits = ndigits;
	381	+ }
	382	+
	383	+ //
	384	+ // add one to the least significant digit.
	385	+ // in the unlikely event there is a carry out,
	386	+ // deal with it.
	387	+ // assert that this will only happen where there
	388	+ // is only one digit, e.g. (float)1e-44 seems to do it.
	389	+ //
	390	+ private void
	391	+ roundup(){
	392	+ int i;
	393	+ int q = digits[ i = (nDigits-1)];
	394	+ if ( q == '9' ){
	395	+ while ( q == '9' && i > 0 ){
	396	+ digits[i] = '0';
	397	+ q = digits[--i];
	398	+ }
	399	+ if ( q == '9' ){
	400	+ // carryout! High-order 1, rest 0s, larger exp.
	401	+ decExponent += 1;
	402	+ digits[0] = '1';
	403	+ return;
	404	+ }
	405	+ // else fall through.
	406	+ }
	407	+ digits[i] = (char)(q+1);
	408	+ }
	409	+
	410	+ // Given the desired number of digits predict the result's exponent.
	411	+ private int checkExponent(int length) {
	412	+ if (length >= nDigits \|\| length < 0)
	413	+ return decExponent;
	414	+
	415	+ for (int i = 0; i < length; i++)
	416	+ if (digits[i] != '9')
	417	+ // a '9' anywhere in digits will absorb the round
	418	+ return decExponent;
	419	+ return decExponent + (digits[length] >= '5' ? 1 : 0);
	420	+ }
	421	+
	422	+ // Unlike roundup(), this method does not modify digits. It also
	423	+ // rounds at a particular precision.
	424	+ private char [] applyPrecision(int length) {
	425	+ char [] result = new char[nDigits];
	426	+ for (int i = 0; i < result.length; i++) result[i] = '0';
	427	+
	428	+ if (length >= nDigits \|\| length < 0) {
	429	+ // no rounding necessary
	430	+ System.arraycopy(digits, 0, result, 0, nDigits);
	431	+ return result;
	432	+ }
	433	+ if (length == 0) {
	434	+ // only one digit (0 or 1) is returned because the precision
	435	+ // excludes all significant digits
	436	+ if (digits[0] >= '5') {
	437	+ result[0] = '1';
	438	+ }
	439	+ return result;
	440	+ }
	441	+
	442	+ int i = length;
	443	+ int q = digits[i];
	444	+ if (q >= '5' && i > 0) {
	445	+ q = digits[--i];
	446	+ if ( q == '9' ) {
	447	+ while ( q == '9' && i > 0 ){
	448	+ q = digits[--i];
	449	+ }
	450	+ if ( q == '9' ){
	451	+ // carryout! High-order 1, rest 0s, larger exp.
	452	+ result[0] = '1';
	453	+ return result;
	454	+ }
	455	+ }
	456	+ result[i] = (char)(q + 1);
	457	+ }
	458	+ while (--i >= 0) {
	459	+ result[i] = digits[i];
	460	+ }
	461	+ return result;
	462	+ }
	463	+
	464	+ /*
	465	+ * FIRST IMPORTANT CONSTRUCTOR: DOUBLE
	466	+ */
	467	+ public FormattedFloatingDecimal( double d )
	468	+ {
	469	+ this(d, Integer.MAX_VALUE, Form.COMPATIBLE);
	470	+ }
	471	+
	472	+ public FormattedFloatingDecimal( double d, int precision, Form form )
	473	+ {
	474	+ long dBits = Double.doubleToLongBits( d );
	475	+ long fractBits;
	476	+ int binExp;
	477	+ int nSignificantBits;
	478	+
	479	+ this.precision = precision;
	480	+ this.form = form;
	481	+
	482	+ // discover and delete sign
	483	+ if ( (dBits&signMask) != 0 ){
	484	+ isNegative = true;
	485	+ dBits ^= signMask;
	486	+ } else {
	487	+ isNegative = false;
	488	+ }
	489	+ // Begin to unpack
	490	+ // Discover obvious special cases of NaN and Infinity.
	491	+ binExp = (int)( (dBits&expMask) >> expShift );
	492	+ fractBits = dBits&fractMask;
	493	+ if ( binExp == (int)(expMask>>expShift) ) {
	494	+ isExceptional = true;
	495	+ if ( fractBits == 0L ){
	496	+ digits = infinity;
	497	+ } else {
	498	+ digits = notANumber;
	499	+ isNegative = false; // NaN has no sign!
	500	+ }
	501	+ nDigits = digits.length;
	502	+ return;
	503	+ }
	504	+ isExceptional = false;
	505	+ // Finish unpacking
	506	+ // Normalize denormalized numbers.
	507	+ // Insert assumed high-order bit for normalized numbers.
	508	+ // Subtract exponent bias.
	509	+ if ( binExp == 0 ){
	510	+ if ( fractBits == 0L ){
	511	+ // not a denorm, just a 0!
	512	+ decExponent = 0;
	513	+ digits = zero;
	514	+ nDigits = 1;
	515	+ return;
	516	+ }
	517	+ while ( (fractBits&fractHOB) == 0L ){
	518	+ fractBits <<= 1;
	519	+ binExp -= 1;
	520	+ }
	521	+ nSignificantBits = expShift + binExp +1; // recall binExp is - shift count.
	522	+ binExp += 1;
	523	+ } else {
	524	+ fractBits \|= fractHOB;
	525	+ nSignificantBits = expShift+1;
	526	+ }
	527	+ binExp -= expBias;
	528	+ // call the routine that actually does all the hard work.
	529	+ dtoa( binExp, fractBits, nSignificantBits );
	530	+ }
	531	+
	532	+ /*
	533	+ * SECOND IMPORTANT CONSTRUCTOR: SINGLE
	534	+ */
	535	+ public FormattedFloatingDecimal( float f )
	536	+ {
	537	+ this(f, Integer.MAX_VALUE, Form.COMPATIBLE);
	538	+ }
	539	+ public FormattedFloatingDecimal( float f, int precision, Form form )
	540	+ {
	541	+ int fBits = Float.floatToIntBits( f );
	542	+ int fractBits;
	543	+ int binExp;
	544	+ int nSignificantBits;
	545	+
	546	+ this.precision = precision;
	547	+ this.form = form;
	548	+
	549	+ // discover and delete sign
	550	+ if ( (fBits&singleSignMask) != 0 ){
	551	+ isNegative = true;
	552	+ fBits ^= singleSignMask;
	553	+ } else {
	554	+ isNegative = false;
	555	+ }
	556	+ // Begin to unpack
	557	+ // Discover obvious special cases of NaN and Infinity.
	558	+ binExp = (int)( (fBits&singleExpMask) >> singleExpShift );
	559	+ fractBits = fBits&singleFractMask;
	560	+ if ( binExp == (int)(singleExpMask>>singleExpShift) ) {
	561	+ isExceptional = true;
	562	+ if ( fractBits == 0L ){
	563	+ digits = infinity;
	564	+ } else {
	565	+ digits = notANumber;
	566	+ isNegative = false; // NaN has no sign!
	567	+ }
	568	+ nDigits = digits.length;
	569	+ return;
	570	+ }
	571	+ isExceptional = false;
	572	+ // Finish unpacking
	573	+ // Normalize denormalized numbers.
	574	+ // Insert assumed high-order bit for normalized numbers.
	575	+ // Subtract exponent bias.
	576	+ if ( binExp == 0 ){
	577	+ if ( fractBits == 0 ){
	578	+ // not a denorm, just a 0!
	579	+ decExponent = 0;
	580	+ digits = zero;
	581	+ nDigits = 1;
	582	+ return;
	583	+ }
	584	+ while ( (fractBits&singleFractHOB) == 0 ){
	585	+ fractBits <<= 1;
	586	+ binExp -= 1;
	587	+ }
	588	+ nSignificantBits = singleExpShift + binExp +1; // recall binExp is - shift count.
	589	+ binExp += 1;
	590	+ } else {
	591	+ fractBits \|= singleFractHOB;
	592	+ nSignificantBits = singleExpShift+1;
	593	+ }
	594	+ binExp -= singleExpBias;
	595	+ // call the routine that actually does all the hard work.
	596	+ dtoa( binExp, ((long)fractBits)<<(expShift-singleExpShift), nSignificantBits );
	597	+ }
	598	+
	599	+ private void
	600	+ dtoa( int binExp, long fractBits, int nSignificantBits )
	601	+ {
	602	+ int nFractBits; // number of significant bits of fractBits;
	603	+ int nTinyBits; // number of these to the right of the point.
	604	+ int decExp;
	605	+
	606	+ // Examine number. Determine if it is an easy case,
	607	+ // which we can do pretty trivially using float/long conversion,
	608	+ // or whether we must do real work.
	609	+ nFractBits = countBits( fractBits );
	610	+ nTinyBits = Math.max( 0, nFractBits - binExp - 1 );
	611	+ if ( binExp <= maxSmallBinExp && binExp >= minSmallBinExp ){
	612	+ // Look more closely at the number to decide if,
	613	+ // with scaling by 10^nTinyBits, the result will fit in
	614	+ // a long.
	615	+ if ( (nTinyBits < long5pow.length) && ((nFractBits + n5bits[nTinyBits]) < 64 ) ){
	616	+ /*
	617	+ * We can do this:
	618	+ * take the fraction bits, which are normalized.
	619	+ * (a) nTinyBits == 0: Shift left or right appropriately
	620	+ * to align the binary point at the extreme right, i.e.
	621	+ * where a long int point is expected to be. The integer
	622	+ * result is easily converted to a string.
	623	+ * (b) nTinyBits > 0: Shift right by expShift-nFractBits,
	624	+ * which effectively converts to long and scales by
	625	+ * 2^nTinyBits. Then multiply by 5^nTinyBits to
	626	+ * complete the scaling. We know this won't overflow
	627	+ * because we just counted the number of bits necessary
	628	+ * in the result. The integer you get from this can
	629	+ * then be converted to a string pretty easily.
	630	+ */
	631	+ long halfULP;
	632	+ if ( nTinyBits == 0 ) {
	633	+ if ( binExp > nSignificantBits ){
	634	+ halfULP = 1L << ( binExp-nSignificantBits-1);
	635	+ } else {
	636	+ halfULP = 0L;
	637	+ }
	638	+ if ( binExp >= expShift ){
	639	+ fractBits <<= (binExp-expShift);
	640	+ } else {
	641	+ fractBits >>>= (expShift-binExp) ;
	642	+ }
	643	+ developLongDigits( 0, fractBits, halfULP );
	644	+ return;
	645	+ }
	646	+ /*
	647	+ * The following causes excess digits to be printed
	648	+ * out in the single-float case. Our manipulation of
	649	+ * halfULP here is apparently not correct. If we
	650	+ * better understand how this works, perhaps we can
	651	+ * use this special case again. But for the time being,
	652	+ * we do not.
	653	+ * else {
	654	+ * fractBits >>>= expShift+1-nFractBits;
	655	+ * fractBits *= long5pow[ nTinyBits ];
	656	+ * halfULP = long5pow[ nTinyBits ] >> (1+nSignificantBits-nFractBits);
	657	+ * developLongDigits( -nTinyBits, fractBits, halfULP );
	658	+ * return;
	659	+ * }
	660	+ */
	661	+ }
	662	+ }
	663	+ /*
	664	+ * This is the hard case. We are going to compute large positive
	665	+ * integers B and S and integer decExp, s.t.
	666	+ * d = ( B / S ) * 10^decExp
	667	+ * 1 <= B / S < 10
	668	+ * Obvious choices are:
	669	+ * decExp = floor( log10(d) )
	670	+ * B = d * 2^nTinyBits * 10^max( 0, -decExp )
	671	+ * S = 10^max( 0, decExp) * 2^nTinyBits
	672	+ * (noting that nTinyBits has already been forced to non-negative)
	673	+ * I am also going to compute a large positive integer
	674	+ * M = (1/2^nSignificantBits) * 2^nTinyBits * 10^max( 0, -decExp )
	675	+ * i.e. M is (1/2) of the ULP of d, scaled like B.
	676	+ * When we iterate through dividing B/S and picking off the
	677	+ * quotient bits, we will know when to stop when the remainder
	678	+ * is <= M.
	679	+ *
	680	+ * We keep track of powers of 2 and powers of 5.
	681	+ */
	682	+
	683	+ /*
	684	+ * Estimate decimal exponent. (If it is small-ish,
	685	+ * we could double-check.)
	686	+ *
	687	+ * First, scale the mantissa bits such that 1 <= d2 < 2.
	688	+ * We are then going to estimate
	689	+ * log10(d2) ~=~ (d2-1.5)/1.5 + log(1.5)
	690	+ * and so we can estimate
	691	+ * log10(d) ~=~ log10(d2) + binExp * log10(2)
	692	+ * take the floor and call it decExp.
	693	+ * FIXME -- use more precise constants here. It costs no more.
	694	+ */
	695	+ double d2 = Double.longBitsToDouble(
	696	+ expOne \| ( fractBits &~ fractHOB ) );
	697	+ decExp = (int)Math.floor(
	698	+ (d2-1.5D)0.289529654D + 0.176091259 + (double)binExp 0.301029995663981 );
	699	+ int B2, B5; // powers of 2 and powers of 5, respectively, in B
	700	+ int S2, S5; // powers of 2 and powers of 5, respectively, in S
	701	+ int M2, M5; // powers of 2 and powers of 5, respectively, in M
	702	+ int Bbits; // binary digits needed to represent B, approx.
	703	+ int tenSbits; // binary digits needed to represent 10*S, approx.
	704	+ FDBigInt Sval, Bval, Mval;
	705	+
	706	+ B5 = Math.max( 0, -decExp );
	707	+ B2 = B5 + nTinyBits + binExp;
	708	+
	709	+ S5 = Math.max( 0, decExp );
	710	+ S2 = S5 + nTinyBits;
	711	+
	712	+ M5 = B5;
	713	+ M2 = B2 - nSignificantBits;
	714	+
	715	+ /*
	716	+ * the long integer fractBits contains the (nFractBits) interesting
	717	+ * bits from the mantissa of d ( hidden 1 added if necessary) followed
	718	+ * by (expShift+1-nFractBits) zeros. In the interest of compactness,
	719	+ * I will shift out those zeros before turning fractBits into a
	720	+ * FDBigInt. The resulting whole number will be
	721	+ * d * 2^(nFractBits-1-binExp).
	722	+ */
	723	+ fractBits >>>= (expShift+1-nFractBits);
	724	+ B2 -= nFractBits-1;
	725	+ int common2factor = Math.min( B2, S2 );
	726	+ B2 -= common2factor;
	727	+ S2 -= common2factor;
	728	+ M2 -= common2factor;
	729	+
	730	+ /*
	731	+ * HACK!! For exact powers of two, the next smallest number
	732	+ * is only half as far away as we think (because the meaning of
	733	+ * ULP changes at power-of-two bounds) for this reason, we
	734	+ * hack M2. Hope this works.
	735	+ */
	736	+ if ( nFractBits == 1 )
	737	+ M2 -= 1;
	738	+
	739	+ if ( M2 < 0 ){
	740	+ // oops.
	741	+ // since we cannot scale M down far enough,
	742	+ // we must scale the other values up.
	743	+ B2 -= M2;
	744	+ S2 -= M2;
	745	+ M2 = 0;
	746	+ }
	747	+ /*
	748	+ * Construct, Scale, iterate.
	749	+ * Some day, we'll write a stopping test that takes
	750	+ * account of the assymetry of the spacing of floating-point
	751	+ * numbers below perfect powers of 2
	752	+ * 26 Sept 96 is not that day.
	753	+ * So we use a symmetric test.
	754	+ */
	755	+ char digits[] = this.digits = new char[18];
	756	+ int ndigit = 0;
	757	+ boolean low, high;
	758	+ long lowDigitDifference;
	759	+ int q;
	760	+
	761	+ /*
	762	+ * Detect the special cases where all the numbers we are about
	763	+ * to compute will fit in int or long integers.
	764	+ * In these cases, we will avoid doing FDBigInt arithmetic.
	765	+ * We use the same algorithms, except that we "normalize"
	766	+ * our FDBigInts before iterating. This is to make division easier,
	767	+ * as it makes our fist guess (quotient of high-order words)
	768	+ * more accurate!
	769	+ *
	770	+ * Some day, we'll write a stopping test that takes
	771	+ * account of the assymetry of the spacing of floating-point
	772	+ * numbers below perfect powers of 2
	773	+ * 26 Sept 96 is not that day.
	774	+ * So we use a symmetric test.
	775	+ */
	776	+ Bbits = nFractBits + B2 + (( B5 < n5bits.length )? n5bits[B5] : ( B5*3 ));
	777	+ tenSbits = S2+1 + (( (S5+1) < n5bits.length )? n5bits[(S5+1)] : ( (S5+1)*3 ));
	778	+ if ( Bbits < 64 && tenSbits < 64){
	779	+ if ( Bbits < 32 && tenSbits < 32){
	780	+ // wa-hoo! They're all ints!
	781	+ int b = ((int)fractBits * small5pow[B5] ) << B2;
	782	+ int s = small5pow[S5] << S2;
	783	+ int m = small5pow[M5] << M2;
	784	+ int tens = s * 10;
	785	+ /*
	786	+ * Unroll the first iteration. If our decExp estimate
	787	+ * was too high, our first quotient will be zero. In this
	788	+ * case, we discard it and decrement decExp.
	789	+ */
	790	+ ndigit = 0;
	791	+ q = b / s;
	792	+ b = 10 * ( b % s );
	793	+ m *= 10;
	794	+ low = (b < m );
	795	+ high = (b+m > tens );
	796	+ assert q < 10 : q; // excessively large digit
	797	+ if ( (q == 0) && ! high ){
	798	+ // oops. Usually ignore leading zero.
	799	+ decExp--;
	800	+ } else {
	801	+ digits[ndigit++] = (char)('0' + q);
	802	+ }
	803	+ /*
	804	+ * HACK! Java spec sez that we always have at least
	805	+ * one digit after the . in either F- or E-form output.
	806	+ * Thus we will need more than one digit if we're using
	807	+ * E-form
	808	+ */
	809	+ if (! (form == Form.COMPATIBLE && -3 < decExp && decExp < 8)) {
	810	+ high = low = false;
	811	+ }
	812	+ while( ! low && ! high ){
	813	+ q = b / s;
	814	+ b = 10 * ( b % s );
	815	+ m *= 10;
	816	+ assert q < 10 : q; // excessively large digit
	817	+ if ( m > 0L ){
	818	+ low = (b < m );
	819	+ high = (b+m > tens );
	820	+ } else {
	821	+ // hack -- m might overflow!
	822	+ // in this case, it is certainly > b,
	823	+ // which won't
	824	+ // and b+m > tens, too, since that has overflowed
	825	+ // either!
	826	+ low = true;
	827	+ high = true;
	828	+ }
	829	+ digits[ndigit++] = (char)('0' + q);
	830	+ }
	831	+ lowDigitDifference = (b<<1) - tens;
	832	+ } else {
	833	+ // still good! they're all longs!
	834	+ long b = (fractBits * long5pow[B5] ) << B2;
	835	+ long s = long5pow[S5] << S2;
	836	+ long m = long5pow[M5] << M2;
	837	+ long tens = s * 10L;
	838	+ /*
	839	+ * Unroll the first iteration. If our decExp estimate
	840	+ * was too high, our first quotient will be zero. In this
	841	+ * case, we discard it and decrement decExp.
	842	+ */
	843	+ ndigit = 0;
	844	+ q = (int) ( b / s );
	845	+ b = 10L * ( b % s );
	846	+ m *= 10L;
	847	+ low = (b < m );
	848	+ high = (b+m > tens );
	849	+ assert q < 10 : q; // excessively large digit
	850	+ if ( (q == 0) && ! high ){
	851	+ // oops. Usually ignore leading zero.
	852	+ decExp--;
	853	+ } else {
	854	+ digits[ndigit++] = (char)('0' + q);
	855	+ }
	856	+ /*
	857	+ * HACK! Java spec sez that we always have at least
	858	+ * one digit after the . in either F- or E-form output.
	859	+ * Thus we will need more than one digit if we're using
	860	+ * E-form
	861	+ */
	862	+ if (! (form == Form.COMPATIBLE && -3 < decExp && decExp < 8)) {
	863	+ high = low = false;
	864	+ }
	865	+ while( ! low && ! high ){
	866	+ q = (int) ( b / s );
	867	+ b = 10 * ( b % s );
	868	+ m *= 10;
	869	+ assert q < 10 : q; // excessively large digit
	870	+ if ( m > 0L ){
	871	+ low = (b < m );
	872	+ high = (b+m > tens );
	873	+ } else {
	874	+ // hack -- m might overflow!
	875	+ // in this case, it is certainly > b,
	876	+ // which won't
	877	+ // and b+m > tens, too, since that has overflowed
	878	+ // either!
	879	+ low = true;
	880	+ high = true;
	881	+ }
	882	+ digits[ndigit++] = (char)('0' + q);
	883	+ }
	884	+ lowDigitDifference = (b<<1) - tens;
	885	+ }
	886	+ } else {
	887	+ FDBigInt tenSval;
	888	+ int shiftBias;
	889	+
	890	+ /*
	891	+ * We really must do FDBigInt arithmetic.
	892	+ * Fist, construct our FDBigInt initial values.
	893	+ */
	894	+ Bval = multPow52( new FDBigInt( fractBits ), B5, B2 );
	895	+ Sval = constructPow52( S5, S2 );
	896	+ Mval = constructPow52( M5, M2 );
	897	+
	898	+
	899	+ // normalize so that division works better
	900	+ Bval.lshiftMe( shiftBias = Sval.normalizeMe() );
	901	+ Mval.lshiftMe( shiftBias );
	902	+ tenSval = Sval.mult( 10 );
	903	+ /*
	904	+ * Unroll the first iteration. If our decExp estimate
	905	+ * was too high, our first quotient will be zero. In this
	906	+ * case, we discard it and decrement decExp.
	907	+ */
	908	+ ndigit = 0;
	909	+ q = Bval.quoRemIteration( Sval );
	910	+ Mval = Mval.mult( 10 );
	911	+ low = (Bval.cmp( Mval ) < 0);
	912	+ high = (Bval.add( Mval ).cmp( tenSval ) > 0 );
	913	+ assert q < 10 : q; // excessively large digit
	914	+ if ( (q == 0) && ! high ){
	915	+ // oops. Usually ignore leading zero.
	916	+ decExp--;
	917	+ } else {
	918	+ digits[ndigit++] = (char)('0' + q);
	919	+ }
	920	+ /*
	921	+ * HACK! Java spec sez that we always have at least
	922	+ * one digit after the . in either F- or E-form output.
	923	+ * Thus we will need more than one digit if we're using
	924	+ * E-form
	925	+ */
	926	+ if (! (form == Form.COMPATIBLE && -3 < decExp && decExp < 8)) {
	927	+ high = low = false;
	928	+ }
	929	+ while( ! low && ! high ){
	930	+ q = Bval.quoRemIteration( Sval );
	931	+ Mval = Mval.mult( 10 );
	932	+ assert q < 10 : q; // excessively large digit
	933	+ low = (Bval.cmp( Mval ) < 0);
	934	+ high = (Bval.add( Mval ).cmp( tenSval ) > 0 );
	935	+ digits[ndigit++] = (char)('0' + q);
	936	+ }
	937	+ if ( high && low ){
	938	+ Bval.lshiftMe(1);
	939	+ lowDigitDifference = Bval.cmp(tenSval);
	940	+ } else
	941	+ lowDigitDifference = 0L; // this here only for flow analysis!
	942	+ }
	943	+ this.decExponent = decExp+1;
	944	+ this.digits = digits;
	945	+ this.nDigits = ndigit;
	946	+ /*
	947	+ * Last digit gets rounded based on stopping condition.
	948	+ */
	949	+ if ( high ){
	950	+ if ( low ){
	951	+ if ( lowDigitDifference == 0L ){
	952	+ // it's a tie!
	953	+ // choose based on which digits we like.
	954	+ if ( (digits[nDigits-1]&1) != 0 ) roundup();
	955	+ } else if ( lowDigitDifference > 0 ){
	956	+ roundup();
	957	+ }
	958	+ } else {
	959	+ roundup();
	960	+ }
	961	+ }
	962	+ }
	963	+
	964	+ public String
	965	+ toString(){
	966	+ // most brain-dead version
	967	+ StringBuffer result = new StringBuffer( nDigits+8 );
	968	+ if ( isNegative ){ result.append( '-' ); }
	969	+ if ( isExceptional ){
	970	+ result.append( digits, 0, nDigits );
	971	+ } else {
	972	+ result.append( "0.");
	973	+ result.append( digits, 0, nDigits );
	974	+ result.append('e');
	975	+ result.append( decExponent );
	976	+ }
	977	+ return new String(result);
	978	+ }
	979	+
	980	+ // returns the exponent before rounding
	981	+ public int getExponent() {
	982	+ return decExponent - 1;
	983	+ }
	984	+
	985	+ // returns the exponent after rounding has been done by applyPrecision
	986	+ public int getExponentRounded() {
	987	+ return decExponentRounded - 1;
	988	+ }
	989	+
	990	+ public int getChars(char[] result) {
	991	+ assert nDigits <= 19 : nDigits; // generous bound on size of nDigits
	992	+ int i = 0;
	993	+ if (isNegative) { result[0] = '-'; i = 1; }
	994	+ if (isExceptional) {
	995	+ System.arraycopy(digits, 0, result, i, nDigits);
	996	+ i += nDigits;
	997	+ } else {
	998	+ char digits [] = this.digits;
	999	+ int exp = decExponent;
	1000	+ switch (form) {
	1001	+ case COMPATIBLE:
	1002	+ break;
	1003	+ case DECIMAL_FLOAT:
	1004	+ exp = checkExponent(decExponent + precision);
	1005	+ digits = applyPrecision(decExponent + precision);
	1006	+ break;
	1007	+ case SCIENTIFIC:
	1008	+ exp = checkExponent(precision + 1);
	1009	+ digits = applyPrecision(precision + 1);
	1010	+ break;
	1011	+ case GENERAL:
	1012	+ exp = checkExponent(precision);
	1013	+ digits = applyPrecision(precision);
	1014	+ // adjust precision to be the number of digits to right of decimal
	1015	+ // the real exponent to be output is actually exp - 1, not exp
	1016	+ if (exp - 1 < -4 \|\| exp - 1 >= precision) {
	1017	+ form = Form.SCIENTIFIC;
	1018	+ precision--;
	1019	+ } else {
	1020	+ form = Form.DECIMAL_FLOAT;
	1021	+ precision = precision - exp;
	1022	+ }
	1023	+ break;
	1024	+ default:
	1025	+ assert false;
	1026	+ }
	1027	+ decExponentRounded = exp;
	1028	+
	1029	+ if (exp > 0
	1030	+ && ((form == Form.COMPATIBLE && (exp < 8))
	1031	+ \|\| (form == Form.DECIMAL_FLOAT)))
	1032	+ {
	1033	+ // print digits.digits.
	1034	+ int charLength = Math.min(nDigits, exp);
	1035	+ System.arraycopy(digits, 0, result, i, charLength);
	1036	+ i += charLength;
	1037	+ if (charLength < exp) {
	1038	+ charLength = exp-charLength;
	1039	+ for (int nz = 0; nz < charLength; nz++)
	1040	+ result[i++] = '0';
	1041	+ // Do not append ".0" for formatted floats since the user
	1042	+ // may request that it be omitted. It is added as necessary
	1043	+ // by the Formatter.
	1044	+ if (form == Form.COMPATIBLE) {
	1045	+ result[i++] = '.';
	1046	+ result[i++] = '0';
	1047	+ }
	1048	+ } else {
	1049	+ // Do not append ".0" for formatted floats since the user
	1050	+ // may request that it be omitted. It is added as necessary
	1051	+ // by the Formatter.
	1052	+ if (form == Form.COMPATIBLE) {
	1053	+ result[i++] = '.';
	1054	+ if (charLength < nDigits) {
	1055	+ int t = Math.min(nDigits - charLength, precision);
	1056	+ System.arraycopy(digits, charLength, result, i, t);
	1057	+ i += t;
	1058	+ } else {
	1059	+ result[i++] = '0';
	1060	+ }
	1061	+ } else {
	1062	+ int t = Math.min(nDigits - charLength, precision);
	1063	+ if (t > 0) {
	1064	+ result[i++] = '.';
	1065	+ System.arraycopy(digits, charLength, result, i, t);
	1066	+ i += t;
	1067	+ }
	1068	+ }
	1069	+ }
	1070	+ } else if (exp <= 0
	1071	+ && ((form == Form.COMPATIBLE && exp > -3)
	1072	+ \|\| (form == Form.DECIMAL_FLOAT)))
	1073	+ {
	1074	+ // print 0.0* digits
	1075	+ result[i++] = '0';
	1076	+ if (exp != 0) {
	1077	+ // write '0' s before the significant digits
	1078	+ int t = Math.min(-exp, precision);
	1079	+ if (t > 0) {
	1080	+ result[i++] = '.';
	1081	+ for (int nz = 0; nz < t; nz++)
	1082	+ result[i++] = '0';
	1083	+ }
	1084	+ }
	1085	+ int t = Math.min(digits.length, precision + exp);
	1086	+ if (t > 0) {
	1087	+ if (i == 1)
	1088	+ result[i++] = '.';
	1089	+ // copy only when significant digits are within the precision
	1090	+ System.arraycopy(digits, 0, result, i, t);
	1091	+ i += t;
	1092	+ }
	1093	+ } else {
	1094	+ result[i++] = digits[0];
	1095	+ if (form == Form.COMPATIBLE) {
	1096	+ result[i++] = '.';
	1097	+ if (nDigits > 1) {
	1098	+ System.arraycopy(digits, 1, result, i, nDigits-1);
	1099	+ i += nDigits-1;
	1100	+ } else {
	1101	+ result[i++] = '0';
	1102	+ }
	1103	+ result[i++] = 'E';
	1104	+ } else {
	1105	+ if (nDigits > 1) {
	1106	+ int t = Math.min(nDigits -1, precision);
	1107	+ if (t > 0) {
	1108	+ result[i++] = '.';
	1109	+ System.arraycopy(digits, 1, result, i, t);
	1110	+ i += t;
	1111	+ }
	1112	+ }
	1113	+ result[i++] = 'e';
	1114	+ }
	1115	+ int e;
	1116	+ if (exp <= 0) {
	1117	+ result[i++] = '-';
	1118	+ e = -exp+1;
	1119	+ } else {
	1120	+ if (form != Form.COMPATIBLE)
	1121	+ result[i++] = '+';
	1122	+ e = exp-1;
	1123	+ }
	1124	+ // decExponent has 1, 2, or 3, digits
	1125	+ if (e <= 9) {
	1126	+ if (form != Form.COMPATIBLE)
	1127	+ result[i++] = '0';
	1128	+ result[i++] = (char)(e+'0');
	1129	+ } else if (e <= 99) {
	1130	+ result[i++] = (char)(e/10 +'0');
	1131	+ result[i++] = (char)(e%10 + '0');
	1132	+ } else {
	1133	+ result[i++] = (char)(e/100+'0');
	1134	+ e %= 100;
	1135	+ result[i++] = (char)(e/10+'0');
	1136	+ result[i++] = (char)(e%10 + '0');
	1137	+ }
	1138	+ }
	1139	+ }
	1140	+ return i;
	1141	+ }
	1142	+
	1143	+ // Per-thread buffer for string/stringbuffer conversion
	1144	+ private static ThreadLocal perThreadBuffer = new ThreadLocal() {
	1145	+ protected synchronized Object initialValue() {
	1146	+ return new char[26];
	1147	+ }
	1148	+ };
	1149	+
	1150	+ /*
	1151	+ * Take a FormattedFloatingDecimal, which we presumably just scanned in,
	1152	+ * and find out what its value is, as a double.
	1153	+ *
	1154	+ * AS A SIDE EFFECT, SET roundDir TO INDICATE PREFERRED
	1155	+ * ROUNDING DIRECTION in case the result is really destined
	1156	+ * for a single-precision float.
	1157	+ */
	1158	+
	1159	+ public strictfp double doubleValue(){
	1160	+ int kDigits = Math.min( nDigits, maxDecimalDigits+1 );
	1161	+ long lValue;
	1162	+ double dValue;
	1163	+ double rValue, tValue;
	1164	+
	1165	+ // First, check for NaN and Infinity values
	1166	+ if(digits == infinity \|\| digits == notANumber) {
	1167	+ if(digits == notANumber)
	1168	+ return Double.NaN;
	1169	+ else
	1170	+ return (isNegative?Double.NEGATIVE_INFINITY:Double.POSITIVE_INFINITY);
	1171	+ }
	1172	+ else {
	1173	+ if (mustSetRoundDir) {
	1174	+ roundDir = 0;
	1175	+ }
	1176	+ /*
	1177	+ * convert the lead kDigits to a long integer.
	1178	+ */
	1179	+ // (special performance hack: start to do it using int)
	1180	+ int iValue = (int)digits[0]-(int)'0';
	1181	+ int iDigits = Math.min( kDigits, intDecimalDigits );
	1182	+ for ( int i=1; i < iDigits; i++ ){
	1183	+ iValue = iValue*10 + (int)digits[i]-(int)'0';
	1184	+ }
	1185	+ lValue = (long)iValue;
	1186	+ for ( int i=iDigits; i < kDigits; i++ ){
	1187	+ lValue = lValue*10L + (long)((int)digits[i]-(int)'0');
	1188	+ }
	1189	+ dValue = (double)lValue;
	1190	+ int exp = decExponent-kDigits;
	1191	+ /*
	1192	+ * lValue now contains a long integer with the value of
	1193	+ * the first kDigits digits of the number.
	1194	+ * dValue contains the (double) of the same.
	1195	+ */
	1196	+
	1197	+ if ( nDigits <= maxDecimalDigits ){
	1198	+ /*
	1199	+ * possibly an easy case.
	1200	+ * We know that the digits can be represented
	1201	+ * exactly. And if the exponent isn't too outrageous,
	1202	+ * the whole thing can be done with one operation,
	1203	+ * thus one rounding error.
	1204	+ * Note that all our constructors trim all leading and
	1205	+ * trailing zeros, so simple values (including zero)
	1206	+ * will always end up here
	1207	+ */
	1208	+ if (exp == 0 \|\| dValue == 0.0)
	1209	+ return (isNegative)? -dValue : dValue; // small floating integer
	1210	+ else if ( exp >= 0 ){
	1211	+ if ( exp <= maxSmallTen ){
	1212	+ /*
	1213	+ * Can get the answer with one operation,
	1214	+ * thus one roundoff.
	1215	+ */
	1216	+ rValue = dValue * small10pow[exp];
	1217	+ if ( mustSetRoundDir ){
	1218	+ tValue = rValue / small10pow[exp];
	1219	+ roundDir = ( tValue == dValue ) ? 0
	1220	+ :( tValue < dValue ) ? 1
	1221	+ : -1;
	1222	+ }
	1223	+ return (isNegative)? -rValue : rValue;
	1224	+ }
	1225	+ int slop = maxDecimalDigits - kDigits;
	1226	+ if ( exp <= maxSmallTen+slop ){
	1227	+ /*
	1228	+ * We can multiply dValue by 10^(slop)
	1229	+ * and it is still "small" and exact.
	1230	+ * Then we can multiply by 10^(exp-slop)
	1231	+ * with one rounding.
	1232	+ */
	1233	+ dValue *= small10pow[slop];
	1234	+ rValue = dValue * small10pow[exp-slop];
	1235	+
	1236	+ if ( mustSetRoundDir ){
	1237	+ tValue = rValue / small10pow[exp-slop];
	1238	+ roundDir = ( tValue == dValue ) ? 0
	1239	+ :( tValue < dValue ) ? 1
	1240	+ : -1;
	1241	+ }
	1242	+ return (isNegative)? -rValue : rValue;
	1243	+ }
	1244	+ /*
	1245	+ * Else we have a hard case with a positive exp.
	1246	+ */
	1247	+ } else {
	1248	+ if ( exp >= -maxSmallTen ){
	1249	+ /*
	1250	+ * Can get the answer in one division.
	1251	+ */
	1252	+ rValue = dValue / small10pow[-exp];
	1253	+ tValue = rValue * small10pow[-exp];
	1254	+ if ( mustSetRoundDir ){
	1255	+ roundDir = ( tValue == dValue ) ? 0
	1256	+ :( tValue < dValue ) ? 1
	1257	+ : -1;
	1258	+ }
	1259	+ return (isNegative)? -rValue : rValue;
	1260	+ }
	1261	+ /*
	1262	+ * Else we have a hard case with a negative exp.
	1263	+ */
	1264	+ }
	1265	+ }
	1266	+
	1267	+ /*
	1268	+ * Harder cases:
	1269	+ * The sum of digits plus exponent is greater than
	1270	+ * what we think we can do with one error.
	1271	+ *
	1272	+ * Start by approximating the right answer by,
	1273	+ * naively, scaling by powers of 10.
	1274	+ */
	1275	+ if ( exp > 0 ){
	1276	+ if ( decExponent > maxDecimalExponent+1 ){
	1277	+ /*
	1278	+ * Lets face it. This is going to be
	1279	+ * Infinity. Cut to the chase.
	1280	+ */
	1281	+ return (isNegative)? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
	1282	+ }
	1283	+ if ( (exp&15) != 0 ){
	1284	+ dValue *= small10pow[exp&15];
	1285	+ }
	1286	+ if ( (exp>>=4) != 0 ){
	1287	+ int j;
	1288	+ for( j = 0; exp > 1; j++, exp>>=1 ){
	1289	+ if ( (exp&1)!=0)
	1290	+ dValue *= big10pow[j];
	1291	+ }
	1292	+ /*
	1293	+ * The reason for the weird exp > 1 condition
	1294	+ * in the above loop was so that the last multiply
	1295	+ * would get unrolled. We handle it here.
	1296	+ * It could overflow.
	1297	+ */
	1298	+ double t = dValue * big10pow[j];
	1299	+ if ( Double.isInfinite( t ) ){
	1300	+ /*
	1301	+ * It did overflow.
	1302	+ * Look more closely at the result.
	1303	+ * If the exponent is just one too large,
	1304	+ * then use the maximum finite as our estimate
	1305	+ * value. Else call the result infinity
	1306	+ * and punt it.
	1307	+ * ( I presume this could happen because
	1308	+ * rounding forces the result here to be
	1309	+ * an ULP or two larger than
	1310	+ * Double.MAX_VALUE ).
	1311	+ */
	1312	+ t = dValue / 2.0;
	1313	+ t *= big10pow[j];
	1314	+ if ( Double.isInfinite( t ) ){
	1315	+ return (isNegative)? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
	1316	+ }
	1317	+ t = Double.MAX_VALUE;
	1318	+ }
	1319	+ dValue = t;
	1320	+ }
	1321	+ } else if ( exp < 0 ){
	1322	+ exp = -exp;
	1323	+ if ( decExponent < minDecimalExponent-1 ){
	1324	+ /*
	1325	+ * Lets face it. This is going to be
	1326	+ * zero. Cut to the chase.
	1327	+ */
	1328	+ return (isNegative)? -0.0 : 0.0;
	1329	+ }
	1330	+ if ( (exp&15) != 0 ){
	1331	+ dValue /= small10pow[exp&15];
	1332	+ }
	1333	+ if ( (exp>>=4) != 0 ){
	1334	+ int j;
	1335	+ for( j = 0; exp > 1; j++, exp>>=1 ){
	1336	+ if ( (exp&1)!=0)
	1337	+ dValue *= tiny10pow[j];
	1338	+ }
	1339	+ /*
	1340	+ * The reason for the weird exp > 1 condition
	1341	+ * in the above loop was so that the last multiply
	1342	+ * would get unrolled. We handle it here.
	1343	+ * It could underflow.
	1344	+ */
	1345	+ double t = dValue * tiny10pow[j];
	1346	+ if ( t == 0.0 ){
	1347	+ /*
	1348	+ * It did underflow.
	1349	+ * Look more closely at the result.
	1350	+ * If the exponent is just one too small,
	1351	+ * then use the minimum finite as our estimate
	1352	+ * value. Else call the result 0.0
	1353	+ * and punt it.
	1354	+ * ( I presume this could happen because
	1355	+ * rounding forces the result here to be
	1356	+ * an ULP or two less than
	1357	+ * Double.MIN_VALUE ).
	1358	+ */
	1359	+ t = dValue * 2.0;
	1360	+ t *= tiny10pow[j];
	1361	+ if ( t == 0.0 ){
	1362	+ return (isNegative)? -0.0 : 0.0;
	1363	+ }
	1364	+ t = Double.MIN_VALUE;
	1365	+ }
	1366	+ dValue = t;
	1367	+ }
	1368	+ }
	1369	+
	1370	+ /*
	1371	+ * dValue is now approximately the result.
	1372	+ * The hard part is adjusting it, by comparison
	1373	+ * with FDBigInt arithmetic.
	1374	+ * Formulate the EXACT big-number result as
	1375	+ * bigD0 * 10^exp
	1376	+ */
	1377	+ FDBigInt bigD0 = new FDBigInt( lValue, digits, kDigits, nDigits );
	1378	+ exp = decExponent - nDigits;
	1379	+
	1380	+ correctionLoop:
	1381	+ while(true){
	1382	+ /* AS A SIDE EFFECT, THIS METHOD WILL SET THE INSTANCE VARIABLES
	1383	+ * bigIntExp and bigIntNBits
	1384	+ */
	1385	+ FDBigInt bigB = doubleToBigInt( dValue );
	1386	+
	1387	+ /*
	1388	+ * Scale bigD, bigB appropriately for
	1389	+ * big-integer operations.
	1390	+ * Naively, we multipy by powers of ten
	1391	+ * and powers of two. What we actually do
	1392	+ * is keep track of the powers of 5 and
	1393	+ * powers of 2 we would use, then factor out
	1394	+ * common divisors before doing the work.
	1395	+ */
	1396	+ int B2, B5; // powers of 2, 5 in bigB
	1397	+ int D2, D5; // powers of 2, 5 in bigD
	1398	+ int Ulp2; // powers of 2 in halfUlp.
	1399	+ if ( exp >= 0 ){
	1400	+ B2 = B5 = 0;
	1401	+ D2 = D5 = exp;
	1402	+ } else {
	1403	+ B2 = B5 = -exp;
	1404	+ D2 = D5 = 0;
	1405	+ }
	1406	+ if ( bigIntExp >= 0 ){
	1407	+ B2 += bigIntExp;
	1408	+ } else {
	1409	+ D2 -= bigIntExp;
	1410	+ }
	1411	+ Ulp2 = B2;
	1412	+ // shift bigB and bigD left by a number s. t.
	1413	+ // halfUlp is still an integer.
	1414	+ int hulpbias;
	1415	+ if ( bigIntExp+bigIntNBits <= -expBias+1 ){
	1416	+ // This is going to be a denormalized number
	1417	+ // (if not actually zero).
	1418	+ // half an ULP is at 2^-(expBias+expShift+1)
	1419	+ hulpbias = bigIntExp+ expBias + expShift;
	1420	+ } else {
	1421	+ hulpbias = expShift + 2 - bigIntNBits;
	1422	+ }
	1423	+ B2 += hulpbias;
	1424	+ D2 += hulpbias;
	1425	+ // if there are common factors of 2, we might just as well
	1426	+ // factor them out, as they add nothing useful.
	1427	+ int common2 = Math.min( B2, Math.min( D2, Ulp2 ) );
	1428	+ B2 -= common2;
	1429	+ D2 -= common2;
	1430	+ Ulp2 -= common2;
	1431	+ // do multiplications by powers of 5 and 2
	1432	+ bigB = multPow52( bigB, B5, B2 );
	1433	+ FDBigInt bigD = multPow52( new FDBigInt( bigD0 ), D5, D2 );
	1434	+ //
	1435	+ // to recap:
	1436	+ // bigB is the scaled-big-int version of our floating-point
	1437	+ // candidate.
	1438	+ // bigD is the scaled-big-int version of the exact value
	1439	+ // as we understand it.
	1440	+ // halfUlp is 1/2 an ulp of bigB, except for special cases
	1441	+ // of exact powers of 2
	1442	+ //
	1443	+ // the plan is to compare bigB with bigD, and if the difference
	1444	+ // is less than halfUlp, then we're satisfied. Otherwise,
	1445	+ // use the ratio of difference to halfUlp to calculate a fudge
	1446	+ // factor to add to the floating value, then go 'round again.
	1447	+ //
	1448	+ FDBigInt diff;
	1449	+ int cmpResult;
	1450	+ boolean overvalue;
	1451	+ if ( (cmpResult = bigB.cmp( bigD ) ) > 0 ){
	1452	+ overvalue = true; // our candidate is too big.
	1453	+ diff = bigB.sub( bigD );
	1454	+ if ( (bigIntNBits == 1) && (bigIntExp > -expBias) ){
	1455	+ // candidate is a normalized exact power of 2 and
	1456	+ // is too big. We will be subtracting.
	1457	+ // For our purposes, ulp is the ulp of the
	1458	+ // next smaller range.
	1459	+ Ulp2 -= 1;
	1460	+ if ( Ulp2 < 0 ){
	1461	+ // rats. Cannot de-scale ulp this far.
	1462	+ // must scale diff in other direction.
	1463	+ Ulp2 = 0;
	1464	+ diff.lshiftMe( 1 );
	1465	+ }
	1466	+ }
	1467	+ } else if ( cmpResult < 0 ){
	1468	+ overvalue = false; // our candidate is too small.
	1469	+ diff = bigD.sub( bigB );
	1470	+ } else {
	1471	+ // the candidate is exactly right!
	1472	+ // this happens with surprising fequency
	1473	+ break correctionLoop;
	1474	+ }
	1475	+ FDBigInt halfUlp = constructPow52( B5, Ulp2 );
	1476	+ if ( (cmpResult = diff.cmp( halfUlp ) ) < 0 ){
	1477	+ // difference is small.
	1478	+ // this is close enough
	1479	+ if (mustSetRoundDir) {
	1480	+ roundDir = overvalue ? -1 : 1;
	1481	+ }
	1482	+ break correctionLoop;
	1483	+ } else if ( cmpResult == 0 ){
	1484	+ // difference is exactly half an ULP
	1485	+ // round to some other value maybe, then finish
	1486	+ dValue += 0.5*ulp( dValue, overvalue );
	1487	+ // should check for bigIntNBits == 1 here??
	1488	+ if (mustSetRoundDir) {
	1489	+ roundDir = overvalue ? -1 : 1;
	1490	+ }
	1491	+ break correctionLoop;
	1492	+ } else {
	1493	+ // difference is non-trivial.
	1494	+ // could scale addend by ratio of difference to
	1495	+ // halfUlp here, if we bothered to compute that difference.
	1496	+ // Most of the time ( I hope ) it is about 1 anyway.
	1497	+ dValue += ulp( dValue, overvalue );
	1498	+ if ( dValue == 0.0 \|\| dValue == Double.POSITIVE_INFINITY )
	1499	+ break correctionLoop; // oops. Fell off end of range.
	1500	+ continue; // try again.
	1501	+ }
	1502	+
	1503	+ }
	1504	+ return (isNegative)? -dValue : dValue;
	1505	+ }
	1506	+ }
	1507	+
	1508	+ /*
	1509	+ * Take a FormattedFloatingDecimal, which we presumably just scanned in,
	1510	+ * and find out what its value is, as a float.
	1511	+ * This is distinct from doubleValue() to avoid the extremely
	1512	+ * unlikely case of a double rounding error, wherein the converstion
	1513	+ * to double has one rounding error, and the conversion of that double
	1514	+ * to a float has another rounding error, IN THE WRONG DIRECTION,
	1515	+ * ( because of the preference to a zero low-order bit ).
	1516	+ */
	1517	+
	1518	+ public strictfp float floatValue(){
	1519	+ int kDigits = Math.min( nDigits, singleMaxDecimalDigits+1 );
	1520	+ int iValue;
	1521	+ float fValue;
	1522	+
	1523	+ // First, check for NaN and Infinity values
	1524	+ if(digits == infinity \|\| digits == notANumber) {
	1525	+ if(digits == notANumber)
	1526	+ return Float.NaN;
	1527	+ else
	1528	+ return (isNegative?Float.NEGATIVE_INFINITY:Float.POSITIVE_INFINITY);
	1529	+ }
	1530	+ else {
	1531	+ /*
	1532	+ * convert the lead kDigits to an integer.
	1533	+ */
	1534	+ iValue = (int)digits[0]-(int)'0';
	1535	+ for ( int i=1; i < kDigits; i++ ){
	1536	+ iValue = iValue*10 + (int)digits[i]-(int)'0';
	1537	+ }
	1538	+ fValue = (float)iValue;
	1539	+ int exp = decExponent-kDigits;
	1540	+ /*
	1541	+ * iValue now contains an integer with the value of
	1542	+ * the first kDigits digits of the number.
	1543	+ * fValue contains the (float) of the same.
	1544	+ */
	1545	+
	1546	+ if ( nDigits <= singleMaxDecimalDigits ){
	1547	+ /*
	1548	+ * possibly an easy case.
	1549	+ * We know that the digits can be represented
	1550	+ * exactly. And if the exponent isn't too outrageous,
	1551	+ * the whole thing can be done with one operation,
	1552	+ * thus one rounding error.
	1553	+ * Note that all our constructors trim all leading and
	1554	+ * trailing zeros, so simple values (including zero)
	1555	+ * will always end up here.
	1556	+ */
	1557	+ if (exp == 0 \|\| fValue == 0.0f)
	1558	+ return (isNegative)? -fValue : fValue; // small floating integer
	1559	+ else if ( exp >= 0 ){
	1560	+ if ( exp <= singleMaxSmallTen ){
	1561	+ /*
	1562	+ * Can get the answer with one operation,
	1563	+ * thus one roundoff.
	1564	+ */
	1565	+ fValue *= singleSmall10pow[exp];
	1566	+ return (isNegative)? -fValue : fValue;
	1567	+ }
	1568	+ int slop = singleMaxDecimalDigits - kDigits;
	1569	+ if ( exp <= singleMaxSmallTen+slop ){
	1570	+ /*
	1571	+ * We can multiply dValue by 10^(slop)
	1572	+ * and it is still "small" and exact.
	1573	+ * Then we can multiply by 10^(exp-slop)
	1574	+ * with one rounding.
	1575	+ */
	1576	+ fValue *= singleSmall10pow[slop];
	1577	+ fValue *= singleSmall10pow[exp-slop];
	1578	+ return (isNegative)? -fValue : fValue;
	1579	+ }
	1580	+ /*
	1581	+ * Else we have a hard case with a positive exp.
	1582	+ */
	1583	+ } else {
	1584	+ if ( exp >= -singleMaxSmallTen ){
	1585	+ /*
	1586	+ * Can get the answer in one division.
	1587	+ */
	1588	+ fValue /= singleSmall10pow[-exp];
	1589	+ return (isNegative)? -fValue : fValue;
	1590	+ }
	1591	+ /*
	1592	+ * Else we have a hard case with a negative exp.
	1593	+ */
	1594	+ }
	1595	+ } else if ( (decExponent >= nDigits) && (nDigits+decExponent <= maxDecimalDigits) ){
	1596	+ /*
	1597	+ * In double-precision, this is an exact floating integer.
	1598	+ * So we can compute to double, then shorten to float
	1599	+ * with one round, and get the right answer.
	1600	+ *
	1601	+ * First, finish accumulating digits.
	1602	+ * Then convert that integer to a double, multiply
	1603	+ * by the appropriate power of ten, and convert to float.
	1604	+ */
	1605	+ long lValue = (long)iValue;
	1606	+ for ( int i=kDigits; i < nDigits; i++ ){
	1607	+ lValue = lValue*10L + (long)((int)digits[i]-(int)'0');
	1608	+ }
	1609	+ double dValue = (double)lValue;
	1610	+ exp = decExponent-nDigits;
	1611	+ dValue *= small10pow[exp];
	1612	+ fValue = (float)dValue;
	1613	+ return (isNegative)? -fValue : fValue;
	1614	+
	1615	+ }
	1616	+ /*
	1617	+ * Harder cases:
	1618	+ * The sum of digits plus exponent is greater than
	1619	+ * what we think we can do with one error.
	1620	+ *
	1621	+ * Start by weeding out obviously out-of-range
	1622	+ * results, then convert to double and go to
	1623	+ * common hard-case code.
	1624	+ */
	1625	+ if ( decExponent > singleMaxDecimalExponent+1 ){
	1626	+ /*
	1627	+ * Lets face it. This is going to be
	1628	+ * Infinity. Cut to the chase.
	1629	+ */
	1630	+ return (isNegative)? Float.NEGATIVE_INFINITY : Float.POSITIVE_INFINITY;
	1631	+ } else if ( decExponent < singleMinDecimalExponent-1 ){
	1632	+ /*
	1633	+ * Lets face it. This is going to be
	1634	+ * zero. Cut to the chase.
	1635	+ */
	1636	+ return (isNegative)? -0.0f : 0.0f;
	1637	+ }
	1638	+
	1639	+ /*
	1640	+ * Here, we do 'way too much work, but throwing away
	1641	+ * our partial results, and going and doing the whole
	1642	+ * thing as double, then throwing away half the bits that computes
	1643	+ * when we convert back to float.
	1644	+ *
	1645	+ * The alternative is to reproduce the whole multiple-precision
	1646	+ * algorythm for float precision, or to try to parameterize it
	1647	+ * for common usage. The former will take about 400 lines of code,
	1648	+ * and the latter I tried without success. Thus the semi-hack
	1649	+ * answer here.
	1650	+ */
	1651	+ mustSetRoundDir = !fromHex;
	1652	+ double dValue = doubleValue();
	1653	+ return stickyRound( dValue );
	1654	+ }
	1655	+ }
	1656	+
	1657	+
	1658	+ /*
	1659	+ * All the positive powers of 10 that can be
	1660	+ * represented exactly in double/float.
	1661	+ */
	1662	+ private static final double small10pow[] = {
	1663	+ 1.0e0,
	1664	+ 1.0e1, 1.0e2, 1.0e3, 1.0e4, 1.0e5,
	1665	+ 1.0e6, 1.0e7, 1.0e8, 1.0e9, 1.0e10,
	1666	+ 1.0e11, 1.0e12, 1.0e13, 1.0e14, 1.0e15,
	1667	+ 1.0e16, 1.0e17, 1.0e18, 1.0e19, 1.0e20,
	1668	+ 1.0e21, 1.0e22
	1669	+ };
	1670	+
	1671	+ private static final float singleSmall10pow[] = {
	1672	+ 1.0e0f,
	1673	+ 1.0e1f, 1.0e2f, 1.0e3f, 1.0e4f, 1.0e5f,
	1674	+ 1.0e6f, 1.0e7f, 1.0e8f, 1.0e9f, 1.0e10f
	1675	+ };
	1676	+
	1677	+ private static final double big10pow[] = {
	1678	+ 1e16, 1e32, 1e64, 1e128, 1e256 };
	1679	+ private static final double tiny10pow[] = {
	1680	+ 1e-16, 1e-32, 1e-64, 1e-128, 1e-256 };
	1681	+
	1682	+ private static final int maxSmallTen = small10pow.length-1;
	1683	+ private static final int singleMaxSmallTen = singleSmall10pow.length-1;
	1684	+
	1685	+ private static final int small5pow[] = {
	1686	+ 1,
	1687	+ 5,
	1688	+ 5*5,
	1689	+ 555,
	1690	+ 555*5,
	1691	+ 55555,
	1692	+ 55555*5,
	1693	+ 5555555,
	1694	+ 5555555*5,
	1695	+ 555555555,
	1696	+ 555555555*5,
	1697	+ 55555555555,
	1698	+ 55555555555*5,
	1699	+ 5555555555555
	1700	+ };
	1701	+
	1702	+
	1703	+ private static final long long5pow[] = {
	1704	+ 1L,
	1705	+ 5L,
	1706	+ 5L*5,
	1707	+ 5L55,
	1708	+ 5L55*5,
	1709	+ 5L5555,
	1710	+ 5L5555*5,
	1711	+ 5L555555,
	1712	+ 5L555555*5,
	1713	+ 5L55555555,
	1714	+ 5L55555555*5,
	1715	+ 5L5555555555,
	1716	+ 5L5555555555*5,
	1717	+ 5L555555555555,
	1718	+ 5L555555555555*5,
	1719	+ 5L55555555555555,
	1720	+ 5L55555555555555*5,
	1721	+ 5L5555555555555555,
	1722	+ 5L5555555555555555*5,
	1723	+ 5L555555555555555555,
	1724	+ 5L555555555555555555*5,
	1725	+ 5L55555555555555555555,
	1726	+ 5L55555555555555555555*5,
	1727	+ 5L5555555555555555555555,
	1728	+ 5L5555555555555555555555*5,
	1729	+ 5L555555555555555555555555,
	1730	+ 5L555555555555555555555555*5,
	1731	+ };
	1732	+
	1733	+ // approximately ceil( log2( long5pow[i] ) )
	1734	+ private static final int n5bits[] = {
	1735	+ 0,
	1736	+ 3,
	1737	+ 5,
	1738	+ 7,
	1739	+ 10,
	1740	+ 12,
	1741	+ 14,
	1742	+ 17,
	1743	+ 19,
	1744	+ 21,
	1745	+ 24,
	1746	+ 26,
	1747	+ 28,
	1748	+ 31,
	1749	+ 33,
	1750	+ 35,
	1751	+ 38,
	1752	+ 40,
	1753	+ 42,
	1754	+ 45,
	1755	+ 47,
	1756	+ 49,
	1757	+ 52,
	1758	+ 54,
	1759	+ 56,
	1760	+ 59,
	1761	+ 61,
	1762	+ };
	1763	+
	1764	+ private static final char infinity[] = { 'I', 'n', 'f', 'i', 'n', 'i', 't', 'y' };
	1765	+ private static final char notANumber[] = { 'N', 'a', 'N' };
	1766	+ private static final char zero[] = { '0', '0', '0', '0', '0', '0', '0', '0' };
	1767	+}