public void testCeilingPowerOfTwo() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { BigInteger result = BigIntegerMath.ceilingPowerOfTwo(x); assertTrue(BigIntegerMath.isPowerOfTwo(result)); assertTrue(result.compareTo(x) >= 0); assertTrue(result.compareTo(x.add(x)) < 0); } }
public void testFloorPowerOfTwo() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { BigInteger result = BigIntegerMath.floorPowerOfTwo(x); assertTrue(BigIntegerMath.isPowerOfTwo(result)); assertTrue(result.compareTo(x) <= 0); assertTrue(result.add(result).compareTo(x) > 0); } }
// Relies on the correctness of log2(BigInteger, {HALF_UP,HALF_DOWN}). public void testLog2HalfEven() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { int halfEven = BigIntegerMath.log2(x, HALF_EVEN); // Now figure out what rounding mode we should behave like (it depends if FLOOR was // odd/even). boolean floorWasEven = (BigIntegerMath.log2(x, FLOOR) & 1) == 0; assertEquals(BigIntegerMath.log2(x, floorWasEven ? HALF_DOWN : HALF_UP), halfEven); } }
// Relies on the correctness of sqrt(BigInteger, {HALF_UP,HALF_DOWN}). @GwtIncompatible // TODO public void testSqrtHalfEven() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { BigInteger halfEven = BigIntegerMath.sqrt(x, HALF_EVEN); // Now figure out what rounding mode we should behave like (it depends if FLOOR was // odd/even). boolean floorWasOdd = BigIntegerMath.sqrt(x, FLOOR).testBit(0); assertEquals(BigIntegerMath.sqrt(x, floorWasOdd ? HALF_UP : HALF_DOWN), halfEven); } }
// Depends on the correctness of BigIntegerMath.factorial private static void runBinomialTest(int firstN, int lastN) { for (int n = firstN; n <= lastN; n++) { for (int k = 0; k <= n; k++) { BigInteger expected = BigIntegerMath.factorial(n) .divide(BigIntegerMath.factorial(k)) .divide(BigIntegerMath.factorial(n - k)); assertEquals(expected, BigIntegerMath.binomial(n, k)); } } }
// Relies on the correctness of isPowerOfTwo(BigInteger). public void testLog2Exact() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { // We only expect an exception if x was not a power of 2. boolean isPowerOf2 = BigIntegerMath.isPowerOfTwo(x); try { assertEquals(x, ZERO.setBit(BigIntegerMath.log2(x, UNNECESSARY))); assertTrue(isPowerOf2); } catch (ArithmeticException e) { assertFalse(isPowerOf2); } } }
// Relies on the correctness of log10(BigInteger, FLOOR). @GwtIncompatible // TODO public void testLog10Exact() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { int logFloor = BigIntegerMath.log10(x, FLOOR); boolean expectSuccess = TEN.pow(logFloor).equals(x); try { assertEquals(logFloor, BigIntegerMath.log10(x, UNNECESSARY)); assertTrue(expectSuccess); } catch (ArithmeticException e) { assertFalse(expectSuccess); } } }
// Relies on the correctness of sqrt(BigInteger, FLOOR). @GwtIncompatible // TODO public void testSqrtExact() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { BigInteger floor = BigIntegerMath.sqrt(x, FLOOR); // We only expect an exception if x was not a perfect square. boolean isPerfectSquare = floor.pow(2).equals(x); try { assertEquals(floor, BigIntegerMath.sqrt(x, UNNECESSARY)); assertTrue(isPerfectSquare); } catch (ArithmeticException e) { assertFalse(isPerfectSquare); } } }
public void testBinomialOutside() { for (int n = 0; n <= 50; n++) { try { BigIntegerMath.binomial(n, -1); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } try { BigIntegerMath.binomial(n, n + 1); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } } }
public void testFactorial() { for (int i = 0; i <= DoubleMath.MAX_FACTORIAL; i++) { double actual = BigIntegerMath.factorial(i).doubleValue(); double result = DoubleMath.factorial(i); assertEquals(actual, result, Math.ulp(actual)); } }
@GwtIncompatible // TODO public void testConstantSqrt2PrecomputedBits() { assertEquals( BigIntegerMath.sqrt( BigInteger.ZERO.setBit(2 * BigIntegerMath.SQRT2_PRECOMPUTE_THRESHOLD + 1), FLOOR), BigIntegerMath.SQRT2_PRECOMPUTED_BITS); }
public void testFactorialNegative() { try { BigIntegerMath.factorial(-1); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } }
public void testCeilingPowerOfTwoZero() { try { BigIntegerMath.ceilingPowerOfTwo(BigInteger.ZERO); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } }
public void testFactorial() { BigInteger expected = BigInteger.ONE; for (int i = 1; i <= 200; i++) { expected = expected.multiply(BigInteger.valueOf(i)); assertEquals(expected, BigIntegerMath.factorial(i)); } }
@GwtIncompatible // TODO @AndroidIncompatible // slow public void testDivNonZeroExact() { boolean isAndroid = System.getProperties().getProperty("java.runtime.name").contains("Android"); for (BigInteger p : NONZERO_BIGINTEGER_CANDIDATES) { for (BigInteger q : NONZERO_BIGINTEGER_CANDIDATES) { if (isAndroid && p.equals(BAD_FOR_ANDROID_P) && q.equals(BAD_FOR_ANDROID_Q)) { // https://code.google.com/p/android/issues/detail?id=196555 continue; } if (isAndroid && p.equals(BAD_FOR_GINGERBREAD_P) && q.equals(BAD_FOR_GINGERBREAD_Q)) { // Works fine under Marshmallow, so I haven't filed a bug. continue; } boolean dividesEvenly = p.remainder(q).equals(ZERO); try { BigInteger quotient = BigIntegerMath.divide(p, q, UNNECESSARY); BigInteger undone = quotient.multiply(q); if (!p.equals(undone)) { failFormat("expected %s.multiply(%s) = %s; got %s", quotient, q, p, undone); } assertTrue(dividesEvenly); } catch (ArithmeticException e) { assertFalse(dividesEvenly); } } } }
public void testIsPowerOfTwo() { for (BigInteger x : ALL_BIGINTEGER_CANDIDATES) { // Checks for a single bit set. boolean expected = x.signum() > 0 & x.and(x.subtract(ONE)).equals(ZERO); assertEquals(expected, BigIntegerMath.isPowerOfTwo(x)); } }
@GwtIncompatible // TODO public void testLog10TrivialOnPowerOf10() { BigInteger x = BigInteger.TEN.pow(100); for (RoundingMode mode : ALL_ROUNDING_MODES) { assertEquals(100, BigIntegerMath.log10(x, mode)); } }
@GwtIncompatible // TODO public void testZeroDivIsAlwaysZero() { for (BigInteger q : NONZERO_BIGINTEGER_CANDIDATES) { for (RoundingMode mode : ALL_ROUNDING_MODES) { assertEquals(ZERO, BigIntegerMath.divide(ZERO, q, mode)); } } }
public void testLog2Floor() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { for (RoundingMode mode : asList(FLOOR, DOWN)) { int result = BigIntegerMath.log2(x, mode); assertTrue(ZERO.setBit(result).compareTo(x) <= 0); assertTrue(ZERO.setBit(result + 1).compareTo(x) > 0); } } }
public void testLog2Ceiling() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { for (RoundingMode mode : asList(CEILING, UP)) { int result = BigIntegerMath.log2(x, mode); assertTrue(ZERO.setBit(result).compareTo(x) >= 0); assertTrue(result == 0 || ZERO.setBit(result - 1).compareTo(x) < 0); } } }
public void testFloorPowerOfTwoNegative() { for (BigInteger x : NEGATIVE_BIGINTEGER_CANDIDATES) { try { BigIntegerMath.floorPowerOfTwo(x); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } } }
public void testLog2NegativeAlwaysThrows() { for (RoundingMode mode : ALL_ROUNDING_MODES) { try { BigIntegerMath.log2(BigInteger.valueOf(-1), mode); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } } }
public void testLog2HalfDown() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { int result = BigIntegerMath.log2(x, HALF_DOWN); BigInteger x2 = x.pow(2); // x^2 <= 2^(2 * result + 1), or else we would have rounded up assertTrue(ZERO.setBit(2 * result + 1).compareTo(x2) >= 0); // x^2 > 2^(2 * result - 1), or else we would have rounded down assertTrue(result == 0 || ZERO.setBit(2 * result - 1).compareTo(x2) < 0); } }
@GwtIncompatible // TODO public void testLog10ZeroAlwaysThrows() { for (RoundingMode mode : ALL_ROUNDING_MODES) { try { BigIntegerMath.log10(ZERO, mode); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } } }
@GwtIncompatible // TODO public void testLog10Floor() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { for (RoundingMode mode : asList(FLOOR, DOWN)) { int result = BigIntegerMath.log10(x, mode); assertTrue(TEN.pow(result).compareTo(x) <= 0); assertTrue(TEN.pow(result + 1).compareTo(x) > 0); } } }
@GwtIncompatible // TODO public void testSqrtNegativeAlwaysThrows() { for (RoundingMode mode : ALL_ROUNDING_MODES) { try { BigIntegerMath.sqrt(BigInteger.valueOf(-1), mode); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } } }
@GwtIncompatible // TODO public void testLog10Ceiling() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { for (RoundingMode mode : asList(CEILING, UP)) { int result = BigIntegerMath.log10(x, mode); assertTrue(TEN.pow(result).compareTo(x) >= 0); assertTrue(result == 0 || TEN.pow(result - 1).compareTo(x) < 0); } } }
@GwtIncompatible // TODO public void testSqrtCeiling() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { for (RoundingMode mode : asList(CEILING, UP)) { BigInteger result = BigIntegerMath.sqrt(x, mode); assertTrue(result.compareTo(ZERO) > 0); assertTrue(result.pow(2).compareTo(x) >= 0); assertTrue(result.signum() == 0 || result.subtract(ONE).pow(2).compareTo(x) < 0); } } }
@GwtIncompatible // TODO public void testSqrtFloor() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { for (RoundingMode mode : asList(FLOOR, DOWN)) { BigInteger result = BigIntegerMath.sqrt(x, mode); assertTrue(result.compareTo(ZERO) > 0); assertTrue(result.pow(2).compareTo(x) <= 0); assertTrue(result.add(ONE).pow(2).compareTo(x) > 0); } } }
@GwtIncompatible // TODO public void testLog10HalfDown() { for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) { int result = BigIntegerMath.log10(x, HALF_DOWN); BigInteger x2 = x.pow(2); // x^2 <= 10^(2 * result + 1), or else we would have rounded up assertTrue(TEN.pow(2 * result + 1).compareTo(x2) >= 0); // x^2 > 10^(2 * result - 1), or else we would have rounded down assertTrue(result == 0 || TEN.pow(2 * result - 1).compareTo(x2) < 0); } }