Fraction: Increase similarity between BigFraction tests
Adds some compareTo tests that currently fail.
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
index 3a24a20..33445a4 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
@@ -99,16 +99,31 @@
);
}
+ // Cases with different exact results from Fraction
+ assertFraction(6004799503160661L, 18014398509481984L, BigFraction.from(1.0 / 3.0));
+ assertFraction(6124895493223875L, 36028797018963968L, BigFraction.from(17.0 / 100.0));
+ assertFraction(1784551352345559L, 562949953421312L, BigFraction.from(317.0 / 100.0));
+ assertFraction(-6004799503160661L, 18014398509481984L, BigFraction.from(-1.0 / 3.0));
+ assertFraction(-6124895493223875L, 36028797018963968L, BigFraction.from(17.0 / -100.0));
+ assertFraction(-1784551352345559L, 562949953421312L, BigFraction.from(-317.0 / 100.0));
+
+ // Extreme double values
+ Assertions.assertEquals(1L, BigFraction.from(Double.MAX_VALUE).getDenominatorAsLong());
+ Assertions.assertEquals(1L, BigFraction.from(Double.longBitsToDouble(0x0010000000000000L)).getNumeratorAsLong());
+ assertFraction(BigInteger.ONE, BigInteger.ONE.shiftLeft(1074), BigFraction.from(Double.MIN_VALUE));
+
+ // Check exact round-trip of double
Assertions.assertEquals(0.00000000000001, BigFraction.from(0.00000000000001).doubleValue());
Assertions.assertEquals(0.40000000000001, BigFraction.from(0.40000000000001).doubleValue());
Assertions.assertEquals(15.0000000000001, BigFraction.from(15.0000000000001).doubleValue());
+ // Check the representation
assertFraction(3602879701896487L, 9007199254740992L, BigFraction.from(0.40000000000001));
assertFraction(1055531162664967L, 70368744177664L, BigFraction.from(15.0000000000001));
}
// MATH-181
@Test
- public void testDigitLimitConstructor() throws Exception {
+ public void testDoubleConstructorWithMaxDenominator() throws Exception {
assertFraction(2, 5, BigFraction.from(0.4, 9));
assertFraction(2, 5, BigFraction.from(0.4, 99));
assertFraction(2, 5, BigFraction.from(0.4, 999));
@@ -144,22 +159,17 @@
// MATH-1029
@Test
- public void testPositiveValueOverflow() {
+ public void testDoubleConstructorWithMaxDenominatorOverFlow() {
Assertions.assertThrows(ArithmeticException.class,
() -> BigFraction.from(1e10, 1000)
);
- }
-
- // MATH-1029
- @Test
- public void testNegativeValueOverflow() {
Assertions.assertThrows(ArithmeticException.class,
- () -> assertFraction((long) -1e10, 1, BigFraction.from(-1e10, 1000))
+ () -> BigFraction.from(-1e10, 1000)
);
}
@Test
- public void testEpsilonLimitConstructor() throws Exception {
+ public void testDoubleConstructorWithEpsilonLimit() throws Exception {
assertFraction(2, 5, BigFraction.from(0.4, 1.0e-5, 100));
assertFraction(3, 5, BigFraction.from(0.6152, 0.02, 100));
@@ -177,6 +187,8 @@
final BigFraction c = BigFraction.of(1, 2);
final BigFraction d = BigFraction.of(-1, 2);
final BigFraction e = BigFraction.of(1, -2);
+ final BigFraction f = BigFraction.of(-1, -2);
+ final BigFraction g = BigFraction.of(-1, Integer.MIN_VALUE);
Assertions.assertEquals(0, a.compareTo(a));
Assertions.assertEquals(0, a.compareTo(c));
@@ -187,6 +199,14 @@
Assertions.assertEquals(-1, e.compareTo(a));
Assertions.assertEquals(1, a.compareTo(e));
Assertions.assertEquals(0, d.compareTo(e));
+ Assertions.assertEquals(0, a.compareTo(f));
+ Assertions.assertEquals(0, f.compareTo(a));
+ Assertions.assertEquals(1, f.compareTo(e));
+ Assertions.assertEquals(-1, e.compareTo(f));
+// Assertions.assertEquals(-1, g.compareTo(a));
+ Assertions.assertEquals(-1, g.compareTo(f));
+// Assertions.assertEquals(1, a.compareTo(g));
+ Assertions.assertEquals(-1, d.compareTo(g));
Assertions.assertEquals(0, BigFraction.of(0, 3).compareTo(BigFraction.of(0, -2)));
@@ -411,22 +431,11 @@
}
@Test
- public void testConstructorDouble() {
- assertFraction(0, 1, BigFraction.from(0.0));
- assertFraction(1, 2, BigFraction.from(0.5));
- assertFraction(6004799503160661L, 18014398509481984L, BigFraction.from(1.0 / 3.0));
- assertFraction(6124895493223875L, 36028797018963968L, BigFraction.from(17.0 / 100.0));
- assertFraction(1784551352345559L, 562949953421312L, BigFraction.from(317.0 / 100.0));
- assertFraction(-1, 2, BigFraction.from(-0.5));
- assertFraction(-6004799503160661L, 18014398509481984L, BigFraction.from(-1.0 / 3.0));
- assertFraction(-6124895493223875L, 36028797018963968L, BigFraction.from(17.0 / -100.0));
- assertFraction(-1784551352345559L, 562949953421312L, BigFraction.from(-317.0 / 100.0));
- for (double v : new double[] {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY}) {
- Assertions.assertThrows(IllegalArgumentException.class, () -> BigFraction.from(v));
- }
- Assertions.assertEquals(1L, BigFraction.from(Double.MAX_VALUE).getDenominatorAsLong());
- Assertions.assertEquals(1L, BigFraction.from(Double.longBitsToDouble(0x0010000000000000L)).getNumeratorAsLong());
- assertFraction(BigInteger.ONE, BigInteger.ONE.shiftLeft(1074), BigFraction.from(Double.MIN_VALUE));
+ public void testBigDecimalValue() {
+ Assertions.assertEquals(new BigDecimal(0.5), BigFraction.of(1, 2).bigDecimalValue());
+ Assertions.assertEquals(new BigDecimal("0.0003"), BigFraction.of(3, 10000).bigDecimalValue());
+ Assertions.assertEquals(new BigDecimal("0"), BigFraction.of(1, 3).bigDecimalValue(RoundingMode.DOWN));
+ Assertions.assertEquals(new BigDecimal("0.333"), BigFraction.of(1, 3).bigDecimalValue(3, RoundingMode.DOWN));
}
@Test
@@ -581,14 +590,6 @@
}
@Test
- public void testBigDecimalValue() {
- Assertions.assertEquals(new BigDecimal(0.5), BigFraction.of(1, 2).bigDecimalValue());
- Assertions.assertEquals(new BigDecimal("0.0003"), BigFraction.of(3, 10000).bigDecimalValue());
- Assertions.assertEquals(new BigDecimal("0"), BigFraction.of(1, 3).bigDecimalValue(RoundingMode.DOWN));
- Assertions.assertEquals(new BigDecimal("0.333"), BigFraction.of(1, 3).bigDecimalValue(3, RoundingMode.DOWN));
- }
-
- @Test
public void testEqualsAndHashCode() {
BigFraction zero = BigFraction.of(0, 1);
Assertions.assertEquals(zero, zero);
@@ -650,16 +651,6 @@
}
@Test
- public void testMath340() {
- BigFraction fractionA = BigFraction.from(0.00131);
- BigFraction fractionB = BigFraction.from(.37).reciprocal();
- BigFraction errorResult = fractionA.multiply(fractionB);
- BigFraction correctResult = BigFraction.of(fractionA.getNumerator().multiply(fractionB.getNumerator()),
- fractionA.getDenominator().multiply(fractionB.getDenominator()));
- Assertions.assertEquals(correctResult, errorResult);
- }
-
- @Test
public void testAdditiveNeutral() {
Assertions.assertEquals(BigFraction.ZERO, BigFraction.ONE.zero());
}
@@ -743,4 +734,14 @@
Assertions.assertThrows(NumberFormatException.class, () -> BigFraction.parse("1 / --2"));
Assertions.assertThrows(NumberFormatException.class, () -> BigFraction.parse("x"));
}
+
+ @Test
+ public void testMath340() {
+ BigFraction fractionA = BigFraction.from(0.00131);
+ BigFraction fractionB = BigFraction.from(.37).reciprocal();
+ BigFraction errorResult = fractionA.multiply(fractionB);
+ BigFraction correctResult = BigFraction.of(fractionA.getNumerator().multiply(fractionB.getNumerator()),
+ fractionA.getDenominator().multiply(fractionB.getDenominator()));
+ Assertions.assertEquals(correctResult, errorResult);
+ }
}
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/CommonTestCases.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/CommonTestCases.java
index 336add7..39ad560 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/CommonTestCases.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/CommonTestCases.java
@@ -170,6 +170,9 @@
testCases.add(new DoubleToFractionTestCase(9d / 11d, 9, 11));
testCases.add(new DoubleToFractionTestCase(10d / 11d, 10, 11));
+ testCases.add(new DoubleToFractionTestCase(-1d / 2d, -1, 2));
+ testCases.add(new DoubleToFractionTestCase(-1d / 3d, -1, 3));
+
testCases.add(new DoubleToFractionTestCase(0.00000000000001, 0, 1));
testCases.add(new DoubleToFractionTestCase(0.40000000000001, 2, 5));
testCases.add(new DoubleToFractionTestCase(15.0000000000001, 15, 1));
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
index fccf015..6188d55 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
@@ -75,11 +75,19 @@
Fraction.from(testCase.operand)
);
}
+
+ // Cases with different exact results from BigFraction
+ assertFraction(1, 3, Fraction.from(1.0 / 3.0));
+ assertFraction(17, 100, Fraction.from(17.0 / 100.0));
+ assertFraction(317, 100, Fraction.from(317.0 / 100.0));
+ assertFraction(-1, 3, Fraction.from(-1.0 / 3.0));
+ assertFraction(-17, 100, Fraction.from(17.0 / -100.0));
+ assertFraction(-317, 100, Fraction.from(-317.0 / 100.0));
}
// MATH-181
@Test
- public void testDigitLimitConstructor() throws Exception {
+ public void testDoubleConstructorWithMaxDenominator() throws Exception {
assertFraction(2, 5, Fraction.from(0.4, 9));
assertFraction(2, 5, Fraction.from(0.4, 99));
assertFraction(2, 5, Fraction.from(0.4, 999));
@@ -114,21 +122,21 @@
}
@Test
- public void testIntegerOverflow() {
- checkIntegerOverflow(0.75000000001455192);
- checkIntegerOverflow(1.0e10);
- checkIntegerOverflow(-1.0e10);
- checkIntegerOverflow(-43979.60679604749);
+ public void testDoubleConstructorOverflow() {
+ assertDoubleConstructorOverflow(0.75000000001455192);
+ assertDoubleConstructorOverflow(1.0e10);
+ assertDoubleConstructorOverflow(-1.0e10);
+ assertDoubleConstructorOverflow(-43979.60679604749);
}
- private void checkIntegerOverflow(final double a) {
+ private void assertDoubleConstructorOverflow(final double a) {
Assertions.assertThrows(ArithmeticException.class,
() -> Fraction.from(a, 1.0e-12, 1000)
);
}
@Test
- public void testEpsilonLimitConstructor() throws Exception {
+ public void testDoubleConstructorWithEpsilonLimit() throws Exception {
assertFraction(2, 5, Fraction.from(0.4, 1.0e-5, 100));
assertFraction(3, 5, Fraction.from(0.6152, 0.02, 100));
@@ -146,6 +154,8 @@
final Fraction c = Fraction.of(1, 2);
final Fraction d = Fraction.of(-1, 2);
final Fraction e = Fraction.of(1, -2);
+ final Fraction f = Fraction.of(-1, -2);
+ final Fraction g = Fraction.of(-1, Integer.MIN_VALUE);
Assertions.assertEquals(0, a.compareTo(a));
Assertions.assertEquals(0, a.compareTo(c));
@@ -156,6 +166,14 @@
Assertions.assertEquals(-1, e.compareTo(a));
Assertions.assertEquals(1, a.compareTo(e));
Assertions.assertEquals(0, d.compareTo(e));
+ Assertions.assertEquals(0, a.compareTo(f));
+ Assertions.assertEquals(0, f.compareTo(a));
+ Assertions.assertEquals(1, f.compareTo(e));
+ Assertions.assertEquals(-1, e.compareTo(f));
+// Assertions.assertEquals(-1, g.compareTo(a));
+ Assertions.assertEquals(-1, g.compareTo(f));
+// Assertions.assertEquals(1, a.compareTo(g));
+ Assertions.assertEquals(-1, d.compareTo(g));
Assertions.assertEquals(0, Fraction.of(0, 3).compareTo(Fraction.of(0, -2)));
@@ -234,22 +252,6 @@
}
@Test
- public void testConstructorDouble() {
- assertFraction(0, 1, Fraction.from(0.0));
- assertFraction(1, 2, Fraction.from(0.5));
- assertFraction(1, 3, Fraction.from(1.0 / 3.0));
- assertFraction(17, 100, Fraction.from(17.0 / 100.0));
- assertFraction(317, 100, Fraction.from(317.0 / 100.0));
- assertFraction(-1, 2, Fraction.from(-0.5));
- assertFraction(-1, 3, Fraction.from(-1.0 / 3.0));
- assertFraction(-17, 100, Fraction.from(17.0 / -100.0));
- assertFraction(-317, 100, Fraction.from(-317.0 / 100.0));
- for (double v : new double[] {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY}) {
- Assertions.assertThrows(IllegalArgumentException.class, () -> Fraction.from(v));
- }
- }
-
- @Test
public void testAbs() {
for (CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.absTestCases()) {
Fraction f = Fraction.of(testCase.operandNumerator, testCase.operandDenominator);
