8362448: Make use of the Double.toString(double) algorithm in java.text.DecimalFormat

Reviewed-by: naoto, jlu

Author: rgiulietti

src/java.base/share/classes/java/text/DecimalFormat.java

@@ -652,17 +652,10 @@ StringBuf format(double number, StringBuf result,
             return result;
         }
 
-        /* Detecting whether a double is negative is easy with the exception of
-         * the value -0.0.  This is a double which has a zero mantissa (and
-         * exponent), but a negative sign bit.  It is semantically distinct from
-         * a zero with a positive sign bit, and this distinction is important
-         * to certain kinds of computations.  However, it's a little tricky to
-         * detect, since (-0.0 == 0.0) and !(-0.0 < 0.0).  How then, you may
-         * ask, does it behave distinctly from +0.0?  Well, 1/(-0.0) ==
-         * -Infinity.  Proper detection of -0.0 is needed to deal with the
+        /* Proper detection of -0.0 is needed to deal with the
          * issues raised by bugs 4106658, 4106667, and 4147706.  Liu 7/6/98.
          */
-        boolean isNegative = ((number < 0.0) || (number == 0.0 && 1/number < 0.0)) ^ (multiplier < 0);
+        boolean isNegative = Double.doubleToRawLongBits(number) < 0 ^ multiplier < 0;
 
         if (multiplier != 1) {
             number *= multiplier;

src/java.base/share/classes/java/text/DigitList.java

@@ -52,11 +52,11 @@
  * DecimalFormat is that DigitList handles the radix 10 representation
  * issues; DecimalFormat handles the locale-specific issues such as
  * positive/negative, grouping, decimal point, currency, and so on.
- *
+ * <p>
  * A DigitList is really a representation of a floating point value.
  * It may be an integer value; we assume that a double has sufficient
  * precision to represent all digits of a long.
- *
+ * <p>
  * The DigitList representation consists of a string of characters,
  * which are the digits radix 10, from '0' to '9'.  It also has a radix
  * 10 exponent associated with it.  The value represented by a DigitList
@@ -82,22 +82,22 @@ final class DigitList implements Cloneable {
 
     /**
      * These data members are intentionally public and can be set directly.
-     *
+     * <p>
      * The value represented is given by placing the decimal point before
      * digits[decimalAt].  If decimalAt is < 0, then leading zeros between
      * the decimal point and the first nonzero digit are implied.  If decimalAt
      * is > count, then trailing zeros between the digits[count-1] and the
      * decimal point are implied.
-     *
+     * <p>
      * Equivalently, the represented value is given by f * 10^decimalAt.  Here
      * f is a value 0.1 <= f < 1 arrived at by placing the digits in Digits to
      * the right of the decimal.
-     *
+     * <p>
      * DigitList is normalized, so if it is non-zero, digits[0] is non-zero.  We
      * don't allow denormalized numbers because our exponent is effectively of
      * unlimited magnitude.  The count value contains the number of significant
      * digits present in digits[].
-     *
+     * <p>
      * Zero is represented by any DigitList with count == 0 or with each digits[i]
      * for all i <= count == '0'.
      */
@@ -166,7 +166,7 @@ public void append(char digit) {
      * If (count == 0) this returns 0.0,
      * unlike Double.parseDouble("") which throws NumberFormatException.
      */
-    public final double getDouble() {
+    public double getDouble() {
         if (count == 0) {
             return 0.0;
         }
@@ -178,7 +178,7 @@ public final double getDouble() {
      * If (count == 0) this returns 0,
      * unlike Long.parseLong("") which throws NumberFormatException.
      */
-    public final long getLong() {
+    public long getLong() {
         // for now, simple implementation; later, do proper IEEE native stuff
 
         if (count == 0) {
@@ -208,7 +208,7 @@ public final long getLong() {
      * If (count == 0) this does not throw a NumberFormatException,
      * unlike BigDecimal("").
      */
-    public final BigDecimal getBigDecimal() {
+    public BigDecimal getBigDecimal() {
         if (count == 0) {
             return BigDecimal.valueOf(0, -decimalAt);
         }
@@ -280,10 +280,26 @@ boolean fitsIntoLong(boolean isPositive, boolean ignoreNegativeZero) {
      * @param maximumFractionDigits The most fractional digits which should
      * be converted.
      */
-    final void set(boolean isNegative, double source, int maximumFractionDigits) {
+    void set(boolean isNegative, double source, int maximumFractionDigits) {
         set(isNegative, source, maximumFractionDigits, true);
     }
 
+    /*
+     * This compatibility option will only be available for a *very* limited
+     * number of releases.
+     * It restores the original behavior to help migrating to the new one,
+     * and is used by adding
+     *      -Djdk.compat.DecimalFormat=true
+     * to the launcher's command line.
+     *
+     * The new behavior differs from the old one only in very rare cases,
+     * so migration should be painless.
+     *
+     * When this option is removed, the old behavior, including relevant
+     * fields and methods, will be removed as well.
+     */
+    private static final boolean COMPAT = Boolean.getBoolean("jdk.compat.DecimalFormat");
+
     /**
      * Set the digit list to a representation of the given double value.
      * This method supports both fixed-point and exponential notation.
@@ -295,9 +311,9 @@ final void set(boolean isNegative, double source, int maximumFractionDigits) {
      * @param fixedPoint If true, then maximumDigits is the maximum
      * fractional digits to be converted.  If false, total digits.
      */
-    final void set(boolean isNegative, double source, int maximumDigits, boolean fixedPoint) {
-
-        FloatingDecimal.BinaryToASCIIConverter fdConverter  = FloatingDecimal.getBinaryToASCIIConverter(source);
+    void set(boolean isNegative, double source, int maximumDigits, boolean fixedPoint) {
+        FloatingDecimal.BinaryToASCIIConverter fdConverter =
+                FloatingDecimal.getBinaryToASCIIConverter(source, COMPAT);
         boolean hasBeenRoundedUp = fdConverter.digitsRoundedUp();
         boolean valueExactAsDecimal = fdConverter.decimalDigitsExact();
         assert !fdConverter.isExceptional();
@@ -415,7 +431,7 @@ private void roundInt(int maximumDigits) {
      *
      * Upon return, count will be less than or equal to maximumDigits.
      */
-    private final void round(int maximumDigits,
+    private void round(int maximumDigits,
                              boolean alreadyRounded,
                              boolean valueExactAsDecimal) {
         // Eliminate digits beyond maximum digits to be displayed.
@@ -582,7 +598,7 @@ private int roundUp(int maximumDigits) {
     /**
      * Utility routine to set the value of the digit list from a long
      */
-    final void set(boolean isNegative, long source) {
+    void set(boolean isNegative, long source) {
         set(isNegative, source, 0);
     }
 
@@ -595,7 +611,7 @@ final void set(boolean isNegative, long source) {
      * If maximumDigits is lower than the number of significant digits
      * in source, the representation will be rounded.  Ignored if <= 0.
      */
-    final void set(boolean isNegative, long source, int maximumDigits) {
+    void set(boolean isNegative, long source, int maximumDigits) {
         this.isNegative = isNegative;
 
         // This method does not expect a negative number. However,
@@ -645,7 +661,7 @@ final void set(boolean isNegative, long source, int maximumDigits) {
      * @param fixedPoint If true, then maximumDigits is the maximum
      * fractional digits to be converted.  If false, total digits.
      */
-    final void set(boolean isNegative, BigDecimal source, int maximumDigits, boolean fixedPoint) {
+    void set(boolean isNegative, BigDecimal source, int maximumDigits, boolean fixedPoint) {
         String s = source.toString();
         extendDigits(s.length());
 
@@ -662,7 +678,7 @@ final void set(boolean isNegative, BigDecimal source, int maximumDigits, boolean
      * If maximumDigits is lower than the number of significant digits
      * in source, the representation will be rounded.  Ignored if <= 0.
      */
-    final void set(boolean isNegative, BigInteger source, int maximumDigits) {
+    void set(boolean isNegative, BigInteger source, int maximumDigits) {
         this.isNegative = isNegative;
         String s = source.toString();
         int len = s.length();
@@ -772,7 +788,7 @@ private void extendDigits(int len) {
         }
     }
 
-    private final char[] getDataChars(int length) {
+    private char[] getDataChars(int length) {
         if (data == null || data.length < length) {
             data = new char[length];
         }

src/java.base/share/classes/jdk/internal/math/DoubleToDecimal.java

@@ -246,7 +246,7 @@ private int toDecimal(byte[] str, int index, double v, FormattedFPDecimal fd) {
                 if (0 < mq & mq < P) {
                     long f = c >> mq;
                     if (f << mq == c) {
-                        return toChars(str, index, f, 0, fd) - start;
+                        return toChars(str, index, f, 0, fd, true, false) - start;
                     }
                 }
                 return toDecimal(str, index, -mq, c, 0, fd) - start;
@@ -324,13 +324,17 @@ private int toDecimal(byte[] str, int index, int q, long c, int dk, FormattedFPD
              * upin    iff    u' = sp10 10^k in Rv
              * wpin    iff    w' = tp10 10^k in Rv
              * See section 9.3 of [1].
+             *
+             * Also,
+             * d_v = v      iff     4 sp10 = vb
              */
             long sp10 = 10 * multiplyHigh(s, 115_292_150_460_684_698L << 4);
             long tp10 = sp10 + 10;
             boolean upin = vbl + out <= sp10 << 2;
             boolean wpin = (tp10 << 2) + out <= vbr;
             if (upin != wpin) {
-                return toChars(str, index, upin ? sp10 : tp10, k, fd);
+                /* Exactly one of u' or w' lies in Rv */
+                return toChars(str, index, upin ? sp10 : tp10, k, fd, sp10 << 2 == vb, wpin);
             }
         }
 
@@ -339,20 +343,24 @@ private int toDecimal(byte[] str, int index, int q, long c, int dk, FormattedFPD
          * uin    iff    u = s 10^k in Rv
          * win    iff    w = t 10^k in Rv
          * See section 9.3 of [1].
+         *
+         * Also,
+         * d_v = v      iff     4 s = vb
          */
         long t = s + 1;
         boolean uin = vbl + out <= s << 2;
         boolean win = (t << 2) + out <= vbr;
         if (uin != win) {
             /* Exactly one of u or w lies in Rv */
-            return toChars(str, index, uin ? s : t, k + dk, fd);
+            return toChars(str, index, uin ? s : t, k + dk, fd, s << 2 == vb, win);
         }
         /*
          * Both u and w lie in Rv: determine the one closest to v.
          * See section 9.3 of [1].
          */
         long cmp = vb - (s + t << 1);
-        return toChars(str, index, cmp < 0 || cmp == 0 && (s & 0x1) == 0 ? s : t, k + dk, fd);
+        boolean away = cmp > 0 || cmp == 0 && (s & 0x1) != 0;
+        return toChars(str, index, away ? t : s, k + dk, fd, s << 2 == vb, away);
     }
 
     /*
@@ -371,7 +379,8 @@ private static long rop(long g1, long g0, long cp) {
     /*
      * Formats the decimal f 10^e.
      */
-    private int toChars(byte[] str, int index, long f, int e, FormattedFPDecimal fd) {
+    private int toChars(byte[] str, int index, long f, int e,
+                        FormattedFPDecimal fd, boolean exact, boolean away) {
         /*
          * For details not discussed here see section 10 of [1].
          *
@@ -383,7 +392,7 @@ private int toChars(byte[] str, int index, long f, int e, FormattedFPDecimal fd)
             len += 1;
         }
         if (fd != null) {
-            fd.set(f, e, len);
+            fd.set(f, e, len, exact, away);
             return index;
         }
 

src/java.base/share/classes/jdk/internal/math/FloatToDecimal.java

@@ -304,6 +304,7 @@ private int toDecimal(byte[] str, int index, int q, int c, int dk) {
             boolean upin = vbl + out <= sp10 << 2;
             boolean wpin = (tp10 << 2) + out <= vbr;
             if (upin != wpin) {
+                /* Exactly one of u' or w' lies in Rv */
                 return toChars(str, index, upin ? sp10 : tp10, k);
             }
         }
@@ -326,7 +327,8 @@ private int toDecimal(byte[] str, int index, int q, int c, int dk) {
          * See section 9.3 of [1].
          */
         int cmp = vb - (s + t << 1);
-        return toChars(str, index, cmp < 0 || cmp == 0 && (s & 0x1) == 0 ? s : t, k + dk);
+        boolean away = cmp > 0 || cmp == 0 && (s & 0x1) != 0;
+        return toChars(str, index, away ? t : s, k + dk);
     }
 
     /*

src/java.base/share/classes/jdk/internal/math/FloatingDecimal.java

@@ -1742,22 +1742,44 @@ public float floatValue() {
      * Returns a <code>BinaryToASCIIConverter</code> for a <code>double</code>.
      * The returned object is a <code>ThreadLocal</code> variable of this class.
      *
-     * @param d The double precision value to convert.
+     * @param d      The double precision value to convert.
+     * @param compat    compatibility with releases < JDK 21
      * @return The converter.
      */
-    public static BinaryToASCIIConverter getBinaryToASCIIConverter(double d) {
-        return getBinaryToASCIIConverter(d, true);
+    public static BinaryToASCIIConverter getBinaryToASCIIConverter(double d, boolean compat) {
+        return compat
+                ? getCompatBinaryToASCIIConverter(d, true)
+                : getBinaryToASCIIConverter(d);
     }
 
-    /**
-     * Returns a <code>BinaryToASCIIConverter</code> for a <code>double</code>.
-     * The returned object is a <code>ThreadLocal</code> variable of this class.
-     *
-     * @param d The double precision value to convert.
-     * @param isCompatibleFormat
-     * @return The converter.
+    private static BinaryToASCIIConverter getBinaryToASCIIConverter(double d) {
+        assert Double.isFinite(d);
+
+        FormattedFPDecimal dec = FormattedFPDecimal.split(d);
+        BinaryToASCIIBuffer buf = getBinaryToASCIIBuffer();
+
+        buf.nDigits = dec.getPrecision();
+        buf.decExponent = dec.getExp() + buf.nDigits;
+        buf.firstDigitIndex = 0;
+        buf.exactDecimalConversion = dec.getExact();
+        buf.decimalDigitsRoundedUp = dec.getAway();
+
+        long f = dec.getSignificand();
+        char[] digits = buf.digits;
+        for (int i = buf.nDigits - 1; i >= 0; --i) {
+            long q = f / 10;
+            digits[i] = (char) ((f - 10 * q) + '0');
+            f = q;
+        }
+        return buf;
+    }
+
+    /*
+     * The old implementation of getBinaryToASCIIConverter().
+     * Should be removed in the future, along with its dependent methods and
+     * fields (> 550 lines).
      */
-    static BinaryToASCIIConverter getBinaryToASCIIConverter(double d, boolean isCompatibleFormat) {
+    private static BinaryToASCIIConverter getCompatBinaryToASCIIConverter(double d, boolean isCompatibleFormat) {
         long dBits = Double.doubleToRawLongBits(d);
         boolean isNegative = (dBits&DoubleConsts.SIGN_BIT_MASK) != 0; // discover sign
         long fractBits = dBits & DoubleConsts.SIGNIF_BIT_MASK;

src/java.base/share/classes/jdk/internal/math/FormattedFPDecimal.java

@@ -47,9 +47,16 @@ public final class FormattedFPDecimal {
     public static final char PLAIN      = 'f';
     public static final char GENERAL    = 'g';
 
-    private long f;
+    /* Whether the decimal exactly represents the double */
+    private boolean exact;
+    /*
+     * When not exact, whether the magnitude of the decimal is larger than
+     * the magnitude of the double. Aka "away from zero".
+     */
+    private boolean away;
     private int e;  // normalized to 0 when f = 0
     private int n;
+    private long f;
     private char[] digits;  // ... and often the decimal separator as well
     private char[] exp;  // [+-][e]ee, that is, sign and minimum 2 digits
 
@@ -68,7 +75,7 @@ public static FormattedFPDecimal valueOf(double v, int prec, char form) {
         };
     }
 
-    private static FormattedFPDecimal split(double v) {
+    static FormattedFPDecimal split(double v) {
         FormattedFPDecimal fd = new FormattedFPDecimal();
         DoubleToDecimal.split(v, fd);
         return fd;
@@ -119,7 +126,7 @@ public static FormattedFPDecimal valueForDoubleToString(double v) {
 
         // Calculate new e based on updated precision
         final int eNew = expR - prec + 1;  // expR is defined as prec + e - 1
-        fd.set(s, eNew, prec);
+        fd.set(s, eNew, prec, fd.exact, fd.away);
 
         return fd;
     }
@@ -132,15 +139,25 @@ public int getPrecision() {
         return n;
     }
 
+    public boolean getAway() {
+        return away;
+    }
+
+    public boolean getExact() {
+        return exact;
+    }
+
     public int getExp() {
         return e;
     }
 
-    public void set(long f, int e, int n) {
+    public void set(long f, int e, int n, boolean exact, boolean away) {
         /* Initially, n = 0 if f = 0, and 10^{n-1} <= f < 10^n if f != 0 */
         this.f = f;
         this.e = e;
         this.n = n;
+        this.exact = exact;
+        this.away = away;
     }
 
     public char[] getExponent() {