Review: 4396272 - Parsing doubles fails to follow IEEE for largest decimal that should yield 0 (original) (raw)

Fri Feb 15 01:23:46 UTC 2013

boolean     mustSetRoundDir = false;
boolean     fromHex = false;
int         roundDir = 0; // set by doubleValue
               dValue += 0.5*ulp( dValue, overvalue );
               // Fix of bug 4396272. This method has strictfp modifier now.
               // Nevertheless, the two comments below explain why it can work without strictfp too.
               //
               // In the logical expression tested on the if-block,
               // bigIntExp = expBiased - expBias + 1 - bigIntNBits so that
               // bigIntExp+bigIntNBits = expBiased - expBias + 1 so the inequality tested is
               // expBiased - expBias + 1 > -expBias+2 or expBiased > 1 which implies
               // exUnbiased > 1 - expBias = -1022 or expUnbiased > -1021 so that
               // old dValue > 2^(-1021) = 2*2^(-1022) = 2*Double.MIN_NORMAL.
               // Either ">" or ">=" could be used in the logical expression
               // as both branches evaluate to the same result when equality obtains.
               //
               // As dValue becomes smaller, the ULP descreases reaching
               // Double.MIN_VALUE for dValue == 2*Double.MIN_NORMAL. Below
               // this the intermediate result 0.5*ULP will be rounded to
               // zero per FP-strict. As a result no correction to dValue
               // will occur. To prevent this, 2*dValue + ULP is first
               // computed so that the effect of adding half the ULP is not
               // lost, then this intermediate result is halved.
               //
               if ( bigIntExp+bigIntNBits > -expBias+2 ) {
                   // Here old dValue > 2*Double.MIN_NORMAL
                   //
                   // Non-FP-strict case:
                   // If overvalue == false then ulp(dValue,false) >= 2*Double.MIN_VALUE and 0.5*ulp is exact.
                   // If overvalue == true and dValue > 2*Double.MIN_NORMAL then ulp(dValue,true) <= -2*Double.MIN_VALUE and 0.5*ulp is exact.
                   // If overvalue == true and dValue == 2*Double.MIN_NORMAL then ulp(dValue,true) == -Double.MIN_VALUE.
                   //   Hence 0.5*ulp is rounded to 0 in double value set and 0.5*ulp is exact in double-extended-exponent value set.
                   //   In both value sets new dValue is rounded to 2*Double.MIN_NOPMAL as expected
                   dValue += 0.5*ulp( dValue, overvalue );
               } else {
                   // Here old dValue <= 2*Double.MIN_NORMAL
                   //
                   // Non-FP-strict case:
                   // If overvalue == false then ulp(dValue,false) == Double.MIN_VALUE
                   //   If dValue >= Double.MIN_NORMAL then dValue*2 + ulp rounds to nearest even and 0.5*(...) is exact
                   //   If dValue < Double.MIN_NORMAL then dValue*2 + ulp is exact and 0.5*(...) rounds to nearest even in double value set
                   //     and is exact in double-extended-exponent value set and then rounds to nearest even double before storing to new dValue. 
                   // If overvalue == true then ulp(dValue,true) == -Double.MIN_VALUE
                   //   If dValue > Double.MIN_NORMAL then dValue*2 + ulp rounds to nearest even and 0.5*(...) is exact
                   //   If dValue <= Double.MIN_NORMAL then dValue*2 + ulp is exact and 0.5*(...) rounds to nearest even in double value set
                   //     and is exact in double-extended-exponent value set and then rounds to nearest even double before storing to new dValue. 
     dValue = 0.5*(dValue*2 + ulp( dValue, overvalue));
               }
               // should check for bigIntNBits == 1 here??
               if (mustSetRoundDir) {
                   roundDir = overvalue ? -1 : 1;
   boolean failed = false;
   BigDecimal TWO = BigDecimal.valueOf(2);
   // An ulp is the same for all subnormal values
   BigDecimal ulp_BD = new BigDecimal(Double.MIN_VALUE);
   // Test subnormal powers of two
   for(int i = -1074; i <= -1022; i++) {
   // Test subnormal powers of two (except Double.MIN_VALUE)
   for(int i = -1073; i <= -1022; i++) {
       double d = Math.scalb(1.0, i);

       /*
        * The region [d - ulp/2, d + ulp/2] should round to d.
        */
       */
       BigDecimal d_BD = new BigDecimal(d);

       BigDecimal lowerBound = d_BD.subtract(ulp_BD.divide(TWO));
         double convertedLowerBound = Double.parseDouble(lowerBound.toString());
         double convertedUpperBound = Double.parseDouble(upperBound.toString());
       if (convertedLowerBound != d) {
           failed = true;
           System.out.printf("2^%d lowerBound converts as %a %s%n",
                             i, convertedLowerBound, lowerBound);
       }
       if (convertedUpperBound != d) {
           failed = true;
           System.out.printf("2^%d upperBound converts as %a %s%n",
                             i, convertedUpperBound, upperBound);
       }
   }
   /*
    * Double.MIN_VALUE
    * The region ]0.5*Double.MIN_VALUE, 1.5*Double.MIN_VALUE[ should round to Double.MIN_VALUE .
    */
   BigDecimal minValue = new BigDecimal(Double.MIN_VALUE);
   if (Double.parseDouble(minValue.multiply(new BigDecimal(0.5)).toString()) != 0.0) {
       failed = true;
       System.out.printf("0.5*MIN_VALUE doesn't convert 0%n");
   }
   if (Double.parseDouble(minValue.multiply(new BigDecimal(0.50000000001)).toString()) != Double.MIN_VALUE) {
       failed = true;
       System.out.printf("0.50000000001*MIN_VALUE doesn't convert to MIN_VALUE%n");
   }
   if (Double.parseDouble(minValue.multiply(new BigDecimal(1.49999999999)).toString()) != Double.MIN_VALUE) {
       failed = true;
       System.out.printf("1.49999999999*MIN_VALUE doesn't convert to MIN_VALUE%n");
   }
   if (Double.parseDouble(minValue.multiply(new BigDecimal(1.5)).toString()) != 2*Double.MIN_VALUE) {
       failed = true;
       System.out.printf("1.5*MIN_VALUE doesn't convert to 2*MIN_VALUE%n");
   }
   if (failed)
       throw new RuntimeException("Inconsistent conversion");
   final double expected = 0x0.0000008000001p-1022;
   final double expected = 0x0.0000008000000p-1022;
   //2^-1047 + 2^-1075
   //2^-1047 + 2^-1075 rounds to 2^-1047
   String decimal = "6.631236871469758276785396630275967243399099947355303144249971758736286630139265439618068200788048744105960420552601852889715006376325666595539603330361800519107591783233358492337208057849499360899425128640718856616503093444922854759159988160304439909868291973931426625698663157749836252274523485312442358651207051292453083278116143932569727918709786004497872322193856150225415211997283078496319412124640111777216148110752815101775295719811974338451936095907419622417538473679495148632480391435931767981122396703443803335529756003353209830071832230689201383015598792184172909927924176339315507402234836120730914783168400715462440053817592702766213559042115986763819482654128770595766806872783349146967171293949598850675682115696218943412532098591327667236328125E-316";

   for(int i = 0; i <= 12_000; i++) {