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

Unified · Split

java/pkg/sun/misc/FloatingDecimal.java+2878−0

@@ -0,0 +1,2878 @@
	1	+/*
	2	+ * Copyright (c) 1996, 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 FloatingDecimal{
	34	+ boolean isExceptional;
	35	+ boolean isNegative;
	36	+ int decExponent;
	37	+ char digits[];
	38	+ int nDigits;
	39	+ int bigIntExp;
	40	+ int bigIntNBits;
	41	+ boolean mustSetRoundDir = false;
	42	+ boolean fromHex = false;
	43	+ int roundDir = 0; // set by doubleValue
	44	+
	45	+ private FloatingDecimal( boolean negSign, int decExponent, char []digits, int n, boolean e )
	46	+ {
	47	+ isNegative = negSign;
	48	+ isExceptional = e;
	49	+ this.decExponent = decExponent;
	50	+ this.digits = digits;
	51	+ this.nDigits = n;
	52	+ }
	53	+
	54	+ /*
	55	+ * Constants of the implementation
	56	+ * Most are IEEE-754 related.
	57	+ * (There are more really boring constants at the end.)
	58	+ */
	59	+ static final long signMask = 0x8000000000000000L;
	60	+ static final long expMask = 0x7ff0000000000000L;
	61	+ static final long fractMask= ~(signMask\|expMask);
	62	+ static final int expShift = 52;
	63	+ static final int expBias = 1023;
	64	+ static final long fractHOB = ( 1L<<expShift ); // assumed High-Order bit
	65	+ static final long expOne = ((long)expBias)<<expShift; // exponent of 1.0
	66	+ static final int maxSmallBinExp = 62;
	67	+ static final int minSmallBinExp = -( 63 / 3 );
	68	+ static final int maxDecimalDigits = 15;
	69	+ static final int maxDecimalExponent = 308;
	70	+ static final int minDecimalExponent = -324;
	71	+ static final int bigDecimalExponent = 324; // i.e. abs(minDecimalExponent)
	72	+
	73	+ static final long highbyte = 0xff00000000000000L;
	74	+ static final long highbit = 0x8000000000000000L;
	75	+ static final long lowbytes = ~highbyte;
	76	+
	77	+ static final int singleSignMask = 0x80000000;
	78	+ static final int singleExpMask = 0x7f800000;
	79	+ static final int singleFractMask = ~(singleSignMask\|singleExpMask);
	80	+ static final int singleExpShift = 23;
	81	+ static final int singleFractHOB = 1<<singleExpShift;
	82	+ static final int singleExpBias = 127;
	83	+ static final int singleMaxDecimalDigits = 7;
	84	+ static final int singleMaxDecimalExponent = 38;
	85	+ static final int singleMinDecimalExponent = -45;
	86	+
	87	+ static final int intDecimalDigits = 9;
	88	+
	89	+
	90	+ /*
	91	+ * count number of bits from high-order 1 bit to low-order 1 bit,
	92	+ * inclusive.
	93	+ */
	94	+ private static int
	95	+ countBits( long v ){
	96	+ //
	97	+ // the strategy is to shift until we get a non-zero sign bit
	98	+ // then shift until we have no bits left, counting the difference.
	99	+ // we do byte shifting as a hack. Hope it helps.
	100	+ //
	101	+ if ( v == 0L ) return 0;
	102	+
	103	+ while ( ( v & highbyte ) == 0L ){
	104	+ v <<= 8;
	105	+ }
	106	+ while ( v > 0L ) { // i.e. while ((v&highbit) == 0L )
	107	+ v <<= 1;
	108	+ }
	109	+
	110	+ int n = 0;
	111	+ while (( v & lowbytes ) != 0L ){
	112	+ v <<= 8;
	113	+ n += 8;
	114	+ }
	115	+ while ( v != 0L ){
	116	+ v <<= 1;
	117	+ n += 1;
	118	+ }
	119	+ return n;
	120	+ }
	121	+
	122	+ /*
	123	+ * Keep big powers of 5 handy for future reference.
	124	+ */
	125	+ private static FDBigInt b5p[];
	126	+
	127	+ private static synchronized FDBigInt
	128	+ big5pow( int p ){
	129	+ assert p >= 0 : p; // negative power of 5
	130	+ if ( b5p == null ){
	131	+ b5p = new FDBigInt[ p+1 ];
	132	+ }else if (b5p.length <= p ){
	133	+ FDBigInt t[] = new FDBigInt[ p+1 ];
	134	+ System.arraycopy( b5p, 0, t, 0, b5p.length );
	135	+ b5p = t;
	136	+ }
	137	+ if ( b5p[p] != null )
	138	+ return b5p[p];
	139	+ else if ( p < small5pow.length )
	140	+ return b5p[p] = new FDBigInt( small5pow[p] );
	141	+ else if ( p < long5pow.length )
	142	+ return b5p[p] = new FDBigInt( long5pow[p] );
	143	+ else {
	144	+ // construct the value.
	145	+ // recursively.
	146	+ int q, r;
	147	+ // in order to compute 5^p,
	148	+ // compute its square root, 5^(p/2) and square.
	149	+ // or, let q = p / 2, r = p -q, then
	150	+ // 5^p = 5^(q+r) = 5^q * 5^r
	151	+ q = p >> 1;
	152	+ r = p - q;
	153	+ FDBigInt bigq = b5p[q];
	154	+ if ( bigq == null )
	155	+ bigq = big5pow ( q );
	156	+ if ( r < small5pow.length ){
	157	+ return (b5p[p] = bigq.mult( small5pow[r] ) );
	158	+ }else{
	159	+ FDBigInt bigr = b5p[ r ];
	160	+ if ( bigr == null )
	161	+ bigr = big5pow( r );
	162	+ return (b5p[p] = bigq.mult( bigr ) );
	163	+ }
	164	+ }
	165	+ }
	166	+
	167	+ //
	168	+ // a common operation
	169	+ //
	170	+ private static FDBigInt
	171	+ multPow52( FDBigInt v, int p5, int p2 ){
	172	+ if ( p5 != 0 ){
	173	+ if ( p5 < small5pow.length ){
	174	+ v = v.mult( small5pow[p5] );
	175	+ } else {
	176	+ v = v.mult( big5pow( p5 ) );
	177	+ }
	178	+ }
	179	+ if ( p2 != 0 ){
	180	+ v.lshiftMe( p2 );
	181	+ }
	182	+ return v;
	183	+ }
	184	+
	185	+ //
	186	+ // another common operation
	187	+ //
	188	+ private static FDBigInt
	189	+ constructPow52( int p5, int p2 ){
	190	+ FDBigInt v = new FDBigInt( big5pow( p5 ) );
	191	+ if ( p2 != 0 ){
	192	+ v.lshiftMe( p2 );
	193	+ }
	194	+ return v;
	195	+ }
	196	+
	197	+ /*
	198	+ * Make a floating double into a FDBigInt.
	199	+ * This could also be structured as a FDBigInt
	200	+ * constructor, but we'd have to build a lot of knowledge
	201	+ * about floating-point representation into it, and we don't want to.
	202	+ *
	203	+ * AS A SIDE EFFECT, THIS METHOD WILL SET THE INSTANCE VARIABLES
	204	+ * bigIntExp and bigIntNBits
	205	+ *
	206	+ */
	207	+ private FDBigInt
	208	+ doubleToBigInt( double dval ){
	209	+ long lbits = Double.doubleToLongBits( dval ) & ~signMask;
	210	+ int binexp = (int)(lbits >>> expShift);
	211	+ lbits &= fractMask;
	212	+ if ( binexp > 0 ){
	213	+ lbits \|= fractHOB;
	214	+ } else {
	215	+ assert lbits != 0L : lbits; // doubleToBigInt(0.0)
	216	+ binexp +=1;
	217	+ while ( (lbits & fractHOB ) == 0L){
	218	+ lbits <<= 1;
	219	+ binexp -= 1;
	220	+ }
	221	+ }
	222	+ binexp -= expBias;
	223	+ int nbits = countBits( lbits );
	224	+ /*
	225	+ * We now know where the high-order 1 bit is,
	226	+ * and we know how many there are.
	227	+ */
	228	+ int lowOrderZeros = expShift+1-nbits;
	229	+ lbits >>>= lowOrderZeros;
	230	+
	231	+ bigIntExp = binexp+1-nbits;
	232	+ bigIntNBits = nbits;
	233	+ return new FDBigInt( lbits );
	234	+ }
	235	+
	236	+ /*
	237	+ * Compute a number that is the ULP of the given value,
	238	+ * for purposes of addition/subtraction. Generally easy.
	239	+ * More difficult if subtracting and the argument
	240	+ * is a normalized a power of 2, as the ULP changes at these points.
	241	+ */
	242	+ private static double ulp( double dval, boolean subtracting ){
	243	+ long lbits = Double.doubleToLongBits( dval ) & ~signMask;
	244	+ int binexp = (int)(lbits >>> expShift);
	245	+ double ulpval;
	246	+ if ( subtracting && ( binexp >= expShift ) && ((lbits&fractMask) == 0L) ){
	247	+ // for subtraction from normalized, powers of 2,
	248	+ // use next-smaller exponent
	249	+ binexp -= 1;
	250	+ }
	251	+ if ( binexp > expShift ){
	252	+ ulpval = Double.longBitsToDouble( ((long)(binexp-expShift))<<expShift );
	253	+ } else if ( binexp == 0 ){
	254	+ ulpval = Double.MIN_VALUE;
	255	+ } else {
	256	+ ulpval = Double.longBitsToDouble( 1L<<(binexp-1) );
	257	+ }
	258	+ if ( subtracting ) ulpval = - ulpval;
	259	+
	260	+ return ulpval;
	261	+ }
	262	+
	263	+ /*
	264	+ * Round a double to a float.
	265	+ * In addition to the fraction bits of the double,
	266	+ * look at the class instance variable roundDir,
	267	+ * which should help us avoid double-rounding error.
	268	+ * roundDir was set in hardValueOf if the estimate was
	269	+ * close enough, but not exact. It tells us which direction
	270	+ * of rounding is preferred.
	271	+ */
	272	+ float
	273	+ stickyRound( double dval ){
	274	+ long lbits = Double.doubleToLongBits( dval );
	275	+ long binexp = lbits & expMask;
	276	+ if ( binexp == 0L \|\| binexp == expMask ){
	277	+ // what we have here is special.
	278	+ // don't worry, the right thing will happen.
	279	+ return (float) dval;
	280	+ }
	281	+ lbits += (long)roundDir; // hack-o-matic.
	282	+ return (float)Double.longBitsToDouble( lbits );
	283	+ }
	284	+
	285	+
	286	+ /*
	287	+ * This is the easy subcase --
	288	+ * all the significant bits, after scaling, are held in lvalue.
	289	+ * negSign and decExponent tell us what processing and scaling
	290	+ * has already been done. Exceptional cases have already been
	291	+ * stripped out.
	292	+ * In particular:
	293	+ * lvalue is a finite number (not Inf, nor NaN)
	294	+ * lvalue > 0L (not zero, nor negative).
	295	+ *
	296	+ * The only reason that we develop the digits here, rather than
	297	+ * calling on Long.toString() is that we can do it a little faster,
	298	+ * and besides want to treat trailing 0s specially. If Long.toString
	299	+ * changes, we should re-evaluate this strategy!
	300	+ */
	301	+ private void
	302	+ developLongDigits( int decExponent, long lvalue, long insignificant ){
	303	+ char digits[];
	304	+ int ndigits;
	305	+ int digitno;
	306	+ int c;
	307	+ //
	308	+ // Discard non-significant low-order bits, while rounding,
	309	+ // up to insignificant value.
	310	+ int i;
	311	+ for ( i = 0; insignificant >= 10L; i++ )
	312	+ insignificant /= 10L;
	313	+ if ( i != 0 ){
	314	+ long pow10 = long5pow[i] << i; // 10^i == 5^i * 2^i;
	315	+ long residue = lvalue % pow10;
	316	+ lvalue /= pow10;
	317	+ decExponent += i;
	318	+ if ( residue >= (pow10>>1) ){
	319	+ // round up based on the low-order bits we're discarding
	320	+ lvalue++;
	321	+ }
	322	+ }
	323	+ if ( lvalue <= Integer.MAX_VALUE ){
	324	+ assert lvalue > 0L : lvalue; // lvalue <= 0
	325	+ // even easier subcase!
	326	+ // can do int arithmetic rather than long!
	327	+ int ivalue = (int)lvalue;
	328	+ ndigits = 10;
	329	+ digits = (char[])(perThreadBuffer.get());
	330	+ digitno = ndigits-1;
	331	+ c = ivalue%10;
	332	+ ivalue /= 10;
	333	+ while ( c == 0 ){
	334	+ decExponent++;
	335	+ c = ivalue%10;
	336	+ ivalue /= 10;
	337	+ }
	338	+ while ( ivalue != 0){
	339	+ digits[digitno--] = (char)(c+'0');
	340	+ decExponent++;
	341	+ c = ivalue%10;
	342	+ ivalue /= 10;
	343	+ }
	344	+ digits[digitno] = (char)(c+'0');
	345	+ } else {
	346	+ // same algorithm as above (same bugs, too )
	347	+ // but using long arithmetic.
	348	+ ndigits = 20;
	349	+ digits = (char[])(perThreadBuffer.get());
	350	+ digitno = ndigits-1;
	351	+ c = (int)(lvalue%10L);
	352	+ lvalue /= 10L;
	353	+ while ( c == 0 ){
	354	+ decExponent++;
	355	+ c = (int)(lvalue%10L);
	356	+ lvalue /= 10L;
	357	+ }
	358	+ while ( lvalue != 0L ){
	359	+ digits[digitno--] = (char)(c+'0');
	360	+ decExponent++;
	361	+ c = (int)(lvalue%10L);
	362	+ lvalue /= 10;
	363	+ }
	364	+ digits[digitno] = (char)(c+'0');
	365	+ }
	366	+ char result [];
	367	+ ndigits -= digitno;
	368	+ result = new char[ ndigits ];
	369	+ System.arraycopy( digits, digitno, result, 0, ndigits );
	370	+ this.digits = result;
	371	+ this.decExponent = decExponent+1;
	372	+ this.nDigits = ndigits;
	373	+ }
	374	+
	375	+ //
	376	+ // add one to the least significant digit.
	377	+ // in the unlikely event there is a carry out,
	378	+ // deal with it.
	379	+ // assert that this will only happen where there
	380	+ // is only one digit, e.g. (float)1e-44 seems to do it.
	381	+ //
	382	+ private void
	383	+ roundup(){
	384	+ int i;
	385	+ int q = digits[ i = (nDigits-1)];
	386	+ if ( q == '9' ){
	387	+ while ( q == '9' && i > 0 ){
	388	+ digits[i] = '0';
	389	+ q = digits[--i];
	390	+ }
	391	+ if ( q == '9' ){
	392	+ // carryout! High-order 1, rest 0s, larger exp.
	393	+ decExponent += 1;
	394	+ digits[0] = '1';
	395	+ return;
	396	+ }
	397	+ // else fall through.
	398	+ }
	399	+ digits[i] = (char)(q+1);
	400	+ }
	401	+
	402	+ /*
	403	+ * FIRST IMPORTANT CONSTRUCTOR: DOUBLE
	404	+ */
	405	+ public FloatingDecimal( double d )
	406	+ {
	407	+ long dBits = Double.doubleToLongBits( d );
	408	+ long fractBits;
	409	+ int binExp;
	410	+ int nSignificantBits;
	411	+
	412	+ // discover and delete sign
	413	+ if ( (dBits&signMask) != 0 ){
	414	+ isNegative = true;
	415	+ dBits ^= signMask;
	416	+ } else {
	417	+ isNegative = false;
	418	+ }
	419	+ // Begin to unpack
	420	+ // Discover obvious special cases of NaN and Infinity.
	421	+ binExp = (int)( (dBits&expMask) >> expShift );
	422	+ fractBits = dBits&fractMask;
	423	+ if ( binExp == (int)(expMask>>expShift) ) {
	424	+ isExceptional = true;
	425	+ if ( fractBits == 0L ){
	426	+ digits = infinity;
	427	+ } else {
	428	+ digits = notANumber;
	429	+ isNegative = false; // NaN has no sign!
	430	+ }
	431	+ nDigits = digits.length;
	432	+ return;
	433	+ }
	434	+ isExceptional = false;
	435	+ // Finish unpacking
	436	+ // Normalize denormalized numbers.
	437	+ // Insert assumed high-order bit for normalized numbers.
	438	+ // Subtract exponent bias.
	439	+ if ( binExp == 0 ){
	440	+ if ( fractBits == 0L ){
	441	+ // not a denorm, just a 0!
	442	+ decExponent = 0;
	443	+ digits = zero;
	444	+ nDigits = 1;
	445	+ return;
	446	+ }
	447	+ while ( (fractBits&fractHOB) == 0L ){
	448	+ fractBits <<= 1;
	449	+ binExp -= 1;
	450	+ }
	451	+ nSignificantBits = expShift + binExp +1; // recall binExp is - shift count.
	452	+ binExp += 1;
	453	+ } else {
	454	+ fractBits \|= fractHOB;
	455	+ nSignificantBits = expShift+1;
	456	+ }
	457	+ binExp -= expBias;
	458	+ // call the routine that actually does all the hard work.
	459	+ dtoa( binExp, fractBits, nSignificantBits );
	460	+ }
	461	+
	462	+ /*
	463	+ * SECOND IMPORTANT CONSTRUCTOR: SINGLE
	464	+ */
	465	+ public FloatingDecimal( float f )
	466	+ {
	467	+ int fBits = Float.floatToIntBits( f );
	468	+ int fractBits;
	469	+ int binExp;
	470	+ int nSignificantBits;
	471	+
	472	+ // discover and delete sign
	473	+ if ( (fBits&singleSignMask) != 0 ){
	474	+ isNegative = true;
	475	+ fBits ^= singleSignMask;
	476	+ } else {
	477	+ isNegative = false;
	478	+ }
	479	+ // Begin to unpack
	480	+ // Discover obvious special cases of NaN and Infinity.
	481	+ binExp = (int)( (fBits&singleExpMask) >> singleExpShift );
	482	+ fractBits = fBits&singleFractMask;
	483	+ if ( binExp == (int)(singleExpMask>>singleExpShift) ) {
	484	+ isExceptional = true;
	485	+ if ( fractBits == 0L ){
	486	+ digits = infinity;
	487	+ } else {
	488	+ digits = notANumber;
	489	+ isNegative = false; // NaN has no sign!
	490	+ }
	491	+ nDigits = digits.length;
	492	+ return;
	493	+ }
	494	+ isExceptional = false;
	495	+ // Finish unpacking
	496	+ // Normalize denormalized numbers.
	497	+ // Insert assumed high-order bit for normalized numbers.
	498	+ // Subtract exponent bias.
	499	+ if ( binExp == 0 ){
	500	+ if ( fractBits == 0 ){
	501	+ // not a denorm, just a 0!
	502	+ decExponent = 0;
	503	+ digits = zero;
	504	+ nDigits = 1;
	505	+ return;
	506	+ }
	507	+ while ( (fractBits&singleFractHOB) == 0 ){
	508	+ fractBits <<= 1;
	509	+ binExp -= 1;
	510	+ }
	511	+ nSignificantBits = singleExpShift + binExp +1; // recall binExp is - shift count.
	512	+ binExp += 1;
	513	+ } else {
	514	+ fractBits \|= singleFractHOB;
	515	+ nSignificantBits = singleExpShift+1;
	516	+ }
	517	+ binExp -= singleExpBias;
	518	+ // call the routine that actually does all the hard work.
	519	+ dtoa( binExp, ((long)fractBits)<<(expShift-singleExpShift), nSignificantBits );
	520	+ }
	521	+
	522	+ private void
	523	+ dtoa( int binExp, long fractBits, int nSignificantBits )
	524	+ {
	525	+ int nFractBits; // number of significant bits of fractBits;
	526	+ int nTinyBits; // number of these to the right of the point.
	527	+ int decExp;
	528	+
	529	+ // Examine number. Determine if it is an easy case,
	530	+ // which we can do pretty trivially using float/long conversion,
	531	+ // or whether we must do real work.
	532	+ nFractBits = countBits( fractBits );
	533	+ nTinyBits = Math.max( 0, nFractBits - binExp - 1 );
	534	+ if ( binExp <= maxSmallBinExp && binExp >= minSmallBinExp ){
	535	+ // Look more closely at the number to decide if,
	536	+ // with scaling by 10^nTinyBits, the result will fit in
	537	+ // a long.
	538	+ if ( (nTinyBits < long5pow.length) && ((nFractBits + n5bits[nTinyBits]) < 64 ) ){
	539	+ /*
	540	+ * We can do this:
	541	+ * take the fraction bits, which are normalized.
	542	+ * (a) nTinyBits == 0: Shift left or right appropriately
	543	+ * to align the binary point at the extreme right, i.e.
	544	+ * where a long int point is expected to be. The integer
	545	+ * result is easily converted to a string.
	546	+ * (b) nTinyBits > 0: Shift right by expShift-nFractBits,
	547	+ * which effectively converts to long and scales by
	548	+ * 2^nTinyBits. Then multiply by 5^nTinyBits to
	549	+ * complete the scaling. We know this won't overflow
	550	+ * because we just counted the number of bits necessary
	551	+ * in the result. The integer you get from this can
	552	+ * then be converted to a string pretty easily.
	553	+ */
	554	+ long halfULP;
	555	+ if ( nTinyBits == 0 ) {
	556	+ if ( binExp > nSignificantBits ){
	557	+ halfULP = 1L << ( binExp-nSignificantBits-1);
	558	+ } else {
	559	+ halfULP = 0L;
	560	+ }
	561	+ if ( binExp >= expShift ){
	562	+ fractBits <<= (binExp-expShift);
	563	+ } else {
	564	+ fractBits >>>= (expShift-binExp) ;
	565	+ }
	566	+ developLongDigits( 0, fractBits, halfULP );
	567	+ return;
	568	+ }
	569	+ /*
	570	+ * The following causes excess digits to be printed
	571	+ * out in the single-float case. Our manipulation of
	572	+ * halfULP here is apparently not correct. If we
	573	+ * better understand how this works, perhaps we can
	574	+ * use this special case again. But for the time being,
	575	+ * we do not.
	576	+ * else {
	577	+ * fractBits >>>= expShift+1-nFractBits;
	578	+ * fractBits *= long5pow[ nTinyBits ];
	579	+ * halfULP = long5pow[ nTinyBits ] >> (1+nSignificantBits-nFractBits);
	580	+ * developLongDigits( -nTinyBits, fractBits, halfULP );
	581	+ * return;
	582	+ * }
	583	+ */
	584	+ }
	585	+ }
	586	+ /*
	587	+ * This is the hard case. We are going to compute large positive
	588	+ * integers B and S and integer decExp, s.t.
	589	+ * d = ( B / S ) * 10^decExp
	590	+ * 1 <= B / S < 10
	591	+ * Obvious choices are:
	592	+ * decExp = floor( log10(d) )
	593	+ * B = d * 2^nTinyBits * 10^max( 0, -decExp )
	594	+ * S = 10^max( 0, decExp) * 2^nTinyBits
	595	+ * (noting that nTinyBits has already been forced to non-negative)
	596	+ * I am also going to compute a large positive integer
	597	+ * M = (1/2^nSignificantBits) * 2^nTinyBits * 10^max( 0, -decExp )
	598	+ * i.e. M is (1/2) of the ULP of d, scaled like B.
	599	+ * When we iterate through dividing B/S and picking off the
	600	+ * quotient bits, we will know when to stop when the remainder
	601	+ * is <= M.
	602	+ *
	603	+ * We keep track of powers of 2 and powers of 5.
	604	+ */
	605	+
	606	+ /*
	607	+ * Estimate decimal exponent. (If it is small-ish,
	608	+ * we could double-check.)
	609	+ *
	610	+ * First, scale the mantissa bits such that 1 <= d2 < 2.
	611	+ * We are then going to estimate
	612	+ * log10(d2) ~=~ (d2-1.5)/1.5 + log(1.5)
	613	+ * and so we can estimate
	614	+ * log10(d) ~=~ log10(d2) + binExp * log10(2)
	615	+ * take the floor and call it decExp.
	616	+ * FIXME -- use more precise constants here. It costs no more.
	617	+ */
	618	+ double d2 = Double.longBitsToDouble(
	619	+ expOne \| ( fractBits &~ fractHOB ) );
	620	+ decExp = (int)Math.floor(
	621	+ (d2-1.5D)0.289529654D + 0.176091259 + (double)binExp 0.301029995663981 );
	622	+ int B2, B5; // powers of 2 and powers of 5, respectively, in B
	623	+ int S2, S5; // powers of 2 and powers of 5, respectively, in S
	624	+ int M2, M5; // powers of 2 and powers of 5, respectively, in M
	625	+ int Bbits; // binary digits needed to represent B, approx.
	626	+ int tenSbits; // binary digits needed to represent 10*S, approx.
	627	+ FDBigInt Sval, Bval, Mval;
	628	+
	629	+ B5 = Math.max( 0, -decExp );
	630	+ B2 = B5 + nTinyBits + binExp;
	631	+
	632	+ S5 = Math.max( 0, decExp );
	633	+ S2 = S5 + nTinyBits;
	634	+
	635	+ M5 = B5;
	636	+ M2 = B2 - nSignificantBits;
	637	+
	638	+ /*
	639	+ * the long integer fractBits contains the (nFractBits) interesting
	640	+ * bits from the mantissa of d ( hidden 1 added if necessary) followed
	641	+ * by (expShift+1-nFractBits) zeros. In the interest of compactness,
	642	+ * I will shift out those zeros before turning fractBits into a
	643	+ * FDBigInt. The resulting whole number will be
	644	+ * d * 2^(nFractBits-1-binExp).
	645	+ */
	646	+ fractBits >>>= (expShift+1-nFractBits);
	647	+ B2 -= nFractBits-1;
	648	+ int common2factor = Math.min( B2, S2 );
	649	+ B2 -= common2factor;
	650	+ S2 -= common2factor;
	651	+ M2 -= common2factor;
	652	+
	653	+ /*
	654	+ * HACK!! For exact powers of two, the next smallest number
	655	+ * is only half as far away as we think (because the meaning of
	656	+ * ULP changes at power-of-two bounds) for this reason, we
	657	+ * hack M2. Hope this works.
	658	+ */
	659	+ if ( nFractBits == 1 )
	660	+ M2 -= 1;
	661	+
	662	+ if ( M2 < 0 ){
	663	+ // oops.
	664	+ // since we cannot scale M down far enough,
	665	+ // we must scale the other values up.
	666	+ B2 -= M2;
	667	+ S2 -= M2;
	668	+ M2 = 0;
	669	+ }
	670	+ /*
	671	+ * Construct, Scale, iterate.
	672	+ * Some day, we'll write a stopping test that takes
	673	+ * account of the asymmetry of the spacing of floating-point
	674	+ * numbers below perfect powers of 2
	675	+ * 26 Sept 96 is not that day.
	676	+ * So we use a symmetric test.
	677	+ */
	678	+ char digits[] = this.digits = new char[18];
	679	+ int ndigit = 0;
	680	+ boolean low, high;
	681	+ long lowDigitDifference;
	682	+ int q;
	683	+
	684	+ /*
	685	+ * Detect the special cases where all the numbers we are about
	686	+ * to compute will fit in int or long integers.
	687	+ * In these cases, we will avoid doing FDBigInt arithmetic.
	688	+ * We use the same algorithms, except that we "normalize"
	689	+ * our FDBigInts before iterating. This is to make division easier,
	690	+ * as it makes our fist guess (quotient of high-order words)
	691	+ * more accurate!
	692	+ *
	693	+ * Some day, we'll write a stopping test that takes
	694	+ * account of the asymmetry of the spacing of floating-point
	695	+ * numbers below perfect powers of 2
	696	+ * 26 Sept 96 is not that day.
	697	+ * So we use a symmetric test.
	698	+ */
	699	+ Bbits = nFractBits + B2 + (( B5 < n5bits.length )? n5bits[B5] : ( B5*3 ));
	700	+ tenSbits = S2+1 + (( (S5+1) < n5bits.length )? n5bits[(S5+1)] : ( (S5+1)*3 ));
	701	+ if ( Bbits < 64 && tenSbits < 64){
	702	+ if ( Bbits < 32 && tenSbits < 32){
	703	+ // wa-hoo! They're all ints!
	704	+ int b = ((int)fractBits * small5pow[B5] ) << B2;
	705	+ int s = small5pow[S5] << S2;
	706	+ int m = small5pow[M5] << M2;
	707	+ int tens = s * 10;
	708	+ /*
	709	+ * Unroll the first iteration. If our decExp estimate
	710	+ * was too high, our first quotient will be zero. In this
	711	+ * case, we discard it and decrement decExp.
	712	+ */
	713	+ ndigit = 0;
	714	+ q = b / s;
	715	+ b = 10 * ( b % s );
	716	+ m *= 10;
	717	+ low = (b < m );
	718	+ high = (b+m > tens );
	719	+ assert q < 10 : q; // excessively large digit
	720	+ if ( (q == 0) && ! high ){
	721	+ // oops. Usually ignore leading zero.
	722	+ decExp--;
	723	+ } else {
	724	+ digits[ndigit++] = (char)('0' + q);
	725	+ }
	726	+ /*
	727	+ * HACK! Java spec sez that we always have at least
	728	+ * one digit after the . in either F- or E-form output.
	729	+ * Thus we will need more than one digit if we're using
	730	+ * E-form
	731	+ */
	732	+ if ( decExp < -3 \|\| decExp >= 8 ){
	733	+ high = low = false;
	734	+ }
	735	+ while( ! low && ! high ){
	736	+ q = b / s;
	737	+ b = 10 * ( b % s );
	738	+ m *= 10;
	739	+ assert q < 10 : q; // excessively large digit
	740	+ if ( m > 0L ){
	741	+ low = (b < m );
	742	+ high = (b+m > tens );
	743	+ } else {
	744	+ // hack -- m might overflow!
	745	+ // in this case, it is certainly > b,
	746	+ // which won't
	747	+ // and b+m > tens, too, since that has overflowed
	748	+ // either!
	749	+ low = true;
	750	+ high = true;
	751	+ }
	752	+ digits[ndigit++] = (char)('0' + q);
	753	+ }
	754	+ lowDigitDifference = (b<<1) - tens;
	755	+ } else {
	756	+ // still good! they're all longs!
	757	+ long b = (fractBits * long5pow[B5] ) << B2;
	758	+ long s = long5pow[S5] << S2;
	759	+ long m = long5pow[M5] << M2;
	760	+ long tens = s * 10L;
	761	+ /*
	762	+ * Unroll the first iteration. If our decExp estimate
	763	+ * was too high, our first quotient will be zero. In this
	764	+ * case, we discard it and decrement decExp.
	765	+ */
	766	+ ndigit = 0;
	767	+ q = (int) ( b / s );
	768	+ b = 10L * ( b % s );
	769	+ m *= 10L;
	770	+ low = (b < m );
	771	+ high = (b+m > tens );
	772	+ assert q < 10 : q; // excessively large digit
	773	+ if ( (q == 0) && ! high ){
	774	+ // oops. Usually ignore leading zero.
	775	+ decExp--;
	776	+ } else {
	777	+ digits[ndigit++] = (char)('0' + q);
	778	+ }
	779	+ /*
	780	+ * HACK! Java spec sez that we always have at least
	781	+ * one digit after the . in either F- or E-form output.
	782	+ * Thus we will need more than one digit if we're using
	783	+ * E-form
	784	+ */
	785	+ if ( decExp < -3 \|\| decExp >= 8 ){
	786	+ high = low = false;
	787	+ }
	788	+ while( ! low && ! high ){
	789	+ q = (int) ( b / s );
	790	+ b = 10 * ( b % s );
	791	+ m *= 10;
	792	+ assert q < 10 : q; // excessively large digit
	793	+ if ( m > 0L ){
	794	+ low = (b < m );
	795	+ high = (b+m > tens );
	796	+ } else {
	797	+ // hack -- m might overflow!
	798	+ // in this case, it is certainly > b,
	799	+ // which won't
	800	+ // and b+m > tens, too, since that has overflowed
	801	+ // either!
	802	+ low = true;
	803	+ high = true;
	804	+ }
	805	+ digits[ndigit++] = (char)('0' + q);
	806	+ }
	807	+ lowDigitDifference = (b<<1) - tens;
	808	+ }
	809	+ } else {
	810	+ FDBigInt tenSval;
	811	+ int shiftBias;
	812	+
	813	+ /*
	814	+ * We really must do FDBigInt arithmetic.
	815	+ * Fist, construct our FDBigInt initial values.
	816	+ */
	817	+ Bval = multPow52( new FDBigInt( fractBits ), B5, B2 );
	818	+ Sval = constructPow52( S5, S2 );
	819	+ Mval = constructPow52( M5, M2 );
	820	+
	821	+
	822	+ // normalize so that division works better
	823	+ Bval.lshiftMe( shiftBias = Sval.normalizeMe() );
	824	+ Mval.lshiftMe( shiftBias );
	825	+ tenSval = Sval.mult( 10 );
	826	+ /*
	827	+ * Unroll the first iteration. If our decExp estimate
	828	+ * was too high, our first quotient will be zero. In this
	829	+ * case, we discard it and decrement decExp.
	830	+ */
	831	+ ndigit = 0;
	832	+ q = Bval.quoRemIteration( Sval );
	833	+ Mval = Mval.mult( 10 );
	834	+ low = (Bval.cmp( Mval ) < 0);
	835	+ high = (Bval.add( Mval ).cmp( tenSval ) > 0 );
	836	+ assert q < 10 : q; // excessively large digit
	837	+ if ( (q == 0) && ! high ){
	838	+ // oops. Usually ignore leading zero.
	839	+ decExp--;
	840	+ } else {
	841	+ digits[ndigit++] = (char)('0' + q);
	842	+ }
	843	+ /*
	844	+ * HACK! Java spec sez that we always have at least
	845	+ * one digit after the . in either F- or E-form output.
	846	+ * Thus we will need more than one digit if we're using
	847	+ * E-form
	848	+ */
	849	+ if ( decExp < -3 \|\| decExp >= 8 ){
	850	+ high = low = false;
	851	+ }
	852	+ while( ! low && ! high ){
	853	+ q = Bval.quoRemIteration( Sval );
	854	+ Mval = Mval.mult( 10 );
	855	+ assert q < 10 : q; // excessively large digit
	856	+ low = (Bval.cmp( Mval ) < 0);
	857	+ high = (Bval.add( Mval ).cmp( tenSval ) > 0 );
	858	+ digits[ndigit++] = (char)('0' + q);
	859	+ }
	860	+ if ( high && low ){
	861	+ Bval.lshiftMe(1);
	862	+ lowDigitDifference = Bval.cmp(tenSval);
	863	+ } else
	864	+ lowDigitDifference = 0L; // this here only for flow analysis!
	865	+ }
	866	+ this.decExponent = decExp+1;
	867	+ this.digits = digits;
	868	+ this.nDigits = ndigit;
	869	+ /*
	870	+ * Last digit gets rounded based on stopping condition.
	871	+ */
	872	+ if ( high ){
	873	+ if ( low ){
	874	+ if ( lowDigitDifference == 0L ){
	875	+ // it's a tie!
	876	+ // choose based on which digits we like.
	877	+ if ( (digits[nDigits-1]&1) != 0 ) roundup();
	878	+ } else if ( lowDigitDifference > 0 ){
	879	+ roundup();
	880	+ }
	881	+ } else {
	882	+ roundup();
	883	+ }
	884	+ }
	885	+ }
	886	+
	887	+ public String
	888	+ toString(){
	889	+ // most brain-dead version
	890	+ StringBuffer result = new StringBuffer( nDigits+8 );
	891	+ if ( isNegative ){ result.append( '-' ); }
	892	+ if ( isExceptional ){
	893	+ result.append( digits, 0, nDigits );
	894	+ } else {
	895	+ result.append( "0.");
	896	+ result.append( digits, 0, nDigits );
	897	+ result.append('e');
	898	+ result.append( decExponent );
	899	+ }
	900	+ return new String(result);
	901	+ }
	902	+
	903	+ public String toJavaFormatString() {
	904	+ char result[] = (char[])(perThreadBuffer.get());
	905	+ int i = getChars(result);
	906	+ return new String(result, 0, i);
	907	+ }
	908	+
	909	+ private int getChars(char[] result) {
	910	+ assert nDigits <= 19 : nDigits; // generous bound on size of nDigits
	911	+ int i = 0;
	912	+ if (isNegative) { result[0] = '-'; i = 1; }
	913	+ if (isExceptional) {
	914	+ System.arraycopy(digits, 0, result, i, nDigits);
	915	+ i += nDigits;
	916	+ } else {
	917	+ if (decExponent > 0 && decExponent < 8) {
	918	+ // print digits.digits.
	919	+ int charLength = Math.min(nDigits, decExponent);
	920	+ System.arraycopy(digits, 0, result, i, charLength);
	921	+ i += charLength;
	922	+ if (charLength < decExponent) {
	923	+ charLength = decExponent-charLength;
	924	+ System.arraycopy(zero, 0, result, i, charLength);
	925	+ i += charLength;
	926	+ result[i++] = '.';
	927	+ result[i++] = '0';
	928	+ } else {
	929	+ result[i++] = '.';
	930	+ if (charLength < nDigits) {
	931	+ int t = nDigits - charLength;
	932	+ System.arraycopy(digits, charLength, result, i, t);
	933	+ i += t;
	934	+ } else {
	935	+ result[i++] = '0';
	936	+ }
	937	+ }
	938	+ } else if (decExponent <=0 && decExponent > -3) {
	939	+ result[i++] = '0';
	940	+ result[i++] = '.';
	941	+ if (decExponent != 0) {
	942	+ System.arraycopy(zero, 0, result, i, -decExponent);
	943	+ i -= decExponent;
	944	+ }
	945	+ System.arraycopy(digits, 0, result, i, nDigits);
	946	+ i += nDigits;
	947	+ } else {
	948	+ result[i++] = digits[0];
	949	+ result[i++] = '.';
	950	+ if (nDigits > 1) {
	951	+ System.arraycopy(digits, 1, result, i, nDigits-1);
	952	+ i += nDigits-1;
	953	+ } else {
	954	+ result[i++] = '0';
	955	+ }
	956	+ result[i++] = 'E';
	957	+ int e;
	958	+ if (decExponent <= 0) {
	959	+ result[i++] = '-';
	960	+ e = -decExponent+1;
	961	+ } else {
	962	+ e = decExponent-1;
	963	+ }
	964	+ // decExponent has 1, 2, or 3, digits
	965	+ if (e <= 9) {
	966	+ result[i++] = (char)(e+'0');
	967	+ } else if (e <= 99) {
	968	+ result[i++] = (char)(e/10 +'0');
	969	+ result[i++] = (char)(e%10 + '0');
	970	+ } else {
	971	+ result[i++] = (char)(e/100+'0');
	972	+ e %= 100;
	973	+ result[i++] = (char)(e/10+'0');
	974	+ result[i++] = (char)(e%10 + '0');
	975	+ }
	976	+ }
	977	+ }
	978	+ return i;
	979	+ }
	980	+
	981	+ // Per-thread buffer for string/stringbuffer conversion
	982	+ private static ThreadLocal perThreadBuffer = new ThreadLocal() {
	983	+ protected synchronized Object initialValue() {
	984	+ return new char[26];
	985	+ }
	986	+ };
	987	+
	988	+ public void appendTo(Appendable buf) {
	989	+ char result[] = (char[])(perThreadBuffer.get());
	990	+ int i = getChars(result);
	991	+ if (buf instanceof StringBuilder)
	992	+ ((StringBuilder) buf).append(result, 0, i);
	993	+ else if (buf instanceof StringBuffer)
	994	+ ((StringBuffer) buf).append(result, 0, i);
	995	+ else
	996	+ assert false;
	997	+ }
	998	+
	999	+ public static FloatingDecimal
	1000	+ readJavaFormatString( String in ) throws NumberFormatException {
	1001	+ boolean isNegative = false;
	1002	+ boolean signSeen = false;
	1003	+ int decExp;
	1004	+ char c;
	1005	+
	1006	+ parseNumber:
	1007	+ try{
	1008	+ in = in.trim(); // don't fool around with white space.
	1009	+ // throws NullPointerException if null
	1010	+ int l = in.length();
	1011	+ if ( l == 0 ) throw new NumberFormatException("empty String");
	1012	+ int i = 0;
	1013	+ switch ( c = in.charAt( i ) ){
	1014	+ case '-':
	1015	+ isNegative = true;
	1016	+ //FALLTHROUGH
	1017	+ case '+':
	1018	+ i++;
	1019	+ signSeen = true;
	1020	+ }
	1021	+
	1022	+ // Check for NaN and Infinity strings
	1023	+ c = in.charAt(i);
	1024	+ if(c == 'N' \|\| c == 'I') { // possible NaN or infinity
	1025	+ boolean potentialNaN = false;
	1026	+ char targetChars[] = null; // char array of "NaN" or "Infinity"
	1027	+
	1028	+ if(c == 'N') {
	1029	+ targetChars = notANumber;
	1030	+ potentialNaN = true;
	1031	+ } else {
	1032	+ targetChars = infinity;
	1033	+ }
	1034	+
	1035	+ // compare Input string to "NaN" or "Infinity"
	1036	+ int j = 0;
	1037	+ while(i < l && j < targetChars.length) {
	1038	+ if(in.charAt(i) == targetChars[j]) {
	1039	+ i++; j++;
	1040	+ }
	1041	+ else // something is amiss, throw exception
	1042	+ break parseNumber;
	1043	+ }
	1044	+
	1045	+ // For the candidate string to be a NaN or infinity,
	1046	+ // all characters in input string and target char[]
	1047	+ // must be matched ==> j must equal targetChars.length
	1048	+ // and i must equal l
	1049	+ if( (j == targetChars.length) && (i == l) ) { // return NaN or infinity
	1050	+ return (potentialNaN ? new FloatingDecimal(Double.NaN) // NaN has no sign
	1051	+ : new FloatingDecimal(isNegative?
	1052	+ Double.NEGATIVE_INFINITY:
	1053	+ Double.POSITIVE_INFINITY)) ;
	1054	+ }
	1055	+ else { // something went wrong, throw exception
	1056	+ break parseNumber;
	1057	+ }
	1058	+
	1059	+ } else if (c == '0') { // check for hexadecimal floating-point number
	1060	+ if (l > i+1 ) {
	1061	+ char ch = in.charAt(i+1);
	1062	+ if (ch == 'x' \|\| ch == 'X' ) // possible hex string
	1063	+ return parseHexString(in);
	1064	+ }
	1065	+ } // look for and process decimal floating-point string
	1066	+
	1067	+ char[] digits = new char[ l ];
	1068	+ int nDigits= 0;
	1069	+ boolean decSeen = false;
	1070	+ int decPt = 0;
	1071	+ int nLeadZero = 0;
	1072	+ int nTrailZero= 0;
	1073	+ digitLoop:
	1074	+ while ( i < l ){
	1075	+ switch ( c = in.charAt( i ) ){
	1076	+ case '0':
	1077	+ if ( nDigits > 0 ){
	1078	+ nTrailZero += 1;
	1079	+ } else {
	1080	+ nLeadZero += 1;
	1081	+ }
	1082	+ break; // out of switch.
	1083	+ case '1':
	1084	+ case '2':
	1085	+ case '3':
	1086	+ case '4':
	1087	+ case '5':
	1088	+ case '6':
	1089	+ case '7':
	1090	+ case '8':
	1091	+ case '9':
	1092	+ while ( nTrailZero > 0 ){
	1093	+ digits[nDigits++] = '0';
	1094	+ nTrailZero -= 1;
	1095	+ }
	1096	+ digits[nDigits++] = c;
	1097	+ break; // out of switch.
	1098	+ case '.':
	1099	+ if ( decSeen ){
	1100	+ // already saw one ., this is the 2nd.
	1101	+ throw new NumberFormatException("multiple points");
	1102	+ }
	1103	+ decPt = i;
	1104	+ if ( signSeen ){
	1105	+ decPt -= 1;
	1106	+ }
	1107	+ decSeen = true;
	1108	+ break; // out of switch.
	1109	+ default:
	1110	+ break digitLoop;
	1111	+ }
	1112	+ i++;
	1113	+ }
	1114	+ /*
	1115	+ * At this point, we've scanned all the digits and decimal
	1116	+ * point we're going to see. Trim off leading and trailing
	1117	+ * zeros, which will just confuse us later, and adjust
	1118	+ * our initial decimal exponent accordingly.
	1119	+ * To review:
	1120	+ * we have seen i total characters.
	1121	+ * nLeadZero of them were zeros before any other digits.
	1122	+ * nTrailZero of them were zeros after any other digits.
	1123	+ * if ( decSeen ), then a . was seen after decPt characters
	1124	+ * ( including leading zeros which have been discarded )
	1125	+ * nDigits characters were neither lead nor trailing
	1126	+ * zeros, nor point
	1127	+ */
	1128	+ /*
	1129	+ * special hack: if we saw no non-zero digits, then the
	1130	+ * answer is zero!
	1131	+ * Unfortunately, we feel honor-bound to keep parsing!
	1132	+ */
	1133	+ if ( nDigits == 0 ){
	1134	+ digits = zero;
	1135	+ nDigits = 1;
	1136	+ if ( nLeadZero == 0 ){
	1137	+ // we saw NO DIGITS AT ALL,
	1138	+ // not even a crummy 0!
	1139	+ // this is not allowed.
	1140	+ break parseNumber; // go throw exception
	1141	+ }
	1142	+
	1143	+ }
	1144	+
	1145	+ /* Our initial exponent is decPt, adjusted by the number of
	1146	+ * discarded zeros. Or, if there was no decPt,
	1147	+ * then its just nDigits adjusted by discarded trailing zeros.
	1148	+ */
	1149	+ if ( decSeen ){
	1150	+ decExp = decPt - nLeadZero;
	1151	+ } else {
	1152	+ decExp = nDigits+nTrailZero;
	1153	+ }
	1154	+
	1155	+ /*
	1156	+ * Look for 'e' or 'E' and an optionally signed integer.
	1157	+ */
	1158	+ if ( (i < l) && (((c = in.charAt(i) )=='e') \|\| (c == 'E') ) ){
	1159	+ int expSign = 1;
	1160	+ int expVal = 0;
	1161	+ int reallyBig = Integer.MAX_VALUE / 10;
	1162	+ boolean expOverflow = false;
	1163	+ switch( in.charAt(++i) ){
	1164	+ case '-':
	1165	+ expSign = -1;
	1166	+ //FALLTHROUGH
	1167	+ case '+':
	1168	+ i++;
	1169	+ }
	1170	+ int expAt = i;
	1171	+ expLoop:
	1172	+ while ( i < l ){
	1173	+ if ( expVal >= reallyBig ){
	1174	+ // the next character will cause integer
	1175	+ // overflow.
	1176	+ expOverflow = true;
	1177	+ }
	1178	+ switch ( c = in.charAt(i++) ){
	1179	+ case '0':
	1180	+ case '1':
	1181	+ case '2':
	1182	+ case '3':
	1183	+ case '4':
	1184	+ case '5':
	1185	+ case '6':
	1186	+ case '7':
	1187	+ case '8':
	1188	+ case '9':
	1189	+ expVal = expVal*10 + ( (int)c - (int)'0' );
	1190	+ continue;
	1191	+ default:
	1192	+ i--; // back up.
	1193	+ break expLoop; // stop parsing exponent.
	1194	+ }
	1195	+ }
	1196	+ int expLimit = bigDecimalExponent+nDigits+nTrailZero;
	1197	+ if ( expOverflow \|\| ( expVal > expLimit ) ){
	1198	+ //
	1199	+ // The intent here is to end up with
	1200	+ // infinity or zero, as appropriate.
	1201	+ // The reason for yielding such a small decExponent,
	1202	+ // rather than something intuitive such as
	1203	+ // expSign*Integer.MAX_VALUE, is that this value
	1204	+ // is subject to further manipulation in
	1205	+ // doubleValue() and floatValue(), and I don't want
	1206	+ // it to be able to cause overflow there!
	1207	+ // (The only way we can get into trouble here is for
	1208	+ // really outrageous nDigits+nTrailZero, such as 2 billion. )
	1209	+ //
	1210	+ decExp = expSign*expLimit;
	1211	+ } else {
	1212	+ // this should not overflow, since we tested
	1213	+ // for expVal > (MAX+N), where N >= abs(decExp)
	1214	+ decExp = decExp + expSign*expVal;
	1215	+ }
	1216	+
	1217	+ // if we saw something not a digit ( or end of string )
	1218	+ // after the [Ee][+-], without seeing any digits at all
	1219	+ // this is certainly an error. If we saw some digits,
	1220	+ // but then some trailing garbage, that might be ok.
	1221	+ // so we just fall through in that case.
	1222	+ // HUMBUG
	1223	+ if ( i == expAt )
	1224	+ break parseNumber; // certainly bad
	1225	+ }
	1226	+ /*
	1227	+ * We parsed everything we could.
	1228	+ * If there are leftovers, then this is not good input!
	1229	+ */
	1230	+ if ( i < l &&
	1231	+ ((i != l - 1) \|\|
	1232	+ (in.charAt(i) != 'f' &&
	1233	+ in.charAt(i) != 'F' &&
	1234	+ in.charAt(i) != 'd' &&
	1235	+ in.charAt(i) != 'D'))) {
	1236	+ break parseNumber; // go throw exception
	1237	+ }
	1238	+
	1239	+ return new FloatingDecimal( isNegative, decExp, digits, nDigits, false );
	1240	+ } catch ( StringIndexOutOfBoundsException e ){ }
	1241	+ throw new NumberFormatException("For input string: \"" + in + "\"");
	1242	+ }
	1243	+
	1244	+ /*
	1245	+ * Take a FloatingDecimal, which we presumably just scanned in,
	1246	+ * and find out what its value is, as a double.
	1247	+ *
	1248	+ * AS A SIDE EFFECT, SET roundDir TO INDICATE PREFERRED
	1249	+ * ROUNDING DIRECTION in case the result is really destined
	1250	+ * for a single-precision float.
	1251	+ */
	1252	+
	1253	+ public strictfp double doubleValue(){
	1254	+ int kDigits = Math.min( nDigits, maxDecimalDigits+1 );
	1255	+ long lValue;
	1256	+ double dValue;
	1257	+ double rValue, tValue;
	1258	+
	1259	+ // First, check for NaN and Infinity values
	1260	+ if(digits == infinity \|\| digits == notANumber) {
	1261	+ if(digits == notANumber)
	1262	+ return Double.NaN;
	1263	+ else
	1264	+ return (isNegative?Double.NEGATIVE_INFINITY:Double.POSITIVE_INFINITY);
	1265	+ }
	1266	+ else {
	1267	+ if (mustSetRoundDir) {
	1268	+ roundDir = 0;
	1269	+ }
	1270	+ /*
	1271	+ * convert the lead kDigits to a long integer.
	1272	+ */
	1273	+ // (special performance hack: start to do it using int)
	1274	+ int iValue = (int)digits[0]-(int)'0';
	1275	+ int iDigits = Math.min( kDigits, intDecimalDigits );
	1276	+ for ( int i=1; i < iDigits; i++ ){
	1277	+ iValue = iValue*10 + (int)digits[i]-(int)'0';
	1278	+ }
	1279	+ lValue = (long)iValue;
	1280	+ for ( int i=iDigits; i < kDigits; i++ ){
	1281	+ lValue = lValue*10L + (long)((int)digits[i]-(int)'0');
	1282	+ }
	1283	+ dValue = (double)lValue;
	1284	+ int exp = decExponent-kDigits;
	1285	+ /*
	1286	+ * lValue now contains a long integer with the value of
	1287	+ * the first kDigits digits of the number.
	1288	+ * dValue contains the (double) of the same.
	1289	+ */
	1290	+
	1291	+ if ( nDigits <= maxDecimalDigits ){
	1292	+ /*
	1293	+ * possibly an easy case.
	1294	+ * We know that the digits can be represented
	1295	+ * exactly. And if the exponent isn't too outrageous,
	1296	+ * the whole thing can be done with one operation,
	1297	+ * thus one rounding error.
	1298	+ * Note that all our constructors trim all leading and
	1299	+ * trailing zeros, so simple values (including zero)
	1300	+ * will always end up here
	1301	+ */
	1302	+ if (exp == 0 \|\| dValue == 0.0)
	1303	+ return (isNegative)? -dValue : dValue; // small floating integer
	1304	+ else if ( exp >= 0 ){
	1305	+ if ( exp <= maxSmallTen ){
	1306	+ /*
	1307	+ * Can get the answer with one operation,
	1308	+ * thus one roundoff.
	1309	+ */
	1310	+ rValue = dValue * small10pow[exp];
	1311	+ if ( mustSetRoundDir ){
	1312	+ tValue = rValue / small10pow[exp];
	1313	+ roundDir = ( tValue == dValue ) ? 0
	1314	+ :( tValue < dValue ) ? 1
	1315	+ : -1;
	1316	+ }
	1317	+ return (isNegative)? -rValue : rValue;
	1318	+ }
	1319	+ int slop = maxDecimalDigits - kDigits;
	1320	+ if ( exp <= maxSmallTen+slop ){
	1321	+ /*
	1322	+ * We can multiply dValue by 10^(slop)
	1323	+ * and it is still "small" and exact.
	1324	+ * Then we can multiply by 10^(exp-slop)
	1325	+ * with one rounding.
	1326	+ */
	1327	+ dValue *= small10pow[slop];
	1328	+ rValue = dValue * small10pow[exp-slop];
	1329	+
	1330	+ if ( mustSetRoundDir ){
	1331	+ tValue = rValue / small10pow[exp-slop];
	1332	+ roundDir = ( tValue == dValue ) ? 0
	1333	+ :( tValue < dValue ) ? 1
	1334	+ : -1;
	1335	+ }
	1336	+ return (isNegative)? -rValue : rValue;
	1337	+ }
	1338	+ /*
	1339	+ * Else we have a hard case with a positive exp.
	1340	+ */
	1341	+ } else {
	1342	+ if ( exp >= -maxSmallTen ){
	1343	+ /*
	1344	+ * Can get the answer in one division.
	1345	+ */
	1346	+ rValue = dValue / small10pow[-exp];
	1347	+ tValue = rValue * small10pow[-exp];
	1348	+ if ( mustSetRoundDir ){
	1349	+ roundDir = ( tValue == dValue ) ? 0
	1350	+ :( tValue < dValue ) ? 1
	1351	+ : -1;
	1352	+ }
	1353	+ return (isNegative)? -rValue : rValue;
	1354	+ }
	1355	+ /*
	1356	+ * Else we have a hard case with a negative exp.
	1357	+ */
	1358	+ }
	1359	+ }
	1360	+
	1361	+ /*
	1362	+ * Harder cases:
	1363	+ * The sum of digits plus exponent is greater than
	1364	+ * what we think we can do with one error.
	1365	+ *
	1366	+ * Start by approximating the right answer by,
	1367	+ * naively, scaling by powers of 10.
	1368	+ */
	1369	+ if ( exp > 0 ){
	1370	+ if ( decExponent > maxDecimalExponent+1 ){
	1371	+ /*
	1372	+ * Lets face it. This is going to be
	1373	+ * Infinity. Cut to the chase.
	1374	+ */
	1375	+ return (isNegative)? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
	1376	+ }
	1377	+ if ( (exp&15) != 0 ){
	1378	+ dValue *= small10pow[exp&15];
	1379	+ }
	1380	+ if ( (exp>>=4) != 0 ){
	1381	+ int j;
	1382	+ for( j = 0; exp > 1; j++, exp>>=1 ){
	1383	+ if ( (exp&1)!=0)
	1384	+ dValue *= big10pow[j];
	1385	+ }
	1386	+ /*
	1387	+ * The reason for the weird exp > 1 condition
	1388	+ * in the above loop was so that the last multiply
	1389	+ * would get unrolled. We handle it here.
	1390	+ * It could overflow.
	1391	+ */
	1392	+ double t = dValue * big10pow[j];
	1393	+ if ( Double.isInfinite( t ) ){
	1394	+ /*
	1395	+ * It did overflow.
	1396	+ * Look more closely at the result.
	1397	+ * If the exponent is just one too large,
	1398	+ * then use the maximum finite as our estimate
	1399	+ * value. Else call the result infinity
	1400	+ * and punt it.
	1401	+ * ( I presume this could happen because
	1402	+ * rounding forces the result here to be
	1403	+ * an ULP or two larger than
	1404	+ * Double.MAX_VALUE ).
	1405	+ */
	1406	+ t = dValue / 2.0;
	1407	+ t *= big10pow[j];
	1408	+ if ( Double.isInfinite( t ) ){
	1409	+ return (isNegative)? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
	1410	+ }
	1411	+ t = Double.MAX_VALUE;
	1412	+ }
	1413	+ dValue = t;
	1414	+ }
	1415	+ } else if ( exp < 0 ){
	1416	+ exp = -exp;
	1417	+ if ( decExponent < minDecimalExponent-1 ){
	1418	+ /*
	1419	+ * Lets face it. This is going to be
	1420	+ * zero. Cut to the chase.
	1421	+ */
	1422	+ return (isNegative)? -0.0 : 0.0;
	1423	+ }
	1424	+ if ( (exp&15) != 0 ){
	1425	+ dValue /= small10pow[exp&15];
	1426	+ }
	1427	+ if ( (exp>>=4) != 0 ){
	1428	+ int j;
	1429	+ for( j = 0; exp > 1; j++, exp>>=1 ){
	1430	+ if ( (exp&1)!=0)
	1431	+ dValue *= tiny10pow[j];
	1432	+ }
	1433	+ /*
	1434	+ * The reason for the weird exp > 1 condition
	1435	+ * in the above loop was so that the last multiply
	1436	+ * would get unrolled. We handle it here.
	1437	+ * It could underflow.
	1438	+ */
	1439	+ double t = dValue * tiny10pow[j];
	1440	+ if ( t == 0.0 ){
	1441	+ /*
	1442	+ * It did underflow.
	1443	+ * Look more closely at the result.
	1444	+ * If the exponent is just one too small,
	1445	+ * then use the minimum finite as our estimate
	1446	+ * value. Else call the result 0.0
	1447	+ * and punt it.
	1448	+ * ( I presume this could happen because
	1449	+ * rounding forces the result here to be
	1450	+ * an ULP or two less than
	1451	+ * Double.MIN_VALUE ).
	1452	+ */
	1453	+ t = dValue * 2.0;
	1454	+ t *= tiny10pow[j];
	1455	+ if ( t == 0.0 ){
	1456	+ return (isNegative)? -0.0 : 0.0;
	1457	+ }
	1458	+ t = Double.MIN_VALUE;
	1459	+ }
	1460	+ dValue = t;
	1461	+ }
	1462	+ }
	1463	+
	1464	+ /*
	1465	+ * dValue is now approximately the result.
	1466	+ * The hard part is adjusting it, by comparison
	1467	+ * with FDBigInt arithmetic.
	1468	+ * Formulate the EXACT big-number result as
	1469	+ * bigD0 * 10^exp
	1470	+ */
	1471	+ FDBigInt bigD0 = new FDBigInt( lValue, digits, kDigits, nDigits );
	1472	+ exp = decExponent - nDigits;
	1473	+
	1474	+ correctionLoop:
	1475	+ while(true){
	1476	+ /* AS A SIDE EFFECT, THIS METHOD WILL SET THE INSTANCE VARIABLES
	1477	+ * bigIntExp and bigIntNBits
	1478	+ */
	1479	+ FDBigInt bigB = doubleToBigInt( dValue );
	1480	+
	1481	+ /*
	1482	+ * Scale bigD, bigB appropriately for
	1483	+ * big-integer operations.
	1484	+ * Naively, we multiply by powers of ten
	1485	+ * and powers of two. What we actually do
	1486	+ * is keep track of the powers of 5 and
	1487	+ * powers of 2 we would use, then factor out
	1488	+ * common divisors before doing the work.
	1489	+ */
	1490	+ int B2, B5; // powers of 2, 5 in bigB
	1491	+ int D2, D5; // powers of 2, 5 in bigD
	1492	+ int Ulp2; // powers of 2 in halfUlp.
	1493	+ if ( exp >= 0 ){
	1494	+ B2 = B5 = 0;
	1495	+ D2 = D5 = exp;
	1496	+ } else {
	1497	+ B2 = B5 = -exp;
	1498	+ D2 = D5 = 0;
	1499	+ }
	1500	+ if ( bigIntExp >= 0 ){
	1501	+ B2 += bigIntExp;
	1502	+ } else {
	1503	+ D2 -= bigIntExp;
	1504	+ }
	1505	+ Ulp2 = B2;
	1506	+ // shift bigB and bigD left by a number s. t.
	1507	+ // halfUlp is still an integer.
	1508	+ int hulpbias;
	1509	+ if ( bigIntExp+bigIntNBits <= -expBias+1 ){
	1510	+ // This is going to be a denormalized number
	1511	+ // (if not actually zero).
	1512	+ // half an ULP is at 2^-(expBias+expShift+1)
	1513	+ hulpbias = bigIntExp+ expBias + expShift;
	1514	+ } else {
	1515	+ hulpbias = expShift + 2 - bigIntNBits;
	1516	+ }
	1517	+ B2 += hulpbias;
	1518	+ D2 += hulpbias;
	1519	+ // if there are common factors of 2, we might just as well
	1520	+ // factor them out, as they add nothing useful.
	1521	+ int common2 = Math.min( B2, Math.min( D2, Ulp2 ) );
	1522	+ B2 -= common2;
	1523	+ D2 -= common2;
	1524	+ Ulp2 -= common2;
	1525	+ // do multiplications by powers of 5 and 2
	1526	+ bigB = multPow52( bigB, B5, B2 );
	1527	+ FDBigInt bigD = multPow52( new FDBigInt( bigD0 ), D5, D2 );
	1528	+ //
	1529	+ // to recap:
	1530	+ // bigB is the scaled-big-int version of our floating-point
	1531	+ // candidate.
	1532	+ // bigD is the scaled-big-int version of the exact value
	1533	+ // as we understand it.
	1534	+ // halfUlp is 1/2 an ulp of bigB, except for special cases
	1535	+ // of exact powers of 2
	1536	+ //
	1537	+ // the plan is to compare bigB with bigD, and if the difference
	1538	+ // is less than halfUlp, then we're satisfied. Otherwise,
	1539	+ // use the ratio of difference to halfUlp to calculate a fudge
	1540	+ // factor to add to the floating value, then go 'round again.
	1541	+ //
	1542	+ FDBigInt diff;
	1543	+ int cmpResult;
	1544	+ boolean overvalue;
	1545	+ if ( (cmpResult = bigB.cmp( bigD ) ) > 0 ){
	1546	+ overvalue = true; // our candidate is too big.
	1547	+ diff = bigB.sub( bigD );
	1548	+ if ( (bigIntNBits == 1) && (bigIntExp > -expBias+1) ){
	1549	+ // candidate is a normalized exact power of 2 and
	1550	+ // is too big. We will be subtracting.
	1551	+ // For our purposes, ulp is the ulp of the
	1552	+ // next smaller range.
	1553	+ Ulp2 -= 1;
	1554	+ if ( Ulp2 < 0 ){
	1555	+ // rats. Cannot de-scale ulp this far.
	1556	+ // must scale diff in other direction.
	1557	+ Ulp2 = 0;
	1558	+ diff.lshiftMe( 1 );
	1559	+ }
	1560	+ }
	1561	+ } else if ( cmpResult < 0 ){
	1562	+ overvalue = false; // our candidate is too small.
	1563	+ diff = bigD.sub( bigB );
	1564	+ } else {
	1565	+ // the candidate is exactly right!
	1566	+ // this happens with surprising frequency
	1567	+ break correctionLoop;
	1568	+ }
	1569	+ FDBigInt halfUlp = constructPow52( B5, Ulp2 );
	1570	+ if ( (cmpResult = diff.cmp( halfUlp ) ) < 0 ){
	1571	+ // difference is small.
	1572	+ // this is close enough
	1573	+ if (mustSetRoundDir) {
	1574	+ roundDir = overvalue ? -1 : 1;
	1575	+ }
	1576	+ break correctionLoop;
	1577	+ } else if ( cmpResult == 0 ){
	1578	+ // difference is exactly half an ULP
	1579	+ // round to some other value maybe, then finish
	1580	+ dValue += 0.5*ulp( dValue, overvalue );
	1581	+ // should check for bigIntNBits == 1 here??
	1582	+ if (mustSetRoundDir) {
	1583	+ roundDir = overvalue ? -1 : 1;
	1584	+ }
	1585	+ break correctionLoop;
	1586	+ } else {
	1587	+ // difference is non-trivial.
	1588	+ // could scale addend by ratio of difference to
	1589	+ // halfUlp here, if we bothered to compute that difference.
	1590	+ // Most of the time ( I hope ) it is about 1 anyway.
	1591	+ dValue += ulp( dValue, overvalue );
	1592	+ if ( dValue == 0.0 \|\| dValue == Double.POSITIVE_INFINITY )
	1593	+ break correctionLoop; // oops. Fell off end of range.
	1594	+ continue; // try again.
	1595	+ }
	1596	+
	1597	+ }
	1598	+ return (isNegative)? -dValue : dValue;
	1599	+ }
	1600	+ }
	1601	+
	1602	+ /*
	1603	+ * Take a FloatingDecimal, which we presumably just scanned in,
	1604	+ * and find out what its value is, as a float.
	1605	+ * This is distinct from doubleValue() to avoid the extremely
	1606	+ * unlikely case of a double rounding error, wherein the conversion
	1607	+ * to double has one rounding error, and the conversion of that double
	1608	+ * to a float has another rounding error, IN THE WRONG DIRECTION,
	1609	+ * ( because of the preference to a zero low-order bit ).
	1610	+ */
	1611	+
	1612	+ public strictfp float floatValue(){
	1613	+ int kDigits = Math.min( nDigits, singleMaxDecimalDigits+1 );
	1614	+ int iValue;
	1615	+ float fValue;
	1616	+
	1617	+ // First, check for NaN and Infinity values
	1618	+ if(digits == infinity \|\| digits == notANumber) {
	1619	+ if(digits == notANumber)
	1620	+ return Float.NaN;
	1621	+ else
	1622	+ return (isNegative?Float.NEGATIVE_INFINITY:Float.POSITIVE_INFINITY);
	1623	+ }
	1624	+ else {
	1625	+ /*
	1626	+ * convert the lead kDigits to an integer.
	1627	+ */
	1628	+ iValue = (int)digits[0]-(int)'0';
	1629	+ for ( int i=1; i < kDigits; i++ ){
	1630	+ iValue = iValue*10 + (int)digits[i]-(int)'0';
	1631	+ }
	1632	+ fValue = (float)iValue;
	1633	+ int exp = decExponent-kDigits;
	1634	+ /*
	1635	+ * iValue now contains an integer with the value of
	1636	+ * the first kDigits digits of the number.
	1637	+ * fValue contains the (float) of the same.
	1638	+ */
	1639	+
	1640	+ if ( nDigits <= singleMaxDecimalDigits ){
	1641	+ /*
	1642	+ * possibly an easy case.
	1643	+ * We know that the digits can be represented
	1644	+ * exactly. And if the exponent isn't too outrageous,
	1645	+ * the whole thing can be done with one operation,
	1646	+ * thus one rounding error.
	1647	+ * Note that all our constructors trim all leading and
	1648	+ * trailing zeros, so simple values (including zero)
	1649	+ * will always end up here.
	1650	+ */
	1651	+ if (exp == 0 \|\| fValue == 0.0f)
	1652	+ return (isNegative)? -fValue : fValue; // small floating integer
	1653	+ else if ( exp >= 0 ){
	1654	+ if ( exp <= singleMaxSmallTen ){
	1655	+ /*
	1656	+ * Can get the answer with one operation,
	1657	+ * thus one roundoff.
	1658	+ */
	1659	+ fValue *= singleSmall10pow[exp];
	1660	+ return (isNegative)? -fValue : fValue;
	1661	+ }
	1662	+ int slop = singleMaxDecimalDigits - kDigits;
	1663	+ if ( exp <= singleMaxSmallTen+slop ){
	1664	+ /*
	1665	+ * We can multiply dValue by 10^(slop)
	1666	+ * and it is still "small" and exact.
	1667	+ * Then we can multiply by 10^(exp-slop)
	1668	+ * with one rounding.
	1669	+ */
	1670	+ fValue *= singleSmall10pow[slop];
	1671	+ fValue *= singleSmall10pow[exp-slop];
	1672	+ return (isNegative)? -fValue : fValue;
	1673	+ }
	1674	+ /*
	1675	+ * Else we have a hard case with a positive exp.
	1676	+ */
	1677	+ } else {
	1678	+ if ( exp >= -singleMaxSmallTen ){
	1679	+ /*
	1680	+ * Can get the answer in one division.
	1681	+ */
	1682	+ fValue /= singleSmall10pow[-exp];
	1683	+ return (isNegative)? -fValue : fValue;
	1684	+ }
	1685	+ /*
	1686	+ * Else we have a hard case with a negative exp.
	1687	+ */
	1688	+ }
	1689	+ } else if ( (decExponent >= nDigits) && (nDigits+decExponent <= maxDecimalDigits) ){
	1690	+ /*
	1691	+ * In double-precision, this is an exact floating integer.
	1692	+ * So we can compute to double, then shorten to float
	1693	+ * with one round, and get the right answer.
	1694	+ *
	1695	+ * First, finish accumulating digits.
	1696	+ * Then convert that integer to a double, multiply
	1697	+ * by the appropriate power of ten, and convert to float.
	1698	+ */
	1699	+ long lValue = (long)iValue;
	1700	+ for ( int i=kDigits; i < nDigits; i++ ){
	1701	+ lValue = lValue*10L + (long)((int)digits[i]-(int)'0');
	1702	+ }
	1703	+ double dValue = (double)lValue;
	1704	+ exp = decExponent-nDigits;
	1705	+ dValue *= small10pow[exp];
	1706	+ fValue = (float)dValue;
	1707	+ return (isNegative)? -fValue : fValue;
	1708	+
	1709	+ }
	1710	+ /*
	1711	+ * Harder cases:
	1712	+ * The sum of digits plus exponent is greater than
	1713	+ * what we think we can do with one error.
	1714	+ *
	1715	+ * Start by weeding out obviously out-of-range
	1716	+ * results, then convert to double and go to
	1717	+ * common hard-case code.
	1718	+ */
	1719	+ if ( decExponent > singleMaxDecimalExponent+1 ){
	1720	+ /*
	1721	+ * Lets face it. This is going to be
	1722	+ * Infinity. Cut to the chase.
	1723	+ */
	1724	+ return (isNegative)? Float.NEGATIVE_INFINITY : Float.POSITIVE_INFINITY;
	1725	+ } else if ( decExponent < singleMinDecimalExponent-1 ){
	1726	+ /*
	1727	+ * Lets face it. This is going to be
	1728	+ * zero. Cut to the chase.
	1729	+ */
	1730	+ return (isNegative)? -0.0f : 0.0f;
	1731	+ }
	1732	+
	1733	+ /*
	1734	+ * Here, we do 'way too much work, but throwing away
	1735	+ * our partial results, and going and doing the whole
	1736	+ * thing as double, then throwing away half the bits that computes
	1737	+ * when we convert back to float.
	1738	+ *
	1739	+ * The alternative is to reproduce the whole multiple-precision
	1740	+ * algorithm for float precision, or to try to parameterize it
	1741	+ * for common usage. The former will take about 400 lines of code,
	1742	+ * and the latter I tried without success. Thus the semi-hack
	1743	+ * answer here.
	1744	+ */
	1745	+ mustSetRoundDir = !fromHex;
	1746	+ double dValue = doubleValue();
	1747	+ return stickyRound( dValue );
	1748	+ }
	1749	+ }
	1750	+
	1751	+
	1752	+ /*
	1753	+ * All the positive powers of 10 that can be
	1754	+ * represented exactly in double/float.
	1755	+ */
	1756	+ private static final double small10pow[] = {
	1757	+ 1.0e0,
	1758	+ 1.0e1, 1.0e2, 1.0e3, 1.0e4, 1.0e5,
	1759	+ 1.0e6, 1.0e7, 1.0e8, 1.0e9, 1.0e10,
	1760	+ 1.0e11, 1.0e12, 1.0e13, 1.0e14, 1.0e15,
	1761	+ 1.0e16, 1.0e17, 1.0e18, 1.0e19, 1.0e20,
	1762	+ 1.0e21, 1.0e22
	1763	+ };
	1764	+
	1765	+ private static final float singleSmall10pow[] = {
	1766	+ 1.0e0f,
	1767	+ 1.0e1f, 1.0e2f, 1.0e3f, 1.0e4f, 1.0e5f,
	1768	+ 1.0e6f, 1.0e7f, 1.0e8f, 1.0e9f, 1.0e10f
	1769	+ };
	1770	+
	1771	+ private static final double big10pow[] = {
	1772	+ 1e16, 1e32, 1e64, 1e128, 1e256 };
	1773	+ private static final double tiny10pow[] = {
	1774	+ 1e-16, 1e-32, 1e-64, 1e-128, 1e-256 };
	1775	+
	1776	+ private static final int maxSmallTen = small10pow.length-1;
	1777	+ private static final int singleMaxSmallTen = singleSmall10pow.length-1;
	1778	+
	1779	+ private static final int small5pow[] = {
	1780	+ 1,
	1781	+ 5,
	1782	+ 5*5,
	1783	+ 555,
	1784	+ 555*5,
	1785	+ 55555,
	1786	+ 55555*5,
	1787	+ 5555555,
	1788	+ 5555555*5,
	1789	+ 555555555,
	1790	+ 555555555*5,
	1791	+ 55555555555,
	1792	+ 55555555555*5,
	1793	+ 5555555555555
	1794	+ };
	1795	+
	1796	+
	1797	+ private static final long long5pow[] = {
	1798	+ 1L,
	1799	+ 5L,
	1800	+ 5L*5,
	1801	+ 5L55,
	1802	+ 5L55*5,
	1803	+ 5L5555,
	1804	+ 5L5555*5,
	1805	+ 5L555555,
	1806	+ 5L555555*5,
	1807	+ 5L55555555,
	1808	+ 5L55555555*5,
	1809	+ 5L5555555555,
	1810	+ 5L5555555555*5,
	1811	+ 5L555555555555,
	1812	+ 5L555555555555*5,
	1813	+ 5L55555555555555,
	1814	+ 5L55555555555555*5,
	1815	+ 5L5555555555555555,
	1816	+ 5L5555555555555555*5,
	1817	+ 5L555555555555555555,
	1818	+ 5L555555555555555555*5,
	1819	+ 5L55555555555555555555,
	1820	+ 5L55555555555555555555*5,
	1821	+ 5L5555555555555555555555,
	1822	+ 5L5555555555555555555555*5,
	1823	+ 5L555555555555555555555555,
	1824	+ 5L555555555555555555555555*5,
	1825	+ };
	1826	+
	1827	+ // approximately ceil( log2( long5pow[i] ) )
	1828	+ private static final int n5bits[] = {
	1829	+ 0,
	1830	+ 3,
	1831	+ 5,
	1832	+ 7,
	1833	+ 10,
	1834	+ 12,
	1835	+ 14,
	1836	+ 17,
	1837	+ 19,
	1838	+ 21,
	1839	+ 24,
	1840	+ 26,
	1841	+ 28,
	1842	+ 31,
	1843	+ 33,
	1844	+ 35,
	1845	+ 38,
	1846	+ 40,
	1847	+ 42,
	1848	+ 45,
	1849	+ 47,
	1850	+ 49,
	1851	+ 52,
	1852	+ 54,
	1853	+ 56,
	1854	+ 59,
	1855	+ 61,
	1856	+ };
	1857	+
	1858	+ private static final char infinity[] = { 'I', 'n', 'f', 'i', 'n', 'i', 't', 'y' };
	1859	+ private static final char notANumber[] = { 'N', 'a', 'N' };
	1860	+ private static final char zero[] = { '0', '0', '0', '0', '0', '0', '0', '0' };
	1861	+
	1862	+
	1863	+ /*
	1864	+ * Grammar is compatible with hexadecimal floating-point constants
	1865	+ * described in section 6.4.4.2 of the C99 specification.
	1866	+ */
	1867	+ private static Pattern hexFloatPattern = null;
	1868	+ private static synchronized Pattern getHexFloatPattern() {
	1869	+ if (hexFloatPattern == null) {
	1870	+ hexFloatPattern = Pattern.compile(
	1871	+ //1 234 56 7 8 9
	1872	+ "([-+])?0[xX](((\\p{XDigit}+)\\.?)\|((\\p{XDigit}*)\\.(\\p{XDigit}+)))[pP]([-+])?(\\p{Digit}+)[fFdD]?"
	1873	+ );
	1874	+ }
	1875	+ return hexFloatPattern;
	1876	+ }
	1877	+
	1878	+ /*
	1879	+ * Convert string s to a suitable floating decimal; uses the
	1880	+ * double constructor and set the roundDir variable appropriately
	1881	+ * in case the value is later converted to a float.
	1882	+ */
	1883	+ static FloatingDecimal parseHexString(String s) {
	1884	+ // Verify string is a member of the hexadecimal floating-point
	1885	+ // string language.
	1886	+ Matcher m = getHexFloatPattern().matcher(s);
	1887	+ boolean validInput = m.matches();
	1888	+
	1889	+ if (!validInput) {
	1890	+ // Input does not match pattern
	1891	+ throw new NumberFormatException("For input string: \"" + s + "\"");
	1892	+ } else { // validInput
	1893	+ /*
	1894	+ * We must isolate the sign, significand, and exponent
	1895	+ * fields. The sign value is straightforward. Since
	1896	+ * floating-point numbers are stored with a normalized
	1897	+ * representation, the significand and exponent are
	1898	+ * interrelated.
	1899	+ *
	1900	+ * After extracting the sign, we normalized the
	1901	+ * significand as a hexadecimal value, calculating an
	1902	+ * exponent adjust for any shifts made during
	1903	+ * normalization. If the significand is zero, the
	1904	+ * exponent doesn't need to be examined since the output
	1905	+ * will be zero.
	1906	+ *
	1907	+ * Next the exponent in the input string is extracted.
	1908	+ * Afterwards, the significand is normalized as a binary
	1909	+ * value and the input value's normalized exponent can be
	1910	+ * computed. The significand bits are copied into a
	1911	+ * double significand; if the string has more logical bits
	1912	+ * than can fit in a double, the extra bits affect the
	1913	+ * round and sticky bits which are used to round the final
	1914	+ * value.
	1915	+ */
	1916	+
	1917	+ // Extract significand sign
	1918	+ String group1 = m.group(1);
	1919	+ double sign = (( group1 == null ) \|\| group1.equals("+"))? 1.0 : -1.0;
	1920	+
	1921	+
	1922	+ // Extract Significand magnitude
	1923	+ /*
	1924	+ * Based on the form of the significand, calculate how the
	1925	+ * binary exponent needs to be adjusted to create a
	1926	+ * normalized hexadecimal floating-point number; that
	1927	+ * is, a number where there is one nonzero hex digit to
	1928	+ * the left of the (hexa)decimal point. Since we are
	1929	+ * adjusting a binary, not hexadecimal exponent, the
	1930	+ * exponent is adjusted by a multiple of 4.
	1931	+ *
	1932	+ * There are a number of significand scenarios to consider;
	1933	+ * letters are used in indicate nonzero digits:
	1934	+ *
	1935	+ * 1. 000xxxx => x.xxx normalized
	1936	+ * increase exponent by (number of x's - 1)*4
	1937	+ *
	1938	+ * 2. 000xxx.yyyy => x.xxyyyy normalized
	1939	+ * increase exponent by (number of x's - 1)*4
	1940	+ *
	1941	+ * 3. .000yyy => y.yy normalized
	1942	+ * decrease exponent by (number of zeros + 1)*4
	1943	+ *
	1944	+ * 4. 000.00000yyy => y.yy normalized
	1945	+ * decrease exponent by (number of zeros to right of point + 1)*4
	1946	+ *
	1947	+ * If the significand is exactly zero, return a properly
	1948	+ * signed zero.
	1949	+ */
	1950	+
	1951	+ String significandString =null;
	1952	+ int signifLength = 0;
	1953	+ int exponentAdjust = 0;
	1954	+ {
	1955	+ int leftDigits = 0; // number of meaningful digits to
	1956	+ // left of "decimal" point
	1957	+ // (leading zeros stripped)
	1958	+ int rightDigits = 0; // number of digits to right of
	1959	+ // "decimal" point; leading zeros
	1960	+ // must always be accounted for
	1961	+ /*
	1962	+ * The significand is made up of either
	1963	+ *
	1964	+ * 1. group 4 entirely (integer portion only)
	1965	+ *
	1966	+ * OR
	1967	+ *
	1968	+ * 2. the fractional portion from group 7 plus any
	1969	+ * (optional) integer portions from group 6.
	1970	+ */
	1971	+ String group4;
	1972	+ if( (group4 = m.group(4)) != null) { // Integer-only significand
	1973	+ // Leading zeros never matter on the integer portion
	1974	+ significandString = stripLeadingZeros(group4);
	1975	+ leftDigits = significandString.length();
	1976	+ }
	1977	+ else {
	1978	+ // Group 6 is the optional integer; leading zeros
	1979	+ // never matter on the integer portion
	1980	+ String group6 = stripLeadingZeros(m.group(6));
	1981	+ leftDigits = group6.length();
	1982	+
	1983	+ // fraction
	1984	+ String group7 = m.group(7);
	1985	+ rightDigits = group7.length();
	1986	+
	1987	+ // Turn "integer.fraction" into "integer"+"fraction"
	1988	+ significandString =
	1989	+ ((group6 == null)?"":group6) + // is the null
	1990	+ // check necessary?
	1991	+ group7;
	1992	+ }
	1993	+
	1994	+ significandString = stripLeadingZeros(significandString);
	1995	+ signifLength = significandString.length();
	1996	+
	1997	+ /*
	1998	+ * Adjust exponent as described above
	1999	+ */
	2000	+ if (leftDigits >= 1) { // Cases 1 and 2
	2001	+ exponentAdjust = 4*(leftDigits - 1);
	2002	+ } else { // Cases 3 and 4
	2003	+ exponentAdjust = -4*( rightDigits - signifLength + 1);
	2004	+ }
	2005	+
	2006	+ // If the significand is zero, the exponent doesn't
	2007	+ // matter; return a properly signed zero.
	2008	+
	2009	+ if (signifLength == 0) { // Only zeros in input
	2010	+ return new FloatingDecimal(sign * 0.0);
	2011	+ }
	2012	+ }
	2013	+
	2014	+ // Extract Exponent
	2015	+ /*
	2016	+ * Use an int to read in the exponent value; this should
	2017	+ * provide more than sufficient range for non-contrived
	2018	+ * inputs. If reading the exponent in as an int does
	2019	+ * overflow, examine the sign of the exponent and
	2020	+ * significand to determine what to do.
	2021	+ */
	2022	+ String group8 = m.group(8);
	2023	+ boolean positiveExponent = ( group8 == null ) \|\| group8.equals("+");
	2024	+ long unsignedRawExponent;
	2025	+ try {
	2026	+ unsignedRawExponent = Integer.parseInt(m.group(9));
	2027	+ }
	2028	+ catch (NumberFormatException e) {
	2029	+ // At this point, we know the exponent is
	2030	+ // syntactically well-formed as a sequence of
	2031	+ // digits. Therefore, if an NumberFormatException
	2032	+ // is thrown, it must be due to overflowing int's
	2033	+ // range. Also, at this point, we have already
	2034	+ // checked for a zero significand. Thus the signs
	2035	+ // of the exponent and significand determine the
	2036	+ // final result:
	2037	+ //
	2038	+ // significand
	2039	+ // + -
	2040	+ // exponent + +infinity -infinity
	2041	+ // - +0.0 -0.0
	2042	+ return new FloatingDecimal(sign * (positiveExponent ?
	2043	+ Double.POSITIVE_INFINITY : 0.0));
	2044	+ }
	2045	+
	2046	+ long rawExponent =
	2047	+ (positiveExponent ? 1L : -1L) * // exponent sign
	2048	+ unsignedRawExponent; // exponent magnitude
	2049	+
	2050	+ // Calculate partially adjusted exponent
	2051	+ long exponent = rawExponent + exponentAdjust ;
	2052	+
	2053	+ // Starting copying non-zero bits into proper position in
	2054	+ // a long; copy explicit bit too; this will be masked
	2055	+ // later for normal values.
	2056	+
	2057	+ boolean round = false;
	2058	+ boolean sticky = false;
	2059	+ int bitsCopied=0;
	2060	+ int nextShift=0;
	2061	+ long significand=0L;
	2062	+ // First iteration is different, since we only copy
	2063	+ // from the leading significand bit; one more exponent
	2064	+ // adjust will be needed...
	2065	+
	2066	+ // IMPORTANT: make leadingDigit a long to avoid
	2067	+ // surprising shift semantics!
	2068	+ long leadingDigit = getHexDigit(significandString, 0);
	2069	+
	2070	+ /*
	2071	+ * Left shift the leading digit (53 - (bit position of
	2072	+ * leading 1 in digit)); this sets the top bit of the
	2073	+ * significand to 1. The nextShift value is adjusted
	2074	+ * to take into account the number of bit positions of
	2075	+ * the leadingDigit actually used. Finally, the
	2076	+ * exponent is adjusted to normalize the significand
	2077	+ * as a binary value, not just a hex value.
	2078	+ */
	2079	+ if (leadingDigit == 1) {
	2080	+ significand \|= leadingDigit << 52;
	2081	+ nextShift = 52 - 4;
	2082	+ /* exponent += 0 */ }
	2083	+ else if (leadingDigit <= 3) { // [2, 3]
	2084	+ significand \|= leadingDigit << 51;
	2085	+ nextShift = 52 - 5;
	2086	+ exponent += 1;
	2087	+ }
	2088	+ else if (leadingDigit <= 7) { // [4, 7]
	2089	+ significand \|= leadingDigit << 50;
	2090	+ nextShift = 52 - 6;
	2091	+ exponent += 2;
	2092	+ }
	2093	+ else if (leadingDigit <= 15) { // [8, f]
	2094	+ significand \|= leadingDigit << 49;
	2095	+ nextShift = 52 - 7;
	2096	+ exponent += 3;
	2097	+ } else {
	2098	+ throw new AssertionError("Result from digit conversion too large!");
	2099	+ }
	2100	+ // The preceding if-else could be replaced by a single
	2101	+ // code block based on the high-order bit set in
	2102	+ // leadingDigit. Given leadingOnePosition,
	2103	+
	2104	+ // significand \|= leadingDigit << (SIGNIFICAND_WIDTH - leadingOnePosition);
	2105	+ // nextShift = 52 - (3 + leadingOnePosition);
	2106	+ // exponent += (leadingOnePosition-1);
	2107	+
	2108	+
	2109	+ /*
	2110	+ * Now the exponent variable is equal to the normalized
	2111	+ * binary exponent. Code below will make representation
	2112	+ * adjustments if the exponent is incremented after
	2113	+ * rounding (includes overflows to infinity) or if the
	2114	+ * result is subnormal.
	2115	+ */
	2116	+
	2117	+ // Copy digit into significand until the significand can't
	2118	+ // hold another full hex digit or there are no more input
	2119	+ // hex digits.
	2120	+ int i = 0;
	2121	+ for(i = 1;
	2122	+ i < signifLength && nextShift >= 0;
	2123	+ i++) {
	2124	+ long currentDigit = getHexDigit(significandString, i);
	2125	+ significand \|= (currentDigit << nextShift);
	2126	+ nextShift-=4;
	2127	+ }
	2128	+
	2129	+ // After the above loop, the bulk of the string is copied.
	2130	+ // Now, we must copy any partial hex digits into the
	2131	+ // significand AND compute the round bit and start computing
	2132	+ // sticky bit.
	2133	+
	2134	+ if ( i < signifLength ) { // at least one hex input digit exists
	2135	+ long currentDigit = getHexDigit(significandString, i);
	2136	+
	2137	+ // from nextShift, figure out how many bits need
	2138	+ // to be copied, if any
	2139	+ switch(nextShift) { // must be negative
	2140	+ case -1:
	2141	+ // three bits need to be copied in; can
	2142	+ // set round bit
	2143	+ significand \|= ((currentDigit & 0xEL) >> 1);
	2144	+ round = (currentDigit & 0x1L) != 0L;
	2145	+ break;
	2146	+
	2147	+ case -2:
	2148	+ // two bits need to be copied in; can
	2149	+ // set round and start sticky
	2150	+ significand \|= ((currentDigit & 0xCL) >> 2);
	2151	+ round = (currentDigit &0x2L) != 0L;
	2152	+ sticky = (currentDigit & 0x1L) != 0;
	2153	+ break;
	2154	+
	2155	+ case -3:
	2156	+ // one bit needs to be copied in
	2157	+ significand \|= ((currentDigit & 0x8L)>>3);
	2158	+ // Now set round and start sticky, if possible
	2159	+ round = (currentDigit &0x4L) != 0L;
	2160	+ sticky = (currentDigit & 0x3L) != 0;
	2161	+ break;
	2162	+
	2163	+ case -4:
	2164	+ // all bits copied into significand; set
	2165	+ // round and start sticky
	2166	+ round = ((currentDigit & 0x8L) != 0); // is top bit set?
	2167	+ // nonzeros in three low order bits?
	2168	+ sticky = (currentDigit & 0x7L) != 0;
	2169	+ break;
	2170	+
	2171	+ default:
	2172	+ throw new AssertionError("Unexpected shift distance remainder.");
	2173	+ // break;
	2174	+ }
	2175	+
	2176	+ // Round is set; sticky might be set.
	2177	+
	2178	+ // For the sticky bit, it suffices to check the
	2179	+ // current digit and test for any nonzero digits in
	2180	+ // the remaining unprocessed input.
	2181	+ i++;
	2182	+ while(i < signifLength && !sticky) {
	2183	+ currentDigit = getHexDigit(significandString,i);
	2184	+ sticky = sticky \|\| (currentDigit != 0);
	2185	+ i++;
	2186	+ }
	2187	+
	2188	+ }
	2189	+ // else all of string was seen, round and sticky are
	2190	+ // correct as false.
	2191	+
	2192	+
	2193	+ // Check for overflow and update exponent accordingly.
	2194	+
	2195	+ if (exponent > DoubleConsts.MAX_EXPONENT) { // Infinite result
	2196	+ // overflow to properly signed infinity
	2197	+ return new FloatingDecimal(sign * Double.POSITIVE_INFINITY);
	2198	+ } else { // Finite return value
	2199	+ if (exponent <= DoubleConsts.MAX_EXPONENT && // (Usually) normal result
	2200	+ exponent >= DoubleConsts.MIN_EXPONENT) {
	2201	+
	2202	+ // The result returned in this block cannot be a
	2203	+ // zero or subnormal; however after the
	2204	+ // significand is adjusted from rounding, we could
	2205	+ // still overflow in infinity.
	2206	+
	2207	+ // AND exponent bits into significand; if the
	2208	+ // significand is incremented and overflows from
	2209	+ // rounding, this combination will update the
	2210	+ // exponent correctly, even in the case of
	2211	+ // Double.MAX_VALUE overflowing to infinity.
	2212	+
	2213	+ significand = (( ((long)exponent +
	2214	+ (long)DoubleConsts.EXP_BIAS) <<
	2215	+ (DoubleConsts.SIGNIFICAND_WIDTH-1))
	2216	+ & DoubleConsts.EXP_BIT_MASK) \|
	2217	+ (DoubleConsts.SIGNIF_BIT_MASK & significand);
	2218	+
	2219	+ } else { // Subnormal or zero
	2220	+ // (exponent < DoubleConsts.MIN_EXPONENT)
	2221	+
	2222	+ if (exponent < (DoubleConsts.MIN_SUB_EXPONENT -1 )) {
	2223	+ // No way to round back to nonzero value
	2224	+ // regardless of significand if the exponent is
	2225	+ // less than -1075.
	2226	+ return new FloatingDecimal(sign * 0.0);
	2227	+ } else { // -1075 <= exponent <= MIN_EXPONENT -1 = -1023
	2228	+ /*
	2229	+ * Find bit position to round to; recompute
	2230	+ * round and sticky bits, and shift
	2231	+ * significand right appropriately.
	2232	+ */
	2233	+
	2234	+ sticky = sticky \|\| round;
	2235	+ round = false;
	2236	+
	2237	+ // Number of bits of significand to preserve is
	2238	+ // exponent - abs_min_exp +1
	2239	+ // check:
	2240	+ // -1075 +1074 + 1 = 0
	2241	+ // -1023 +1074 + 1 = 52
	2242	+
	2243	+ int bitsDiscarded = 53 -
	2244	+ ((int)exponent - DoubleConsts.MIN_SUB_EXPONENT + 1);
	2245	+ assert bitsDiscarded >= 1 && bitsDiscarded <= 53;
	2246	+
	2247	+ // What to do here:
	2248	+ // First, isolate the new round bit
	2249	+ round = (significand & (1L << (bitsDiscarded -1))) != 0L;
	2250	+ if (bitsDiscarded > 1) {
	2251	+ // create mask to update sticky bits; low
	2252	+ // order bitsDiscarded bits should be 1
	2253	+ long mask = ~((~0L) << (bitsDiscarded -1));
	2254	+ sticky = sticky \|\| ((significand & mask) != 0L ) ;
	2255	+ }
	2256	+
	2257	+ // Now, discard the bits
	2258	+ significand = significand >> bitsDiscarded;
	2259	+
	2260	+ significand = (( ((long)(DoubleConsts.MIN_EXPONENT -1) + // subnorm exp.
	2261	+ (long)DoubleConsts.EXP_BIAS) <<
	2262	+ (DoubleConsts.SIGNIFICAND_WIDTH-1))
	2263	+ & DoubleConsts.EXP_BIT_MASK) \|
	2264	+ (DoubleConsts.SIGNIF_BIT_MASK & significand);
	2265	+ }
	2266	+ }
	2267	+
	2268	+ // The significand variable now contains the currently
	2269	+ // appropriate exponent bits too.
	2270	+
	2271	+ /*
	2272	+ * Determine if significand should be incremented;
	2273	+ * making this determination depends on the least
	2274	+ * significant bit and the round and sticky bits.
	2275	+ *
	2276	+ * Round to nearest even rounding table, adapted from
	2277	+ * table 4.7 in "Computer Arithmetic" by IsraelKoren.
	2278	+ * The digit to the left of the "decimal" point is the
	2279	+ * least significant bit, the digits to the right of
	2280	+ * the point are the round and sticky bits
	2281	+ *
	2282	+ * Number Round(x)
	2283	+ * x0.00 x0.
	2284	+ * x0.01 x0.
	2285	+ * x0.10 x0.
	2286	+ * x0.11 x1. = x0. +1
	2287	+ * x1.00 x1.
	2288	+ * x1.01 x1.
	2289	+ * x1.10 x1. + 1
	2290	+ * x1.11 x1. + 1
	2291	+ */
	2292	+ boolean incremented = false;
	2293	+ boolean leastZero = ((significand & 1L) == 0L);
	2294	+ if( ( leastZero && round && sticky ) \|\|
	2295	+ ((!leastZero) && round )) {
	2296	+ incremented = true;
	2297	+ significand++;
	2298	+ }
	2299	+
	2300	+ FloatingDecimal fd = new FloatingDecimal(FpUtils.rawCopySign(
	2301	+ Double.longBitsToDouble(significand),
	2302	+ sign));
	2303	+
	2304	+ /*
	2305	+ * Set roundingDir variable field of fd properly so
	2306	+ * that the input string can be properly rounded to a
	2307	+ * float value. There are two cases to consider:
	2308	+ *
	2309	+ * 1. rounding to double discards sticky bit
	2310	+ * information that would change the result of a float
	2311	+ * rounding (near halfway case between two floats)
	2312	+ *
	2313	+ * 2. rounding to double rounds up when rounding up
	2314	+ * would not occur when rounding to float.
	2315	+ *
	2316	+ * For former case only needs to be considered when
	2317	+ * the bits rounded away when casting to float are all
	2318	+ * zero; otherwise, float round bit is properly set
	2319	+ * and sticky will already be true.
	2320	+ *
	2321	+ * The lower exponent bound for the code below is the
	2322	+ * minimum (normalized) subnormal exponent - 1 since a
	2323	+ * value with that exponent can round up to the
	2324	+ * minimum subnormal value and the sticky bit
	2325	+ * information must be preserved (i.e. case 1).
	2326	+ */
	2327	+ if ((exponent >= FloatConsts.MIN_SUB_EXPONENT-1) &&
	2328	+ (exponent <= FloatConsts.MAX_EXPONENT ) ){
	2329	+ // Outside above exponent range, the float value
	2330	+ // will be zero or infinity.
	2331	+
	2332	+ /*
	2333	+ * If the low-order 28 bits of a rounded double
	2334	+ * significand are 0, the double could be a
	2335	+ * half-way case for a rounding to float. If the
	2336	+ * double value is a half-way case, the double
	2337	+ * significand may have to be modified to round
	2338	+ * the the right float value (see the stickyRound
	2339	+ * method). If the rounding to double has lost
	2340	+ * what would be float sticky bit information, the
	2341	+ * double significand must be incremented. If the
	2342	+ * double value's significand was itself
	2343	+ * incremented, the float value may end up too
	2344	+ * large so the increment should be undone.
	2345	+ */
	2346	+ if ((significand & 0xfffffffL) == 0x0L) {
	2347	+ // For negative values, the sign of the
	2348	+ // roundDir is the same as for positive values
	2349	+ // since adding 1 increasing the significand's
	2350	+ // magnitude and subtracting 1 decreases the
	2351	+ // significand's magnitude. If neither round
	2352	+ // nor sticky is true, the double value is
	2353	+ // exact and no adjustment is required for a
	2354	+ // proper float rounding.
	2355	+ if( round \|\| sticky) {
	2356	+ if (leastZero) { // prerounding lsb is 0
	2357	+ // If round and sticky were both true,
	2358	+ // and the least significant
	2359	+ // significand bit were 0, the rounded
	2360	+ // significand would not have its
	2361	+ // low-order bits be zero. Therefore,
	2362	+ // we only need to adjust the
	2363	+ // significand if round XOR sticky is
	2364	+ // true.
	2365	+ if (round ^ sticky) {
	2366	+ fd.roundDir = 1;
	2367	+ }
	2368	+ }
	2369	+ else { // prerounding lsb is 1
	2370	+ // If the prerounding lsb is 1 and the
	2371	+ // resulting significand has its
	2372	+ // low-order bits zero, the significand
	2373	+ // was incremented. Here, we undo the
	2374	+ // increment, which will ensure the
	2375	+ // right guard and sticky bits for the
	2376	+ // float rounding.
	2377	+ if (round)
	2378	+ fd.roundDir = -1;
	2379	+ }
	2380	+ }
	2381	+ }
	2382	+ }
	2383	+
	2384	+ fd.fromHex = true;
	2385	+ return fd;
	2386	+ }
	2387	+ }
	2388	+ }
	2389	+
	2390	+ /**
	2391	+ * Return <code>s</code> with any leading zeros removed.
	2392	+ */
	2393	+ static String stripLeadingZeros(String s) {
	2394	+ return s.replaceFirst("^0+", "");
	2395	+ }
	2396	+
	2397	+ /**
	2398	+ * Extract a hexadecimal digit from position <code>position</code>
	2399	+ * of string <code>s</code>.
	2400	+ */
	2401	+ static int getHexDigit(String s, int position) {
	2402	+ int value = Character.digit(s.charAt(position), 16);
	2403	+ if (value <= -1 \|\| value >= 16) {
	2404	+ throw new AssertionError("Unexpected failure of digit conversion of " +
	2405	+ s.charAt(position));
	2406	+ }
	2407	+ return value;
	2408	+ }
	2409	+
	2410	+
	2411	+}
	2412	+
	2413	+/*
	2414	+ * A really, really simple bigint package
	2415	+ * tailored to the needs of floating base conversion.
	2416	+ */
	2417	+class FDBigInt {
	2418	+ int nWords; // number of words used
	2419	+ int data[]; // value: data[0] is least significant
	2420	+
	2421	+
	2422	+ public FDBigInt( int v ){
	2423	+ nWords = 1;
	2424	+ data = new int[1];
	2425	+ data[0] = v;
	2426	+ }
	2427	+
	2428	+ public FDBigInt( long v ){
	2429	+ data = new int[2];
	2430	+ data[0] = (int)v;
	2431	+ data[1] = (int)(v>>>32);
	2432	+ nWords = (data[1]==0) ? 1 : 2;
	2433	+ }
	2434	+
	2435	+ public FDBigInt( FDBigInt other ){
	2436	+ data = new int[nWords = other.nWords];
	2437	+ System.arraycopy( other.data, 0, data, 0, nWords );
	2438	+ }
	2439	+
	2440	+ private FDBigInt( int [] d, int n ){
	2441	+ data = d;
	2442	+ nWords = n;
	2443	+ }
	2444	+
	2445	+ public FDBigInt( long seed, char digit[], int nd0, int nd ){
	2446	+ int n= (nd+8)/9; // estimate size needed.
	2447	+ if ( n < 2 ) n = 2;
	2448	+ data = new int[n]; // allocate enough space
	2449	+ data[0] = (int)seed; // starting value
	2450	+ data[1] = (int)(seed>>>32);
	2451	+ nWords = (data[1]==0) ? 1 : 2;
	2452	+ int i = nd0;
	2453	+ int limit = nd-5; // slurp digits 5 at a time.
	2454	+ int v;
	2455	+ while ( i < limit ){
	2456	+ int ilim = i+5;
	2457	+ v = (int)digit[i++]-(int)'0';
	2458	+ while( i <ilim ){
	2459	+ v = 10*v + (int)digit[i++]-(int)'0';
	2460	+ }
	2461	+ multaddMe( 100000, v); // ... where 100000 is 10^5.
	2462	+ }
	2463	+ int factor = 1;
	2464	+ v = 0;
	2465	+ while ( i < nd ){
	2466	+ v = 10*v + (int)digit[i++]-(int)'0';
	2467	+ factor *= 10;
	2468	+ }
	2469	+ if ( factor != 1 ){
	2470	+ multaddMe( factor, v );
	2471	+ }
	2472	+ }
	2473	+
	2474	+ /*
	2475	+ * Left shift by c bits.
	2476	+ * Shifts this in place.
	2477	+ */
	2478	+ public void
	2479	+ lshiftMe( int c )throws IllegalArgumentException {
	2480	+ if ( c <= 0 ){
	2481	+ if ( c == 0 )
	2482	+ return; // silly.
	2483	+ else
	2484	+ throw new IllegalArgumentException("negative shift count");
	2485	+ }
	2486	+ int wordcount = c>>5;
	2487	+ int bitcount = c & 0x1f;
	2488	+ int anticount = 32-bitcount;
	2489	+ int t[] = data;
	2490	+ int s[] = data;
	2491	+ if ( nWords+wordcount+1 > t.length ){
	2492	+ // reallocate.
	2493	+ t = new int[ nWords+wordcount+1 ];
	2494	+ }
	2495	+ int target = nWords+wordcount;
	2496	+ int src = nWords-1;
	2497	+ if ( bitcount == 0 ){
	2498	+ // special hack, since an anticount of 32 won't go!
	2499	+ System.arraycopy( s, 0, t, wordcount, nWords );
	2500	+ target = wordcount-1;
	2501	+ } else {
	2502	+ t[target--] = s[src]>>>anticount;
	2503	+ while ( src >= 1 ){
	2504	+ t[target--] = (s[src]<<bitcount) \| (s[--src]>>>anticount);
	2505	+ }
	2506	+ t[target--] = s[src]<<bitcount;
	2507	+ }
	2508	+ while( target >= 0 ){
	2509	+ t[target--] = 0;
	2510	+ }
	2511	+ data = t;
	2512	+ nWords += wordcount + 1;
	2513	+ // may have constructed high-order word of 0.
	2514	+ // if so, trim it
	2515	+ while ( nWords > 1 && data[nWords-1] == 0 )
	2516	+ nWords--;
	2517	+ }
	2518	+
	2519	+ /*
	2520	+ * normalize this number by shifting until
	2521	+ * the MSB of the number is at 0x08000000.
	2522	+ * This is in preparation for quoRemIteration, below.
	2523	+ * The idea is that, to make division easier, we want the
	2524	+ * divisor to be "normalized" -- usually this means shifting
	2525	+ * the MSB into the high words sign bit. But because we know that
	2526	+ * the quotient will be 0 < q < 10, we would like to arrange that
	2527	+ * the dividend not span up into another word of precision.
	2528	+ * (This needs to be explained more clearly!)
	2529	+ */
	2530	+ public int
	2531	+ normalizeMe() throws IllegalArgumentException {
	2532	+ int src;
	2533	+ int wordcount = 0;
	2534	+ int bitcount = 0;
	2535	+ int v = 0;
	2536	+ for ( src= nWords-1 ; src >= 0 && (v=data[src]) == 0 ; src--){
	2537	+ wordcount += 1;
	2538	+ }
	2539	+ if ( src < 0 ){
	2540	+ // oops. Value is zero. Cannot normalize it!
	2541	+ throw new IllegalArgumentException("zero value");
	2542	+ }
	2543	+ /*
	2544	+ * In most cases, we assume that wordcount is zero. This only
	2545	+ * makes sense, as we try not to maintain any high-order
	2546	+ * words full of zeros. In fact, if there are zeros, we will
	2547	+ * simply SHORTEN our number at this point. Watch closely...
	2548	+ */
	2549	+ nWords -= wordcount;
	2550	+ /*
	2551	+ * Compute how far left we have to shift v s.t. its highest-
	2552	+ * order bit is in the right place. Then call lshiftMe to
	2553	+ * do the work.
	2554	+ */
	2555	+ if ( (v & 0xf0000000) != 0 ){
	2556	+ // will have to shift up into the next word.
	2557	+ // too bad.
	2558	+ for( bitcount = 32 ; (v & 0xf0000000) != 0 ; bitcount-- )
	2559	+ v >>>= 1;
	2560	+ } else {
	2561	+ while ( v <= 0x000fffff ){
	2562	+ // hack: byte-at-a-time shifting
	2563	+ v <<= 8;
	2564	+ bitcount += 8;
	2565	+ }
	2566	+ while ( v <= 0x07ffffff ){
	2567	+ v <<= 1;
	2568	+ bitcount += 1;
	2569	+ }
	2570	+ }
	2571	+ if ( bitcount != 0 )
	2572	+ lshiftMe( bitcount );
	2573	+ return bitcount;
	2574	+ }
	2575	+
	2576	+ /*
	2577	+ * Multiply a FDBigInt by an int.
	2578	+ * Result is a new FDBigInt.
	2579	+ */
	2580	+ public FDBigInt
	2581	+ mult( int iv ) {
	2582	+ long v = iv;
	2583	+ int r[];
	2584	+ long p;
	2585	+
	2586	+ // guess adequate size of r.
	2587	+ r = new int[ ( v * ((long)data[nWords-1]&0xffffffffL) > 0xfffffffL ) ? nWords+1 : nWords ];
	2588	+ p = 0L;
	2589	+ for( int i=0; i < nWords; i++ ) {
	2590	+ p += v * ((long)data[i]&0xffffffffL);
	2591	+ r[i] = (int)p;
	2592	+ p >>>= 32;
	2593	+ }
	2594	+ if ( p == 0L){
	2595	+ return new FDBigInt( r, nWords );
	2596	+ } else {
	2597	+ r[nWords] = (int)p;
	2598	+ return new FDBigInt( r, nWords+1 );
	2599	+ }
	2600	+ }
	2601	+
	2602	+ /*
	2603	+ * Multiply a FDBigInt by an int and add another int.
	2604	+ * Result is computed in place.
	2605	+ * Hope it fits!
	2606	+ */
	2607	+ public void
	2608	+ multaddMe( int iv, int addend ) {
	2609	+ long v = iv;
	2610	+ long p;
	2611	+
	2612	+ // unroll 0th iteration, doing addition.
	2613	+ p = v * ((long)data[0]&0xffffffffL) + ((long)addend&0xffffffffL);
	2614	+ data[0] = (int)p;
	2615	+ p >>>= 32;
	2616	+ for( int i=1; i < nWords; i++ ) {
	2617	+ p += v * ((long)data[i]&0xffffffffL);
	2618	+ data[i] = (int)p;
	2619	+ p >>>= 32;
	2620	+ }
	2621	+ if ( p != 0L){
	2622	+ data[nWords] = (int)p; // will fail noisily if illegal!
	2623	+ nWords++;
	2624	+ }
	2625	+ }
	2626	+
	2627	+ /*
	2628	+ * Multiply a FDBigInt by another FDBigInt.
	2629	+ * Result is a new FDBigInt.
	2630	+ */
	2631	+ public FDBigInt
	2632	+ mult( FDBigInt other ){
	2633	+ // crudely guess adequate size for r
	2634	+ int r[] = new int[ nWords + other.nWords ];
	2635	+ int i;
	2636	+ // I think I am promised zeros...
	2637	+
	2638	+ for( i = 0; i < this.nWords; i++ ){
	2639	+ long v = (long)this.data[i] & 0xffffffffL; // UNSIGNED CONVERSION
	2640	+ long p = 0L;
	2641	+ int j;
	2642	+ for( j = 0; j < other.nWords; j++ ){
	2643	+ p += ((long)r[i+j]&0xffffffffL) + v*((long)other.data[j]&0xffffffffL); // UNSIGNED CONVERSIONS ALL 'ROUND.
	2644	+ r[i+j] = (int)p;
	2645	+ p >>>= 32;
	2646	+ }
	2647	+ r[i+j] = (int)p;
	2648	+ }
	2649	+ // compute how much of r we actually needed for all that.
	2650	+ for ( i = r.length-1; i> 0; i--)
	2651	+ if ( r[i] != 0 )
	2652	+ break;
	2653	+ return new FDBigInt( r, i+1 );
	2654	+ }
	2655	+
	2656	+ /*
	2657	+ * Add one FDBigInt to another. Return a FDBigInt
	2658	+ */
	2659	+ public FDBigInt
	2660	+ add( FDBigInt other ){
	2661	+ int i;
	2662	+ int a[], b[];
	2663	+ int n, m;
	2664	+ long c = 0L;
	2665	+ // arrange such that a.nWords >= b.nWords;
	2666	+ // n = a.nWords, m = b.nWords
	2667	+ if ( this.nWords >= other.nWords ){
	2668	+ a = this.data;
	2669	+ n = this.nWords;
	2670	+ b = other.data;
	2671	+ m = other.nWords;
	2672	+ } else {
	2673	+ a = other.data;
	2674	+ n = other.nWords;
	2675	+ b = this.data;
	2676	+ m = this.nWords;
	2677	+ }
	2678	+ int r[] = new int[ n ];
	2679	+ for ( i = 0; i < n; i++ ){
	2680	+ c += (long)a[i] & 0xffffffffL;
	2681	+ if ( i < m ){
	2682	+ c += (long)b[i] & 0xffffffffL;
	2683	+ }
	2684	+ r[i] = (int) c;
	2685	+ c >>= 32; // signed shift.
	2686	+ }
	2687	+ if ( c != 0L ){
	2688	+ // oops -- carry out -- need longer result.
	2689	+ int s[] = new int[ r.length+1 ];
	2690	+ System.arraycopy( r, 0, s, 0, r.length );
	2691	+ s[i++] = (int)c;
	2692	+ return new FDBigInt( s, i );
	2693	+ }
	2694	+ return new FDBigInt( r, i );
	2695	+ }
	2696	+
	2697	+ /*
	2698	+ * Subtract one FDBigInt from another. Return a FDBigInt
	2699	+ * Assert that the result is positive.
	2700	+ */
	2701	+ public FDBigInt
	2702	+ sub( FDBigInt other ){
	2703	+ int r[] = new int[ this.nWords ];
	2704	+ int i;
	2705	+ int n = this.nWords;
	2706	+ int m = other.nWords;
	2707	+ int nzeros = 0;
	2708	+ long c = 0L;
	2709	+ for ( i = 0; i < n; i++ ){
	2710	+ c += (long)this.data[i] & 0xffffffffL;
	2711	+ if ( i < m ){
	2712	+ c -= (long)other.data[i] & 0xffffffffL;
	2713	+ }
	2714	+ if ( ( r[i] = (int) c ) == 0 )
	2715	+ nzeros++;
	2716	+ else
	2717	+ nzeros = 0;
	2718	+ c >>= 32; // signed shift
	2719	+ }
	2720	+ assert c == 0L : c; // borrow out of subtract
	2721	+ assert dataInRangeIsZero(i, m, other); // negative result of subtract
	2722	+ return new FDBigInt( r, n-nzeros );
	2723	+ }
	2724	+
	2725	+ private static boolean dataInRangeIsZero(int i, int m, FDBigInt other) {
	2726	+ while ( i < m )
	2727	+ if (other.data[i++] != 0)
	2728	+ return false;
	2729	+ return true;
	2730	+ }
	2731	+
	2732	+ /*
	2733	+ * Compare FDBigInt with another FDBigInt. Return an integer
	2734	+ * >0: this > other
	2735	+ * 0: this == other
	2736	+ * <0: this < other
	2737	+ */
	2738	+ public int
	2739	+ cmp( FDBigInt other ){
	2740	+ int i;
	2741	+ if ( this.nWords > other.nWords ){
	2742	+ // if any of my high-order words is non-zero,
	2743	+ // then the answer is evident
	2744	+ int j = other.nWords-1;
	2745	+ for ( i = this.nWords-1; i > j ; i-- )
	2746	+ if ( this.data[i] != 0 ) return 1;
	2747	+ }else if ( this.nWords < other.nWords ){
	2748	+ // if any of other's high-order words is non-zero,
	2749	+ // then the answer is evident
	2750	+ int j = this.nWords-1;
	2751	+ for ( i = other.nWords-1; i > j ; i-- )
	2752	+ if ( other.data[i] != 0 ) return -1;
	2753	+ } else{
	2754	+ i = this.nWords-1;
	2755	+ }
	2756	+ for ( ; i > 0 ; i-- )
	2757	+ if ( this.data[i] != other.data[i] )
	2758	+ break;
	2759	+ // careful! want unsigned compare!
	2760	+ // use brute force here.
	2761	+ int a = this.data[i];
	2762	+ int b = other.data[i];
	2763	+ if ( a < 0 ){
	2764	+ // a is really big, unsigned
	2765	+ if ( b < 0 ){
	2766	+ return a-b; // both big, negative
	2767	+ } else {
	2768	+ return 1; // b not big, answer is obvious;
	2769	+ }
	2770	+ } else {
	2771	+ // a is not really big
	2772	+ if ( b < 0 ) {
	2773	+ // but b is really big
	2774	+ return -1;
	2775	+ } else {
	2776	+ return a - b;
	2777	+ }
	2778	+ }
	2779	+ }
	2780	+
	2781	+ /*
	2782	+ * Compute
	2783	+ * q = (int)( this / S )
	2784	+ * this = 10 * ( this mod S )
	2785	+ * Return q.
	2786	+ * This is the iteration step of digit development for output.
	2787	+ * We assume that S has been normalized, as above, and that
	2788	+ * "this" has been lshift'ed accordingly.
	2789	+ * Also assume, of course, that the result, q, can be expressed
	2790	+ * as an integer, 0 <= q < 10.
	2791	+ */
	2792	+ public int
	2793	+ quoRemIteration( FDBigInt S )throws IllegalArgumentException {
	2794	+ // ensure that this and S have the same number of
	2795	+ // digits. If S is properly normalized and q < 10 then
	2796	+ // this must be so.
	2797	+ if ( nWords != S.nWords ){
	2798	+ throw new IllegalArgumentException("disparate values");
	2799	+ }
	2800	+ // estimate q the obvious way. We will usually be
	2801	+ // right. If not, then we're only off by a little and
	2802	+ // will re-add.
	2803	+ int n = nWords-1;
	2804	+ long q = ((long)data[n]&0xffffffffL) / (long)S.data[n];
	2805	+ long diff = 0L;
	2806	+ for ( int i = 0; i <= n ; i++ ){
	2807	+ diff += ((long)data[i]&0xffffffffL) - q*((long)S.data[i]&0xffffffffL);
	2808	+ data[i] = (int)diff;
	2809	+ diff >>= 32; // N.B. SIGNED shift.
	2810	+ }
	2811	+ if ( diff != 0L ) {
	2812	+ // damn, damn, damn. q is too big.
	2813	+ // add S back in until this turns +. This should
	2814	+ // not be very many times!
	2815	+ long sum = 0L;
	2816	+ while ( sum == 0L ){
	2817	+ sum = 0L;
	2818	+ for ( int i = 0; i <= n; i++ ){
	2819	+ sum += ((long)data[i]&0xffffffffL) + ((long)S.data[i]&0xffffffffL);
	2820	+ data[i] = (int) sum;
	2821	+ sum >>= 32; // Signed or unsigned, answer is 0 or 1
	2822	+ }
	2823	+ /*
	2824	+ * Originally the following line read
	2825	+ * "if ( sum !=0 && sum != -1 )"
	2826	+ * but that would be wrong, because of the
	2827	+ * treatment of the two values as entirely unsigned,
	2828	+ * it would be impossible for a carry-out to be interpreted
	2829	+ * as -1 -- it would have to be a single-bit carry-out, or
	2830	+ * +1.
	2831	+ */
	2832	+ assert sum == 0 \|\| sum == 1 : sum; // carry out of division correction
	2833	+ q -= 1;
	2834	+ }
	2835	+ }
	2836	+ // finally, we can multiply this by 10.
	2837	+ // it cannot overflow, right, as the high-order word has
	2838	+ // at least 4 high-order zeros!
	2839	+ long p = 0L;
	2840	+ for ( int i = 0; i <= n; i++ ){
	2841	+ p += 10*((long)data[i]&0xffffffffL);
	2842	+ data[i] = (int)p;
	2843	+ p >>= 32; // SIGNED shift.
	2844	+ }
	2845	+ assert p == 0L : p; // Carry out of *10
	2846	+ return (int)q;
	2847	+ }
	2848	+
	2849	+ public long
	2850	+ longValue(){
	2851	+ // if this can be represented as a long, return the value
	2852	+ assert this.nWords > 0 : this.nWords; // longValue confused
	2853	+
	2854	+ if (this.nWords == 1)
	2855	+ return ((long)data[0]&0xffffffffL);
	2856	+
	2857	+ assert dataInRangeIsZero(2, this.nWords, this); // value too big
	2858	+ assert data[1] >= 0; // value too big
	2859	+ return ((long)(data[1]) << 32) \| ((long)data[0]&0xffffffffL);
	2860	+ }
	2861	+
	2862	+ public String
	2863	+ toString() {
	2864	+ StringBuffer r = new StringBuffer(30);
	2865	+ r.append('[');
	2866	+ int i = Math.min( nWords-1, data.length-1) ;
	2867	+ if ( nWords > data.length ){
	2868	+ r.append( "("+data.length+"<"+nWords+"!)" );
	2869	+ }
	2870	+ for( ; i> 0 ; i-- ){
	2871	+ r.append( Integer.toHexString( data[i] ) );
	2872	+ r.append(' ');
	2873	+ }
	2874	+ r.append( Integer.toHexString( data[0] ) );
	2875	+ r.append(']');
	2876	+ return new String( r );
	2877	+ }
	2878	+}