You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ma...@apache.org on 2021/04/29 12:40:24 UTC
[commons-numbers] branch master updated: NUMBERS-77: additional
unit tests for Precision.DoubleEquivalence
This is an automated email from the ASF dual-hosted git repository.
mattjuntunen pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
The following commit(s) were added to refs/heads/master by this push:
new dfba842 NUMBERS-77: additional unit tests for Precision.DoubleEquivalence
dfba842 is described below
commit dfba842bf7107f1715fe84dd10277abf8bf8d3a5
Author: Matt Juntunen <ma...@apache.org>
AuthorDate: Wed Apr 28 09:48:23 2021 -0400
NUMBERS-77: additional unit tests for Precision.DoubleEquivalence
---
.../numbers/core/EpsilonDoubleEquivalenceTest.java | 111 +++++++++++++++++++++
1 file changed, 111 insertions(+)
diff --git a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/EpsilonDoubleEquivalenceTest.java b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/EpsilonDoubleEquivalenceTest.java
index 5eac0e8..fb479f9 100644
--- a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/EpsilonDoubleEquivalenceTest.java
+++ b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/EpsilonDoubleEquivalenceTest.java
@@ -67,6 +67,21 @@ class EpsilonDoubleEquivalenceTest {
}
@Test
+ void testCompare_simple() {
+ // arrange
+ final Precision.DoubleEquivalence cmp = Precision.doubleEquivalenceOfEpsilon(1e-10);
+
+ // act/assert
+ Assertions.assertEquals(0, cmp.compare(1, 1));
+ Assertions.assertEquals(-1, cmp.compare(1, 2));
+ Assertions.assertEquals(1, cmp.compare(2, 1));
+
+ Assertions.assertEquals(0, cmp.compare(-1, -1));
+ Assertions.assertEquals(1, cmp.compare(-1, -2));
+ Assertions.assertEquals(-1, cmp.compare(-2, -1));
+ }
+
+ @Test
void testCompare_compareToZero() {
// arrange
final double eps = 1e-2;
@@ -147,6 +162,102 @@ class EpsilonDoubleEquivalenceTest {
Assertions.assertEquals(0, cmp.compare(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY));
}
+ @Test
+ void testEq() {
+ // arrange
+ final double eps = Math.ulp(1.0);
+ final double twoEps = 2 * eps;
+ final Precision.DoubleEquivalence cmp = Precision.doubleEquivalenceOfEpsilon(eps);
+
+ // act/assert
+ Assertions.assertTrue(cmp.eq(0.0, 0.0));
+
+ Assertions.assertTrue(cmp.eq(1.0, 1.0));
+ Assertions.assertTrue(cmp.eq(1.0, 1.0 + eps));
+ Assertions.assertTrue(cmp.eq(1.0, 1.0 - eps));
+ Assertions.assertFalse(cmp.eq(1.0, 1.0 + twoEps));
+ Assertions.assertFalse(cmp.eq(1.0, 1.0 - twoEps));
+
+ Assertions.assertTrue(cmp.eq(-1.0, -1.0));
+ Assertions.assertTrue(cmp.eq(-1.0, -1.0 + eps));
+ Assertions.assertTrue(cmp.eq(-1.0, -1.0 - eps));
+ Assertions.assertFalse(cmp.eq(-1.0, -1.0 + twoEps));
+ Assertions.assertFalse(cmp.eq(-1.0, -1.0 - twoEps));
+ }
+
+ @Test
+ void testEqZero() {
+ // arrange
+ final double eps = 1e-6;
+ final Precision.DoubleEquivalence cmp = Precision.doubleEquivalenceOfEpsilon(eps);
+
+ // act/assert
+ Assertions.assertTrue(cmp.eqZero(0.0));
+
+ Assertions.assertFalse(cmp.eqZero(Math.nextUp(eps)));
+ Assertions.assertFalse(cmp.eqZero(Math.nextDown(-eps)));
+ }
+
+ @Test
+ void testLt() {
+ // arrange
+ final Precision.DoubleEquivalence cmp = Precision.doubleEquivalenceOfEpsilon(1e-6);
+
+ // act/assert
+ Assertions.assertTrue(cmp.lt(1, 2));
+ Assertions.assertTrue(cmp.lt(-2, -1));
+
+ Assertions.assertFalse(cmp.lt(1, 1));
+ Assertions.assertFalse(cmp.lt(-1, -1));
+ Assertions.assertFalse(cmp.lt(2, 1));
+ Assertions.assertFalse(cmp.lt(-1, -2));
+ }
+
+ @Test
+ void testLte() {
+ // arrange
+ final Precision.DoubleEquivalence cmp = Precision.doubleEquivalenceOfEpsilon(1e-6);
+
+ // act/assert
+ Assertions.assertTrue(cmp.lte(1, 2));
+ Assertions.assertTrue(cmp.lte(-2, -1));
+ Assertions.assertTrue(cmp.lte(1, 1));
+ Assertions.assertTrue(cmp.lte(-1, -1));
+
+ Assertions.assertFalse(cmp.lte(2, 1));
+ Assertions.assertFalse(cmp.lte(-1, -2));
+ }
+
+ @Test
+ void testGt() {
+ // arrange
+ final Precision.DoubleEquivalence cmp = Precision.doubleEquivalenceOfEpsilon(1e-6);
+
+ // act/assert
+ Assertions.assertTrue(cmp.gt(2, 1));
+ Assertions.assertTrue(cmp.gt(-1, -2));
+
+ Assertions.assertFalse(cmp.gt(1, 1));
+ Assertions.assertFalse(cmp.gt(-1, -1));
+ Assertions.assertFalse(cmp.gt(1, 2));
+ Assertions.assertFalse(cmp.gt(-2, -1));
+ }
+
+ @Test
+ void testGte() {
+ // arrange
+ final Precision.DoubleEquivalence cmp = Precision.doubleEquivalenceOfEpsilon(1e-6);
+
+ // act/assert
+ Assertions.assertTrue(cmp.gte(2, 1));
+ Assertions.assertTrue(cmp.gte(-1, -2));
+ Assertions.assertTrue(cmp.gte(1, 1));
+ Assertions.assertTrue(cmp.gte(-1, -1));
+
+ Assertions.assertFalse(cmp.gte(1, 2));
+ Assertions.assertFalse(cmp.gte(-2, -1));
+ }
+
/**
* Increments the given double value {@code count} number of times
* using {@link Math#nextUp(double)}.