8366017: Extend the set of inputs handled by fast paths in FloatingDecimal

Reviewed-by: darcy

Author: rgiulietti

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

@@ -322,7 +322,7 @@ void set(boolean isNegative, double source, int maximumFractionDigits) {
     void set(boolean isNegative, double source, int maximumDigits, boolean fixedPoint) {
         assert Double.isFinite(source);
 
-        FloatingDecimal.BinaryToASCIIConverter fdConverter =
+        FloatingDecimal.BinaryToASCIIBuffer fdConverter =
                 FloatingDecimal.getBinaryToASCIIConverter(source, COMPAT);
         boolean hasBeenRoundedUp = fdConverter.digitsRoundedUp();
         boolean valueExactAsDecimal = fdConverter.decimalDigitsExact();

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

@@ -43,7 +43,7 @@ final class MathUtils {
      */
 
     /*
-     * N = max{n : 10^n - 1 <= 2^Long.SIZE - 1}
+     * N = max{n : 10^n - 1 ≤ 2^Long.SIZE - 1}
      * Every positive integer up to N decimal digits fits in an unsigned long,
      * but there are positive integers of N + 1 digits that do not.
      */
@@ -52,16 +52,16 @@ final class MathUtils {
     /*
      * Given integer e, let 10^e = beta 2^r for the unique integer r and
      * real beta meeting
-     *      2^125 <= beta < 2^126.
+     *      2^125 ≤ beta < 2^126.
      * The unique r and beta are
      *      r = floor(log2(10^e)) - 125,  beta = 10^e 2^(-r)
      * Let g = floor(beta) + 1.
      * Thus,
-     *      (g - 1) 2^r <= 10^e < g 2^r
+     *      (g - 1) 2^r ≤ 10^e < g 2^r
      * Further, let
      *      g1 = floor(g 2^(-63)),  g0 = g - g1 2^63
      *
-     * For e with GE_MIN <= e <= GE_MAX, the values g1 and g0 are available
+     * For e with GE_MIN ≤ e ≤ GE_MAX, the values g1 and g0 are available
      * by invoking methods g1(e) and g0(e).
      * In addition, r = flog2pow10(e) - 125.
      *
@@ -73,17 +73,27 @@ final class MathUtils {
      * discussed in [1].
      * (See DoubleToDecimal.K_MIN and DoubleToDecimal.K_MAX.)
      *
-     * Let x = f 10^ep, where integers f and ep meet 10^(n-1) <= f < 10^n
+     * Let x = f 10^ep, where integers f and ep meet 10^(n-1) ≤ f < 10^n
      * (that is, f has n digits) and E_THR_Z < ep + n < E_THR_I.
      * (See DoubleToDecimal.E_THR_Z and DoubleToDecimal.E_THR_I.)
      *
-     * The decimal->double fast paths assume n <= N.
-     * Thus, E_THR_Z - (N - 1) <= ep <= E_THR_I - 2, which means that
+     * The decimal->double fast paths assume n ≤ N.
+     * Thus, E_THR_Z - (N - 1) ≤ ep ≤ E_THR_I - 2, which means that
      * the interval [GE_MIN, GE_MAX] must include the interval
      * [E_THR_Z - (N - 1), E_THR_I - 2].
      * That is,
      *      GE_MIN = min(-K_MAX, E_THR_Z - (N - 1))
      *      GE_MAX = max(-K_MIN, E_THR_I - 2)
+     *
+     * For the record, while the definition of g allows the case g = 2^126,
+     * the maximal g1 in the lookup table is 0x7FDD_E7F4_CA72_E30FL (e = -146),
+     * the minimal g1 is 0x4000_0000_0000_0000L (for e = 0),
+     * and the minimal g0 is 1.
+     * Hence, as easily verified, we always have
+     *      2^62 < g1 + 1 < 2^31 (2^32 - 1) < 2^63
+     *      2^125 < g = g1 2^63 + g0 < (g1 + 1) 2^63 < 2^94 (2^32 - 1) < 2^126
+     * We will assume these bounds observed by glancing at the lookup table,
+     * and use them liberally when so needed.
      */
     static final int GE_MIN = -342;
     static final int GE_MAX = 324;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -23,7 +23,8 @@
 
 /*
  * @test
- * @bug 4160406 4705734 4707389 4826774 4895911 4421494 6358355 7021568 7039369 4396272
+ * @bug 4160406 4705734 4707389 4826774 4895911 4421494 6358355 7021568
+ *      7039369 4396272 8366017
  * @summary Test for Double.parseDouble method and acceptance regex
  */
 
@@ -759,6 +760,39 @@ private static void testStrictness() {
             throw new RuntimeException("Inconsistent conversion");
     }
 
+    private static void testFastPaths() {
+        /* Exercises the fast paths in jdk.internal.math.FloatingDecimal. */
+        check("1", 0x1.0p0);  // 1.0
+        check("2.34000e2", 0x1.d4p7);  // 234.0
+        check("9.223e18", 0x1.fffab689adb6p62);  // 9.223e18
+        check("9.876e18", 0x1.121d33597384p63);  // 9.876e18
+        check("9223372036854776833", 0x1.0000000000001p63);  // 9.223372036854778E18
+        check("9223372036854776832", 0x1.0p63);  // 9.223372036854776E18
+
+        check("1.23", 0x1.3ae147ae147aep0);  // 1.23
+        check("0.000234", 0x1.eabbcb1cc9646p-13);  // 2.34E-4
+        check("3.45e23", 0x1.2439f32cbea41p78);  // 3.45E23
+        check("576460752303423616e20", 0x1.5af1d78b58c41p125);  // 5.764607523034236E37
+
+        check("1e37", 0x1.e17b84357691bp122);  // 1.0E37
+        check("8999e34", 0x1.0ecdc63717fbdp126);  // 8.999E37
+        check("0.9999e36", 0x1.8125c09cb78b7p119);  // 9.999E35
+        check("0.9876e37", 0x1.db831933296cep122);  // 9.876E36
+
+        check("1.2e-200", 0x1.d64af4cc52935p-665);  // 1.2E-200
+        check("2.3e100", 0x1.507ed84d17a69p333);  // 2.3E100
+        check("1.2000000000000000003e-200", 0x1.d64af4cc52935p-665);  // 1.2E-200
+        check("2.3000000000000000004e100", 0x1.507ed84d17a69p333);  // 2.3E100
+        check("5.249320425370670463e308", Double.POSITIVE_INFINITY);
+        check("5.2493204253706704633e308", Double.POSITIVE_INFINITY);
+
+        check("1.2e-320", 0x0.000000000097dp-1022);  // 1.2E-320
+        check("1.2000000000000000003e-320", 0x0.000000000097dp-1022);  // 1.2E-320
+
+        check("2.225073858507201383e-308", Double.MIN_NORMAL);
+        check("2.2250738585072013831e-308", Double.MIN_NORMAL);
+    }
+
     public static void main(String[] args) throws Exception {
         rudimentaryTest();
 
@@ -775,5 +809,8 @@ public static void main(String[] args) throws Exception {
         testSubnormalPowers();
         testPowers();
         testStrictness();
+
+        testFastPaths();
     }
+
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -23,8 +23,10 @@
 
 /*
  * @test
- * @bug 4160406 4705734 4707389 6358355 7032154
- * @summary Tests for Float.parseFloat method
+ * @bug 4160406 4705734 4707389 6358355 7032154 8366017
+ * @summary Tests for Float.parseFloat method (use -DallRoundtrips=true
+ *      to additionally check all non-negative, non-NaN float->String->float
+ *      roundtrips)
  */
 
 import java.math.BigDecimal;
@@ -315,6 +317,22 @@ private static void testPowers() {
         check(new BigDecimal(Float.MAX_VALUE).add(new BigDecimal(Math.ulp(Float.MAX_VALUE)).multiply(HALF)).toString());
     }
 
+    private static final int N = Float.floatToIntBits(Float.POSITIVE_INFINITY);
+
+    /* Tests all non-negative, non-NaN float->String->float roundtrips. */
+    private static void testAllRoundtrips() {
+        for (int i = 0; i <= N; ++i) {
+            float v = Float.intBitsToFloat(i);
+            String s = Float.toString(v);
+            float v0 = Float.parseFloat(s);
+            if (v != v0) {
+                fail(s, v0);
+            }
+        }
+    }
+
+    private static final String ALL_ROUNDTRIPS_PROP = "allRoundtrips";
+
     public static void main(String[] args) throws Exception {
         rudimentaryTest();
 
@@ -324,5 +342,9 @@ public static void main(String[] args) throws Exception {
         testParsing(paddedBadStrings, true);
 
         testPowers();
+
+        if (Boolean.getBoolean(ALL_ROUNDTRIPS_PROP)) {
+            testAllRoundtrips();
+        }
     }
 }