8336274: MutableBigInteger.leftShift(int) optimization
Reviewed-by: rgiulietti
This commit is contained in:
parent
a4ca6267e1
commit
d6820d1324
src/java.base/share/classes/java/math
test/jdk/java/math/BigInteger
@ -597,44 +597,52 @@ class MutableBigInteger {
|
|||||||
*/
|
*/
|
||||||
if (intLen == 0)
|
if (intLen == 0)
|
||||||
return;
|
return;
|
||||||
|
|
||||||
int nInts = n >>> 5;
|
int nInts = n >>> 5;
|
||||||
int nBits = n&0x1F;
|
int nBits = n & 0x1F;
|
||||||
int bitsInHighWord = BigInteger.bitLengthForInt(value[offset]);
|
int leadingZeros = Integer.numberOfLeadingZeros(value[offset]);
|
||||||
|
|
||||||
// If shift can be done without moving words, do so
|
// If shift can be done without moving words, do so
|
||||||
if (n <= (32-bitsInHighWord)) {
|
if (n <= leadingZeros) {
|
||||||
primitiveLeftShift(nBits);
|
primitiveLeftShift(nBits);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
int newLen = intLen + nInts +1;
|
int newLen = intLen + nInts;
|
||||||
if (nBits <= (32-bitsInHighWord))
|
if (nBits > leadingZeros)
|
||||||
newLen--;
|
newLen++;
|
||||||
if (value.length < newLen) {
|
|
||||||
// The array must grow
|
int[] result;
|
||||||
int[] result = new int[newLen];
|
final int newOffset;
|
||||||
for (int i=0; i < intLen; i++)
|
if (value.length < newLen) { // The array must grow
|
||||||
result[i] = value[offset+i];
|
result = new int[newLen];
|
||||||
setValue(result, newLen);
|
newOffset = 0;
|
||||||
} else if (value.length - offset >= newLen) {
|
|
||||||
// Use space on right
|
|
||||||
for(int i=0; i < newLen - intLen; i++)
|
|
||||||
value[offset+intLen+i] = 0;
|
|
||||||
} else {
|
} else {
|
||||||
// Must use space on left
|
result = value;
|
||||||
for (int i=0; i < intLen; i++)
|
newOffset = value.length - offset >= newLen ? offset : 0;
|
||||||
value[i] = value[offset+i];
|
|
||||||
for (int i=intLen; i < newLen; i++)
|
|
||||||
value[i] = 0;
|
|
||||||
offset = 0;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
int trailingZerosPos = newOffset + intLen;
|
||||||
|
if (nBits != 0) {
|
||||||
|
// Do primitive shift directly for speed
|
||||||
|
if (nBits <= leadingZeros) {
|
||||||
|
primitiveLeftShift(nBits, result, newOffset); // newOffset <= offset
|
||||||
|
} else {
|
||||||
|
int lastInt = value[offset + intLen - 1];
|
||||||
|
primitiveRightShift(32 - nBits, result, newOffset); // newOffset <= offset
|
||||||
|
result[trailingZerosPos++] = lastInt << nBits;
|
||||||
|
}
|
||||||
|
} else if (result != value || newOffset != offset) {
|
||||||
|
System.arraycopy(value, offset, result, newOffset, intLen);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add trailing zeros
|
||||||
|
if (result == value)
|
||||||
|
Arrays.fill(result, trailingZerosPos, newOffset + newLen, 0);
|
||||||
|
|
||||||
|
value = result;
|
||||||
intLen = newLen;
|
intLen = newLen;
|
||||||
if (nBits == 0)
|
offset = newOffset;
|
||||||
return;
|
|
||||||
if (nBits <= (32-bitsInHighWord))
|
|
||||||
primitiveLeftShift(nBits);
|
|
||||||
else
|
|
||||||
primitiveRightShift(32 -nBits);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@ -698,15 +706,30 @@ class MutableBigInteger {
|
|||||||
* less than 32.
|
* less than 32.
|
||||||
* Assumes that intLen > 0, n > 0 for speed
|
* Assumes that intLen > 0, n > 0 for speed
|
||||||
*/
|
*/
|
||||||
private final void primitiveRightShift(int n) {
|
private void primitiveRightShift(int n) {
|
||||||
|
primitiveRightShift(n, value, offset);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Right shift this MutableBigInteger n bits, where n is
|
||||||
|
* less than 32, placing the result in the specified array.
|
||||||
|
* Assumes that intLen > 0, n > 0 for speed.
|
||||||
|
* The result can be the value array of this MutableBigInteger,
|
||||||
|
* but for speed the copy is not performed safely, so, in that case
|
||||||
|
* the caller has to make sure that
|
||||||
|
* {@code (resFrom <= offset || resFrom >= offset + intLen)}.
|
||||||
|
*/
|
||||||
|
private void primitiveRightShift(int n, int[] result, int resFrom) {
|
||||||
int[] val = value;
|
int[] val = value;
|
||||||
int n2 = 32 - n;
|
int n2 = 32 - n;
|
||||||
for (int i=offset+intLen-1, c=val[i]; i > offset; i--) {
|
|
||||||
int b = c;
|
int b = val[offset];
|
||||||
c = val[i-1];
|
result[resFrom] = b >>> n;
|
||||||
val[i] = (c << n2) | (b >>> n);
|
for (int i = 1; i < intLen; i++) {
|
||||||
|
int c = b;
|
||||||
|
b = val[offset + i];
|
||||||
|
result[resFrom + i] = (c << n2) | (b >>> n);
|
||||||
}
|
}
|
||||||
val[offset] >>>= n;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@ -714,15 +737,30 @@ class MutableBigInteger {
|
|||||||
* less than 32.
|
* less than 32.
|
||||||
* Assumes that intLen > 0, n > 0 for speed
|
* Assumes that intLen > 0, n > 0 for speed
|
||||||
*/
|
*/
|
||||||
private final void primitiveLeftShift(int n) {
|
private void primitiveLeftShift(int n) {
|
||||||
|
primitiveLeftShift(n, value, offset);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Left shift this MutableBigInteger n bits, where n is
|
||||||
|
* less than 32, placing the result in the specified array.
|
||||||
|
* Assumes that intLen > 0, n > 0 for speed.
|
||||||
|
* The result can be the value array of this MutableBigInteger,
|
||||||
|
* but for speed the copy is not performed safely, so, in that case
|
||||||
|
* the caller has to make sure that
|
||||||
|
* {@code (resFrom <= offset || resFrom >= offset + intLen)}.
|
||||||
|
*/
|
||||||
|
private void primitiveLeftShift(int n, int[] result, int resFrom) {
|
||||||
int[] val = value;
|
int[] val = value;
|
||||||
int n2 = 32 - n;
|
int n2 = 32 - n;
|
||||||
for (int i=offset, c=val[i], m=i+intLen-1; i < m; i++) {
|
final int m = intLen - 1;
|
||||||
int b = c;
|
int b = val[offset];
|
||||||
c = val[i+1];
|
for (int i = 0; i < m; i++) {
|
||||||
val[i] = (b << n) | (c >>> n2);
|
int c = val[offset + i + 1];
|
||||||
|
result[resFrom + i] = (b << n) | (c >>> n2);
|
||||||
|
b = c;
|
||||||
}
|
}
|
||||||
val[offset+intLen-1] <<= n;
|
result[resFrom + m] = b << n;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@ -1511,17 +1549,6 @@ class MutableBigInteger {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private static void copyAndShift(int[] src, int srcFrom, int srcLen, int[] dst, int dstFrom, int shift) {
|
|
||||||
int n2 = 32 - shift;
|
|
||||||
int c=src[srcFrom];
|
|
||||||
for (int i=0; i < srcLen-1; i++) {
|
|
||||||
int b = c;
|
|
||||||
c = src[++srcFrom];
|
|
||||||
dst[dstFrom+i] = (b << shift) | (c >>> n2);
|
|
||||||
}
|
|
||||||
dst[dstFrom+srcLen-1] = c << shift;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Divide this MutableBigInteger by the divisor.
|
* Divide this MutableBigInteger by the divisor.
|
||||||
* The quotient will be placed into the provided quotient object &
|
* The quotient will be placed into the provided quotient object &
|
||||||
@ -1539,13 +1566,13 @@ class MutableBigInteger {
|
|||||||
MutableBigInteger rem; // Remainder starts as dividend with space for a leading zero
|
MutableBigInteger rem; // Remainder starts as dividend with space for a leading zero
|
||||||
if (shift > 0) {
|
if (shift > 0) {
|
||||||
divisor = new int[dlen];
|
divisor = new int[dlen];
|
||||||
copyAndShift(div.value,div.offset,dlen,divisor,0,shift);
|
div.primitiveLeftShift(shift, divisor, 0);
|
||||||
if (Integer.numberOfLeadingZeros(value[offset]) >= shift) {
|
if (Integer.numberOfLeadingZeros(value[offset]) >= shift) {
|
||||||
int[] remarr = new int[intLen + 1];
|
int[] remarr = new int[intLen + 1];
|
||||||
rem = new MutableBigInteger(remarr);
|
rem = new MutableBigInteger(remarr);
|
||||||
rem.intLen = intLen;
|
rem.intLen = intLen;
|
||||||
rem.offset = 1;
|
rem.offset = 1;
|
||||||
copyAndShift(value,offset,intLen,remarr,1,shift);
|
this.primitiveLeftShift(shift, remarr, 1);
|
||||||
} else {
|
} else {
|
||||||
int[] remarr = new int[intLen + 2];
|
int[] remarr = new int[intLen + 2];
|
||||||
rem = new MutableBigInteger(remarr);
|
rem = new MutableBigInteger(remarr);
|
||||||
|
191
test/jdk/java/math/BigInteger/MutableBigIntegerShiftTests.java
Normal file
191
test/jdk/java/math/BigInteger/MutableBigIntegerShiftTests.java
Normal file
@ -0,0 +1,191 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (c) 2024, 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
|
||||||
|
* under the terms of the GNU General Public License version 2 only, as
|
||||||
|
* published by the Free Software Foundation.
|
||||||
|
*
|
||||||
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||||
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||||
|
* version 2 for more details (a copy is included in the LICENSE file that
|
||||||
|
* accompanied this code).
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License version
|
||||||
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||||
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
*
|
||||||
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||||
|
* or visit www.oracle.com if you need additional information or have any
|
||||||
|
* questions.
|
||||||
|
*/
|
||||||
|
|
||||||
|
import jdk.test.lib.RandomFactory;
|
||||||
|
import org.junit.jupiter.params.ParameterizedTest;
|
||||||
|
import org.junit.jupiter.params.provider.MethodSource;
|
||||||
|
import org.junit.jupiter.params.provider.Arguments;
|
||||||
|
|
||||||
|
import java.math.BigInteger;
|
||||||
|
import java.math.MutableBigIntegerBox;
|
||||||
|
import java.util.Arrays;
|
||||||
|
import java.util.Random;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
import static java.math.MutableBigIntegerBox.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @test
|
||||||
|
* @bug 8336274
|
||||||
|
* @summary Tests for correctness of MutableBigInteger.leftShift(int)
|
||||||
|
* @library /test/lib
|
||||||
|
* @build jdk.test.lib.RandomFactory
|
||||||
|
* @build java.base/java.math.MutableBigIntegerBox
|
||||||
|
* @key randomness
|
||||||
|
* @run junit MutableBigIntegerShiftTests
|
||||||
|
*/
|
||||||
|
public class MutableBigIntegerShiftTests {
|
||||||
|
|
||||||
|
private static final int ORDER_SMALL = 60;
|
||||||
|
private static final int ORDER_MEDIUM = 100;
|
||||||
|
|
||||||
|
private static final Random random = RandomFactory.getRandom();
|
||||||
|
|
||||||
|
private static int[] orders() {
|
||||||
|
return new int[] { ORDER_SMALL, ORDER_MEDIUM };
|
||||||
|
}
|
||||||
|
|
||||||
|
@ParameterizedTest
|
||||||
|
@MethodSource("orders")
|
||||||
|
public void shift(int order) {
|
||||||
|
for (int i = 0; i < 100; i++) {
|
||||||
|
test(fetchNumber(order), random.nextInt(200));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@ParameterizedTest
|
||||||
|
@MethodSource("pathTargetedCases")
|
||||||
|
public void test(MutableBigIntegerBox x, int n) {
|
||||||
|
leftShiftAssertions(x, n);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static Arguments[] pathTargetedCases() {
|
||||||
|
return new Arguments[] {
|
||||||
|
// intLen == 0
|
||||||
|
Arguments.of(MutableBigIntegerBox.ZERO,
|
||||||
|
random.nextInt(33)),
|
||||||
|
// intLen != 0 && n <= leadingZeros
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
|
||||||
|
random.nextInt(1, 17)),
|
||||||
|
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits == 0
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32) }),
|
||||||
|
32),
|
||||||
|
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits != 0
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
|
||||||
|
32 + random.nextInt(1, 17)),
|
||||||
|
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
|
||||||
|
// && newOffset != offset
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 32) }, 1, 1),
|
||||||
|
32),
|
||||||
|
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
|
||||||
|
// && newOffset == offset
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32), random.nextInt() }, 0, 1),
|
||||||
|
32),
|
||||||
|
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
|
||||||
|
// && newOffset != offset
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 16) }, 1, 1),
|
||||||
|
32 + random.nextInt(1, 17)),
|
||||||
|
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
|
||||||
|
// && newOffset == offset
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16), random.nextInt() }, 0, 1),
|
||||||
|
32 + random.nextInt(1, 17)),
|
||||||
|
// intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length < newLen
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32) }),
|
||||||
|
random.nextInt(17, 32)),
|
||||||
|
// intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset != offset
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L << 15, 1L << 32) }, 1, 1),
|
||||||
|
random.nextInt(17, 32)),
|
||||||
|
// intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset == offset
|
||||||
|
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32), random.nextInt() }, 0, 1),
|
||||||
|
random.nextInt(17, 32)),
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void leftShiftAssertions(MutableBigIntegerBox x, int n) {
|
||||||
|
MutableBigIntegerBox xShifted = x.shiftLeft(n);
|
||||||
|
assertEquals(x.multiply(new MutableBigIntegerBox(BigInteger.TWO.pow(n))), xShifted);
|
||||||
|
assertEquals(x, xShifted.shiftRight(n));
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Get a random or boundary-case number. This is designed to provide
|
||||||
|
* a lot of numbers that will find failure points, such as max sized
|
||||||
|
* numbers, empty MutableBigIntegers, etc.
|
||||||
|
*
|
||||||
|
* If order is less than 2, order is changed to 2.
|
||||||
|
*/
|
||||||
|
private static MutableBigIntegerBox fetchNumber(int order) {
|
||||||
|
int numType = random.nextInt(8);
|
||||||
|
MutableBigIntegerBox result = null;
|
||||||
|
if (order < 2) order = 2;
|
||||||
|
|
||||||
|
int[] val;
|
||||||
|
switch (numType) {
|
||||||
|
case 0: // Empty
|
||||||
|
result = MutableBigIntegerBox.ZERO;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 1: // One
|
||||||
|
result = MutableBigIntegerBox.ONE;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 2: // All bits set in number
|
||||||
|
int numInts = (order + 31) >> 5;
|
||||||
|
int[] fullBits = new int[numInts];
|
||||||
|
Arrays.fill(fullBits, -1);
|
||||||
|
|
||||||
|
fullBits[0] &= -1 >>> -order;
|
||||||
|
result = new MutableBigIntegerBox(fullBits);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 3: // One bit in number
|
||||||
|
result = MutableBigIntegerBox.ONE.shiftLeft(random.nextInt(order));
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 4: // Random bit density
|
||||||
|
val = new int[(order + 31) >> 5];
|
||||||
|
int iterations = random.nextInt(order);
|
||||||
|
for (int i = 0; i < iterations; i++) {
|
||||||
|
int bitIdx = random.nextInt(order);
|
||||||
|
val[bitIdx >> 5] |= 1 << bitIdx;
|
||||||
|
}
|
||||||
|
result = new MutableBigIntegerBox(val);
|
||||||
|
break;
|
||||||
|
case 5: // Runs of consecutive ones and zeros
|
||||||
|
result = ZERO;
|
||||||
|
int remaining = order;
|
||||||
|
int bit = random.nextInt(2);
|
||||||
|
while (remaining > 0) {
|
||||||
|
int runLength = Math.min(remaining, random.nextInt(order));
|
||||||
|
result = result.shiftLeft(runLength);
|
||||||
|
if (bit > 0)
|
||||||
|
result = result.add(ONE.shiftLeft(runLength).subtract(ONE));
|
||||||
|
remaining -= runLength;
|
||||||
|
bit = 1 - bit;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 6: // random bits with trailing space
|
||||||
|
int len = random.nextInt((order + 31) >> 5) + 1;
|
||||||
|
int offset = random.nextInt(len);
|
||||||
|
val = new int[len << 1];
|
||||||
|
for (int i = 0; i < val.length; i++)
|
||||||
|
val[i] = random.nextInt();
|
||||||
|
result = new MutableBigIntegerBox(val, offset, len);
|
||||||
|
break;
|
||||||
|
default: // random bits
|
||||||
|
result = new MutableBigIntegerBox(new BigInteger(order, random));
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
}
|
@ -0,0 +1,180 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (c) 2024, 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
|
||||||
|
* under the terms of the GNU General Public License version 2 only, as
|
||||||
|
* published by the Free Software Foundation.
|
||||||
|
*
|
||||||
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||||
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||||
|
* version 2 for more details (a copy is included in the LICENSE file that
|
||||||
|
* accompanied this code).
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License version
|
||||||
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||||
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
*
|
||||||
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||||
|
* or visit www.oracle.com if you need additional information or have any
|
||||||
|
* questions.
|
||||||
|
*/
|
||||||
|
|
||||||
|
package java.math;
|
||||||
|
|
||||||
|
import java.util.Arrays;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A class for tests.
|
||||||
|
*/
|
||||||
|
public class MutableBigIntegerBox {
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Constant zero
|
||||||
|
*/
|
||||||
|
public static final MutableBigIntegerBox ZERO = new MutableBigIntegerBox(new MutableBigInteger());
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Constant one
|
||||||
|
*/
|
||||||
|
public static final MutableBigIntegerBox ONE = new MutableBigIntegerBox(MutableBigInteger.ONE);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Constant two
|
||||||
|
*/
|
||||||
|
public static final MutableBigIntegerBox TWO = new MutableBigIntegerBox(new MutableBigInteger(2));
|
||||||
|
|
||||||
|
private MutableBigInteger val;
|
||||||
|
|
||||||
|
MutableBigIntegerBox(MutableBigInteger val) {
|
||||||
|
this.val = val;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Construct MutableBigIntegerBox from magnitude, starting from
|
||||||
|
* offset and with a length of intLen ints.
|
||||||
|
* The value is normalized.
|
||||||
|
* @param mag the magnitude
|
||||||
|
* @param offset the offset where the value starts
|
||||||
|
* @param intLen the length of the value, in int words.
|
||||||
|
*/
|
||||||
|
public MutableBigIntegerBox(int[] mag, int offset, int intLen) {
|
||||||
|
this(new MutableBigInteger(mag));
|
||||||
|
val.offset = offset;
|
||||||
|
val.intLen = intLen;
|
||||||
|
val.normalize();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Construct MutableBigIntegerBox from magnitude.
|
||||||
|
* The value is normalized.
|
||||||
|
* @param mag the magnitude
|
||||||
|
*/
|
||||||
|
public MutableBigIntegerBox(int[] mag) {
|
||||||
|
this(mag, 0, mag.length);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Construct MutableBigIntegerBox from BigInteger val
|
||||||
|
* @param val the value
|
||||||
|
*/
|
||||||
|
public MutableBigIntegerBox(BigInteger val) {
|
||||||
|
this(val.mag);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the bit length of this MutableBigInteger value
|
||||||
|
* @return the bit length of this MutableBigInteger value
|
||||||
|
*/
|
||||||
|
public long bitLength() {
|
||||||
|
return val.bitLength();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return {@code this << n}
|
||||||
|
* @return {@code this << n}
|
||||||
|
* @param n the shift
|
||||||
|
*/
|
||||||
|
public MutableBigIntegerBox shiftLeft(int n) {
|
||||||
|
MutableBigIntegerBox res = new MutableBigIntegerBox(val.value.clone(), val.offset, val.intLen);
|
||||||
|
res.val.safeLeftShift(n);
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return {@code this >> n}
|
||||||
|
* @return {@code this >> n}
|
||||||
|
* @param n the shift
|
||||||
|
*/
|
||||||
|
public MutableBigIntegerBox shiftRight(int n) {
|
||||||
|
MutableBigInteger res = new MutableBigInteger(val);
|
||||||
|
res.safeRightShift(n);
|
||||||
|
return new MutableBigIntegerBox(res);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return this + addend
|
||||||
|
* @return this + addend
|
||||||
|
* @param addend the addend
|
||||||
|
*/
|
||||||
|
public MutableBigIntegerBox add(MutableBigIntegerBox addend) {
|
||||||
|
MutableBigInteger res = new MutableBigInteger(val);
|
||||||
|
res.add(addend.val);
|
||||||
|
return new MutableBigIntegerBox(res);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return this - subtraend
|
||||||
|
* @return this - subtraend
|
||||||
|
* @param subtraend the subtraend
|
||||||
|
*/
|
||||||
|
public MutableBigIntegerBox subtract(MutableBigIntegerBox subtraend) {
|
||||||
|
MutableBigInteger res = new MutableBigInteger(val);
|
||||||
|
res.subtract(subtraend.val);
|
||||||
|
return new MutableBigIntegerBox(res);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return this * multiplier
|
||||||
|
* @return this * multiplier
|
||||||
|
* @param multiplier the multiplier
|
||||||
|
*/
|
||||||
|
public MutableBigIntegerBox multiply(MutableBigIntegerBox multiplier) {
|
||||||
|
MutableBigInteger res = new MutableBigInteger();
|
||||||
|
if (!(val.isZero() || multiplier.val.isZero()))
|
||||||
|
val.multiply(multiplier.val, res);
|
||||||
|
|
||||||
|
return new MutableBigIntegerBox(res);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Compare the magnitude of two MutableBigIntegers. Returns -1, 0 or 1
|
||||||
|
* as this is numerically less than, equal to, or greater than {@code b}.
|
||||||
|
* @return -1, 0 or 1 as this is numerically less than, equal to, or
|
||||||
|
* greater than {@code b}.
|
||||||
|
* @param b the value to compare
|
||||||
|
*/
|
||||||
|
public int compare(MutableBigIntegerBox b) {
|
||||||
|
return val.compare(b.val);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Compares this MutableBigIntegerBox with the specified Object for equality.
|
||||||
|
*
|
||||||
|
* @param x Object to which this MutableBigIntegerBox is to be compared.
|
||||||
|
* @return {@code true} if and only if the specified Object is a
|
||||||
|
* MutableBigIntegerBox whose value is numerically equal to this MutableBigIntegerBox.
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public boolean equals(Object x) {
|
||||||
|
return (x instanceof MutableBigIntegerBox xInt)
|
||||||
|
&& Arrays.equals(val.value, val.offset, val.offset + val.intLen,
|
||||||
|
xInt.val.value, xInt.val.offset, xInt.val.offset + xInt.val.intLen);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String toString() {
|
||||||
|
return val.toString();
|
||||||
|
}
|
||||||
|
}
|
Loading…
x
Reference in New Issue
Block a user