You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by lu...@apache.org on 2011/03/20 18:24:19 UTC
svn commit: r1083514 [14/15] - in
/commons/proper/math/trunk/src/test/java/org/apache/commons/math: ./
analysis/integration/ analysis/interpolation/ analysis/polynomials/
analysis/solvers/ complex/ distribution/ fraction/ genetics/ geometry/
linear/ od...
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java?rev=1083514&r1=1083513&r2=1083514&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java Sun Mar 20 17:24:14 2011
@@ -20,7 +20,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import junit.framework.TestCase;
import org.apache.commons.math.TestUtils;
import org.apache.commons.math.exception.NonMonotonousSequenceException;
@@ -31,17 +30,15 @@ import org.apache.commons.math.exception
import org.apache.commons.math.exception.NullArgumentException;
import org.apache.commons.math.exception.util.LocalizedFormats;
import org.apache.commons.math.random.RandomDataImpl;
+import org.junit.Assert;
+import org.junit.Test;
/**
* Test cases for the MathUtils class.
* @version $Revision$ $Date: 2007-08-16 15:36:33 -0500 (Thu, 16 Aug
* 2007) $
*/
-public final class MathUtilsTest extends TestCase {
-
- public MathUtilsTest(String name) {
- super(name);
- }
+public final class MathUtilsTest {
/** cached binomial coefficients */
private static final List<Map<Integer, Long>> binomialCache = new ArrayList<Map<Integer, Long>>();
@@ -94,39 +91,42 @@ public final class MathUtilsTest extends
}
/** Verify that b(0,0) = 1 */
+ @Test
public void test0Choose0() {
- assertEquals(MathUtils.binomialCoefficientDouble(0, 0), 1d, 0);
- assertEquals(MathUtils.binomialCoefficientLog(0, 0), 0d, 0);
- assertEquals(MathUtils.binomialCoefficient(0, 0), 1);
+ Assert.assertEquals(MathUtils.binomialCoefficientDouble(0, 0), 1d, 0);
+ Assert.assertEquals(MathUtils.binomialCoefficientLog(0, 0), 0d, 0);
+ Assert.assertEquals(MathUtils.binomialCoefficient(0, 0), 1);
}
+ @Test
public void testAddAndCheck() {
int big = Integer.MAX_VALUE;
int bigNeg = Integer.MIN_VALUE;
- assertEquals(big, MathUtils.addAndCheck(big, 0));
+ Assert.assertEquals(big, MathUtils.addAndCheck(big, 0));
try {
MathUtils.addAndCheck(big, 1);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
try {
MathUtils.addAndCheck(bigNeg, -1);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
}
+ @Test
public void testAddAndCheckLong() {
long max = Long.MAX_VALUE;
long min = Long.MIN_VALUE;
- assertEquals(max, MathUtils.addAndCheck(max, 0L));
- assertEquals(min, MathUtils.addAndCheck(min, 0L));
- assertEquals(max, MathUtils.addAndCheck(0L, max));
- assertEquals(min, MathUtils.addAndCheck(0L, min));
- assertEquals(1, MathUtils.addAndCheck(-1L, 2L));
- assertEquals(1, MathUtils.addAndCheck(2L, -1L));
- assertEquals(-3, MathUtils.addAndCheck(-2L, -1L));
- assertEquals(min, MathUtils.addAndCheck(min + 1, -1L));
+ Assert.assertEquals(max, MathUtils.addAndCheck(max, 0L));
+ Assert.assertEquals(min, MathUtils.addAndCheck(min, 0L));
+ Assert.assertEquals(max, MathUtils.addAndCheck(0L, max));
+ Assert.assertEquals(min, MathUtils.addAndCheck(0L, min));
+ Assert.assertEquals(1, MathUtils.addAndCheck(-1L, 2L));
+ Assert.assertEquals(1, MathUtils.addAndCheck(2L, -1L));
+ Assert.assertEquals(-3, MathUtils.addAndCheck(-2L, -1L));
+ Assert.assertEquals(min, MathUtils.addAndCheck(min + 1, -1L));
testAddAndCheckLongFailure(max, 1L);
testAddAndCheckLongFailure(min, -1L);
testAddAndCheckLongFailure(1L, max);
@@ -136,12 +136,13 @@ public final class MathUtilsTest extends
private void testAddAndCheckLongFailure(long a, long b) {
try {
MathUtils.addAndCheck(a, b);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// success
}
}
+ @Test
public void testBinomialCoefficient() {
long[] bcoef5 = {
1,
@@ -159,17 +160,17 @@ public final class MathUtilsTest extends
6,
1 };
for (int i = 0; i < 6; i++) {
- assertEquals("5 choose " + i, bcoef5[i], MathUtils.binomialCoefficient(5, i));
+ Assert.assertEquals("5 choose " + i, bcoef5[i], MathUtils.binomialCoefficient(5, i));
}
for (int i = 0; i < 7; i++) {
- assertEquals("6 choose " + i, bcoef6[i], MathUtils.binomialCoefficient(6, i));
+ Assert.assertEquals("6 choose " + i, bcoef6[i], MathUtils.binomialCoefficient(6, i));
}
for (int n = 1; n < 10; n++) {
for (int k = 0; k <= n; k++) {
- assertEquals(n + " choose " + k, binomialCoefficient(n, k), MathUtils.binomialCoefficient(n, k));
- assertEquals(n + " choose " + k, binomialCoefficient(n, k), MathUtils.binomialCoefficientDouble(n, k), Double.MIN_VALUE);
- assertEquals(n + " choose " + k, FastMath.log(binomialCoefficient(n, k)), MathUtils.binomialCoefficientLog(n, k), 10E-12);
+ Assert.assertEquals(n + " choose " + k, binomialCoefficient(n, k), MathUtils.binomialCoefficient(n, k));
+ Assert.assertEquals(n + " choose " + k, binomialCoefficient(n, k), MathUtils.binomialCoefficientDouble(n, k), Double.MIN_VALUE);
+ Assert.assertEquals(n + " choose " + k, FastMath.log(binomialCoefficient(n, k)), MathUtils.binomialCoefficientLog(n, k), 10E-12);
}
}
@@ -177,11 +178,11 @@ public final class MathUtilsTest extends
int[] k = { 17, 33, 10, 1500 - 4, 4 };
for (int i = 0; i < n.length; i++) {
long expected = binomialCoefficient(n[i], k[i]);
- assertEquals(n[i] + " choose " + k[i], expected,
+ Assert.assertEquals(n[i] + " choose " + k[i], expected,
MathUtils.binomialCoefficient(n[i], k[i]));
- assertEquals(n[i] + " choose " + k[i], expected,
+ Assert.assertEquals(n[i] + " choose " + k[i], expected,
MathUtils.binomialCoefficientDouble(n[i], k[i]), 0.0);
- assertEquals("log(" + n[i] + " choose " + k[i] + ")", FastMath.log(expected),
+ Assert.assertEquals("log(" + n[i] + " choose " + k[i] + ")", FastMath.log(expected),
MathUtils.binomialCoefficientLog(n[i], k[i]), 0.0);
}
}
@@ -190,6 +191,7 @@ public final class MathUtilsTest extends
* Tests correctness for large n and sharpness of upper bound in API doc
* JIRA: MATH-241
*/
+ @Test
public void testBinomialCoefficientLarge() throws Exception {
// This tests all legal and illegal values for n <= 200.
for (int n = 0; n <= 200; n++) {
@@ -208,14 +210,14 @@ public final class MathUtilsTest extends
} catch (MathArithmeticException ex) {
shouldThrow = true;
}
- assertEquals(n + " choose " + k, exactResult, ourResult);
- assertEquals(n + " choose " + k, shouldThrow, didThrow);
- assertTrue(n + " choose " + k, (n > 66 || !didThrow));
+ Assert.assertEquals(n + " choose " + k, exactResult, ourResult);
+ Assert.assertEquals(n + " choose " + k, shouldThrow, didThrow);
+ Assert.assertTrue(n + " choose " + k, (n > 66 || !didThrow));
if (!shouldThrow && exactResult > 1) {
- assertEquals(n + " choose " + k, 1.,
+ Assert.assertEquals(n + " choose " + k, 1.,
MathUtils.binomialCoefficientDouble(n, k) / exactResult, 1e-10);
- assertEquals(n + " choose " + k, 1,
+ Assert.assertEquals(n + " choose " + k, 1,
MathUtils.binomialCoefficientLog(n, k) / FastMath.log(exactResult), 1e-10);
}
}
@@ -223,16 +225,16 @@ public final class MathUtilsTest extends
long ourResult = MathUtils.binomialCoefficient(300, 3);
long exactResult = binomialCoefficient(300, 3);
- assertEquals(exactResult, ourResult);
+ Assert.assertEquals(exactResult, ourResult);
ourResult = MathUtils.binomialCoefficient(700, 697);
exactResult = binomialCoefficient(700, 697);
- assertEquals(exactResult, ourResult);
+ Assert.assertEquals(exactResult, ourResult);
// This one should throw
try {
MathUtils.binomialCoefficient(700, 300);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// Expected
}
@@ -240,86 +242,91 @@ public final class MathUtilsTest extends
int n = 10000;
ourResult = MathUtils.binomialCoefficient(n, 3);
exactResult = binomialCoefficient(n, 3);
- assertEquals(exactResult, ourResult);
- assertEquals(1, MathUtils.binomialCoefficientDouble(n, 3) / exactResult, 1e-10);
- assertEquals(1, MathUtils.binomialCoefficientLog(n, 3) / FastMath.log(exactResult), 1e-10);
+ Assert.assertEquals(exactResult, ourResult);
+ Assert.assertEquals(1, MathUtils.binomialCoefficientDouble(n, 3) / exactResult, 1e-10);
+ Assert.assertEquals(1, MathUtils.binomialCoefficientLog(n, 3) / FastMath.log(exactResult), 1e-10);
}
+ @Test
public void testBinomialCoefficientFail() {
try {
MathUtils.binomialCoefficient(4, 5);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
MathUtils.binomialCoefficientDouble(4, 5);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
MathUtils.binomialCoefficientLog(4, 5);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
MathUtils.binomialCoefficient(-1, -2);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
MathUtils.binomialCoefficientDouble(-1, -2);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
MathUtils.binomialCoefficientLog(-1, -2);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
MathUtils.binomialCoefficient(67, 30);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// ignored
}
try {
MathUtils.binomialCoefficient(67, 34);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// ignored
}
double x = MathUtils.binomialCoefficientDouble(1030, 515);
- assertTrue("expecting infinite binomial coefficient", Double
+ Assert.assertTrue("expecting infinite binomial coefficient", Double
.isInfinite(x));
}
+ @Test
public void testCompareTo() {
- assertEquals(0, MathUtils.compareTo(152.33, 152.32, .011));
- assertTrue(MathUtils.compareTo(152.308, 152.32, .011) < 0);
- assertTrue(MathUtils.compareTo(152.33, 152.318, .011) > 0);
+ Assert.assertEquals(0, MathUtils.compareTo(152.33, 152.32, .011));
+ Assert.assertTrue(MathUtils.compareTo(152.308, 152.32, .011) < 0);
+ Assert.assertTrue(MathUtils.compareTo(152.33, 152.318, .011) > 0);
}
+ @Test
public void testCosh() {
double x = 3.0;
double expected = 10.06766;
- assertEquals(expected, MathUtils.cosh(x), 1.0e-5);
+ Assert.assertEquals(expected, MathUtils.cosh(x), 1.0e-5);
}
+ @Test
public void testCoshNaN() {
- assertTrue(Double.isNaN(MathUtils.cosh(Double.NaN)));
+ Assert.assertTrue(Double.isNaN(MathUtils.cosh(Double.NaN)));
}
+ @Test
public void testEqualsIncludingNaN() {
double[] testArray = {
Double.NaN,
@@ -330,28 +337,30 @@ public final class MathUtilsTest extends
for (int i = 0; i < testArray.length; i++) {
for (int j = 0; j < testArray.length; j++) {
if (i == j) {
- assertTrue(MathUtils.equalsIncludingNaN(testArray[i], testArray[j]));
- assertTrue(MathUtils.equalsIncludingNaN(testArray[j], testArray[i]));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(testArray[i], testArray[j]));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(testArray[j], testArray[i]));
} else {
- assertTrue(!MathUtils.equalsIncludingNaN(testArray[i], testArray[j]));
- assertTrue(!MathUtils.equalsIncludingNaN(testArray[j], testArray[i]));
+ Assert.assertTrue(!MathUtils.equalsIncludingNaN(testArray[i], testArray[j]));
+ Assert.assertTrue(!MathUtils.equalsIncludingNaN(testArray[j], testArray[i]));
}
}
}
}
+ @Test
public void testEqualsWithAllowedDelta() {
- assertTrue(MathUtils.equals(153.0000, 153.0000, .0625));
- assertTrue(MathUtils.equals(153.0000, 153.0625, .0625));
- assertTrue(MathUtils.equals(152.9375, 153.0000, .0625));
- assertFalse(MathUtils.equals(153.0000, 153.0625, .0624));
- assertFalse(MathUtils.equals(152.9374, 153.0000, .0625));
- assertFalse(MathUtils.equals(Double.NaN, Double.NaN, 1.0));
- assertTrue(MathUtils.equals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
- assertTrue(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1.0));
- assertFalse(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
+ Assert.assertTrue(MathUtils.equals(153.0000, 153.0000, .0625));
+ Assert.assertTrue(MathUtils.equals(153.0000, 153.0625, .0625));
+ Assert.assertTrue(MathUtils.equals(152.9375, 153.0000, .0625));
+ Assert.assertFalse(MathUtils.equals(153.0000, 153.0625, .0624));
+ Assert.assertFalse(MathUtils.equals(152.9374, 153.0000, .0625));
+ Assert.assertFalse(MathUtils.equals(Double.NaN, Double.NaN, 1.0));
+ Assert.assertTrue(MathUtils.equals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
+ Assert.assertTrue(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1.0));
+ Assert.assertFalse(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
}
+ @Test
public void testMath475() {
final double a = 1.7976931348623182E16;
final double b = FastMath.nextUp(a);
@@ -360,322 +369,333 @@ public final class MathUtilsTest extends
// Because they are adjacent floating point numbers, "a" and "b" are
// considered equal even though the allowed error is smaller than
// their difference.
- assertTrue(MathUtils.equals(a, b, 0.5 * diff));
+ Assert.assertTrue(MathUtils.equals(a, b, 0.5 * diff));
final double c = FastMath.nextUp(b);
diff = FastMath.abs(a - c);
// Because "a" and "c" are not adjacent, the tolerance is taken into
// account for assessing equality.
- assertTrue(MathUtils.equals(a, c, diff));
- assertFalse(MathUtils.equals(a, c, (1 - 1e-16) * diff));
+ Assert.assertTrue(MathUtils.equals(a, c, diff));
+ Assert.assertFalse(MathUtils.equals(a, c, (1 - 1e-16) * diff));
}
+ @Test
public void testEqualsIncludingNaNWithAllowedDelta() {
- assertTrue(MathUtils.equalsIncludingNaN(153.0000, 153.0000, .0625));
- assertTrue(MathUtils.equalsIncludingNaN(153.0000, 153.0625, .0625));
- assertTrue(MathUtils.equalsIncludingNaN(152.9375, 153.0000, .0625));
- assertTrue(MathUtils.equalsIncludingNaN(Double.NaN, Double.NaN, 1.0));
- assertTrue(MathUtils.equalsIncludingNaN(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
- assertTrue(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1.0));
- assertFalse(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
- assertFalse(MathUtils.equalsIncludingNaN(153.0000, 153.0625, .0624));
- assertFalse(MathUtils.equalsIncludingNaN(152.9374, 153.0000, .0625));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0000, 153.0000, .0625));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0000, 153.0625, .0625));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(152.9375, 153.0000, .0625));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.NaN, Double.NaN, 1.0));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1.0));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(153.0000, 153.0625, .0624));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(152.9374, 153.0000, .0625));
}
// Tests for floating point equality
+ @Test
public void testFloatEqualsWithAllowedUlps() {
- assertTrue("+0.0f == -0.0f",MathUtils.equals(0.0f, -0.0f));
- assertTrue("+0.0f == -0.0f (1 ulp)",MathUtils.equals(0.0f, -0.0f, 1));
+ Assert.assertTrue("+0.0f == -0.0f",MathUtils.equals(0.0f, -0.0f));
+ Assert.assertTrue("+0.0f == -0.0f (1 ulp)",MathUtils.equals(0.0f, -0.0f, 1));
float oneFloat = 1.0f;
- assertTrue("1.0f == 1.0f + 1 ulp",MathUtils.equals(oneFloat, Float.intBitsToFloat(1 + Float.floatToIntBits(oneFloat))));
- assertTrue("1.0f == 1.0f + 1 ulp (1 ulp)",MathUtils.equals(oneFloat, Float.intBitsToFloat(1 + Float.floatToIntBits(oneFloat)), 1));
- assertFalse("1.0f != 1.0f + 2 ulp (1 ulp)",MathUtils.equals(oneFloat, Float.intBitsToFloat(2 + Float.floatToIntBits(oneFloat)), 1));
+ Assert.assertTrue("1.0f == 1.0f + 1 ulp",MathUtils.equals(oneFloat, Float.intBitsToFloat(1 + Float.floatToIntBits(oneFloat))));
+ Assert.assertTrue("1.0f == 1.0f + 1 ulp (1 ulp)",MathUtils.equals(oneFloat, Float.intBitsToFloat(1 + Float.floatToIntBits(oneFloat)), 1));
+ Assert.assertFalse("1.0f != 1.0f + 2 ulp (1 ulp)",MathUtils.equals(oneFloat, Float.intBitsToFloat(2 + Float.floatToIntBits(oneFloat)), 1));
- assertTrue(MathUtils.equals(153.0f, 153.0f, 1));
+ Assert.assertTrue(MathUtils.equals(153.0f, 153.0f, 1));
// These tests need adjusting for floating point precision
-// assertTrue(MathUtils.equals(153.0f, 153.00000000000003f, 1));
-// assertFalse(MathUtils.equals(153.0f, 153.00000000000006f, 1));
-// assertTrue(MathUtils.equals(153.0f, 152.99999999999997f, 1));
-// assertFalse(MathUtils.equals(153f, 152.99999999999994f, 1));
+// Assert.assertTrue(MathUtils.equals(153.0f, 153.00000000000003f, 1));
+// Assert.assertFalse(MathUtils.equals(153.0f, 153.00000000000006f, 1));
+// Assert.assertTrue(MathUtils.equals(153.0f, 152.99999999999997f, 1));
+// Assert.assertFalse(MathUtils.equals(153f, 152.99999999999994f, 1));
//
-// assertTrue(MathUtils.equals(-128.0f, -127.99999999999999f, 1));
-// assertFalse(MathUtils.equals(-128.0f, -127.99999999999997f, 1));
-// assertTrue(MathUtils.equals(-128.0f, -128.00000000000003f, 1));
-// assertFalse(MathUtils.equals(-128.0f, -128.00000000000006f, 1));
+// Assert.assertTrue(MathUtils.equals(-128.0f, -127.99999999999999f, 1));
+// Assert.assertFalse(MathUtils.equals(-128.0f, -127.99999999999997f, 1));
+// Assert.assertTrue(MathUtils.equals(-128.0f, -128.00000000000003f, 1));
+// Assert.assertFalse(MathUtils.equals(-128.0f, -128.00000000000006f, 1));
- assertTrue(MathUtils.equals(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, 1));
- assertTrue(MathUtils.equals(Double.MAX_VALUE, Float.POSITIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equals(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equals(Double.MAX_VALUE, Float.POSITIVE_INFINITY, 1));
- assertTrue(MathUtils.equals(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, 1));
- assertTrue(MathUtils.equals(-Float.MAX_VALUE, Float.NEGATIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equals(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equals(-Float.MAX_VALUE, Float.NEGATIVE_INFINITY, 1));
- assertFalse(MathUtils.equals(Float.NaN, Float.NaN, 1));
+ Assert.assertFalse(MathUtils.equals(Float.NaN, Float.NaN, 1));
- assertFalse(MathUtils.equals(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, 100000));
+ Assert.assertFalse(MathUtils.equals(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, 100000));
}
+ @Test
public void testEqualsWithAllowedUlps() {
- assertTrue(MathUtils.equals(0.0, -0.0, 1));
+ Assert.assertTrue(MathUtils.equals(0.0, -0.0, 1));
- assertTrue(MathUtils.equals(1.0, 1 + FastMath.ulp(1d), 1));
- assertFalse(MathUtils.equals(1.0, 1 + 2 * FastMath.ulp(1d), 1));
+ Assert.assertTrue(MathUtils.equals(1.0, 1 + FastMath.ulp(1d), 1));
+ Assert.assertFalse(MathUtils.equals(1.0, 1 + 2 * FastMath.ulp(1d), 1));
final double nUp1 = FastMath.nextAfter(1d, Double.POSITIVE_INFINITY);
final double nnUp1 = FastMath.nextAfter(nUp1, Double.POSITIVE_INFINITY);
- assertTrue(MathUtils.equals(1.0, nUp1, 1));
- assertTrue(MathUtils.equals(nUp1, nnUp1, 1));
- assertFalse(MathUtils.equals(1.0, nnUp1, 1));
+ Assert.assertTrue(MathUtils.equals(1.0, nUp1, 1));
+ Assert.assertTrue(MathUtils.equals(nUp1, nnUp1, 1));
+ Assert.assertFalse(MathUtils.equals(1.0, nnUp1, 1));
- assertTrue(MathUtils.equals(0.0, FastMath.ulp(0d), 1));
- assertTrue(MathUtils.equals(0.0, -FastMath.ulp(0d), 1));
+ Assert.assertTrue(MathUtils.equals(0.0, FastMath.ulp(0d), 1));
+ Assert.assertTrue(MathUtils.equals(0.0, -FastMath.ulp(0d), 1));
- assertTrue(MathUtils.equals(153.0, 153.0, 1));
+ Assert.assertTrue(MathUtils.equals(153.0, 153.0, 1));
- assertTrue(MathUtils.equals(153.0, 153.00000000000003, 1));
- assertFalse(MathUtils.equals(153.0, 153.00000000000006, 1));
- assertTrue(MathUtils.equals(153.0, 152.99999999999997, 1));
- assertFalse(MathUtils.equals(153, 152.99999999999994, 1));
+ Assert.assertTrue(MathUtils.equals(153.0, 153.00000000000003, 1));
+ Assert.assertFalse(MathUtils.equals(153.0, 153.00000000000006, 1));
+ Assert.assertTrue(MathUtils.equals(153.0, 152.99999999999997, 1));
+ Assert.assertFalse(MathUtils.equals(153, 152.99999999999994, 1));
- assertTrue(MathUtils.equals(-128.0, -127.99999999999999, 1));
- assertFalse(MathUtils.equals(-128.0, -127.99999999999997, 1));
- assertTrue(MathUtils.equals(-128.0, -128.00000000000003, 1));
- assertFalse(MathUtils.equals(-128.0, -128.00000000000006, 1));
+ Assert.assertTrue(MathUtils.equals(-128.0, -127.99999999999999, 1));
+ Assert.assertFalse(MathUtils.equals(-128.0, -127.99999999999997, 1));
+ Assert.assertTrue(MathUtils.equals(-128.0, -128.00000000000003, 1));
+ Assert.assertFalse(MathUtils.equals(-128.0, -128.00000000000006, 1));
- assertTrue(MathUtils.equals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1));
- assertTrue(MathUtils.equals(Double.MAX_VALUE, Double.POSITIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equals(Double.MAX_VALUE, Double.POSITIVE_INFINITY, 1));
- assertTrue(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1));
- assertTrue(MathUtils.equals(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equals(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY, 1));
- assertFalse(MathUtils.equals(Double.NaN, Double.NaN, 1));
+ Assert.assertFalse(MathUtils.equals(Double.NaN, Double.NaN, 1));
- assertFalse(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 100000));
+ Assert.assertFalse(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 100000));
}
+ @Test
public void testEqualsIncludingNaNWithAllowedUlps() {
- assertTrue(MathUtils.equalsIncludingNaN(0.0, -0.0, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(0.0, -0.0, 1));
- assertTrue(MathUtils.equalsIncludingNaN(1.0, 1 + FastMath.ulp(1d), 1));
- assertFalse(MathUtils.equalsIncludingNaN(1.0, 1 + 2 * FastMath.ulp(1d), 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(1.0, 1 + FastMath.ulp(1d), 1));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(1.0, 1 + 2 * FastMath.ulp(1d), 1));
final double nUp1 = FastMath.nextAfter(1d, Double.POSITIVE_INFINITY);
final double nnUp1 = FastMath.nextAfter(nUp1, Double.POSITIVE_INFINITY);
- assertTrue(MathUtils.equalsIncludingNaN(1.0, nUp1, 1));
- assertTrue(MathUtils.equalsIncludingNaN(nUp1, nnUp1, 1));
- assertFalse(MathUtils.equalsIncludingNaN(1.0, nnUp1, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(1.0, nUp1, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(nUp1, nnUp1, 1));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(1.0, nnUp1, 1));
- assertTrue(MathUtils.equalsIncludingNaN(0.0, FastMath.ulp(0d), 1));
- assertTrue(MathUtils.equalsIncludingNaN(0.0, -FastMath.ulp(0d), 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(0.0, FastMath.ulp(0d), 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(0.0, -FastMath.ulp(0d), 1));
- assertTrue(MathUtils.equalsIncludingNaN(153.0, 153.0, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0, 153.0, 1));
- assertTrue(MathUtils.equalsIncludingNaN(153.0, 153.00000000000003, 1));
- assertFalse(MathUtils.equalsIncludingNaN(153.0, 153.00000000000006, 1));
- assertTrue(MathUtils.equalsIncludingNaN(153.0, 152.99999999999997, 1));
- assertFalse(MathUtils.equalsIncludingNaN(153, 152.99999999999994, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0, 153.00000000000003, 1));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(153.0, 153.00000000000006, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0, 152.99999999999997, 1));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(153, 152.99999999999994, 1));
- assertTrue(MathUtils.equalsIncludingNaN(-128.0, -127.99999999999999, 1));
- assertFalse(MathUtils.equalsIncludingNaN(-128.0, -127.99999999999997, 1));
- assertTrue(MathUtils.equalsIncludingNaN(-128.0, -128.00000000000003, 1));
- assertFalse(MathUtils.equalsIncludingNaN(-128.0, -128.00000000000006, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(-128.0, -127.99999999999999, 1));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(-128.0, -127.99999999999997, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(-128.0, -128.00000000000003, 1));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(-128.0, -128.00000000000006, 1));
- assertTrue(MathUtils.equalsIncludingNaN(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1));
- assertTrue(MathUtils.equalsIncludingNaN(Double.MAX_VALUE, Double.POSITIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.MAX_VALUE, Double.POSITIVE_INFINITY, 1));
- assertTrue(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1));
- assertTrue(MathUtils.equalsIncludingNaN(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY, 1));
- assertTrue(MathUtils.equalsIncludingNaN(Double.NaN, Double.NaN, 1));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.NaN, Double.NaN, 1));
- assertFalse(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 100000));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 100000));
}
+ @Test
public void testArrayEquals() {
- assertFalse(MathUtils.equals(new double[] { 1d }, null));
- assertFalse(MathUtils.equals(null, new double[] { 1d }));
- assertTrue(MathUtils.equals((double[]) null, (double[]) null));
-
- assertFalse(MathUtils.equals(new double[] { 1d }, new double[0]));
- assertTrue(MathUtils.equals(new double[] { 1d }, new double[] { 1d }));
- assertTrue(MathUtils.equals(new double[] {
+ Assert.assertFalse(MathUtils.equals(new double[] { 1d }, null));
+ Assert.assertFalse(MathUtils.equals(null, new double[] { 1d }));
+ Assert.assertTrue(MathUtils.equals((double[]) null, (double[]) null));
+
+ Assert.assertFalse(MathUtils.equals(new double[] { 1d }, new double[0]));
+ Assert.assertTrue(MathUtils.equals(new double[] { 1d }, new double[] { 1d }));
+ Assert.assertTrue(MathUtils.equals(new double[] {
Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY, 1d, 0d
}, new double[] {
Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY, 1d, 0d
}));
- assertFalse(MathUtils.equals(new double[] { Double.NaN },
+ Assert.assertFalse(MathUtils.equals(new double[] { Double.NaN },
new double[] { Double.NaN }));
- assertFalse(MathUtils.equals(new double[] { Double.POSITIVE_INFINITY },
+ Assert.assertFalse(MathUtils.equals(new double[] { Double.POSITIVE_INFINITY },
new double[] { Double.NEGATIVE_INFINITY }));
- assertFalse(MathUtils.equals(new double[] { 1d },
+ Assert.assertFalse(MathUtils.equals(new double[] { 1d },
new double[] { FastMath.nextAfter(FastMath.nextAfter(1d, 2d), 2d) }));
}
+ @Test
public void testArrayEqualsIncludingNaN() {
- assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d }, null));
- assertFalse(MathUtils.equalsIncludingNaN(null, new double[] { 1d }));
- assertTrue(MathUtils.equalsIncludingNaN((double[]) null, (double[]) null));
-
- assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d }, new double[0]));
- assertTrue(MathUtils.equalsIncludingNaN(new double[] { 1d }, new double[] { 1d }));
- assertTrue(MathUtils.equalsIncludingNaN(new double[] {
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d }, null));
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(null, new double[] { 1d }));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN((double[]) null, (double[]) null));
+
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d }, new double[0]));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(new double[] { 1d }, new double[] { 1d }));
+ Assert.assertTrue(MathUtils.equalsIncludingNaN(new double[] {
Double.NaN, Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY, 1d, 0d
}, new double[] {
Double.NaN, Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY, 1d, 0d
}));
- assertFalse(MathUtils.equalsIncludingNaN(new double[] { Double.POSITIVE_INFINITY },
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(new double[] { Double.POSITIVE_INFINITY },
new double[] { Double.NEGATIVE_INFINITY }));
- assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d },
+ Assert.assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d },
new double[] { FastMath.nextAfter(FastMath.nextAfter(1d, 2d), 2d) }));
}
+ @Test
public void testFactorial() {
for (int i = 1; i < 21; i++) {
- assertEquals(i + "! ", factorial(i), MathUtils.factorial(i));
- assertEquals(i + "! ", factorial(i), MathUtils.factorialDouble(i), Double.MIN_VALUE);
- assertEquals(i + "! ", FastMath.log(factorial(i)), MathUtils.factorialLog(i), 10E-12);
+ Assert.assertEquals(i + "! ", factorial(i), MathUtils.factorial(i));
+ Assert.assertEquals(i + "! ", factorial(i), MathUtils.factorialDouble(i), Double.MIN_VALUE);
+ Assert.assertEquals(i + "! ", FastMath.log(factorial(i)), MathUtils.factorialLog(i), 10E-12);
}
- assertEquals("0", 1, MathUtils.factorial(0));
- assertEquals("0", 1.0d, MathUtils.factorialDouble(0), 1E-14);
- assertEquals("0", 0.0d, MathUtils.factorialLog(0), 1E-14);
+ Assert.assertEquals("0", 1, MathUtils.factorial(0));
+ Assert.assertEquals("0", 1.0d, MathUtils.factorialDouble(0), 1E-14);
+ Assert.assertEquals("0", 0.0d, MathUtils.factorialLog(0), 1E-14);
}
+ @Test
public void testFactorialFail() {
try {
MathUtils.factorial(-1);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
MathUtils.factorialDouble(-1);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
MathUtils.factorialLog(-1);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {
// ignored
}
try {
MathUtils.factorial(21);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// ignored
}
- assertTrue("expecting infinite factorial value", Double.isInfinite(MathUtils.factorialDouble(171)));
+ Assert.assertTrue("expecting infinite factorial value", Double.isInfinite(MathUtils.factorialDouble(171)));
}
+ @Test
public void testGcd() {
int a = 30;
int b = 50;
int c = 77;
- assertEquals(0, MathUtils.gcd(0, 0));
+ Assert.assertEquals(0, MathUtils.gcd(0, 0));
- assertEquals(b, MathUtils.gcd(0, b));
- assertEquals(a, MathUtils.gcd(a, 0));
- assertEquals(b, MathUtils.gcd(0, -b));
- assertEquals(a, MathUtils.gcd(-a, 0));
-
- assertEquals(10, MathUtils.gcd(a, b));
- assertEquals(10, MathUtils.gcd(-a, b));
- assertEquals(10, MathUtils.gcd(a, -b));
- assertEquals(10, MathUtils.gcd(-a, -b));
-
- assertEquals(1, MathUtils.gcd(a, c));
- assertEquals(1, MathUtils.gcd(-a, c));
- assertEquals(1, MathUtils.gcd(a, -c));
- assertEquals(1, MathUtils.gcd(-a, -c));
-
- assertEquals(3 * (1<<15), MathUtils.gcd(3 * (1<<20), 9 * (1<<15)));
-
- assertEquals(Integer.MAX_VALUE, MathUtils.gcd(Integer.MAX_VALUE, 0));
- assertEquals(Integer.MAX_VALUE, MathUtils.gcd(-Integer.MAX_VALUE, 0));
- assertEquals(1<<30, MathUtils.gcd(1<<30, -Integer.MIN_VALUE));
+ Assert.assertEquals(b, MathUtils.gcd(0, b));
+ Assert.assertEquals(a, MathUtils.gcd(a, 0));
+ Assert.assertEquals(b, MathUtils.gcd(0, -b));
+ Assert.assertEquals(a, MathUtils.gcd(-a, 0));
+
+ Assert.assertEquals(10, MathUtils.gcd(a, b));
+ Assert.assertEquals(10, MathUtils.gcd(-a, b));
+ Assert.assertEquals(10, MathUtils.gcd(a, -b));
+ Assert.assertEquals(10, MathUtils.gcd(-a, -b));
+
+ Assert.assertEquals(1, MathUtils.gcd(a, c));
+ Assert.assertEquals(1, MathUtils.gcd(-a, c));
+ Assert.assertEquals(1, MathUtils.gcd(a, -c));
+ Assert.assertEquals(1, MathUtils.gcd(-a, -c));
+
+ Assert.assertEquals(3 * (1<<15), MathUtils.gcd(3 * (1<<20), 9 * (1<<15)));
+
+ Assert.assertEquals(Integer.MAX_VALUE, MathUtils.gcd(Integer.MAX_VALUE, 0));
+ Assert.assertEquals(Integer.MAX_VALUE, MathUtils.gcd(-Integer.MAX_VALUE, 0));
+ Assert.assertEquals(1<<30, MathUtils.gcd(1<<30, -Integer.MIN_VALUE));
try {
// gcd(Integer.MIN_VALUE, 0) > Integer.MAX_VALUE
MathUtils.gcd(Integer.MIN_VALUE, 0);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
// gcd(0, Integer.MIN_VALUE) > Integer.MAX_VALUE
MathUtils.gcd(0, Integer.MIN_VALUE);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
// gcd(Integer.MIN_VALUE, Integer.MIN_VALUE) > Integer.MAX_VALUE
MathUtils.gcd(Integer.MIN_VALUE, Integer.MIN_VALUE);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
}
+ @Test
public void testGcdLong(){
long a = 30;
long b = 50;
long c = 77;
- assertEquals(0, MathUtils.gcd(0L, 0));
+ Assert.assertEquals(0, MathUtils.gcd(0L, 0));
- assertEquals(b, MathUtils.gcd(0, b));
- assertEquals(a, MathUtils.gcd(a, 0));
- assertEquals(b, MathUtils.gcd(0, -b));
- assertEquals(a, MathUtils.gcd(-a, 0));
-
- assertEquals(10, MathUtils.gcd(a, b));
- assertEquals(10, MathUtils.gcd(-a, b));
- assertEquals(10, MathUtils.gcd(a, -b));
- assertEquals(10, MathUtils.gcd(-a, -b));
-
- assertEquals(1, MathUtils.gcd(a, c));
- assertEquals(1, MathUtils.gcd(-a, c));
- assertEquals(1, MathUtils.gcd(a, -c));
- assertEquals(1, MathUtils.gcd(-a, -c));
-
- assertEquals(3L * (1L<<45), MathUtils.gcd(3L * (1L<<50), 9L * (1L<<45)));
-
- assertEquals(1L<<45, MathUtils.gcd(1L<<45, Long.MIN_VALUE));
-
- assertEquals(Long.MAX_VALUE, MathUtils.gcd(Long.MAX_VALUE, 0L));
- assertEquals(Long.MAX_VALUE, MathUtils.gcd(-Long.MAX_VALUE, 0L));
- assertEquals(1, MathUtils.gcd(60247241209L, 153092023L));
+ Assert.assertEquals(b, MathUtils.gcd(0, b));
+ Assert.assertEquals(a, MathUtils.gcd(a, 0));
+ Assert.assertEquals(b, MathUtils.gcd(0, -b));
+ Assert.assertEquals(a, MathUtils.gcd(-a, 0));
+
+ Assert.assertEquals(10, MathUtils.gcd(a, b));
+ Assert.assertEquals(10, MathUtils.gcd(-a, b));
+ Assert.assertEquals(10, MathUtils.gcd(a, -b));
+ Assert.assertEquals(10, MathUtils.gcd(-a, -b));
+
+ Assert.assertEquals(1, MathUtils.gcd(a, c));
+ Assert.assertEquals(1, MathUtils.gcd(-a, c));
+ Assert.assertEquals(1, MathUtils.gcd(a, -c));
+ Assert.assertEquals(1, MathUtils.gcd(-a, -c));
+
+ Assert.assertEquals(3L * (1L<<45), MathUtils.gcd(3L * (1L<<50), 9L * (1L<<45)));
+
+ Assert.assertEquals(1L<<45, MathUtils.gcd(1L<<45, Long.MIN_VALUE));
+
+ Assert.assertEquals(Long.MAX_VALUE, MathUtils.gcd(Long.MAX_VALUE, 0L));
+ Assert.assertEquals(Long.MAX_VALUE, MathUtils.gcd(-Long.MAX_VALUE, 0L));
+ Assert.assertEquals(1, MathUtils.gcd(60247241209L, 153092023L));
try {
// gcd(Long.MIN_VALUE, 0) > Long.MAX_VALUE
MathUtils.gcd(Long.MIN_VALUE, 0);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
// gcd(0, Long.MIN_VALUE) > Long.MAX_VALUE
MathUtils.gcd(0, Long.MIN_VALUE);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
// gcd(Long.MIN_VALUE, Long.MIN_VALUE) > Long.MAX_VALUE
MathUtils.gcd(Long.MIN_VALUE, Long.MIN_VALUE);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
}
+ @Test
public void testGcdConsistency() {
int[] primeList = {19, 23, 53, 67, 73, 79, 101, 103, 111, 131};
ArrayList<Integer> primes = new ArrayList<Integer>();
@@ -692,13 +712,14 @@ public final class MathUtilsTest extends
int i1 = p1 * p2 * p3;
int i2 = p1 * p2 * p4;
int gcd = p1 * p2;
- assertEquals(gcd, MathUtils.gcd(i1, i2));
+ Assert.assertEquals(gcd, MathUtils.gcd(i1, i2));
long l1 = i1;
long l2 = i2;
- assertEquals(gcd, MathUtils.gcd(l1, l2));
+ Assert.assertEquals(gcd, MathUtils.gcd(l1, l2));
}
}
+ @Test
public void testHash() {
double[] testArray = {
Double.NaN,
@@ -713,19 +734,20 @@ public final class MathUtilsTest extends
for (int i = 0; i < testArray.length; i++) {
for (int j = 0; j < testArray.length; j++) {
if (i == j) {
- assertEquals(MathUtils.hash(testArray[i]), MathUtils.hash(testArray[j]));
- assertEquals(MathUtils.hash(testArray[j]), MathUtils.hash(testArray[i]));
+ Assert.assertEquals(MathUtils.hash(testArray[i]), MathUtils.hash(testArray[j]));
+ Assert.assertEquals(MathUtils.hash(testArray[j]), MathUtils.hash(testArray[i]));
} else {
- assertTrue(MathUtils.hash(testArray[i]) != MathUtils.hash(testArray[j]));
- assertTrue(MathUtils.hash(testArray[j]) != MathUtils.hash(testArray[i]));
+ Assert.assertTrue(MathUtils.hash(testArray[i]) != MathUtils.hash(testArray[j]));
+ Assert.assertTrue(MathUtils.hash(testArray[j]) != MathUtils.hash(testArray[i]));
}
}
}
}
+ @Test
public void testArrayHash() {
- assertEquals(0, MathUtils.hash((double[]) null));
- assertEquals(MathUtils.hash(new double[] {
+ Assert.assertEquals(0, MathUtils.hash((double[]) null));
+ Assert.assertEquals(MathUtils.hash(new double[] {
Double.NaN, Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY, 1d, 0d
}),
@@ -733,15 +755,16 @@ public final class MathUtilsTest extends
Double.NaN, Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY, 1d, 0d
}));
- assertFalse(MathUtils.hash(new double[] { 1d }) ==
+ Assert.assertFalse(MathUtils.hash(new double[] { 1d }) ==
MathUtils.hash(new double[] { FastMath.nextAfter(1d, 2d) }));
- assertFalse(MathUtils.hash(new double[] { 1d }) ==
+ Assert.assertFalse(MathUtils.hash(new double[] { 1d }) ==
MathUtils.hash(new double[] { 1d, 1d }));
}
/**
* Make sure that permuted arrays do not hash to the same value.
*/
+ @Test
public void testPermutedArrayHash() {
double[] original = new double[10];
double[] permuted = new double[10];
@@ -765,74 +788,81 @@ public final class MathUtilsTest extends
} while (isIdentity);
// Verify that permuted array has different hash
- assertFalse(MathUtils.hash(original) == MathUtils.hash(permuted));
+ Assert.assertFalse(MathUtils.hash(original) == MathUtils.hash(permuted));
}
+ @Test
public void testIndicatorByte() {
- assertEquals((byte)1, MathUtils.indicator((byte)2));
- assertEquals((byte)1, MathUtils.indicator((byte)0));
- assertEquals((byte)(-1), MathUtils.indicator((byte)(-2)));
+ Assert.assertEquals((byte)1, MathUtils.indicator((byte)2));
+ Assert.assertEquals((byte)1, MathUtils.indicator((byte)0));
+ Assert.assertEquals((byte)(-1), MathUtils.indicator((byte)(-2)));
}
+ @Test
public void testIndicatorDouble() {
double delta = 0.0;
- assertEquals(1.0, MathUtils.indicator(2.0), delta);
- assertEquals(1.0, MathUtils.indicator(0.0), delta);
- assertEquals(-1.0, MathUtils.indicator(-2.0), delta);
- assertEquals(Double.NaN, MathUtils.indicator(Double.NaN));
+ Assert.assertEquals(1.0, MathUtils.indicator(2.0), delta);
+ Assert.assertEquals(1.0, MathUtils.indicator(0.0), delta);
+ Assert.assertEquals(-1.0, MathUtils.indicator(-2.0), delta);
+ Assert.assertTrue(Double.isNaN(MathUtils.indicator(Double.NaN)));
}
+ @Test
public void testIndicatorFloat() {
float delta = 0.0F;
- assertEquals(1.0F, MathUtils.indicator(2.0F), delta);
- assertEquals(1.0F, MathUtils.indicator(0.0F), delta);
- assertEquals(-1.0F, MathUtils.indicator(-2.0F), delta);
+ Assert.assertEquals(1.0F, MathUtils.indicator(2.0F), delta);
+ Assert.assertEquals(1.0F, MathUtils.indicator(0.0F), delta);
+ Assert.assertEquals(-1.0F, MathUtils.indicator(-2.0F), delta);
}
+ @Test
public void testIndicatorInt() {
- assertEquals(1, MathUtils.indicator((2)));
- assertEquals(1, MathUtils.indicator((0)));
- assertEquals((-1), MathUtils.indicator((-2)));
+ Assert.assertEquals(1, MathUtils.indicator((2)));
+ Assert.assertEquals(1, MathUtils.indicator((0)));
+ Assert.assertEquals((-1), MathUtils.indicator((-2)));
}
+ @Test
public void testIndicatorLong() {
- assertEquals(1L, MathUtils.indicator(2L));
- assertEquals(1L, MathUtils.indicator(0L));
- assertEquals(-1L, MathUtils.indicator(-2L));
+ Assert.assertEquals(1L, MathUtils.indicator(2L));
+ Assert.assertEquals(1L, MathUtils.indicator(0L));
+ Assert.assertEquals(-1L, MathUtils.indicator(-2L));
}
+ @Test
public void testIndicatorShort() {
- assertEquals((short)1, MathUtils.indicator((short)2));
- assertEquals((short)1, MathUtils.indicator((short)0));
- assertEquals((short)(-1), MathUtils.indicator((short)(-2)));
+ Assert.assertEquals((short)1, MathUtils.indicator((short)2));
+ Assert.assertEquals((short)1, MathUtils.indicator((short)0));
+ Assert.assertEquals((short)(-1), MathUtils.indicator((short)(-2)));
}
+ @Test
public void testLcm() {
int a = 30;
int b = 50;
int c = 77;
- assertEquals(0, MathUtils.lcm(0, b));
- assertEquals(0, MathUtils.lcm(a, 0));
- assertEquals(b, MathUtils.lcm(1, b));
- assertEquals(a, MathUtils.lcm(a, 1));
- assertEquals(150, MathUtils.lcm(a, b));
- assertEquals(150, MathUtils.lcm(-a, b));
- assertEquals(150, MathUtils.lcm(a, -b));
- assertEquals(150, MathUtils.lcm(-a, -b));
- assertEquals(2310, MathUtils.lcm(a, c));
+ Assert.assertEquals(0, MathUtils.lcm(0, b));
+ Assert.assertEquals(0, MathUtils.lcm(a, 0));
+ Assert.assertEquals(b, MathUtils.lcm(1, b));
+ Assert.assertEquals(a, MathUtils.lcm(a, 1));
+ Assert.assertEquals(150, MathUtils.lcm(a, b));
+ Assert.assertEquals(150, MathUtils.lcm(-a, b));
+ Assert.assertEquals(150, MathUtils.lcm(a, -b));
+ Assert.assertEquals(150, MathUtils.lcm(-a, -b));
+ Assert.assertEquals(2310, MathUtils.lcm(a, c));
// Assert that no intermediate value overflows:
// The naive implementation of lcm(a,b) would be (a*b)/gcd(a,b)
- assertEquals((1<<20)*15, MathUtils.lcm((1<<20)*3, (1<<20)*5));
+ Assert.assertEquals((1<<20)*15, MathUtils.lcm((1<<20)*3, (1<<20)*5));
// Special case
- assertEquals(0, MathUtils.lcm(0, 0));
+ Assert.assertEquals(0, MathUtils.lcm(0, 0));
try {
// lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
MathUtils.lcm(Integer.MIN_VALUE, 1);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
@@ -840,47 +870,48 @@ public final class MathUtilsTest extends
try {
// lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
MathUtils.lcm(Integer.MIN_VALUE, 1<<20);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
try {
MathUtils.lcm(Integer.MAX_VALUE, Integer.MAX_VALUE - 1);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
}
+ @Test
public void testLcmLong() {
long a = 30;
long b = 50;
long c = 77;
- assertEquals(0, MathUtils.lcm(0, b));
- assertEquals(0, MathUtils.lcm(a, 0));
- assertEquals(b, MathUtils.lcm(1, b));
- assertEquals(a, MathUtils.lcm(a, 1));
- assertEquals(150, MathUtils.lcm(a, b));
- assertEquals(150, MathUtils.lcm(-a, b));
- assertEquals(150, MathUtils.lcm(a, -b));
- assertEquals(150, MathUtils.lcm(-a, -b));
- assertEquals(2310, MathUtils.lcm(a, c));
+ Assert.assertEquals(0, MathUtils.lcm(0, b));
+ Assert.assertEquals(0, MathUtils.lcm(a, 0));
+ Assert.assertEquals(b, MathUtils.lcm(1, b));
+ Assert.assertEquals(a, MathUtils.lcm(a, 1));
+ Assert.assertEquals(150, MathUtils.lcm(a, b));
+ Assert.assertEquals(150, MathUtils.lcm(-a, b));
+ Assert.assertEquals(150, MathUtils.lcm(a, -b));
+ Assert.assertEquals(150, MathUtils.lcm(-a, -b));
+ Assert.assertEquals(2310, MathUtils.lcm(a, c));
- assertEquals(Long.MAX_VALUE, MathUtils.lcm(60247241209L, 153092023L));
+ Assert.assertEquals(Long.MAX_VALUE, MathUtils.lcm(60247241209L, 153092023L));
// Assert that no intermediate value overflows:
// The naive implementation of lcm(a,b) would be (a*b)/gcd(a,b)
- assertEquals((1L<<50)*15, MathUtils.lcm((1L<<45)*3, (1L<<50)*5));
+ Assert.assertEquals((1L<<50)*15, MathUtils.lcm((1L<<45)*3, (1L<<50)*5));
// Special case
- assertEquals(0L, MathUtils.lcm(0L, 0L));
+ Assert.assertEquals(0L, MathUtils.lcm(0L, 0L));
try {
// lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
MathUtils.lcm(Long.MIN_VALUE, 1);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
@@ -888,60 +919,63 @@ public final class MathUtilsTest extends
try {
// lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
MathUtils.lcm(Long.MIN_VALUE, 1<<20);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
- assertEquals((long) Integer.MAX_VALUE * (Integer.MAX_VALUE - 1),
+ Assert.assertEquals((long) Integer.MAX_VALUE * (Integer.MAX_VALUE - 1),
MathUtils.lcm((long)Integer.MAX_VALUE, Integer.MAX_VALUE - 1));
try {
MathUtils.lcm(Long.MAX_VALUE, Long.MAX_VALUE - 1);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException expected) {
// expected
}
}
+ @Test
public void testLog() {
- assertEquals(2.0, MathUtils.log(2, 4), 0);
- assertEquals(3.0, MathUtils.log(2, 8), 0);
- assertTrue(Double.isNaN(MathUtils.log(-1, 1)));
- assertTrue(Double.isNaN(MathUtils.log(1, -1)));
- assertTrue(Double.isNaN(MathUtils.log(0, 0)));
- assertEquals(0, MathUtils.log(0, 10), 0);
- assertEquals(Double.NEGATIVE_INFINITY, MathUtils.log(10, 0), 0);
+ Assert.assertEquals(2.0, MathUtils.log(2, 4), 0);
+ Assert.assertEquals(3.0, MathUtils.log(2, 8), 0);
+ Assert.assertTrue(Double.isNaN(MathUtils.log(-1, 1)));
+ Assert.assertTrue(Double.isNaN(MathUtils.log(1, -1)));
+ Assert.assertTrue(Double.isNaN(MathUtils.log(0, 0)));
+ Assert.assertEquals(0, MathUtils.log(0, 10), 0);
+ Assert.assertEquals(Double.NEGATIVE_INFINITY, MathUtils.log(10, 0), 0);
}
+ @Test
public void testMulAndCheck() {
int big = Integer.MAX_VALUE;
int bigNeg = Integer.MIN_VALUE;
- assertEquals(big, MathUtils.mulAndCheck(big, 1));
+ Assert.assertEquals(big, MathUtils.mulAndCheck(big, 1));
try {
MathUtils.mulAndCheck(big, 2);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
try {
MathUtils.mulAndCheck(bigNeg, 2);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
}
+ @Test
public void testMulAndCheckLong() {
long max = Long.MAX_VALUE;
long min = Long.MIN_VALUE;
- assertEquals(max, MathUtils.mulAndCheck(max, 1L));
- assertEquals(min, MathUtils.mulAndCheck(min, 1L));
- assertEquals(0L, MathUtils.mulAndCheck(max, 0L));
- assertEquals(0L, MathUtils.mulAndCheck(min, 0L));
- assertEquals(max, MathUtils.mulAndCheck(1L, max));
- assertEquals(min, MathUtils.mulAndCheck(1L, min));
- assertEquals(0L, MathUtils.mulAndCheck(0L, max));
- assertEquals(0L, MathUtils.mulAndCheck(0L, min));
- assertEquals(1L, MathUtils.mulAndCheck(-1L, -1L));
- assertEquals(min, MathUtils.mulAndCheck(min / 2, 2));
+ Assert.assertEquals(max, MathUtils.mulAndCheck(max, 1L));
+ Assert.assertEquals(min, MathUtils.mulAndCheck(min, 1L));
+ Assert.assertEquals(0L, MathUtils.mulAndCheck(max, 0L));
+ Assert.assertEquals(0L, MathUtils.mulAndCheck(min, 0L));
+ Assert.assertEquals(max, MathUtils.mulAndCheck(1L, max));
+ Assert.assertEquals(min, MathUtils.mulAndCheck(1L, min));
+ Assert.assertEquals(0L, MathUtils.mulAndCheck(0L, max));
+ Assert.assertEquals(0L, MathUtils.mulAndCheck(0L, min));
+ Assert.assertEquals(1L, MathUtils.mulAndCheck(-1L, -1L));
+ Assert.assertEquals(min, MathUtils.mulAndCheck(min / 2, 2));
testMulAndCheckLongFailure(max, 2L);
testMulAndCheckLongFailure(2L, max);
testMulAndCheckLongFailure(min, 2L);
@@ -953,24 +987,26 @@ public final class MathUtilsTest extends
private void testMulAndCheckLongFailure(long a, long b) {
try {
MathUtils.mulAndCheck(a, b);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
// success
}
}
+ @Test
public void testNormalizeAngle() {
for (double a = -15.0; a <= 15.0; a += 0.1) {
for (double b = -15.0; b <= 15.0; b += 0.2) {
double c = MathUtils.normalizeAngle(a, b);
- assertTrue((b - FastMath.PI) <= c);
- assertTrue(c <= (b + FastMath.PI));
+ Assert.assertTrue((b - FastMath.PI) <= c);
+ Assert.assertTrue(c <= (b + FastMath.PI));
double twoK = FastMath.rint((a - c) / FastMath.PI);
- assertEquals(c, a - twoK * FastMath.PI, 1.0e-14);
+ Assert.assertEquals(c, a - twoK * FastMath.PI, 1.0e-14);
}
}
}
+ @Test
public void testNormalizeArray() {
double[] testValues1 = new double[] {1, 1, 2};
TestUtils.assertEquals(
@@ -995,322 +1031,335 @@ public final class MathUtilsTest extends
double[] zeroSum = new double[] {-1, 1};
try {
MathUtils.normalizeArray(zeroSum, 1);
- fail("expecting MathArithmeticException");
+ Assert.fail("expecting MathArithmeticException");
} catch (MathArithmeticException ex) {}
// Infinite elements -> MathArithmeticException
double[] hasInf = new double[] {1, 2, 1, Double.NEGATIVE_INFINITY};
try {
MathUtils.normalizeArray(hasInf, 1);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {}
// Infinite target -> MathIllegalArgumentException
try {
MathUtils.normalizeArray(testValues1, Double.POSITIVE_INFINITY);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {}
// NaN target -> MathIllegalArgumentException
try {
MathUtils.normalizeArray(testValues1, Double.NaN);
- fail("expecting MathIllegalArgumentException");
+ Assert.fail("expecting MathIllegalArgumentException");
} catch (MathIllegalArgumentException ex) {}
}
+ @Test
public void testRoundDouble() {
double x = 1.234567890;
- assertEquals(1.23, MathUtils.round(x, 2), 0.0);
- assertEquals(1.235, MathUtils.round(x, 3), 0.0);
- assertEquals(1.2346, MathUtils.round(x, 4), 0.0);
+ Assert.assertEquals(1.23, MathUtils.round(x, 2), 0.0);
+ Assert.assertEquals(1.235, MathUtils.round(x, 3), 0.0);
+ Assert.assertEquals(1.2346, MathUtils.round(x, 4), 0.0);
// JIRA MATH-151
- assertEquals(39.25, MathUtils.round(39.245, 2), 0.0);
- assertEquals(39.24, MathUtils.round(39.245, 2, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(39.25, MathUtils.round(39.245, 2), 0.0);
+ Assert.assertEquals(39.24, MathUtils.round(39.245, 2, BigDecimal.ROUND_DOWN), 0.0);
double xx = 39.0;
xx = xx + 245d / 1000d;
- assertEquals(39.25, MathUtils.round(xx, 2), 0.0);
+ Assert.assertEquals(39.25, MathUtils.round(xx, 2), 0.0);
// BZ 35904
- assertEquals(30.1d, MathUtils.round(30.095d, 2), 0.0d);
- assertEquals(30.1d, MathUtils.round(30.095d, 1), 0.0d);
- assertEquals(33.1d, MathUtils.round(33.095d, 1), 0.0d);
- assertEquals(33.1d, MathUtils.round(33.095d, 2), 0.0d);
- assertEquals(50.09d, MathUtils.round(50.085d, 2), 0.0d);
- assertEquals(50.19d, MathUtils.round(50.185d, 2), 0.0d);
- assertEquals(50.01d, MathUtils.round(50.005d, 2), 0.0d);
- assertEquals(30.01d, MathUtils.round(30.005d, 2), 0.0d);
- assertEquals(30.65d, MathUtils.round(30.645d, 2), 0.0d);
-
- assertEquals(1.24, MathUtils.round(x, 2, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(-1.234, MathUtils.round(-x, 3, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(-1.2345, MathUtils.round(-x, 4, BigDecimal.ROUND_CEILING), 0.0);
-
- assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(1.234, MathUtils.round(x, 3, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(1.2345, MathUtils.round(x, 4, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(-1.234, MathUtils.round(-x, 3, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(-1.2345, MathUtils.round(-x, 4, BigDecimal.ROUND_DOWN), 0.0);
-
- assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(1.234, MathUtils.round(x, 3, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(1.2345, MathUtils.round(x, 4, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(-1.24, MathUtils.round(-x, 2, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_FLOOR), 0.0);
-
- assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(1.234, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(-1.234, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-
- assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(1.234, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.234, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(1.236, MathUtils.round(1.2355, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.236, MathUtils.round(-1.2355, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-
- assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(1.235, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.235, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(30.1d, MathUtils.round(30.095d, 2), 0.0d);
+ Assert.assertEquals(30.1d, MathUtils.round(30.095d, 1), 0.0d);
+ Assert.assertEquals(33.1d, MathUtils.round(33.095d, 1), 0.0d);
+ Assert.assertEquals(33.1d, MathUtils.round(33.095d, 2), 0.0d);
+ Assert.assertEquals(50.09d, MathUtils.round(50.085d, 2), 0.0d);
+ Assert.assertEquals(50.19d, MathUtils.round(50.185d, 2), 0.0d);
+ Assert.assertEquals(50.01d, MathUtils.round(50.005d, 2), 0.0d);
+ Assert.assertEquals(30.01d, MathUtils.round(30.005d, 2), 0.0d);
+ Assert.assertEquals(30.65d, MathUtils.round(30.645d, 2), 0.0d);
+
+ Assert.assertEquals(1.24, MathUtils.round(x, 2, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(-1.234, MathUtils.round(-x, 3, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(-1.2345, MathUtils.round(-x, 4, BigDecimal.ROUND_CEILING), 0.0);
+
+ Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(1.234, MathUtils.round(x, 3, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(1.2345, MathUtils.round(x, 4, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(-1.234, MathUtils.round(-x, 3, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(-1.2345, MathUtils.round(-x, 4, BigDecimal.ROUND_DOWN), 0.0);
+
+ Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(1.234, MathUtils.round(x, 3, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(1.2345, MathUtils.round(x, 4, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(-1.24, MathUtils.round(-x, 2, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_FLOOR), 0.0);
+
+ Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(1.234, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(-1.234, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+
+ Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(1.234, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.234, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(1.236, MathUtils.round(1.2355, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.236, MathUtils.round(-1.2355, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+
+ Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(1.235, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(-1.235, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.23, MathUtils.round(-1.23, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
- assertEquals(1.23, MathUtils.round(1.23, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
+ Assert.assertEquals(-1.23, MathUtils.round(-1.23, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
+ Assert.assertEquals(1.23, MathUtils.round(1.23, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
try {
MathUtils.round(1.234, 2, BigDecimal.ROUND_UNNECESSARY);
- fail();
+ Assert.fail();
} catch (MathRuntimeException ex) { // XXX Loosing semantics?
// success
}
- assertEquals(1.24, MathUtils.round(x, 2, BigDecimal.ROUND_UP), 0.0);
- assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_UP), 0.0);
- assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_UP), 0.0);
- assertEquals(-1.24, MathUtils.round(-x, 2, BigDecimal.ROUND_UP), 0.0);
- assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_UP), 0.0);
- assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(1.24, MathUtils.round(x, 2, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(-1.24, MathUtils.round(-x, 2, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_UP), 0.0);
try {
MathUtils.round(1.234, 2, 1923);
- fail();
+ Assert.fail();
} catch (MathRuntimeException ex) { // XXX Loosing semantics?
// success
}
// MATH-151
- assertEquals(39.25, MathUtils.round(39.245, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(39.25, MathUtils.round(39.245, 2, BigDecimal.ROUND_HALF_UP), 0.0);
// special values
TestUtils.assertEquals(Double.NaN, MathUtils.round(Double.NaN, 2), 0.0);
- assertEquals(0.0, MathUtils.round(0.0, 2), 0.0);
- assertEquals(Double.POSITIVE_INFINITY, MathUtils.round(Double.POSITIVE_INFINITY, 2), 0.0);
- assertEquals(Double.NEGATIVE_INFINITY, MathUtils.round(Double.NEGATIVE_INFINITY, 2), 0.0);
+ Assert.assertEquals(0.0, MathUtils.round(0.0, 2), 0.0);
+ Assert.assertEquals(Double.POSITIVE_INFINITY, MathUtils.round(Double.POSITIVE_INFINITY, 2), 0.0);
+ Assert.assertEquals(Double.NEGATIVE_INFINITY, MathUtils.round(Double.NEGATIVE_INFINITY, 2), 0.0);
}
+ @Test
public void testRoundFloat() {
float x = 1.234567890f;
- assertEquals(1.23f, MathUtils.round(x, 2), 0.0);
- assertEquals(1.235f, MathUtils.round(x, 3), 0.0);
- assertEquals(1.2346f, MathUtils.round(x, 4), 0.0);
+ Assert.assertEquals(1.23f, MathUtils.round(x, 2), 0.0);
+ Assert.assertEquals(1.235f, MathUtils.round(x, 3), 0.0);
+ Assert.assertEquals(1.2346f, MathUtils.round(x, 4), 0.0);
// BZ 35904
- assertEquals(30.1f, MathUtils.round(30.095f, 2), 0.0f);
- assertEquals(30.1f, MathUtils.round(30.095f, 1), 0.0f);
- assertEquals(50.09f, MathUtils.round(50.085f, 2), 0.0f);
- assertEquals(50.19f, MathUtils.round(50.185f, 2), 0.0f);
- assertEquals(50.01f, MathUtils.round(50.005f, 2), 0.0f);
- assertEquals(30.01f, MathUtils.round(30.005f, 2), 0.0f);
- assertEquals(30.65f, MathUtils.round(30.645f, 2), 0.0f);
-
- assertEquals(1.24f, MathUtils.round(x, 2, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(-1.234f, MathUtils.round(-x, 3, BigDecimal.ROUND_CEILING), 0.0);
- assertEquals(-1.2345f, MathUtils.round(-x, 4, BigDecimal.ROUND_CEILING), 0.0);
-
- assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(1.234f, MathUtils.round(x, 3, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(1.2345f, MathUtils.round(x, 4, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(-1.234f, MathUtils.round(-x, 3, BigDecimal.ROUND_DOWN), 0.0);
- assertEquals(-1.2345f, MathUtils.round(-x, 4, BigDecimal.ROUND_DOWN), 0.0);
-
- assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(1.234f, MathUtils.round(x, 3, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(1.2345f, MathUtils.round(x, 4, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(-1.24f, MathUtils.round(-x, 2, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_FLOOR), 0.0);
- assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_FLOOR), 0.0);
-
- assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(1.234f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
- assertEquals(-1.234f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-
- assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(1.234f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.234f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(1.236f, MathUtils.round(1.2355f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
- assertEquals(-1.236f, MathUtils.round(-1.2355f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-
- assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(1.235f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.235f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(30.1f, MathUtils.round(30.095f, 2), 0.0f);
+ Assert.assertEquals(30.1f, MathUtils.round(30.095f, 1), 0.0f);
+ Assert.assertEquals(50.09f, MathUtils.round(50.085f, 2), 0.0f);
+ Assert.assertEquals(50.19f, MathUtils.round(50.185f, 2), 0.0f);
+ Assert.assertEquals(50.01f, MathUtils.round(50.005f, 2), 0.0f);
+ Assert.assertEquals(30.01f, MathUtils.round(30.005f, 2), 0.0f);
+ Assert.assertEquals(30.65f, MathUtils.round(30.645f, 2), 0.0f);
+
+ Assert.assertEquals(1.24f, MathUtils.round(x, 2, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(-1.234f, MathUtils.round(-x, 3, BigDecimal.ROUND_CEILING), 0.0);
+ Assert.assertEquals(-1.2345f, MathUtils.round(-x, 4, BigDecimal.ROUND_CEILING), 0.0);
+
+ Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(1.234f, MathUtils.round(x, 3, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(1.2345f, MathUtils.round(x, 4, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(-1.234f, MathUtils.round(-x, 3, BigDecimal.ROUND_DOWN), 0.0);
+ Assert.assertEquals(-1.2345f, MathUtils.round(-x, 4, BigDecimal.ROUND_DOWN), 0.0);
+
+ Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(1.234f, MathUtils.round(x, 3, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(1.2345f, MathUtils.round(x, 4, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(-1.24f, MathUtils.round(-x, 2, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_FLOOR), 0.0);
+ Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_FLOOR), 0.0);
+
+ Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(1.234f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+ Assert.assertEquals(-1.234f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+
+ Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(1.234f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.234f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(1.236f, MathUtils.round(1.2355f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+ Assert.assertEquals(-1.236f, MathUtils.round(-1.2355f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+
+ Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(1.235f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+ Assert.assertEquals(-1.235f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_UP), 0.0);
- assertEquals(-1.23f, MathUtils.round(-1.23f, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
- assertEquals(1.23f, MathUtils.round(1.23f, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
+ Assert.assertEquals(-1.23f, MathUtils.round(-1.23f, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
+ Assert.assertEquals(1.23f, MathUtils.round(1.23f, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
try {
MathUtils.round(1.234f, 2, BigDecimal.ROUND_UNNECESSARY);
- fail();
+ Assert.fail();
} catch (MathArithmeticException ex) {
// success
}
- assertEquals(1.24f, MathUtils.round(x, 2, BigDecimal.ROUND_UP), 0.0);
- assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_UP), 0.0);
- assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_UP), 0.0);
- assertEquals(-1.24f, MathUtils.round(-x, 2, BigDecimal.ROUND_UP), 0.0);
- assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_UP), 0.0);
- assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(1.24f, MathUtils.round(x, 2, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(-1.24f, MathUtils.round(-x, 2, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_UP), 0.0);
+ Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_UP), 0.0);
try {
MathUtils.round(1.234f, 2, 1923);
- fail();
+ Assert.fail();
} catch (MathIllegalArgumentException ex) {
// success
}
// special values
TestUtils.assertEquals(Float.NaN, MathUtils.round(Float.NaN, 2), 0.0f);
- assertEquals(0.0f, MathUtils.round(0.0f, 2), 0.0f);
- assertEquals(Float.POSITIVE_INFINITY, MathUtils.round(Float.POSITIVE_INFINITY, 2), 0.0f);
- assertEquals(Float.NEGATIVE_INFINITY, MathUtils.round(Float.NEGATIVE_INFINITY, 2), 0.0f);
+ Assert.assertEquals(0.0f, MathUtils.round(0.0f, 2), 0.0f);
+ Assert.assertEquals(Float.POSITIVE_INFINITY, MathUtils.round(Float.POSITIVE_INFINITY, 2), 0.0f);
+ Assert.assertEquals(Float.NEGATIVE_INFINITY, MathUtils.round(Float.NEGATIVE_INFINITY, 2), 0.0f);
}
+ @Test
public void testSignByte() {
- assertEquals((byte) 1, MathUtils.sign((byte) 2));
- assertEquals((byte) 0, MathUtils.sign((byte) 0));
- assertEquals((byte) (-1), MathUtils.sign((byte) (-2)));
+ Assert.assertEquals((byte) 1, MathUtils.sign((byte) 2));
+ Assert.assertEquals((byte) 0, MathUtils.sign((byte) 0));
+ Assert.assertEquals((byte) (-1), MathUtils.sign((byte) (-2)));
}
+ @Test
public void testSignDouble() {
double delta = 0.0;
- assertEquals(1.0, MathUtils.sign(2.0), delta);
- assertEquals(0.0, MathUtils.sign(0.0), delta);
- assertEquals(-1.0, MathUtils.sign(-2.0), delta);
+ Assert.assertEquals(1.0, MathUtils.sign(2.0), delta);
+ Assert.assertEquals(0.0, MathUtils.sign(0.0), delta);
+ Assert.assertEquals(-1.0, MathUtils.sign(-2.0), delta);
TestUtils.assertSame(-0. / 0., MathUtils.sign(Double.NaN));
}
+ @Test
public void testSignFloat() {
float delta = 0.0F;
- assertEquals(1.0F, MathUtils.sign(2.0F), delta);
- assertEquals(0.0F, MathUtils.sign(0.0F), delta);
- assertEquals(-1.0F, MathUtils.sign(-2.0F), delta);
+ Assert.assertEquals(1.0F, MathUtils.sign(2.0F), delta);
+ Assert.assertEquals(0.0F, MathUtils.sign(0.0F), delta);
+ Assert.assertEquals(-1.0F, MathUtils.sign(-2.0F), delta);
TestUtils.assertSame(Float.NaN, MathUtils.sign(Float.NaN));
}
+ @Test
public void testSignInt() {
- assertEquals(1, MathUtils.sign(2));
- assertEquals(0, MathUtils.sign(0));
- assertEquals((-1), MathUtils.sign((-2)));
+ Assert.assertEquals(1, MathUtils.sign(2));
+ Assert.assertEquals(0, MathUtils.sign(0));
+ Assert.assertEquals((-1), MathUtils.sign((-2)));
}
+ @Test
public void testSignLong() {
- assertEquals(1L, MathUtils.sign(2L));
- assertEquals(0L, MathUtils.sign(0L));
- assertEquals(-1L, MathUtils.sign(-2L));
+ Assert.assertEquals(1L, MathUtils.sign(2L));
+ Assert.assertEquals(0L, MathUtils.sign(0L));
+ Assert.assertEquals(-1L, MathUtils.sign(-2L));
}
+ @Test
public void testSignShort() {
- assertEquals((short) 1, MathUtils.sign((short) 2));
- assertEquals((short) 0, MathUtils.sign((short) 0));
- assertEquals((short) (-1), MathUtils.sign((short) (-2)));
+ Assert.assertEquals((short) 1, MathUtils.sign((short) 2));
+ Assert.assertEquals((short) 0, MathUtils.sign((short) 0));
+ Assert.assertEquals((short) (-1), MathUtils.sign((short) (-2)));
}
+ @Test
public void testSinh() {
double x = 3.0;
double expected = 10.01787;
- assertEquals(expected, MathUtils.sinh(x), 1.0e-5);
+ Assert.assertEquals(expected, MathUtils.sinh(x), 1.0e-5);
}
+ @Test
public void testSinhNaN() {
- assertTrue(Double.isNaN(MathUtils.sinh(Double.NaN)));
+ Assert.assertTrue(Double.isNaN(MathUtils.sinh(Double.NaN)));
}
+ @Test
public void testSubAndCheck() {
int big = Integer.MAX_VALUE;
int bigNeg = Integer.MIN_VALUE;
- assertEquals(big, MathUtils.subAndCheck(big, 0));
- assertEquals(bigNeg + 1, MathUtils.subAndCheck(bigNeg, -1));
- assertEquals(-1, MathUtils.subAndCheck(bigNeg, -big));
+ Assert.assertEquals(big, MathUtils.subAndCheck(big, 0));
+ Assert.assertEquals(bigNeg + 1, MathUtils.subAndCheck(bigNeg, -1));
+ Assert.assertEquals(-1, MathUtils.subAndCheck(bigNeg, -big));
try {
MathUtils.subAndCheck(big, -1);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
} catch (MathArithmeticException ex) {
}
try {
MathUtils.subAndCheck(bigNeg, 1);
- fail("Expecting MathArithmeticException");
+ Assert.fail("Expecting MathArithmeticException");
[... 452 lines stripped ...]