Re: JDK 9 RFR of 8058505: BigIntegerTest does not exercise Burnikel-Ziegler division

[Joe Darcy]

Hi Brian,

The test change looks fine; thanks,

-Joe

On 9/15/2014 1:30 PM, Brian Burkhalter wrote:

Hello,

This is a test-only change.

Issue:https://bugs.openjdk.java.net/browse/JDK-8058505

Webrev:http://cr.openjdk.java.net/~bpb/8058505/webrev.00/ <http://cr.openjdk.java.net/%7Ebpb/8058505/webrev.00/>

I verified that the updated version passes (as mentioned below) and in fact exercises the B-Z division branch of the library code.

Thanks,

Brian

On Sep 15, 2014, at 7:17 AM, Robert Gibson <robbiexgib...@yahoo.com <mailto:robbiexgib...@yahoo.com>> wrote:

Here is a patch to fix the test bug mentioned previously. The Burnikel-Ziegler division code is now exercised, and you'll be glad to know that the tests still pass!

Robert

--- BigIntegerTest.java 2014-09-15 15:55:47.632012000 +0200
+++ BigIntegerTestPatched.java  2014-09-15 16:07:53.363563000 +0200
@@ -71,6 +71,7 @@
    static final int BITS_TOOM_COOK_SQUARE = 6912;
    static final int BITS_SCHOENHAGE_BASE = 640;
    static final int BITS_BURNIKEL_ZIEGLER = 2560;
+    static final int BITS_BURNIKEL_ZIEGLER_OFFSET = 1280;
    static final int ORDER_SMALL = 60;
    static final int ORDER_MEDIUM = 100;
@@ -288,19 +289,19 @@
     * where {@code abs(u) > abs(v)} and {@code a > b && b > 0}, then if
     * {@code w/z = q1*z + r1} and {@code u/v = q2*v + r2}, then
     * {@code q1 = q2*pow(2,a-b)} and {@code r1 = r2*pow(2,b)}.  The test

- * ensures that {@code v} is just under the B-Z threshold and that {@code w} - * and {@code z} are both over the threshold. This implies that {@code u/v}

-     * uses the standard division algorithm and {@code w/z} uses the B-Z

- * algorithm. The results of the two algorithms are then compared using the - * observation described in the foregoing and if they are not equal a

-     * failure is logged.

+ * ensures that {@code v} is just under the B-Z threshold, that {@code z} is + * over the threshold and {@code w} is much larger than {@code z}. This

+     * implies that {@code u/v} uses the standard division algorithm and

+ * {@code w/z} uses the B-Z algorithm. The results of the two algorithms + * are then compared using the observation described in the foregoing and

+     * if they are not equal a failure is logged.
     */
    public static void divideLarge() {
        int failCount = 0;

- BigInteger base = BigInteger.ONE.shiftLeft(BITS_BURNIKEL_ZIEGLER - 33); + BigInteger base = BigInteger.ONE.shiftLeft(BITS_BURNIKEL_ZIEGLER + BITS_BURNIKEL_ZIEGLER_OFFSET - 33);

        for (int i=0; i<SIZE; i++) {

- BigInteger addend = new BigInteger(BITS_BURNIKEL_ZIEGLER - 34, rnd); + BigInteger addend = new BigInteger(BITS_BURNIKEL_ZIEGLER + BITS_BURNIKEL_ZIEGLER_OFFSET - 34, rnd);

            BigInteger v = base.add(addend);

BigInteger u = v.multiply(BigInteger.valueOf(2 + rnd.nextInt(Short.MAX_VALUE - 1)));

@@ -312,14 +313,14 @@
                v = v.negate();
            }
-            int a = 17 + rnd.nextInt(16);
+            int a = BITS_BURNIKEL_ZIEGLER_OFFSET + rnd.nextInt(16);
            int b = 1 + rnd.nextInt(16);
-            BigInteger w = u.multiply(BigInteger.valueOf(1L << a));
-            BigInteger z = v.multiply(BigInteger.valueOf(1L << b));
+            BigInteger w = u.multiply(BigInteger.ONE.shiftLeft(a));
+            BigInteger z = v.multiply(BigInteger.ONE.shiftLeft(b));
            BigInteger[] divideResult = u.divideAndRemainder(v);

- divideResult[0] = divideResult[0].multiply(BigInteger.valueOf(1L << (a - b))); - divideResult[1] = divideResult[1].multiply(BigInteger.valueOf(1L << b)); + divideResult[0] = divideResult[0].multiply(BigInteger.ONE.shiftLeft(a - b)); + divideResult[1] = divideResult[1].multiply(BigInteger.ONE.shiftLeft(b));

            BigInteger[] bzResult = w.divideAndRemainder(z);
            if (divideResult[0].compareTo(bzResult[0]) != 0 ||