1 /*

     2  * Copyright (c) 1996, 2013, 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.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 //package sun.misc;

    25 

    26 import java.util.regex.*;

    27 

    28 public class OldFloatingDecimalForTest{

    29     boolean     isExceptional;

    30     boolean     isNegative;

    31     int         decExponent;

    32     char        digits[];

    33     int         nDigits;

    34     int         bigIntExp;

    35     int         bigIntNBits;

    36     boolean     mustSetRoundDir = false;

    37     boolean     fromHex = false;

    38     int         roundDir = 0; // set by doubleValue

    39 

    40     /*

    41      * The fields below provides additional information about the result of

    42      * the binary to decimal digits conversion done in dtoa() and roundup()

    43      * methods. They are changed if needed by those two methods.

    44      */

    45 

    46     // True if the dtoa() binary to decimal conversion was exact.

    47     boolean     exactDecimalConversion = false;

    48 

    49     // True if the result of the binary to decimal conversion was rounded-up

    50     // at the end of the conversion process, i.e. roundUp() method was called.

    51     boolean     decimalDigitsRoundedUp = false;

    52 

    53     private     OldFloatingDecimalForTest( boolean negSign, int decExponent, char []digits, int n,  boolean e )

    54     {

    55         isNegative = negSign;

    56         isExceptional = e;

    57         this.decExponent = decExponent;

    58         this.digits = digits;

    59         this.nDigits = n;

    60     }

    61 

    62     /*

    63      * Constants of the implementation

    64      * Most are IEEE-754 related.

    65      * (There are more really boring constants at the end.)

    66      */

    67     static final long   signMask = 0x8000000000000000L;

    68     static final long   expMask  = 0x7ff0000000000000L;

    69     static final long   fractMask= ~(signMask|expMask);

    70     static final int    expShift = 52;

    71     static final int    expBias  = 1023;

    72     static final long   fractHOB = ( 1L<<expShift ); // assumed High-Order bit

    73     static final long   expOne   = ((long)expBias)<<expShift; // exponent of 1.0

    74     static final int    maxSmallBinExp = 62;

    75     static final int    minSmallBinExp = -( 63 / 3 );

    76     static final int    maxDecimalDigits = 15;

    77     static final int    maxDecimalExponent = 308;

    78     static final int    minDecimalExponent = -324;

    79     static final int    bigDecimalExponent = 324; // i.e. abs(minDecimalExponent)

    80 

    81     static final long   highbyte = 0xff00000000000000L;

    82     static final long   highbit  = 0x8000000000000000L;

    83     static final long   lowbytes = ~highbyte;

    84 

    85     static final int    singleSignMask =    0x80000000;

    86     static final int    singleExpMask  =    0x7f800000;

    87     static final int    singleFractMask =   ~(singleSignMask|singleExpMask);

    88     static final int    singleExpShift  =   23;

    89     static final int    singleFractHOB  =   1<<singleExpShift;

    90     static final int    singleExpBias   =   127;

    91     static final int    singleMaxDecimalDigits = 7;

    92     static final int    singleMaxDecimalExponent = 38;

    93     static final int    singleMinDecimalExponent = -45;

    94 

    95     static final int    intDecimalDigits = 9;

    96 

    97 

    98     /*

    99      * count number of bits from high-order 1 bit to low-order 1 bit,

   100      * inclusive.

   101      */

   102     private static int

   103     countBits( long v ){

   104         //

   105         // the strategy is to shift until we get a non-zero sign bit

   106         // then shift until we have no bits left, counting the difference.

   107         // we do byte shifting as a hack. Hope it helps.

   108         //

   109         if ( v == 0L ) return 0;

   110 

   111         while ( ( v & highbyte ) == 0L ){

   112             v <<= 8;

   113         }

   114         while ( v > 0L ) { // i.e. while ((v&highbit) == 0L )

   115             v <<= 1;

   116         }

   117 

   118         int n = 0;

   119         while (( v & lowbytes ) != 0L ){

   120             v <<= 8;

   121             n += 8;

   122         }

   123         while ( v != 0L ){

   124             v <<= 1;

   125             n += 1;

   126         }

   127         return n;

   128     }

   129 

   130     /*

   131      * Keep big powers of 5 handy for future reference.

   132      */

   133     private static OldFDBigIntForTest b5p[];

   134 

   135     private static synchronized OldFDBigIntForTest

   136     big5pow( int p ){

   137         assert p >= 0 : p; // negative power of 5

   138         if ( b5p == null ){

   139             b5p = new OldFDBigIntForTest[ p+1 ];

   140         }else if (b5p.length <= p ){

   141             OldFDBigIntForTest t[] = new OldFDBigIntForTest[ p+1 ];

   142             System.arraycopy( b5p, 0, t, 0, b5p.length );

   143             b5p = t;

   144         }

   145         if ( b5p[p] != null )

   146             return b5p[p];

   147         else if ( p < small5pow.length )

   148             return b5p[p] = new OldFDBigIntForTest( small5pow[p] );

   149         else if ( p < long5pow.length )

   150             return b5p[p] = new OldFDBigIntForTest( long5pow[p] );

   151         else {

   152             // construct the value.

   153             // recursively.

   154             int q, r;

   155             // in order to compute 5^p,

   156             // compute its square root, 5^(p/2) and square.

   157             // or, let q = p / 2, r = p -q, then

   158             // 5^p = 5^(q+r) = 5^q * 5^r

   159             q = p >> 1;

   160             r = p - q;

   161             OldFDBigIntForTest bigq =  b5p[q];

   162             if ( bigq == null )

   163                 bigq = big5pow ( q );

   164             if ( r < small5pow.length ){

   165                 return (b5p[p] = bigq.mult( small5pow[r] ) );

   166             }else{

   167                 OldFDBigIntForTest bigr = b5p[ r ];

   168                 if ( bigr == null )

   169                     bigr = big5pow( r );

   170                 return (b5p[p] = bigq.mult( bigr ) );

   171             }

   172         }

   173     }

   174 

   175     //

   176     // a common operation

   177     //

   178     private static OldFDBigIntForTest

   179     multPow52( OldFDBigIntForTest v, int p5, int p2 ){

   180         if ( p5 != 0 ){

   181             if ( p5 < small5pow.length ){

   182                 v = v.mult( small5pow[p5] );

   183             } else {

   184                 v = v.mult( big5pow( p5 ) );

   185             }

   186         }

   187         if ( p2 != 0 ){

   188             v.lshiftMe( p2 );

   189         }

   190         return v;

   191     }

   192 

   193     //

   194     // another common operation

   195     //

   196     private static OldFDBigIntForTest

   197     constructPow52( int p5, int p2 ){

   198         OldFDBigIntForTest v = new OldFDBigIntForTest( big5pow( p5 ) );

   199         if ( p2 != 0 ){

   200             v.lshiftMe( p2 );

   201         }

   202         return v;

   203     }

   204 

   205     /*

   206      * Make a floating double into a OldFDBigIntForTest.

   207      * This could also be structured as a OldFDBigIntForTest

   208      * constructor, but we'd have to build a lot of knowledge

   209      * about floating-point representation into it, and we don't want to.

   210      *

   211      * AS A SIDE EFFECT, THIS METHOD WILL SET THE INSTANCE VARIABLES

   212      * bigIntExp and bigIntNBits

   213      *

   214      */

   215     private OldFDBigIntForTest

   216     doubleToBigInt( double dval ){

   217         long lbits = Double.doubleToLongBits( dval ) & ~signMask;

   218         int binexp = (int)(lbits >>> expShift);

   219         lbits &= fractMask;

   220         if ( binexp > 0 ){

   221             lbits |= fractHOB;

   222         } else {

   223             assert lbits != 0L : lbits; // doubleToBigInt(0.0)

   224             binexp +=1;

   225             while ( (lbits & fractHOB ) == 0L){

   226                 lbits <<= 1;

   227                 binexp -= 1;

   228             }

   229         }

   230         binexp -= expBias;

   231         int nbits = countBits( lbits );

   232         /*

   233          * We now know where the high-order 1 bit is,

   234          * and we know how many there are.

   235          */

   236         int lowOrderZeros = expShift+1-nbits;

   237         lbits >>>= lowOrderZeros;

   238 

   239         bigIntExp = binexp+1-nbits;

   240         bigIntNBits = nbits;

   241         return new OldFDBigIntForTest( lbits );

   242     }

   243 

   244     /*

   245      * Compute a number that is the ULP of the given value,

   246      * for purposes of addition/subtraction. Generally easy.

   247      * More difficult if subtracting and the argument

   248      * is a normalized a power of 2, as the ULP changes at these points.

   249      */

   250     private static double ulp( double dval, boolean subtracting ){

   251         long lbits = Double.doubleToLongBits( dval ) & ~signMask;

   252         int binexp = (int)(lbits >>> expShift);

   253         double ulpval;

   254         if ( subtracting && ( binexp >= expShift ) && ((lbits&fractMask) == 0L) ){

   255             // for subtraction from normalized, powers of 2,

   256             // use next-smaller exponent

   257             binexp -= 1;

   258         }

   259         if ( binexp > expShift ){

   260             ulpval = Double.longBitsToDouble( ((long)(binexp-expShift))<<expShift );

   261         } else if ( binexp == 0 ){

   262             ulpval = Double.MIN_VALUE;

   263         } else {

   264             ulpval = Double.longBitsToDouble( 1L<<(binexp-1) );

   265         }

   266         if ( subtracting ) ulpval = - ulpval;

   267 

   268         return ulpval;

   269     }

   270 

   271     /*

   272      * Round a double to a float.

   273      * In addition to the fraction bits of the double,

   274      * look at the class instance variable roundDir,

   275      * which should help us avoid double-rounding error.

   276      * roundDir was set in hardValueOf if the estimate was

   277      * close enough, but not exact. It tells us which direction

   278      * of rounding is preferred.

   279      */

   280     float

   281     stickyRound( double dval ){

   282         long lbits = Double.doubleToLongBits( dval );

   283         long binexp = lbits & expMask;

   284         if ( binexp == 0L || binexp == expMask ){

   285             // what we have here is special.

   286             // don't worry, the right thing will happen.

   287             return (float) dval;

   288         }

   289         lbits += (long)roundDir; // hack-o-matic.

   290         return (float)Double.longBitsToDouble( lbits );

   291     }

   292 

   293 

   294     /*

   295      * This is the easy subcase --

   296      * all the significant bits, after scaling, are held in lvalue.

   297      * negSign and decExponent tell us what processing and scaling

   298      * has already been done. Exceptional cases have already been

   299      * stripped out.

   300      * In particular:

   301      * lvalue is a finite number (not Inf, nor NaN)

   302      * lvalue > 0L (not zero, nor negative).

   303      *

   304      * The only reason that we develop the digits here, rather than

   305      * calling on Long.toString() is that we can do it a little faster,

   306      * and besides want to treat trailing 0s specially. If Long.toString

   307      * changes, we should re-evaluate this strategy!

   308      */

   309     private void

   310     developLongDigits( int decExponent, long lvalue, long insignificant ){

   311         char digits[];

   312         int  ndigits;

   313         int  digitno;

   314         int  c;

   315         //

   316         // Discard non-significant low-order bits, while rounding,

   317         // up to insignificant value.

   318         int i;

   319         for ( i = 0; insignificant >= 10L; i++ )

   320             insignificant /= 10L;

   321         if ( i != 0 ){

   322             long pow10 = long5pow[i] << i; // 10^i == 5^i * 2^i;

   323             long residue = lvalue % pow10;

   324             lvalue /= pow10;

   325             decExponent += i;

   326             if ( residue >= (pow10>>1) ){

   327                 // round up based on the low-order bits we're discarding

   328                 lvalue++;

   329             }

   330         }

   331         if ( lvalue <= Integer.MAX_VALUE ){

   332             assert lvalue > 0L : lvalue; // lvalue <= 0

   333             // even easier subcase!

   334             // can do int arithmetic rather than long!

   335             int  ivalue = (int)lvalue;

   336             ndigits = 10;

   337             digits = perThreadBuffer.get();

   338             digitno = ndigits-1;

   339             c = ivalue%10;

   340             ivalue /= 10;

   341             while ( c == 0 ){

   342                 decExponent++;

   343                 c = ivalue%10;

   344                 ivalue /= 10;

   345             }

   346             while ( ivalue != 0){

   347                 digits[digitno--] = (char)(c+'0');

   348                 decExponent++;

   349                 c = ivalue%10;

   350                 ivalue /= 10;

   351             }

   352             digits[digitno] = (char)(c+'0');

   353         } else {

   354             // same algorithm as above (same bugs, too )

   355             // but using long arithmetic.

   356             ndigits = 20;

   357             digits = perThreadBuffer.get();

   358             digitno = ndigits-1;

   359             c = (int)(lvalue%10L);

   360             lvalue /= 10L;

   361             while ( c == 0 ){

   362                 decExponent++;

   363                 c = (int)(lvalue%10L);

   364                 lvalue /= 10L;

   365             }

   366             while ( lvalue != 0L ){

   367                 digits[digitno--] = (char)(c+'0');

   368                 decExponent++;

   369                 c = (int)(lvalue%10L);

   370                 lvalue /= 10;

   371             }

   372             digits[digitno] = (char)(c+'0');

   373         }

   374         char result [];

   375         ndigits -= digitno;

   376         result = new char[ ndigits ];

   377         System.arraycopy( digits, digitno, result, 0, ndigits );

   378         this.digits = result;

   379         this.decExponent = decExponent+1;

   380         this.nDigits = ndigits;

   381     }

   382 

   383     //

   384     // add one to the least significant digit.

   385     // in the unlikely event there is a carry out,

   386     // deal with it.

   387     // assert that this will only happen where there

   388     // is only one digit, e.g. (float)1e-44 seems to do it.

   389     //

   390     private void

   391     roundup(){

   392         int i;

   393         int q = digits[ i = (nDigits-1)];

   394         if ( q == '9' ){

   395             while ( q == '9' && i > 0 ){

   396                 digits[i] = '0';

   397                 q = digits[--i];

   398             }

   399             if ( q == '9' ){

   400                 // carryout! High-order 1, rest 0s, larger exp.

   401                 decExponent += 1;

   402                 digits[0] = '1';

   403                 return;

   404             }

   405             // else fall through.

   406         }

   407         digits[i] = (char)(q+1);

   408         decimalDigitsRoundedUp = true;

   409     }

   410 

   411     public boolean digitsRoundedUp() {

   412         return decimalDigitsRoundedUp;

   413     }

   414 

   415     /*

   416      * FIRST IMPORTANT CONSTRUCTOR: DOUBLE

   417      */

   418     public OldFloatingDecimalForTest( double d )

   419     {

   420         long    dBits = Double.doubleToLongBits( d );

   421         long    fractBits;

   422         int     binExp;

   423         int     nSignificantBits;

   424 

   425         // discover and delete sign

   426         if ( (dBits&signMask) != 0 ){

   427             isNegative = true;

   428             dBits ^= signMask;

   429         } else {

   430             isNegative = false;

   431         }

   432         // Begin to unpack

   433         // Discover obvious special cases of NaN and Infinity.

   434         binExp = (int)( (dBits&expMask) >> expShift );

   435         fractBits = dBits&fractMask;

   436         if ( binExp == (int)(expMask>>expShift) ) {

   437             isExceptional = true;

   438             if ( fractBits == 0L ){

   439                 digits =  infinity;

   440             } else {

   441                 digits = notANumber;

   442                 isNegative = false; // NaN has no sign!

   443             }

   444             nDigits = digits.length;

   445             return;

   446         }

   447         isExceptional = false;

   448         // Finish unpacking

   449         // Normalize denormalized numbers.

   450         // Insert assumed high-order bit for normalized numbers.

   451         // Subtract exponent bias.

   452         if ( binExp == 0 ){

   453             if ( fractBits == 0L ){

   454                 // not a denorm, just a 0!

   455                 decExponent = 0;

   456                 digits = zero;

   457                 nDigits = 1;

   458                 return;

   459             }

   460             while ( (fractBits&fractHOB) == 0L ){

   461                 fractBits <<= 1;

   462                 binExp -= 1;

   463             }

   464             nSignificantBits = expShift + binExp +1; // recall binExp is  - shift count.

   465             binExp += 1;

   466         } else {

   467             fractBits |= fractHOB;

   468             nSignificantBits = expShift+1;

   469         }

   470         binExp -= expBias;

   471         // call the routine that actually does all the hard work.

   472         dtoa( binExp, fractBits, nSignificantBits );

   473     }

   474 

   475     /*

   476      * SECOND IMPORTANT CONSTRUCTOR: SINGLE

   477      */

   478     public OldFloatingDecimalForTest( float f )

   479     {

   480         int     fBits = Float.floatToIntBits( f );

   481         int     fractBits;

   482         int     binExp;

   483         int     nSignificantBits;

   484 

   485         // discover and delete sign

   486         if ( (fBits&singleSignMask) != 0 ){

   487             isNegative = true;

   488             fBits ^= singleSignMask;

   489         } else {

   490             isNegative = false;

   491         }

   492         // Begin to unpack

   493         // Discover obvious special cases of NaN and Infinity.

   494         binExp = (fBits&singleExpMask) >> singleExpShift;

   495         fractBits = fBits&singleFractMask;

   496         if ( binExp == (singleExpMask>>singleExpShift) ) {

   497             isExceptional = true;

   498             if ( fractBits == 0L ){

   499                 digits =  infinity;

   500             } else {

   501                 digits = notANumber;

   502                 isNegative = false; // NaN has no sign!

   503             }

   504             nDigits = digits.length;

   505             return;

   506         }

   507         isExceptional = false;

   508         // Finish unpacking

   509         // Normalize denormalized numbers.

   510         // Insert assumed high-order bit for normalized numbers.

   511         // Subtract exponent bias.

   512         if ( binExp == 0 ){

   513             if ( fractBits == 0 ){

   514                 // not a denorm, just a 0!

   515                 decExponent = 0;

   516                 digits = zero;

   517                 nDigits = 1;

   518                 return;

   519             }

   520             while ( (fractBits&singleFractHOB) == 0 ){

   521                 fractBits <<= 1;

   522                 binExp -= 1;

   523             }

   524             nSignificantBits = singleExpShift + binExp +1; // recall binExp is  - shift count.

   525             binExp += 1;

   526         } else {

   527             fractBits |= singleFractHOB;

   528             nSignificantBits = singleExpShift+1;

   529         }

   530         binExp -= singleExpBias;

   531         // call the routine that actually does all the hard work.

   532         dtoa( binExp, ((long)fractBits)<<(expShift-singleExpShift), nSignificantBits );

   533     }

   534 

   535     private void

   536     dtoa( int binExp, long fractBits, int nSignificantBits )

   537     {

   538         int     nFractBits; // number of significant bits of fractBits;

   539         int     nTinyBits;  // number of these to the right of the point.

   540         int     decExp;

   541 

   542         // Examine number. Determine if it is an easy case,

   543         // which we can do pretty trivially using float/long conversion,

   544         // or whether we must do real work.

   545         nFractBits = countBits( fractBits );

   546         nTinyBits = Math.max( 0, nFractBits - binExp - 1 );

   547         if ( binExp <= maxSmallBinExp && binExp >= minSmallBinExp ){

   548             // Look more closely at the number to decide if,

   549             // with scaling by 10^nTinyBits, the result will fit in

   550             // a long.

   551             if ( (nTinyBits < long5pow.length) && ((nFractBits + n5bits[nTinyBits]) < 64 ) ){

   552                 /*

   553                  * We can do this:

   554                  * take the fraction bits, which are normalized.

   555                  * (a) nTinyBits == 0: Shift left or right appropriately

   556                  *     to align the binary point at the extreme right, i.e.

   557                  *     where a long int point is expected to be. The integer

   558                  *     result is easily converted to a string.

   559                  * (b) nTinyBits > 0: Shift right by expShift-nFractBits,

   560                  *     which effectively converts to long and scales by

   561                  *     2^nTinyBits. Then multiply by 5^nTinyBits to

   562                  *     complete the scaling. We know this won't overflow

   563                  *     because we just counted the number of bits necessary

   564                  *     in the result. The integer you get from this can

   565                  *     then be converted to a string pretty easily.

   566                  */

   567                 long halfULP;

   568                 if ( nTinyBits == 0 ) {

   569                     if ( binExp > nSignificantBits ){

   570                         halfULP = 1L << ( binExp-nSignificantBits-1);

   571                     } else {

   572                         halfULP = 0L;

   573                     }

   574                     if ( binExp >= expShift ){

   575                         fractBits <<= (binExp-expShift);

   576                     } else {

   577                         fractBits >>>= (expShift-binExp) ;

   578                     }

   579                     developLongDigits( 0, fractBits, halfULP );

   580                     return;

   581                 }

   582                 /*

   583                  * The following causes excess digits to be printed

   584                  * out in the single-float case. Our manipulation of

   585                  * halfULP here is apparently not correct. If we

   586                  * better understand how this works, perhaps we can

   587                  * use this special case again. But for the time being,

   588                  * we do not.

   589                  * else {

   590                  *     fractBits >>>= expShift+1-nFractBits;

   591                  *     fractBits *= long5pow[ nTinyBits ];

   592                  *     halfULP = long5pow[ nTinyBits ] >> (1+nSignificantBits-nFractBits);

   593                  *     developLongDigits( -nTinyBits, fractBits, halfULP );

   594                  *     return;

   595                  * }

   596                  */

   597             }

   598         }

   599         /*

   600          * This is the hard case. We are going to compute large positive

   601          * integers B and S and integer decExp, s.t.

   602          *      d = ( B / S ) * 10^decExp

   603          *      1 <= B / S < 10

   604          * Obvious choices are:

   605          *      decExp = floor( log10(d) )

   606          *      B      = d * 2^nTinyBits * 10^max( 0, -decExp )

   607          *      S      = 10^max( 0, decExp) * 2^nTinyBits

   608          * (noting that nTinyBits has already been forced to non-negative)

   609          * I am also going to compute a large positive integer

   610          *      M      = (1/2^nSignificantBits) * 2^nTinyBits * 10^max( 0, -decExp )

   611          * i.e. M is (1/2) of the ULP of d, scaled like B.

   612          * When we iterate through dividing B/S and picking off the

   613          * quotient bits, we will know when to stop when the remainder

   614          * is <= M.

   615          *

   616          * We keep track of powers of 2 and powers of 5.

   617          */

   618 

   619         /*

   620          * Estimate decimal exponent. (If it is small-ish,

   621          * we could double-check.)

   622          *

   623          * First, scale the mantissa bits such that 1 <= d2 < 2.

   624          * We are then going to estimate

   625          *          log10(d2) ~=~  (d2-1.5)/1.5 + log(1.5)

   626          * and so we can estimate

   627          *      log10(d) ~=~ log10(d2) + binExp * log10(2)

   628          * take the floor and call it decExp.

   629          * FIXME -- use more precise constants here. It costs no more.

   630          */

   631         double d2 = Double.longBitsToDouble(

   632             expOne | ( fractBits &~ fractHOB ) );

   633         decExp = (int)Math.floor(

   634             (d2-1.5D)*0.289529654D + 0.176091259 + (double)binExp * 0.301029995663981 );

   635         int B2, B5; // powers of 2 and powers of 5, respectively, in B

   636         int S2, S5; // powers of 2 and powers of 5, respectively, in S

   637         int M2, M5; // powers of 2 and powers of 5, respectively, in M

   638         int Bbits; // binary digits needed to represent B, approx.

   639         int tenSbits; // binary digits needed to represent 10*S, approx.

   640         OldFDBigIntForTest Sval, Bval, Mval;

   641 

   642         B5 = Math.max( 0, -decExp );

   643         B2 = B5 + nTinyBits + binExp;

   644 

   645         S5 = Math.max( 0, decExp );

   646         S2 = S5 + nTinyBits;

   647 

   648         M5 = B5;

   649         M2 = B2 - nSignificantBits;

   650 

   651         /*

   652          * the long integer fractBits contains the (nFractBits) interesting

   653          * bits from the mantissa of d ( hidden 1 added if necessary) followed

   654          * by (expShift+1-nFractBits) zeros. In the interest of compactness,

   655          * I will shift out those zeros before turning fractBits into a

   656          * OldFDBigIntForTest. The resulting whole number will be

   657          *      d * 2^(nFractBits-1-binExp).

   658          */

   659         fractBits >>>= (expShift+1-nFractBits);

   660         B2 -= nFractBits-1;

   661         int common2factor = Math.min( B2, S2 );

   662         B2 -= common2factor;

   663         S2 -= common2factor;

   664         M2 -= common2factor;

   665 

   666         /*

   667          * HACK!! For exact powers of two, the next smallest number

   668          * is only half as far away as we think (because the meaning of

   669          * ULP changes at power-of-two bounds) for this reason, we

   670          * hack M2. Hope this works.

   671          */

   672         if ( nFractBits == 1 )

   673             M2 -= 1;

   674 

   675         if ( M2 < 0 ){

   676             // oops.

   677             // since we cannot scale M down far enough,

   678             // we must scale the other values up.

   679             B2 -= M2;

   680             S2 -= M2;

   681             M2 =  0;

   682         }

   683         /*

   684          * Construct, Scale, iterate.

   685          * Some day, we'll write a stopping test that takes

   686          * account of the asymmetry of the spacing of floating-point

   687          * numbers below perfect powers of 2

   688          * 26 Sept 96 is not that day.

   689          * So we use a symmetric test.

   690          */

   691         char digits[] = this.digits = new char[18];

   692         int  ndigit = 0;

   693         boolean low, high;

   694         long lowDigitDifference;

   695         int  q;

   696 

   697         /*

   698          * Detect the special cases where all the numbers we are about

   699          * to compute will fit in int or long integers.

   700          * In these cases, we will avoid doing OldFDBigIntForTest arithmetic.

   701          * We use the same algorithms, except that we "normalize"

   702          * our OldFDBigIntForTests before iterating. This is to make division easier,

   703          * as it makes our fist guess (quotient of high-order words)

   704          * more accurate!

   705          *

   706          * Some day, we'll write a stopping test that takes

   707          * account of the asymmetry of the spacing of floating-point

   708          * numbers below perfect powers of 2

   709          * 26 Sept 96 is not that day.

   710          * So we use a symmetric test.

   711          */

   712         Bbits = nFractBits + B2 + (( B5 < n5bits.length )? n5bits[B5] : ( B5*3 ));

   713         tenSbits = S2+1 + (( (S5+1) < n5bits.length )? n5bits[(S5+1)] : ( (S5+1)*3 ));

   714         if ( Bbits < 64 && tenSbits < 64){

   715             if ( Bbits < 32 && tenSbits < 32){

   716                 // wa-hoo! They're all ints!

   717                 int b = ((int)fractBits * small5pow[B5] ) << B2;

   718                 int s = small5pow[S5] << S2;

   719                 int m = small5pow[M5] << M2;

   720                 int tens = s * 10;

   721                 /*

   722                  * Unroll the first iteration. If our decExp estimate

   723                  * was too high, our first quotient will be zero. In this

   724                  * case, we discard it and decrement decExp.

   725                  */

   726                 ndigit = 0;

   727                 q = b / s;

   728                 b = 10 * ( b % s );

   729                 m *= 10;

   730                 low  = (b <  m );

   731                 high = (b+m > tens );

   732                 assert q < 10 : q; // excessively large digit

   733                 if ( (q == 0) && ! high ){

   734                     // oops. Usually ignore leading zero.

   735                     decExp--;

   736                 } else {

   737                     digits[ndigit++] = (char)('0' + q);

   738                 }

   739                 /*

   740                  * HACK! Java spec sez that we always have at least

   741                  * one digit after the . in either F- or E-form output.

   742                  * Thus we will need more than one digit if we're using

   743                  * E-form

   744                  */

   745                 if ( decExp < -3 || decExp >= 8 ){

   746                     high = low = false;

   747                 }

   748                 while( ! low && ! high ){

   749                     q = b / s;

   750                     b = 10 * ( b % s );

   751                     m *= 10;

   752                     assert q < 10 : q; // excessively large digit

   753                     if ( m > 0L ){

   754                         low  = (b <  m );

   755                         high = (b+m > tens );

   756                     } else {

   757                         // hack -- m might overflow!

   758                         // in this case, it is certainly > b,

   759                         // which won't

   760                         // and b+m > tens, too, since that has overflowed

   761                         // either!

   762                         low = true;

   763                         high = true;

   764                     }

   765                     digits[ndigit++] = (char)('0' + q);

   766                 }

   767                 lowDigitDifference = (b<<1) - tens;

   768                 exactDecimalConversion  = (b == 0);

   769             } else {

   770                 // still good! they're all longs!

   771                 long b = (fractBits * long5pow[B5] ) << B2;

   772                 long s = long5pow[S5] << S2;

   773                 long m = long5pow[M5] << M2;

   774                 long tens = s * 10L;

   775                 /*

   776                  * Unroll the first iteration. If our decExp estimate

   777                  * was too high, our first quotient will be zero. In this

   778                  * case, we discard it and decrement decExp.

   779                  */

   780                 ndigit = 0;

   781                 q = (int) ( b / s );

   782                 b = 10L * ( b % s );

   783                 m *= 10L;

   784                 low  = (b <  m );

   785                 high = (b+m > tens );

   786                 assert q < 10 : q; // excessively large digit

   787                 if ( (q == 0) && ! high ){

   788                     // oops. Usually ignore leading zero.

   789                     decExp--;

   790                 } else {

   791                     digits[ndigit++] = (char)('0' + q);

   792                 }

   793                 /*

   794                  * HACK! Java spec sez that we always have at least

   795                  * one digit after the . in either F- or E-form output.

   796                  * Thus we will need more than one digit if we're using

   797                  * E-form

   798                  */

   799                 if ( decExp < -3 || decExp >= 8 ){

   800                     high = low = false;

   801                 }

   802                 while( ! low && ! high ){

   803                     q = (int) ( b / s );

   804                     b = 10 * ( b % s );

   805                     m *= 10;

   806                     assert q < 10 : q;  // excessively large digit

   807                     if ( m > 0L ){

   808                         low  = (b <  m );

   809                         high = (b+m > tens );

   810                     } else {

   811                         // hack -- m might overflow!

   812                         // in this case, it is certainly > b,

   813                         // which won't

   814                         // and b+m > tens, too, since that has overflowed

   815                         // either!

   816                         low = true;

   817                         high = true;

   818                     }

   819                     digits[ndigit++] = (char)('0' + q);

   820                 }

   821                 lowDigitDifference = (b<<1) - tens;

   822                 exactDecimalConversion  = (b == 0);

   823             }

   824         } else {

   825             OldFDBigIntForTest ZeroVal = new OldFDBigIntForTest(0);

   826             OldFDBigIntForTest tenSval;

   827             int  shiftBias;

   828 

   829             /*

   830              * We really must do OldFDBigIntForTest arithmetic.

   831              * Fist, construct our OldFDBigIntForTest initial values.

   832              */

   833             Bval = multPow52( new OldFDBigIntForTest( fractBits  ), B5, B2 );

   834             Sval = constructPow52( S5, S2 );

   835             Mval = constructPow52( M5, M2 );

   836 

   837 

   838             // normalize so that division works better

   839             Bval.lshiftMe( shiftBias = Sval.normalizeMe() );

   840             Mval.lshiftMe( shiftBias );

   841             tenSval = Sval.mult( 10 );

   842             /*

   843              * Unroll the first iteration. If our decExp estimate

   844              * was too high, our first quotient will be zero. In this

   845              * case, we discard it and decrement decExp.

   846              */

   847             ndigit = 0;

   848             q = Bval.quoRemIteration( Sval );

   849             Mval = Mval.mult( 10 );

   850             low  = (Bval.cmp( Mval ) < 0);

   851             high = (Bval.add( Mval ).cmp( tenSval ) > 0 );

   852             assert q < 10 : q; // excessively large digit

   853             if ( (q == 0) && ! high ){

   854                 // oops. Usually ignore leading zero.

   855                 decExp--;

   856             } else {

   857                 digits[ndigit++] = (char)('0' + q);

   858             }

   859             /*

   860              * HACK! Java spec sez that we always have at least

   861              * one digit after the . in either F- or E-form output.

   862              * Thus we will need more than one digit if we're using

   863              * E-form

   864              */

   865             if ( decExp < -3 || decExp >= 8 ){

   866                 high = low = false;

   867             }

   868             while( ! low && ! high ){

   869                 q = Bval.quoRemIteration( Sval );

   870                 Mval = Mval.mult( 10 );

   871                 assert q < 10 : q;  // excessively large digit

   872                 low  = (Bval.cmp( Mval ) < 0);

   873                 high = (Bval.add( Mval ).cmp( tenSval ) > 0 );

   874                 digits[ndigit++] = (char)('0' + q);

   875             }

   876             if ( high && low ){

   877                 Bval.lshiftMe(1);

   878                 lowDigitDifference = Bval.cmp(tenSval);

   879             } else {

   880                 lowDigitDifference = 0L; // this here only for flow analysis!

   881             }

   882             exactDecimalConversion  = (Bval.cmp( ZeroVal ) == 0);

   883         }

   884         this.decExponent = decExp+1;

   885         this.digits = digits;

   886         this.nDigits = ndigit;

   887         /*

   888          * Last digit gets rounded based on stopping condition.

   889          */

   890         if ( high ){

   891             if ( low ){

   892                 if ( lowDigitDifference == 0L ){

   893                     // it's a tie!

   894                     // choose based on which digits we like.

   895                     if ( (digits[nDigits-1]&1) != 0 ) roundup();

   896                 } else if ( lowDigitDifference > 0 ){

   897                     roundup();

   898                 }

   899             } else {

   900                 roundup();

   901             }

   902         }

   903     }

   904 

   905     public boolean decimalDigitsExact() {

   906         return exactDecimalConversion;

   907     }

   908 

   909     public String

   910     toString(){

   911         // most brain-dead version

   912         StringBuffer result = new StringBuffer( nDigits+8 );

   913         if ( isNegative ){ result.append( '-' ); }

   914         if ( isExceptional ){

   915             result.append( digits, 0, nDigits );

   916         } else {

   917             result.append( "0.");

   918             result.append( digits, 0, nDigits );

   919             result.append('e');

   920             result.append( decExponent );

   921         }

   922         return new String(result);

   923     }

   924 

   925     public String toJavaFormatString() {

   926         char result[] = perThreadBuffer.get();

   927         int i = getChars(result);

   928         return new String(result, 0, i);

   929     }

   930 

   931     private int getChars(char[] result) {

   932         assert nDigits <= 19 : nDigits; // generous bound on size of nDigits

   933         int i = 0;

   934         if (isNegative) { result[0] = '-'; i = 1; }

   935         if (isExceptional) {

   936             System.arraycopy(digits, 0, result, i, nDigits);

   937             i += nDigits;

   938         } else {

   939             if (decExponent > 0 && decExponent < 8) {

   940                 // print digits.digits.

   941                 int charLength = Math.min(nDigits, decExponent);

   942                 System.arraycopy(digits, 0, result, i, charLength);

   943                 i += charLength;

   944                 if (charLength < decExponent) {

   945                     charLength = decExponent-charLength;

   946                     System.arraycopy(zero, 0, result, i, charLength);

   947                     i += charLength;

   948                     result[i++] = '.';

   949                     result[i++] = '0';

   950                 } else {

   951                     result[i++] = '.';

   952                     if (charLength < nDigits) {

   953                         int t = nDigits - charLength;

   954                         System.arraycopy(digits, charLength, result, i, t);

   955                         i += t;

   956                     } else {

   957                         result[i++] = '0';

   958                     }

   959                 }

   960             } else if (decExponent <=0 && decExponent > -3) {

   961                 result[i++] = '0';

   962                 result[i++] = '.';

   963                 if (decExponent != 0) {

   964                     System.arraycopy(zero, 0, result, i, -decExponent);

   965                     i -= decExponent;

   966                 }

   967                 System.arraycopy(digits, 0, result, i, nDigits);

   968                 i += nDigits;

   969             } else {

   970                 result[i++] = digits[0];

   971                 result[i++] = '.';

   972                 if (nDigits > 1) {

   973                     System.arraycopy(digits, 1, result, i, nDigits-1);

   974                     i += nDigits-1;

   975                 } else {

   976                     result[i++] = '0';

   977                 }

   978                 result[i++] = 'E';

   979                 int e;

   980                 if (decExponent <= 0) {

   981                     result[i++] = '-';

   982                     e = -decExponent+1;

   983                 } else {

   984                     e = decExponent-1;

   985                 }

   986                 // decExponent has 1, 2, or 3, digits

   987                 if (e <= 9) {

   988                     result[i++] = (char)(e+'0');

   989                 } else if (e <= 99) {

   990                     result[i++] = (char)(e/10 +'0');

   991                     result[i++] = (char)(e%10 + '0');

   992                 } else {

   993                     result[i++] = (char)(e/100+'0');

   994                     e %= 100;

   995                     result[i++] = (char)(e/10+'0');

   996                     result[i++] = (char)(e%10 + '0');

   997                 }

   998             }

   999         }

  1000         return i;

  1001     }

  1002 

  1003     // Per-thread buffer for string/stringbuffer conversion

  1004     private static ThreadLocal<char[]> perThreadBuffer = new ThreadLocal<char[]>() {

  1005             protected synchronized char[] initialValue() {

  1006                 return new char[26];

  1007             }

  1008         };

  1009 

  1010     public void appendTo(Appendable buf) {

  1011           char result[] = perThreadBuffer.get();

  1012           int i = getChars(result);

  1013         if (buf instanceof StringBuilder)

  1014             ((StringBuilder) buf).append(result, 0, i);

  1015         else if (buf instanceof StringBuffer)

  1016             ((StringBuffer) buf).append(result, 0, i);

  1017         else

  1018             assert false;

  1019     }

  1020 

  1021     @SuppressWarnings("fallthrough")

  1022     public static OldFloatingDecimalForTest

  1023     readJavaFormatString( String in ) throws NumberFormatException {

  1024         boolean isNegative = false;

  1025         boolean signSeen   = false;

  1026         int     decExp;

  1027         char    c;

  1028 

  1029     parseNumber:

  1030         try{

  1031             in = in.trim(); // don't fool around with white space.

  1032                             // throws NullPointerException if null

  1033             int l = in.length();

  1034             if ( l == 0 ) throw new NumberFormatException("empty String");

  1035             int i = 0;

  1036             switch ( c = in.charAt( i ) ){

  1037             case '-':

  1038                 isNegative = true;

  1039                 //FALLTHROUGH

  1040             case '+':

  1041                 i++;

  1042                 signSeen = true;

  1043             }

  1044 

  1045             // Check for NaN and Infinity strings

  1046             c = in.charAt(i);

  1047             if(c == 'N' || c == 'I') { // possible NaN or infinity

  1048                 boolean potentialNaN = false;

  1049                 char targetChars[] = null;  // char array of "NaN" or "Infinity"

  1050 

  1051                 if(c == 'N') {

  1052                     targetChars = notANumber;

  1053                     potentialNaN = true;

  1054                 } else {

  1055                     targetChars = infinity;

  1056                 }

  1057 

  1058                 // compare Input string to "NaN" or "Infinity"

  1059                 int j = 0;

  1060                 while(i < l && j < targetChars.length) {

  1061                     if(in.charAt(i) == targetChars[j]) {

  1062                         i++; j++;

  1063                     }

  1064                     else // something is amiss, throw exception

  1065                         break parseNumber;

  1066                 }

  1067 

  1068                 // For the candidate string to be a NaN or infinity,

  1069                 // all characters in input string and target char[]

  1070                 // must be matched ==> j must equal targetChars.length

  1071                 // and i must equal l

  1072                 if( (j == targetChars.length) && (i == l) ) { // return NaN or infinity

  1073                     return (potentialNaN ? new OldFloatingDecimalForTest(Double.NaN) // NaN has no sign

  1074                             : new OldFloatingDecimalForTest(isNegative?

  1075                                                   Double.NEGATIVE_INFINITY:

  1076                                                   Double.POSITIVE_INFINITY)) ;

  1077                 }

  1078                 else { // something went wrong, throw exception

  1079                     break parseNumber;

  1080                 }

  1081 

  1082             } else if (c == '0')  { // check for hexadecimal floating-point number

  1083                 if (l > i+1 ) {

  1084                     char ch = in.charAt(i+1);

  1085                     if (ch == 'x' || ch == 'X' ) // possible hex string

  1086                         return parseHexString(in);

  1087                 }

  1088             }  // look for and process decimal floating-point string

  1089 

  1090             char[] digits = new char[ l ];

  1091             int    nDigits= 0;

  1092             boolean decSeen = false;

  1093             int decPt = 0;

  1094             int nLeadZero = 0;

  1095             int nTrailZero= 0;

  1096         digitLoop:

  1097             while ( i < l ){

  1098                 switch ( c = in.charAt( i ) ){

  1099                 case '0':

  1100                     if ( nDigits > 0 ){

  1101                         nTrailZero += 1;

  1102                     } else {

  1103                         nLeadZero += 1;

  1104                     }

  1105                     break; // out of switch.

  1106                 case '1':

  1107                 case '2':

  1108                 case '3':

  1109                 case '4':

  1110                 case '5':

  1111                 case '6':

  1112                 case '7':

  1113                 case '8':

  1114                 case '9':

  1115                     while ( nTrailZero > 0 ){

  1116                         digits[nDigits++] = '0';

  1117                         nTrailZero -= 1;

  1118                     }

  1119                     digits[nDigits++] = c;

  1120                     break; // out of switch.

  1121                 case '.':

  1122                     if ( decSeen ){

  1123                         // already saw one ., this is the 2nd.

  1124                         throw new NumberFormatException("multiple points");

  1125                     }

  1126                     decPt = i;

  1127                     if ( signSeen ){

  1128                         decPt -= 1;

  1129                     }

  1130                     decSeen = true;

  1131                     break; // out of switch.

  1132                 default:

  1133                     break digitLoop;

  1134                 }