Author: celestin
Date: Thu Oct 13 11:20:48 2011
New Revision: 1182787
URL: http://svn.apache.org/viewvc?rev=1182787&view=rev
Log: (empty)
Added:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticUtils.java
- copied, changed from r1182658,
commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticsUtils.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticUtilsTest.java
- copied, changed from r1182658,
commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticsUtilsTest.java
Removed:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticsUtils.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticsUtilsTest.java
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtils.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/HypergeometricDistributionImpl.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/PascalDistributionImpl.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math/fraction/Fraction.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/RandomDataImpl.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtilsTest.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/InverseHilbertMatrix.java
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtils.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtils.java?rev=1182787&r1=1182786&r2=1182787&view=diff
==============================================================================
---
commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtils.java
(original)
+++
commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtils.java
Thu Oct 13 11:20:48 2011
@@ -22,7 +22,7 @@ import java.util.List;
import java.util.Map;
import org.apache.commons.math.fraction.BigFraction;
-import org.apache.commons.math.util.ArithmeticsUtils;
+import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
/**
@@ -326,7 +326,7 @@ public class PolynomialsUtils {
final int[][] coeff = new int[dp1][dp1];
for (int i = 0; i < dp1; i++){
for(int j = 0; j <= i; j++){
- coeff[i][j] = (int) ArithmeticsUtils.binomialCoefficient(i, j);
+ coeff[i][j] = (int) ArithmeticUtils.binomialCoefficient(i, j);
}
}
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/HypergeometricDistributionImpl.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/HypergeometricDistributionImpl.java?rev=1182787&r1=1182786&r2=1182787&view=diff
==============================================================================
---
commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/HypergeometricDistributionImpl.java
(original)
+++
commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/HypergeometricDistributionImpl.java
Thu Oct 13 11:20:48 2011
@@ -23,7 +23,7 @@ import org.apache.commons.math.exception
import org.apache.commons.math.exception.NotStrictlyPositiveException;
import org.apache.commons.math.exception.NumberIsTooLargeException;
import org.apache.commons.math.exception.util.LocalizedFormats;
-import org.apache.commons.math.util.ArithmeticsUtils;
+import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
/**
@@ -231,9 +231,9 @@ public class HypergeometricDistributionI
* @return PMF for the distribution.
*/
private double probability(int n, int m, int k, int x) {
- return FastMath.exp(ArithmeticsUtils.binomialCoefficientLog(m, x) +
- ArithmeticsUtils.binomialCoefficientLog(n - m, k - x) -
- ArithmeticsUtils.binomialCoefficientLog(n, k));
+ return FastMath.exp(ArithmeticUtils.binomialCoefficientLog(m, x) +
+ ArithmeticUtils.binomialCoefficientLog(n - m, k - x) -
+ ArithmeticUtils.binomialCoefficientLog(n, k));
}
/**
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/PascalDistributionImpl.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/PascalDistributionImpl.java?rev=1182787&r1=1182786&r2=1182787&view=diff
==============================================================================
---
commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/PascalDistributionImpl.java
(original)
+++
commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/PascalDistributionImpl.java
Thu Oct 13 11:20:48 2011
@@ -22,7 +22,7 @@ import org.apache.commons.math.exception
import org.apache.commons.math.exception.NotPositiveException;
import org.apache.commons.math.exception.util.LocalizedFormats;
import org.apache.commons.math.special.Beta;
-import org.apache.commons.math.util.ArithmeticsUtils;
+import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
/**
@@ -128,7 +128,7 @@ public class PascalDistributionImpl exte
if (x < 0) {
ret = 0.0;
} else {
- ret = ArithmeticsUtils.binomialCoefficientDouble(x +
+ ret = ArithmeticUtils.binomialCoefficientDouble(x +
numberOfSuccesses - 1, numberOfSuccesses - 1) *
FastMath.pow(probabilityOfSuccess, numberOfSuccesses) *
FastMath.pow(1.0 - probabilityOfSuccess, x);
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/fraction/Fraction.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/fraction/Fraction.java?rev=1182787&r1=1182786&r2=1182787&view=diff
==============================================================================
---
commons/proper/math/trunk/src/main/java/org/apache/commons/math/fraction/Fraction.java
(original)
+++
commons/proper/math/trunk/src/main/java/org/apache/commons/math/fraction/Fraction.java
Thu Oct 13 11:20:48 2011
@@ -23,7 +23,7 @@ import org.apache.commons.math.FieldElem
import org.apache.commons.math.exception.util.LocalizedFormats;
import org.apache.commons.math.exception.MathArithmeticException;
import org.apache.commons.math.exception.NullArgumentException;
-import org.apache.commons.math.util.ArithmeticsUtils;
+import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
/**
@@ -268,7 +268,7 @@ public class Fraction
den = -den;
}
// reduce numerator and denominator by greatest common denominator.
- final int d = ArithmeticsUtils.gcd(num, den);
+ final int d = ArithmeticUtils.gcd(num, den);
if (d > 1) {
num /= d;
den /= d;
@@ -486,15 +486,15 @@ public class Fraction
}
// if denominators are randomly distributed, d1 will be 1 about 61%
// of the time.
- int d1 = ArithmeticsUtils.gcd(denominator, fraction.denominator);
+ int d1 = ArithmeticUtils.gcd(denominator, fraction.denominator);
if (d1==1) {
// result is ( (u*v' +/- u'v) / u'v')
- int uvp = ArithmeticsUtils.mulAndCheck(numerator,
fraction.denominator);
- int upv = ArithmeticsUtils.mulAndCheck(fraction.numerator,
denominator);
+ int uvp = ArithmeticUtils.mulAndCheck(numerator,
fraction.denominator);
+ int upv = ArithmeticUtils.mulAndCheck(fraction.numerator,
denominator);
return new Fraction
- (isAdd ? ArithmeticsUtils.addAndCheck(uvp, upv) :
- ArithmeticsUtils.subAndCheck(uvp, upv),
- ArithmeticsUtils.mulAndCheck(denominator,
fraction.denominator));
+ (isAdd ? ArithmeticUtils.addAndCheck(uvp, upv) :
+ ArithmeticUtils.subAndCheck(uvp, upv),
+ ArithmeticUtils.mulAndCheck(denominator,
fraction.denominator));
}
// the quantity 't' requires 65 bits of precision; see knuth 4.5.1
// exercise 7. we're going to use a BigInteger.
@@ -507,7 +507,7 @@ public class Fraction
// but d2 doesn't need extra precision because
// d2 = gcd(t,d1) = gcd(t mod d1, d1)
int tmodd1 = t.mod(BigInteger.valueOf(d1)).intValue();
- int d2 = (tmodd1==0)?d1:ArithmeticsUtils.gcd(tmodd1, d1);
+ int d2 = (tmodd1==0)?d1:ArithmeticUtils.gcd(tmodd1, d1);
// result is (t/d2) / (u'/d1)(v'/d2)
BigInteger w = t.divide(BigInteger.valueOf(d2));
@@ -516,7 +516,7 @@ public class Fraction
w);
}
return new Fraction (w.intValue(),
- ArithmeticsUtils.mulAndCheck(denominator/d1,
+ ArithmeticUtils.mulAndCheck(denominator/d1,
fraction.denominator/d2));
}
@@ -539,11 +539,11 @@ public class Fraction
}
// knuth 4.5.1
// make sure we don't overflow unless the result *must* overflow.
- int d1 = ArithmeticsUtils.gcd(numerator, fraction.denominator);
- int d2 = ArithmeticsUtils.gcd(fraction.numerator, denominator);
+ int d1 = ArithmeticUtils.gcd(numerator, fraction.denominator);
+ int d2 = ArithmeticUtils.gcd(fraction.numerator, denominator);
return getReducedFraction
- (ArithmeticsUtils.mulAndCheck(numerator/d1, fraction.numerator/d2),
- ArithmeticsUtils.mulAndCheck(denominator/d2,
fraction.denominator/d1));
+ (ArithmeticUtils.mulAndCheck(numerator/d1, fraction.numerator/d2),
+ ArithmeticUtils.mulAndCheck(denominator/d2,
fraction.denominator/d1));
}
/**
@@ -618,7 +618,7 @@ public class Fraction
denominator = -denominator;
}
// simplify fraction.
- int gcd = ArithmeticsUtils.gcd(numerator, denominator);
+ int gcd = ArithmeticUtils.gcd(numerator, denominator);
numerator /= gcd;
denominator /= gcd;
return new Fraction(numerator, denominator);
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/RandomDataImpl.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/RandomDataImpl.java?rev=1182787&r1=1182786&r2=1182787&view=diff
==============================================================================
---
commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/RandomDataImpl.java
(original)
+++
commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/RandomDataImpl.java
Thu Oct 13 11:20:48 2011
@@ -40,7 +40,7 @@ import org.apache.commons.math.exception
import org.apache.commons.math.exception.NotStrictlyPositiveException;
import org.apache.commons.math.exception.NumberIsTooLargeException;
import org.apache.commons.math.exception.util.LocalizedFormats;
-import org.apache.commons.math.util.ArithmeticsUtils;
+import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
import org.apache.commons.math.util.ResizableDoubleArray;
@@ -148,7 +148,7 @@ public class RandomDataImpl implements R
final ResizableDoubleArray ra = new ResizableDoubleArray(20);
while (qi < 1) {
- qi += FastMath.pow(LN2, i) / ArithmeticsUtils.factorial(i);
+ qi += FastMath.pow(LN2, i) / ArithmeticUtils.factorial(i);
ra.addElement(qi);
++i;
}
@@ -424,7 +424,7 @@ public class RandomDataImpl implements R
final double lambda = FastMath.floor(mean);
final double lambdaFractional = mean - lambda;
final double logLambda = FastMath.log(lambda);
- final double logLambdaFactorial =
ArithmeticsUtils.factorialLog((int) lambda);
+ final double logLambdaFactorial =
ArithmeticUtils.factorialLog((int) lambda);
final long y2 = lambdaFractional < Double.MIN_VALUE ? 0 :
nextPoisson(lambdaFractional);
final double delta = FastMath.sqrt(lambda * FastMath.log(32 *
lambda / FastMath.PI + 1));
final double halfDelta = delta / 2;
@@ -479,7 +479,7 @@ public class RandomDataImpl implements R
if (v > qr) {
continue;
}
- if (v < y * logLambda - ArithmeticsUtils.factorialLog((int) (y
+ lambda)) + logLambdaFactorial) {
+ if (v < y * logLambda - ArithmeticUtils.factorialLog((int) (y
+ lambda)) + logLambdaFactorial) {
y = lambda + y;
break;
}
Copied:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticUtils.java
(from r1182658,
commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticsUtils.java)
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticUtils.java?p2=commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticUtils.java&p1=commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticsUtils.java&r1=1182658&r2=1182787&rev=1182787&view=diff
==============================================================================
---
commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticsUtils.java
(original)
+++
commons/proper/math/trunk/src/main/java/org/apache/commons/math/util/ArithmeticUtils.java
Thu Oct 13 11:20:48 2011
@@ -28,7 +28,7 @@ import org.apache.commons.math.exception
*
* @version $Id$
*/
-public final class ArithmeticsUtils {
+public final class ArithmeticUtils {
/** All long-representable factorials */
static final long[] FACTORIALS = new long[] {
@@ -41,7 +41,7 @@ public final class ArithmeticsUtils {
6402373705728000l, 121645100408832000l, 2432902008176640000l };
/** Private constructor. */
- private ArithmeticsUtils() {
+ private ArithmeticUtils() {
super();
}
@@ -74,7 +74,7 @@ public final class ArithmeticsUtils {
* @since 1.2
*/
public static long addAndCheck(long a, long b) {
- return ArithmeticsUtils.addAndCheck(a, b,
LocalizedFormats.OVERFLOW_IN_ADDITION);
+ return ArithmeticUtils.addAndCheck(a, b,
LocalizedFormats.OVERFLOW_IN_ADDITION);
}
/**
@@ -103,7 +103,7 @@ public final class ArithmeticsUtils {
* represented by a long integer.
*/
public static long binomialCoefficient(final int n, final int k) {
- ArithmeticsUtils.checkBinomial(n, k);
+ ArithmeticUtils.checkBinomial(n, k);
if ((n == k) || (k == 0)) {
return 1;
}
@@ -180,7 +180,7 @@ public final class ArithmeticsUtils {
* @throws IllegalArgumentException if preconditions are not met.
*/
public static double binomialCoefficientDouble(final int n, final int k) {
- ArithmeticsUtils.checkBinomial(n, k);
+ ArithmeticUtils.checkBinomial(n, k);
if ((n == k) || (k == 0)) {
return 1d;
}
@@ -221,7 +221,7 @@ public final class ArithmeticsUtils {
* @throws IllegalArgumentException if preconditions are not met.
*/
public static double binomialCoefficientLog(final int n, final int k) {
- ArithmeticsUtils.checkBinomial(n, k);
+ ArithmeticUtils.checkBinomial(n, k);
if ((n == k) || (k == 0)) {
return 0;
}
@@ -323,7 +323,7 @@ public final class ArithmeticsUtils {
if (n < 21) {
return factorial(n);
}
- return FastMath.floor(FastMath.exp(ArithmeticsUtils.factorialLog(n)) +
0.5);
+ return FastMath.floor(FastMath.exp(ArithmeticUtils.factorialLog(n)) +
0.5);
}
/**
@@ -548,7 +548,7 @@ public final class ArithmeticsUtils {
if (a == 0 || b == 0){
return 0;
}
- int lcm = FastMath.abs(ArithmeticsUtils.mulAndCheck(a / gcd(a, b), b));
+ int lcm = FastMath.abs(ArithmeticUtils.mulAndCheck(a / gcd(a, b), b));
if (lcm == Integer.MIN_VALUE) {
throw new
MathArithmeticException(LocalizedFormats.LCM_OVERFLOW_32_BITS,
a, b);
@@ -582,7 +582,7 @@ public final class ArithmeticsUtils {
if (a == 0 || b == 0){
return 0;
}
- long lcm = FastMath.abs(ArithmeticsUtils.mulAndCheck(a / gcd(a, b),
b));
+ long lcm = FastMath.abs(ArithmeticUtils.mulAndCheck(a / gcd(a, b), b));
if (lcm == Long.MIN_VALUE){
throw new
MathArithmeticException(LocalizedFormats.LCM_OVERFLOW_64_BITS,
a, b);
Modified:
commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtilsTest.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtilsTest.java?rev=1182787&r1=1182786&r2=1182787&view=diff
==============================================================================
---
commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtilsTest.java
(original)
+++
commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/polynomials/PolynomialsUtilsTest.java
Thu Oct 13 11:20:48 2011
@@ -18,7 +18,7 @@ package org.apache.commons.math.analysis
import org.apache.commons.math.analysis.UnivariateRealFunction;
import org.apache.commons.math.analysis.integration.LegendreGaussIntegrator;
-import org.apache.commons.math.util.ArithmeticsUtils;
+import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
import org.apache.commons.math.util.Precision;
import org.junit.Assert;
@@ -289,7 +289,7 @@ public class PolynomialsUtilsTest {
for (int w = 0; w < 10; ++w) {
for (int i = 0; i < 10; ++i) {
PolynomialFunction jacobi =
PolynomialsUtils.createJacobiPolynomial(i, v, w);
- double binomial = ArithmeticsUtils.binomialCoefficient(v +
i, i);
+ double binomial = ArithmeticUtils.binomialCoefficient(v +
i, i);
Assert.assertTrue(Precision.equals(binomial,
jacobi.value(1.0), 1));
}
}
Modified:
commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/InverseHilbertMatrix.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/InverseHilbertMatrix.java?rev=1182787&r1=1182786&r2=1182787&view=diff
==============================================================================
---
commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/InverseHilbertMatrix.java
(original)
+++
commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/InverseHilbertMatrix.java
Thu Oct 13 11:20:48 2011
@@ -17,7 +17,7 @@
package org.apache.commons.math.linear;
import org.apache.commons.math.exception.DimensionMismatchException;
-import org.apache.commons.math.util.ArithmeticsUtils;
+import org.apache.commons.math.util.ArithmeticUtils;
/**
* This class implements inverses of Hilbert Matrices as
@@ -54,13 +54,13 @@ public class InverseHilbertMatrix
*/
public long getEntry(final int i, final int j) {
long val = i + j + 1;
- long aux = ArithmeticsUtils.binomialCoefficient(n + i, n - j - 1);
- val = ArithmeticsUtils.mulAndCheck(val, aux);
- aux = ArithmeticsUtils.binomialCoefficient(n + j, n - i - 1);
- val = ArithmeticsUtils.mulAndCheck(val, aux);
- aux = ArithmeticsUtils.binomialCoefficient(i + j, i);
- val = ArithmeticsUtils.mulAndCheck(val, aux);
- val = ArithmeticsUtils.mulAndCheck(val, aux);
+ long aux = ArithmeticUtils.binomialCoefficient(n + i, n - j - 1);
+ val = ArithmeticUtils.mulAndCheck(val, aux);
+ aux = ArithmeticUtils.binomialCoefficient(n + j, n - i - 1);
+ val = ArithmeticUtils.mulAndCheck(val, aux);
+ aux = ArithmeticUtils.binomialCoefficient(i + j, i);
+ val = ArithmeticUtils.mulAndCheck(val, aux);
+ val = ArithmeticUtils.mulAndCheck(val, aux);
return ((i + j) & 1) == 0 ? val : -val;
}
Copied:
commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticUtilsTest.java
(from r1182658,
commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticsUtilsTest.java)
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticUtilsTest.java?p2=commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticUtilsTest.java&p1=commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticsUtilsTest.java&r1=1182658&r2=1182787&rev=1182787&view=diff
==============================================================================
---
commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticsUtilsTest.java
(original)
+++
commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ArithmeticUtilsTest.java
Thu Oct 13 11:20:48 2011
@@ -28,11 +28,11 @@ import org.junit.Assert;
import org.junit.Test;
/**
- * Test cases for the {@link ArithmeticsUtils} class.
+ * Test cases for the {@link ArithmeticUtils} class.
*
* @version $Id$
*/
-public class ArithmeticsUtilsTest {
+public class ArithmeticUtilsTest {
/** cached binomial coefficients */
private static final List<Map<Integer, Long>> binomialCache = new
ArrayList<Map<Integer, Long>>();
@@ -40,23 +40,23 @@ public class ArithmeticsUtilsTest {
/** Verify that b(0,0) = 1 */
@Test
public void test0Choose0() {
- Assert.assertEquals(ArithmeticsUtils.binomialCoefficientDouble(0, 0),
1d, 0);
- Assert.assertEquals(ArithmeticsUtils.binomialCoefficientLog(0, 0), 0d,
0);
- Assert.assertEquals(ArithmeticsUtils.binomialCoefficient(0, 0), 1);
+ Assert.assertEquals(ArithmeticUtils.binomialCoefficientDouble(0, 0),
1d, 0);
+ Assert.assertEquals(ArithmeticUtils.binomialCoefficientLog(0, 0), 0d,
0);
+ Assert.assertEquals(ArithmeticUtils.binomialCoefficient(0, 0), 1);
}
@Test
public void testAddAndCheck() {
int big = Integer.MAX_VALUE;
int bigNeg = Integer.MIN_VALUE;
- Assert.assertEquals(big, ArithmeticsUtils.addAndCheck(big, 0));
+ Assert.assertEquals(big, ArithmeticUtils.addAndCheck(big, 0));
try {
- ArithmeticsUtils.addAndCheck(big, 1);
+ ArithmeticUtils.addAndCheck(big, 1);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
try {
- ArithmeticsUtils.addAndCheck(bigNeg, -1);
+ ArithmeticUtils.addAndCheck(bigNeg, -1);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
@@ -66,14 +66,14 @@ public class ArithmeticsUtilsTest {
public void testAddAndCheckLong() {
long max = Long.MAX_VALUE;
long min = Long.MIN_VALUE;
- Assert.assertEquals(max, ArithmeticsUtils.addAndCheck(max, 0L));
- Assert.assertEquals(min, ArithmeticsUtils.addAndCheck(min, 0L));
- Assert.assertEquals(max, ArithmeticsUtils.addAndCheck(0L, max));
- Assert.assertEquals(min, ArithmeticsUtils.addAndCheck(0L, min));
- Assert.assertEquals(1, ArithmeticsUtils.addAndCheck(-1L, 2L));
- Assert.assertEquals(1, ArithmeticsUtils.addAndCheck(2L, -1L));
- Assert.assertEquals(-3, ArithmeticsUtils.addAndCheck(-2L, -1L));
- Assert.assertEquals(min, ArithmeticsUtils.addAndCheck(min + 1, -1L));
+ Assert.assertEquals(max, ArithmeticUtils.addAndCheck(max, 0L));
+ Assert.assertEquals(min, ArithmeticUtils.addAndCheck(min, 0L));
+ Assert.assertEquals(max, ArithmeticUtils.addAndCheck(0L, max));
+ Assert.assertEquals(min, ArithmeticUtils.addAndCheck(0L, min));
+ Assert.assertEquals(1, ArithmeticUtils.addAndCheck(-1L, 2L));
+ Assert.assertEquals(1, ArithmeticUtils.addAndCheck(2L, -1L));
+ Assert.assertEquals(-3, ArithmeticUtils.addAndCheck(-2L, -1L));
+ Assert.assertEquals(min, ArithmeticUtils.addAndCheck(min + 1, -1L));
testAddAndCheckLongFailure(max, 1L);
testAddAndCheckLongFailure(min, -1L);
testAddAndCheckLongFailure(1L, max);
@@ -99,17 +99,17 @@ public class ArithmeticsUtilsTest {
6,
1 };
for (int i = 0; i < 6; i++) {
- Assert.assertEquals("5 choose " + i, bcoef5[i],
ArithmeticsUtils.binomialCoefficient(5, i));
+ Assert.assertEquals("5 choose " + i, bcoef5[i],
ArithmeticUtils.binomialCoefficient(5, i));
}
for (int i = 0; i < 7; i++) {
- Assert.assertEquals("6 choose " + i, bcoef6[i],
ArithmeticsUtils.binomialCoefficient(6, i));
+ Assert.assertEquals("6 choose " + i, bcoef6[i],
ArithmeticUtils.binomialCoefficient(6, i));
}
for (int n = 1; n < 10; n++) {
for (int k = 0; k <= n; k++) {
- Assert.assertEquals(n + " choose " + k, binomialCoefficient(n,
k), ArithmeticsUtils.binomialCoefficient(n, k));
- Assert.assertEquals(n + " choose " + k, binomialCoefficient(n,
k), ArithmeticsUtils.binomialCoefficientDouble(n, k), Double.MIN_VALUE);
- Assert.assertEquals(n + " choose " + k,
FastMath.log(binomialCoefficient(n, k)),
ArithmeticsUtils.binomialCoefficientLog(n, k), 10E-12);
+ Assert.assertEquals(n + " choose " + k, binomialCoefficient(n,
k), ArithmeticUtils.binomialCoefficient(n, k));
+ Assert.assertEquals(n + " choose " + k, binomialCoefficient(n,
k), ArithmeticUtils.binomialCoefficientDouble(n, k), Double.MIN_VALUE);
+ Assert.assertEquals(n + " choose " + k,
FastMath.log(binomialCoefficient(n, k)),
ArithmeticUtils.binomialCoefficientLog(n, k), 10E-12);
}
}
@@ -118,69 +118,69 @@ public class ArithmeticsUtilsTest {
for (int i = 0; i < n.length; i++) {
long expected = binomialCoefficient(n[i], k[i]);
Assert.assertEquals(n[i] + " choose " + k[i], expected,
- ArithmeticsUtils.binomialCoefficient(n[i], k[i]));
+ ArithmeticUtils.binomialCoefficient(n[i], k[i]));
Assert.assertEquals(n[i] + " choose " + k[i], expected,
- ArithmeticsUtils.binomialCoefficientDouble(n[i], k[i]), 0.0);
+ ArithmeticUtils.binomialCoefficientDouble(n[i], k[i]), 0.0);
Assert.assertEquals("log(" + n[i] + " choose " + k[i] + ")",
FastMath.log(expected),
- ArithmeticsUtils.binomialCoefficientLog(n[i], k[i]), 0.0);
+ ArithmeticUtils.binomialCoefficientLog(n[i], k[i]), 0.0);
}
}
@Test
public void testBinomialCoefficientFail() {
try {
- ArithmeticsUtils.binomialCoefficient(4, 5);
+ ArithmeticUtils.binomialCoefficient(4, 5);
Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
- ArithmeticsUtils.binomialCoefficientDouble(4, 5);
+ ArithmeticUtils.binomialCoefficientDouble(4, 5);
Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
- ArithmeticsUtils.binomialCoefficientLog(4, 5);
+ ArithmeticUtils.binomialCoefficientLog(4, 5);
Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
- ArithmeticsUtils.binomialCoefficient(-1, -2);
+ ArithmeticUtils.binomialCoefficient(-1, -2);
Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
- ArithmeticsUtils.binomialCoefficientDouble(-1, -2);
+ ArithmeticUtils.binomialCoefficientDouble(-1, -2);
Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
- ArithmeticsUtils.binomialCoefficientLog(-1, -2);
+ ArithmeticUtils.binomialCoefficientLog(-1, -2);
Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
- ArithmeticsUtils.binomialCoefficient(67, 30);
+ ArithmeticUtils.binomialCoefficient(67, 30);
Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// ignored
}
try {
- ArithmeticsUtils.binomialCoefficient(67, 34);
+ ArithmeticUtils.binomialCoefficient(67, 34);
Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// ignored
}
- double x = ArithmeticsUtils.binomialCoefficientDouble(1030, 515);
+ double x = ArithmeticUtils.binomialCoefficientDouble(1030, 515);
Assert.assertTrue("expecting infinite binomial coefficient", Double
.isInfinite(x));
}
@@ -199,7 +199,7 @@ public class ArithmeticsUtilsTest {
boolean shouldThrow = false;
boolean didThrow = false;
try {
- ourResult = ArithmeticsUtils.binomialCoefficient(n, k);
+ ourResult = ArithmeticUtils.binomialCoefficient(n, k);
} catch (MathArithmeticException ex) {
didThrow = true;
}
@@ -214,78 +214,78 @@ public class ArithmeticsUtilsTest {
if (!shouldThrow && exactResult > 1) {
Assert.assertEquals(n + " choose " + k, 1.,
- ArithmeticsUtils.binomialCoefficientDouble(n, k) /
exactResult, 1e-10);
+ ArithmeticUtils.binomialCoefficientDouble(n, k) /
exactResult, 1e-10);
Assert.assertEquals(n + " choose " + k, 1,
- ArithmeticsUtils.binomialCoefficientLog(n, k) /
FastMath.log(exactResult), 1e-10);
+ ArithmeticUtils.binomialCoefficientLog(n, k) /
FastMath.log(exactResult), 1e-10);
}
}
}
- long ourResult = ArithmeticsUtils.binomialCoefficient(300, 3);
+ long ourResult = ArithmeticUtils.binomialCoefficient(300, 3);
long exactResult = binomialCoefficient(300, 3);
Assert.assertEquals(exactResult, ourResult);
- ourResult = ArithmeticsUtils.binomialCoefficient(700, 697);
+ ourResult = ArithmeticUtils.binomialCoefficient(700, 697);
exactResult = binomialCoefficient(700, 697);
Assert.assertEquals(exactResult, ourResult);
// This one should throw
try {
- ArithmeticsUtils.binomialCoefficient(700, 300);
+ ArithmeticUtils.binomialCoefficient(700, 300);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// Expected
}
int n = 10000;
- ourResult = ArithmeticsUtils.binomialCoefficient(n, 3);
+ ourResult = ArithmeticUtils.binomialCoefficient(n, 3);
exactResult = binomialCoefficient(n, 3);
Assert.assertEquals(exactResult, ourResult);
- Assert.assertEquals(1, ArithmeticsUtils.binomialCoefficientDouble(n,
3) / exactResult, 1e-10);
- Assert.assertEquals(1, ArithmeticsUtils.binomialCoefficientLog(n, 3) /
FastMath.log(exactResult), 1e-10);
+ Assert.assertEquals(1, ArithmeticUtils.binomialCoefficientDouble(n, 3)
/ exactResult, 1e-10);
+ Assert.assertEquals(1, ArithmeticUtils.binomialCoefficientLog(n, 3) /
FastMath.log(exactResult), 1e-10);
}
@Test
public void testFactorial() {
for (int i = 1; i < 21; i++) {
- Assert.assertEquals(i + "! ", factorial(i),
ArithmeticsUtils.factorial(i));
- Assert.assertEquals(i + "! ", factorial(i),
ArithmeticsUtils.factorialDouble(i), Double.MIN_VALUE);
- Assert.assertEquals(i + "! ", FastMath.log(factorial(i)),
ArithmeticsUtils.factorialLog(i), 10E-12);
+ Assert.assertEquals(i + "! ", factorial(i),
ArithmeticUtils.factorial(i));
+ Assert.assertEquals(i + "! ", factorial(i),
ArithmeticUtils.factorialDouble(i), Double.MIN_VALUE);
+ Assert.assertEquals(i + "! ", FastMath.log(factorial(i)),
ArithmeticUtils.factorialLog(i), 10E-12);
}
- Assert.assertEquals("0", 1, ArithmeticsUtils.factorial(0));
- Assert.assertEquals("0", 1.0d, ArithmeticsUtils.factorialDouble(0),
1E-14);
- Assert.assertEquals("0", 0.0d, ArithmeticsUtils.factorialLog(0),
1E-14);
+ Assert.assertEquals("0", 1, ArithmeticUtils.factorial(0));
+ Assert.assertEquals("0", 1.0d, ArithmeticUtils.factorialDouble(0),
1E-14);
+ Assert.assertEquals("0", 0.0d, ArithmeticUtils.factorialLog(0), 1E-14);
}
@Test
public void testFactorialFail() {
try {
- ArithmeticsUtils.factorial(-1);
+ ArithmeticUtils.factorial(-1);
Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
- ArithmeticsUtils.factorialDouble(-1);
+ ArithmeticUtils.factorialDouble(-1);
Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
- ArithmeticsUtils.factorialLog(-1);
+ ArithmeticUtils.factorialLog(-1);
Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
- ArithmeticsUtils.factorial(21);
+ ArithmeticUtils.factorial(21);
Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// ignored
}
- Assert.assertTrue("expecting infinite factorial value",
Double.isInfinite(ArithmeticsUtils.factorialDouble(171)));
+ Assert.assertTrue("expecting infinite factorial value",
Double.isInfinite(ArithmeticUtils.factorialDouble(171)));
}
@Test
@@ -294,45 +294,45 @@ public class ArithmeticsUtilsTest {
int b = 50;
int c = 77;
- Assert.assertEquals(0, ArithmeticsUtils.gcd(0, 0));
+ Assert.assertEquals(0, ArithmeticUtils.gcd(0, 0));
- Assert.assertEquals(b, ArithmeticsUtils.gcd(0, b));
- Assert.assertEquals(a, ArithmeticsUtils.gcd(a, 0));
- Assert.assertEquals(b, ArithmeticsUtils.gcd(0, -b));
- Assert.assertEquals(a, ArithmeticsUtils.gcd(-a, 0));
-
- Assert.assertEquals(10, ArithmeticsUtils.gcd(a, b));
- Assert.assertEquals(10, ArithmeticsUtils.gcd(-a, b));
- Assert.assertEquals(10, ArithmeticsUtils.gcd(a, -b));
- Assert.assertEquals(10, ArithmeticsUtils.gcd(-a, -b));
-
- Assert.assertEquals(1, ArithmeticsUtils.gcd(a, c));
- Assert.assertEquals(1, ArithmeticsUtils.gcd(-a, c));
- Assert.assertEquals(1, ArithmeticsUtils.gcd(a, -c));
- Assert.assertEquals(1, ArithmeticsUtils.gcd(-a, -c));
-
- Assert.assertEquals(3 * (1<<15), ArithmeticsUtils.gcd(3 * (1<<20), 9 *
(1<<15)));
-
- Assert.assertEquals(Integer.MAX_VALUE,
ArithmeticsUtils.gcd(Integer.MAX_VALUE, 0));
- Assert.assertEquals(Integer.MAX_VALUE,
ArithmeticsUtils.gcd(-Integer.MAX_VALUE, 0));
- Assert.assertEquals(1<<30, ArithmeticsUtils.gcd(1<<30,
-Integer.MIN_VALUE));
+ Assert.assertEquals(b, ArithmeticUtils.gcd(0, b));
+ Assert.assertEquals(a, ArithmeticUtils.gcd(a, 0));
+ Assert.assertEquals(b, ArithmeticUtils.gcd(0, -b));
+ Assert.assertEquals(a, ArithmeticUtils.gcd(-a, 0));
+
+ Assert.assertEquals(10, ArithmeticUtils.gcd(a, b));
+ Assert.assertEquals(10, ArithmeticUtils.gcd(-a, b));
+ Assert.assertEquals(10, ArithmeticUtils.gcd(a, -b));
+ Assert.assertEquals(10, ArithmeticUtils.gcd(-a, -b));
+
+ Assert.assertEquals(1, ArithmeticUtils.gcd(a, c));
+ Assert.assertEquals(1, ArithmeticUtils.gcd(-a, c));
+ Assert.assertEquals(1, ArithmeticUtils.gcd(a, -c));
+ Assert.assertEquals(1, ArithmeticUtils.gcd(-a, -c));
+
+ Assert.assertEquals(3 * (1<<15), ArithmeticUtils.gcd(3 * (1<<20), 9 *
(1<<15)));
+
+ Assert.assertEquals(Integer.MAX_VALUE,
ArithmeticUtils.gcd(Integer.MAX_VALUE, 0));
+ Assert.assertEquals(Integer.MAX_VALUE,
ArithmeticUtils.gcd(-Integer.MAX_VALUE, 0));
+ Assert.assertEquals(1<<30, ArithmeticUtils.gcd(1<<30,
-Integer.MIN_VALUE));
try {
// gcd(Integer.MIN_VALUE, 0) > Integer.MAX_VALUE
- ArithmeticsUtils.gcd(Integer.MIN_VALUE, 0);
+ ArithmeticUtils.gcd(Integer.MIN_VALUE, 0);
Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
// gcd(0, Integer.MIN_VALUE) > Integer.MAX_VALUE
- ArithmeticsUtils.gcd(0, Integer.MIN_VALUE);
+ ArithmeticUtils.gcd(0, Integer.MIN_VALUE);
Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
// gcd(Integer.MIN_VALUE, Integer.MIN_VALUE) > Integer.MAX_VALUE
- ArithmeticsUtils.gcd(Integer.MIN_VALUE, Integer.MIN_VALUE);
+ ArithmeticUtils.gcd(Integer.MIN_VALUE, Integer.MIN_VALUE);
Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
@@ -356,10 +356,10 @@ public class ArithmeticsUtilsTest {
int i1 = p1 * p2 * p3;
int i2 = p1 * p2 * p4;
int gcd = p1 * p2;
- Assert.assertEquals(gcd, ArithmeticsUtils.gcd(i1, i2));
+ Assert.assertEquals(gcd, ArithmeticUtils.gcd(i1, i2));
long l1 = i1;
long l2 = i2;
- Assert.assertEquals(gcd, ArithmeticsUtils.gcd(l1, l2));
+ Assert.assertEquals(gcd, ArithmeticUtils.gcd(l1, l2));
}
}
@@ -369,47 +369,47 @@ public class ArithmeticsUtilsTest {
long b = 50;
long c = 77;
- Assert.assertEquals(0, ArithmeticsUtils.gcd(0L, 0));
+ Assert.assertEquals(0, ArithmeticUtils.gcd(0L, 0));
- Assert.assertEquals(b, ArithmeticsUtils.gcd(0, b));
- Assert.assertEquals(a, ArithmeticsUtils.gcd(a, 0));
- Assert.assertEquals(b, ArithmeticsUtils.gcd(0, -b));
- Assert.assertEquals(a, ArithmeticsUtils.gcd(-a, 0));
-
- Assert.assertEquals(10, ArithmeticsUtils.gcd(a, b));
- Assert.assertEquals(10, ArithmeticsUtils.gcd(-a, b));
- Assert.assertEquals(10, ArithmeticsUtils.gcd(a, -b));
- Assert.assertEquals(10, ArithmeticsUtils.gcd(-a, -b));
-
- Assert.assertEquals(1, ArithmeticsUtils.gcd(a, c));
- Assert.assertEquals(1, ArithmeticsUtils.gcd(-a, c));
- Assert.assertEquals(1, ArithmeticsUtils.gcd(a, -c));
- Assert.assertEquals(1, ArithmeticsUtils.gcd(-a, -c));
-
- Assert.assertEquals(3L * (1L<<45), ArithmeticsUtils.gcd(3L * (1L<<50),
9L * (1L<<45)));
-
- Assert.assertEquals(1L<<45, ArithmeticsUtils.gcd(1L<<45,
Long.MIN_VALUE));
-
- Assert.assertEquals(Long.MAX_VALUE,
ArithmeticsUtils.gcd(Long.MAX_VALUE, 0L));
- Assert.assertEquals(Long.MAX_VALUE,
ArithmeticsUtils.gcd(-Long.MAX_VALUE, 0L));
- Assert.assertEquals(1, ArithmeticsUtils.gcd(60247241209L, 153092023L));
+ Assert.assertEquals(b, ArithmeticUtils.gcd(0, b));
+ Assert.assertEquals(a, ArithmeticUtils.gcd(a, 0));
+ Assert.assertEquals(b, ArithmeticUtils.gcd(0, -b));
+ Assert.assertEquals(a, ArithmeticUtils.gcd(-a, 0));
+
+ Assert.assertEquals(10, ArithmeticUtils.gcd(a, b));
+ Assert.assertEquals(10, ArithmeticUtils.gcd(-a, b));
+ Assert.assertEquals(10, ArithmeticUtils.gcd(a, -b));
+ Assert.assertEquals(10, ArithmeticUtils.gcd(-a, -b));
+
+ Assert.assertEquals(1, ArithmeticUtils.gcd(a, c));
+ Assert.assertEquals(1, ArithmeticUtils.gcd(-a, c));
+ Assert.assertEquals(1, ArithmeticUtils.gcd(a, -c));
+ Assert.assertEquals(1, ArithmeticUtils.gcd(-a, -c));
+
+ Assert.assertEquals(3L * (1L<<45), ArithmeticUtils.gcd(3L * (1L<<50),
9L * (1L<<45)));
+
+ Assert.assertEquals(1L<<45, ArithmeticUtils.gcd(1L<<45,
Long.MIN_VALUE));
+
+ Assert.assertEquals(Long.MAX_VALUE,
ArithmeticUtils.gcd(Long.MAX_VALUE, 0L));
+ Assert.assertEquals(Long.MAX_VALUE,
ArithmeticUtils.gcd(-Long.MAX_VALUE, 0L));
+ Assert.assertEquals(1, ArithmeticUtils.gcd(60247241209L, 153092023L));
try {
// gcd(Long.MIN_VALUE, 0) > Long.MAX_VALUE
- ArithmeticsUtils.gcd(Long.MIN_VALUE, 0);
+ ArithmeticUtils.gcd(Long.MIN_VALUE, 0);
Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
// gcd(0, Long.MIN_VALUE) > Long.MAX_VALUE
- ArithmeticsUtils.gcd(0, Long.MIN_VALUE);
+ ArithmeticUtils.gcd(0, Long.MIN_VALUE);
Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
// gcd(Long.MIN_VALUE, Long.MIN_VALUE) > Long.MAX_VALUE
- ArithmeticsUtils.gcd(Long.MIN_VALUE, Long.MIN_VALUE);
+ ArithmeticUtils.gcd(Long.MIN_VALUE, Long.MIN_VALUE);
Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
@@ -423,26 +423,26 @@ public class ArithmeticsUtilsTest {
int b = 50;
int c = 77;
- Assert.assertEquals(0, ArithmeticsUtils.lcm(0, b));
- Assert.assertEquals(0, ArithmeticsUtils.lcm(a, 0));
- Assert.assertEquals(b, ArithmeticsUtils.lcm(1, b));
- Assert.assertEquals(a, ArithmeticsUtils.lcm(a, 1));
- Assert.assertEquals(150, ArithmeticsUtils.lcm(a, b));
- Assert.assertEquals(150, ArithmeticsUtils.lcm(-a, b));
- Assert.assertEquals(150, ArithmeticsUtils.lcm(a, -b));
- Assert.assertEquals(150, ArithmeticsUtils.lcm(-a, -b));
- Assert.assertEquals(2310, ArithmeticsUtils.lcm(a, c));
+ Assert.assertEquals(0, ArithmeticUtils.lcm(0, b));
+ Assert.assertEquals(0, ArithmeticUtils.lcm(a, 0));
+ Assert.assertEquals(b, ArithmeticUtils.lcm(1, b));
+ Assert.assertEquals(a, ArithmeticUtils.lcm(a, 1));
+ Assert.assertEquals(150, ArithmeticUtils.lcm(a, b));
+ Assert.assertEquals(150, ArithmeticUtils.lcm(-a, b));
+ Assert.assertEquals(150, ArithmeticUtils.lcm(a, -b));
+ Assert.assertEquals(150, ArithmeticUtils.lcm(-a, -b));
+ Assert.assertEquals(2310, ArithmeticUtils.lcm(a, c));
// Assert that no intermediate value overflows:
// The naive implementation of lcm(a,b) would be (a*b)/gcd(a,b)
- Assert.assertEquals((1<<20)*15, ArithmeticsUtils.lcm((1<<20)*3,
(1<<20)*5));
+ Assert.assertEquals((1<<20)*15, ArithmeticUtils.lcm((1<<20)*3,
(1<<20)*5));
// Special case
- Assert.assertEquals(0, ArithmeticsUtils.lcm(0, 0));
+ Assert.assertEquals(0, ArithmeticUtils.lcm(0, 0));
try {
// lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
- ArithmeticsUtils.lcm(Integer.MIN_VALUE, 1);
+ ArithmeticUtils.lcm(Integer.MIN_VALUE, 1);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
@@ -450,14 +450,14 @@ public class ArithmeticsUtilsTest {
try {
// lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
- ArithmeticsUtils.lcm(Integer.MIN_VALUE, 1<<20);
+ ArithmeticUtils.lcm(Integer.MIN_VALUE, 1<<20);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
- ArithmeticsUtils.lcm(Integer.MAX_VALUE, Integer.MAX_VALUE - 1);
+ ArithmeticUtils.lcm(Integer.MAX_VALUE, Integer.MAX_VALUE - 1);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
@@ -470,28 +470,28 @@ public class ArithmeticsUtilsTest {
long b = 50;
long c = 77;
- Assert.assertEquals(0, ArithmeticsUtils.lcm(0, b));
- Assert.assertEquals(0, ArithmeticsUtils.lcm(a, 0));
- Assert.assertEquals(b, ArithmeticsUtils.lcm(1, b));
- Assert.assertEquals(a, ArithmeticsUtils.lcm(a, 1));
- Assert.assertEquals(150, ArithmeticsUtils.lcm(a, b));
- Assert.assertEquals(150, ArithmeticsUtils.lcm(-a, b));
- Assert.assertEquals(150, ArithmeticsUtils.lcm(a, -b));
- Assert.assertEquals(150, ArithmeticsUtils.lcm(-a, -b));
- Assert.assertEquals(2310, ArithmeticsUtils.lcm(a, c));
+ Assert.assertEquals(0, ArithmeticUtils.lcm(0, b));
+ Assert.assertEquals(0, ArithmeticUtils.lcm(a, 0));
+ Assert.assertEquals(b, ArithmeticUtils.lcm(1, b));
+ Assert.assertEquals(a, ArithmeticUtils.lcm(a, 1));
+ Assert.assertEquals(150, ArithmeticUtils.lcm(a, b));
+ Assert.assertEquals(150, ArithmeticUtils.lcm(-a, b));
+ Assert.assertEquals(150, ArithmeticUtils.lcm(a, -b));
+ Assert.assertEquals(150, ArithmeticUtils.lcm(-a, -b));
+ Assert.assertEquals(2310, ArithmeticUtils.lcm(a, c));
- Assert.assertEquals(Long.MAX_VALUE, ArithmeticsUtils.lcm(60247241209L,
153092023L));
+ Assert.assertEquals(Long.MAX_VALUE, ArithmeticUtils.lcm(60247241209L,
153092023L));
// Assert that no intermediate value overflows:
// The naive implementation of lcm(a,b) would be (a*b)/gcd(a,b)
- Assert.assertEquals((1L<<50)*15, ArithmeticsUtils.lcm((1L<<45)*3,
(1L<<50)*5));
+ Assert.assertEquals((1L<<50)*15, ArithmeticUtils.lcm((1L<<45)*3,
(1L<<50)*5));
// Special case
- Assert.assertEquals(0L, ArithmeticsUtils.lcm(0L, 0L));
+ Assert.assertEquals(0L, ArithmeticUtils.lcm(0L, 0L));
try {
// lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
- ArithmeticsUtils.lcm(Long.MIN_VALUE, 1);
+ ArithmeticUtils.lcm(Long.MIN_VALUE, 1);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
@@ -499,16 +499,16 @@ public class ArithmeticsUtilsTest {
try {
// lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
- ArithmeticsUtils.lcm(Long.MIN_VALUE, 1<<20);
+ ArithmeticUtils.lcm(Long.MIN_VALUE, 1<<20);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
Assert.assertEquals((long) Integer.MAX_VALUE * (Integer.MAX_VALUE - 1),
- ArithmeticsUtils.lcm((long)Integer.MAX_VALUE, Integer.MAX_VALUE -
1));
+ ArithmeticUtils.lcm((long)Integer.MAX_VALUE, Integer.MAX_VALUE -
1));
try {
- ArithmeticsUtils.lcm(Long.MAX_VALUE, Long.MAX_VALUE - 1);
+ ArithmeticUtils.lcm(Long.MAX_VALUE, Long.MAX_VALUE - 1);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
@@ -519,14 +519,14 @@ public class ArithmeticsUtilsTest {
public void testMulAndCheck() {
int big = Integer.MAX_VALUE;
int bigNeg = Integer.MIN_VALUE;
- Assert.assertEquals(big, ArithmeticsUtils.mulAndCheck(big, 1));
+ Assert.assertEquals(big, ArithmeticUtils.mulAndCheck(big, 1));
try {
- ArithmeticsUtils.mulAndCheck(big, 2);
+ ArithmeticUtils.mulAndCheck(big, 2);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
try {
- ArithmeticsUtils.mulAndCheck(bigNeg, 2);
+ ArithmeticUtils.mulAndCheck(bigNeg, 2);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
@@ -536,16 +536,16 @@ public class ArithmeticsUtilsTest {
public void testMulAndCheckLong() {
long max = Long.MAX_VALUE;
long min = Long.MIN_VALUE;
- Assert.assertEquals(max, ArithmeticsUtils.mulAndCheck(max, 1L));
- Assert.assertEquals(min, ArithmeticsUtils.mulAndCheck(min, 1L));
- Assert.assertEquals(0L, ArithmeticsUtils.mulAndCheck(max, 0L));
- Assert.assertEquals(0L, ArithmeticsUtils.mulAndCheck(min, 0L));
- Assert.assertEquals(max, ArithmeticsUtils.mulAndCheck(1L, max));
- Assert.assertEquals(min, ArithmeticsUtils.mulAndCheck(1L, min));
- Assert.assertEquals(0L, ArithmeticsUtils.mulAndCheck(0L, max));
- Assert.assertEquals(0L, ArithmeticsUtils.mulAndCheck(0L, min));
- Assert.assertEquals(1L, ArithmeticsUtils.mulAndCheck(-1L, -1L));
- Assert.assertEquals(min, ArithmeticsUtils.mulAndCheck(min / 2, 2));
+ Assert.assertEquals(max, ArithmeticUtils.mulAndCheck(max, 1L));
+ Assert.assertEquals(min, ArithmeticUtils.mulAndCheck(min, 1L));
+ Assert.assertEquals(0L, ArithmeticUtils.mulAndCheck(max, 0L));
+ Assert.assertEquals(0L, ArithmeticUtils.mulAndCheck(min, 0L));
+ Assert.assertEquals(max, ArithmeticUtils.mulAndCheck(1L, max));
+ Assert.assertEquals(min, ArithmeticUtils.mulAndCheck(1L, min));
+ Assert.assertEquals(0L, ArithmeticUtils.mulAndCheck(0L, max));
+ Assert.assertEquals(0L, ArithmeticUtils.mulAndCheck(0L, min));
+ Assert.assertEquals(1L, ArithmeticUtils.mulAndCheck(-1L, -1L));
+ Assert.assertEquals(min, ArithmeticUtils.mulAndCheck(min / 2, 2));
testMulAndCheckLongFailure(max, 2L);
testMulAndCheckLongFailure(2L, max);
testMulAndCheckLongFailure(min, 2L);
@@ -558,16 +558,16 @@ public class ArithmeticsUtilsTest {
public void testSubAndCheck() {
int big = Integer.MAX_VALUE;
int bigNeg = Integer.MIN_VALUE;
- Assert.assertEquals(big, ArithmeticsUtils.subAndCheck(big, 0));
- Assert.assertEquals(bigNeg + 1, ArithmeticsUtils.subAndCheck(bigNeg,
-1));
- Assert.assertEquals(-1, ArithmeticsUtils.subAndCheck(bigNeg, -big));
+ Assert.assertEquals(big, ArithmeticUtils.subAndCheck(big, 0));
+ Assert.assertEquals(bigNeg + 1, ArithmeticUtils.subAndCheck(bigNeg,
-1));
+ Assert.assertEquals(-1, ArithmeticUtils.subAndCheck(bigNeg, -big));
try {
- ArithmeticsUtils.subAndCheck(big, -1);
+ ArithmeticUtils.subAndCheck(big, -1);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
try {
- ArithmeticsUtils.subAndCheck(bigNeg, 1);
+ ArithmeticUtils.subAndCheck(bigNeg, 1);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
@@ -577,7 +577,7 @@ public class ArithmeticsUtilsTest {
public void testSubAndCheckErrorMessage() {
int big = Integer.MAX_VALUE;
try {
- ArithmeticsUtils.subAndCheck(big, -1);
+ ArithmeticUtils.subAndCheck(big, -1);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
Assert.assertTrue(ex.getMessage().length() > 1);
@@ -588,13 +588,13 @@ public class ArithmeticsUtilsTest {
public void testSubAndCheckLong() {
long max = Long.MAX_VALUE;
long min = Long.MIN_VALUE;
- Assert.assertEquals(max, ArithmeticsUtils.subAndCheck(max, 0));
- Assert.assertEquals(min, ArithmeticsUtils.subAndCheck(min, 0));
- Assert.assertEquals(-max, ArithmeticsUtils.subAndCheck(0, max));
- Assert.assertEquals(min + 1, ArithmeticsUtils.subAndCheck(min, -1));
+ Assert.assertEquals(max, ArithmeticUtils.subAndCheck(max, 0));
+ Assert.assertEquals(min, ArithmeticUtils.subAndCheck(min, 0));
+ Assert.assertEquals(-max, ArithmeticUtils.subAndCheck(0, max));
+ Assert.assertEquals(min + 1, ArithmeticUtils.subAndCheck(min, -1));
// min == -1-max
- Assert.assertEquals(-1, ArithmeticsUtils.subAndCheck(-max - 1, -max));
- Assert.assertEquals(max, ArithmeticsUtils.subAndCheck(-1, -1 - max));
+ Assert.assertEquals(-1, ArithmeticUtils.subAndCheck(-max - 1, -max));
+ Assert.assertEquals(max, ArithmeticUtils.subAndCheck(-1, -1 - max));
testSubAndCheckLongFailure(0L, min);
testSubAndCheckLongFailure(max, -1L);
testSubAndCheckLongFailure(min, 1L);
@@ -623,7 +623,7 @@ public class ArithmeticsUtilsTest {
if (k > 100) {
binomialCoefficient(n - 100, k - 100);
}
- result = ArithmeticsUtils.addAndCheck(binomialCoefficient(n - 1, k
- 1),
+ result = ArithmeticUtils.addAndCheck(binomialCoefficient(n - 1, k
- 1),
binomialCoefficient(n - 1, k));
}
if (result == -1) {
@@ -649,7 +649,7 @@ public class ArithmeticsUtilsTest {
private void testAddAndCheckLongFailure(long a, long b) {
try {
- ArithmeticsUtils.addAndCheck(a, b);
+ ArithmeticUtils.addAndCheck(a, b);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// success
@@ -658,7 +658,7 @@ public class ArithmeticsUtilsTest {
private void testMulAndCheckLongFailure(long a, long b) {
try {
- ArithmeticsUtils.mulAndCheck(a, b);
+ ArithmeticUtils.mulAndCheck(a, b);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// success
@@ -667,7 +667,7 @@ public class ArithmeticsUtilsTest {
private void testSubAndCheckLongFailure(long a, long b) {
try {
- ArithmeticsUtils.subAndCheck(a, b);
+ ArithmeticUtils.subAndCheck(a, b);
Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// success
