--- a/jdk/src/java.base/share/classes/java/math/MutableBigInteger.java Thu Dec 10 15:57:27 2015 -0800
+++ b/jdk/src/java.base/share/classes/java/math/MutableBigInteger.java Thu Dec 10 17:47:26 2015 -0800
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2015, 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
@@ -1867,6 +1867,96 @@
}
/**
+ * Calculate the integer square root {@code floor(sqrt(this))} where
+ * {@code sqrt(.)} denotes the mathematical square root. The contents of
+ * {@code this} are <b>not</b> changed. The value of {@code this} is assumed
+ * to be non-negative.
+ *
+ * @implNote The implementation is based on the material in Henry S. Warren,
+ * Jr., <i>Hacker's Delight (2nd ed.)</i> (Addison Wesley, 2013), 279-282.
+ *
+ * @throws ArithmeticException if the value returned by {@code bitLength()}
+ * overflows the range of {@code int}.
+ * @return the integer square root of {@code this}
+ * @since 1.9
+ */
+ MutableBigInteger sqrt() {
+ // Special cases.
+ if (this.isZero()) {
+ return new MutableBigInteger(0);
+ } else if (this.value.length == 1
+ && (this.value[0] & LONG_MASK) < 4) { // result is unity
+ return ONE;
+ }
+
+ if (bitLength() <= 63) {
+ // Initial estimate is the square root of the positive long value.
+ long v = new BigInteger(this.value, 1).longValueExact();
+ long xk = (long)Math.floor(Math.sqrt(v));
+
+ // Refine the estimate.
+ do {
+ long xk1 = (xk + v/xk)/2;
+
+ // Terminate when non-decreasing.
+ if (xk1 >= xk) {
+ return new MutableBigInteger(new int[] {
+ (int)(xk >>> 32), (int)(xk & LONG_MASK)
+ });
+ }
+
+ xk = xk1;
+ } while (true);
+ } else {
+ // Set up the initial estimate of the iteration.
+
+ // Obtain the bitLength > 63.
+ int bitLength = (int) this.bitLength();
+ if (bitLength != this.bitLength()) {
+ throw new ArithmeticException("bitLength() integer overflow");
+ }
+
+ // Determine an even valued right shift into positive long range.
+ int shift = bitLength - 63;
+ if (shift % 2 == 1) {
+ shift++;
+ }
+
+ // Shift the value into positive long range.
+ MutableBigInteger xk = new MutableBigInteger(this);
+ xk.rightShift(shift);
+ xk.normalize();
+
+ // Use the square root of the shifted value as an approximation.
+ double d = new BigInteger(xk.value, 1).doubleValue();
+ BigInteger bi = BigInteger.valueOf((long)Math.ceil(Math.sqrt(d)));
+ xk = new MutableBigInteger(bi.mag);
+
+ // Shift the approximate square root back into the original range.
+ xk.leftShift(shift / 2);
+
+ // Refine the estimate.
+ MutableBigInteger xk1 = new MutableBigInteger();
+ do {
+ // xk1 = (xk + n/xk)/2
+ this.divide(xk, xk1, false);
+ xk1.add(xk);
+ xk1.rightShift(1);
+
+ // Terminate when non-decreasing.
+ if (xk1.compare(xk) >= 0) {
+ return xk;
+ }
+
+ // xk = xk1
+ xk.copyValue(xk1);
+
+ xk1.reset();
+ } while (true);
+ }
+ }
+
+ /**
* Calculate GCD of this and b. This and b are changed by the computation.
*/
MutableBigInteger hybridGCD(MutableBigInteger b) {