commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From er...@apache.org
Subject [commons-geometry] 05/08: GEOMETRY-68: removing Equivalency interface in favor of defining eq() methods that accept DoublePrecisionContext objects as arguments
Date Tue, 07 Jan 2020 15:14:39 GMT
This is an automated email from the ASF dual-hosted git repository.

erans pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-geometry.git

commit 66740f454c4a4ff81afcf0d57b034c4b4d2b6e43
Author: Matt Juntunen <matt.juntunen@hotmail.com>
AuthorDate: Fri Jan 3 22:30:37 2020 -0500

    GEOMETRY-68: removing Equivalency interface in favor of defining eq() methods that accept
DoublePrecisionContext objects as arguments
---
 .../apache/commons/geometry/core/Equivalency.java  | 33 --------------------
 .../geometry/euclidean/oned/OrientedPoint.java     | 32 ++++++++------------
 .../commons/geometry/euclidean/threed/Line3D.java  | 30 ++++++-------------
 .../geometry/euclidean/threed/LinecastPoint3D.java | 34 +++++++++------------
 .../commons/geometry/euclidean/threed/Plane.java   | 34 +++++++--------------
 .../geometry/euclidean/threed/SubPlane.java        |  2 +-
 .../commons/geometry/euclidean/twod/Line.java      | 34 +++++++--------------
 .../geometry/euclidean/twod/LinecastPoint2D.java   | 35 +++++++++-------------
 .../commons/geometry/euclidean/twod/SubLine.java   |  2 +-
 .../geometry/euclidean/oned/OrientedPointTest.java | 17 +++++------
 .../geometry/euclidean/threed/Line3DTest.java      | 35 ++++++++++------------
 .../euclidean/threed/LinecastPoint3DTest.java      | 10 +++----
 .../geometry/euclidean/threed/PlaneTest.java       | 14 ++++-----
 .../commons/geometry/euclidean/twod/LineTest.java  | 35 ++++++++++------------
 .../euclidean/twod/LinecastPoint2DTest.java        | 10 +++----
 .../euclidean/twod/RegionBSPTree2DTest.java        |  2 +-
 .../commons/geometry/spherical/oned/CutAngle.java  | 30 +++++++------------
 .../geometry/spherical/twod/GreatCircle.java       | 24 +++++++--------
 .../geometry/spherical/twod/SubGreatCircle.java    |  2 +-
 .../geometry/spherical/oned/CutAngleTest.java      | 16 +++++-----
 .../geometry/spherical/twod/GreatCircleTest.java   | 20 ++++++-------
 21 files changed, 172 insertions(+), 279 deletions(-)

diff --git a/commons-geometry-core/src/main/java/org/apache/commons/geometry/core/Equivalency.java
b/commons-geometry-core/src/main/java/org/apache/commons/geometry/core/Equivalency.java
deleted file mode 100644
index 64b47de..0000000
--- a/commons-geometry-core/src/main/java/org/apache/commons/geometry/core/Equivalency.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.geometry.core;
-
-/** Interface for determining equivalency, not exact equality, between
- * two objects. This is performs a function similar to {@link Object#equals(Object)}
- * but allows fuzzy comparisons to occur instead of strict equality. This is
- * especially useful when comparing objects with floating point values that
- * may not be exact but are operationally equivalent.
- * @param <T> The type being compared
- */
-public interface Equivalency<T> {
-
-    /** Determine if this object is equivalent (effectively equal) to the argument.
-     * @param other the object to compare for equivalency
-     * @return true if this object is equivalent to the argument; false otherwise
-     */
-    boolean eq(T other);
-}
diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/OrientedPoint.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/OrientedPoint.java
index 78491a9..4973dca 100644
--- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/OrientedPoint.java
+++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/OrientedPoint.java
@@ -20,7 +20,6 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 
-import org.apache.commons.geometry.core.Equivalency;
 import org.apache.commons.geometry.core.RegionLocation;
 import org.apache.commons.geometry.core.Transform;
 import org.apache.commons.geometry.core.partitioning.AbstractHyperplane;
@@ -39,7 +38,7 @@ import org.apache.commons.geometry.core.precision.DoublePrecisionContext;
  * <p>Instances of this class are guaranteed to be immutable.</p>
  */
 public final class OrientedPoint extends AbstractHyperplane<Vector1D>
-    implements Hyperplane<Vector1D>, Equivalency<OrientedPoint> {
+    implements Hyperplane<Vector1D> {
     /** Hyperplane location as a point. */
     private final Vector1D point;
 
@@ -184,27 +183,20 @@ public final class OrientedPoint extends AbstractHyperplane<Vector1D>
         return new SubOrientedPoint(this);
     }
 
-    /** {@inheritDoc}
-     *
+    /** Return true if this instance should be considered equivalent to the argument, using
the
+     * given precision context for comparison.
      * <p>Instances are considered equivalent if they
-     * <ul>
-     *  <li>contain equal {@link DoublePrecisionContext precision contexts},</li>
-     *  <li>have equivalent locations as evaluated by the precision context, and</li>
-     *  <li>point in the same direction</li>
-     * </ul>
+     * <ol>
+     *      <li>have equivalent locations and</li>
+     *      <li>point in the same direction.</li>
+     * </ol>
      * @param other the point to compare with
+     * @param precision precision context to use for the comparison
      * @return true if this instance should be considered equivalent to the argument
+     * @see Vector1D#eq(Vector1D, DoublePrecisionContext)
      */
-    @Override
-    public boolean eq(final OrientedPoint other) {
-        if (this == other) {
-            return true;
-        }
-
-        final DoublePrecisionContext precision = getPrecision();
-
-        return precision.equals(other.getPrecision()) &&
-                point.eq(other.point, precision) &&
+    public boolean eq(final OrientedPoint other, final DoublePrecisionContext precision)
{
+        return point.eq(other.point, precision) &&
                 positiveFacing == other.positiveFacing;
     }
 
@@ -525,7 +517,7 @@ public final class OrientedPoint extends AbstractHyperplane<Vector1D>
             final OrientedPoint baseHyper = base.getHyperplane();
             final OrientedPoint inputHyper = (OrientedPoint) sub.getHyperplane();
 
-            if (!baseHyper.eq(inputHyper)) {
+            if (!baseHyper.eq(inputHyper, baseHyper.getPrecision())) {
                 throw new IllegalArgumentException("Argument is not on the same " +
                         "hyperplane. Expected " + baseHyper + " but was " +
                         inputHyper);
diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Line3D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Line3D.java
index fe16fba..5eb1f0b 100644
--- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Line3D.java
+++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Line3D.java
@@ -19,7 +19,6 @@ package org.apache.commons.geometry.euclidean.threed;
 import java.util.Objects;
 
 import org.apache.commons.geometry.core.Embedding;
-import org.apache.commons.geometry.core.Equivalency;
 import org.apache.commons.geometry.core.Transform;
 import org.apache.commons.geometry.core.precision.DoublePrecisionContext;
 import org.apache.commons.geometry.euclidean.oned.AffineTransformMatrix1D;
@@ -30,7 +29,7 @@ import org.apache.commons.geometry.euclidean.oned.Vector1D;
  *
  * <p>Instances of this class are guaranteed to be immutable.</p>
  */
-public final class Line3D implements Embedding<Vector3D, Vector1D>, Equivalency<Line3D>
{
+public final class Line3D implements Embedding<Vector3D, Vector1D> {
     /** Line point closest to the origin. */
     private final Vector3D origin;
 
@@ -320,28 +319,17 @@ public final class Line3D implements Embedding<Vector3D, Vector1D>,
Equivalency<
         return new SubLine3D(this);
     }
 
-    /**{@inheritDoc}
-     *
-     * <p>Instances are considered equivalent if they</p>
-     * <ul>
-     *   <li>contain equal {@link DoublePrecisionContext precision contexts},</li>
-     *   <li>have equivalent origin locations (as evaluated by the precision context),
and</li>
-     *   <li>point in the same direction (as evaluated by the precision context)</li>
-     * </ul>
+    /** Return true if this instance should be considered equivalent to the argument, using
the
+     * given precision context for comparison. Instances are considered equivalent if they
have
+     * equivalent {@code origin}s and {@code direction}s.
      * @param other the point to compare with
+     * @param ctx precision context to use for the comparison
      * @return true if this instance should be considered equivalent to the argument
+     * @see Vector3D#eq(Vector3D, DoublePrecisionContext)
      */
-    @Override
-    public boolean eq(final Line3D other) {
-        if (this == other) {
-            return true;
-        }
-
-        final DoublePrecisionContext testPrecision = getPrecision();
-
-        return testPrecision.equals(other.getPrecision()) &&
-                getOrigin().eq(other.getOrigin(), precision) &&
-                getDirection().eq(other.getDirection(), precision);
+    public boolean eq(final Line3D other, final DoublePrecisionContext ctx) {
+        return getOrigin().eq(other.getOrigin(), ctx) &&
+                getDirection().eq(other.getDirection(), ctx);
     }
 
     /** {@inheritDoc} */
diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/LinecastPoint3D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/LinecastPoint3D.java
index e1776e4..cc1e6e4 100644
--- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/LinecastPoint3D.java
+++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/LinecastPoint3D.java
@@ -22,7 +22,6 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.ListIterator;
 
-import org.apache.commons.geometry.core.Equivalency;
 import org.apache.commons.geometry.core.precision.DoublePrecisionContext;
 import org.apache.commons.geometry.euclidean.AbstractLinecastPoint;
 
@@ -31,8 +30,7 @@ import org.apache.commons.geometry.euclidean.AbstractLinecastPoint;
  * of the target at the point of intersection.
  * @see Linecastable3D
  */
-public class LinecastPoint3D extends AbstractLinecastPoint<Vector3D, Vector3D.Unit, Line3D>
-    implements Equivalency<LinecastPoint3D> {
+public class LinecastPoint3D extends AbstractLinecastPoint<Vector3D, Vector3D.Unit, Line3D>
 {
 
     /** Comparator that sorts intersection instances by increasing abscissa order. If two
abscissa
      * values are equal, the comparison uses {@link Vector3D#COORDINATE_ASCENDING_ORDER}
with the
@@ -55,28 +53,22 @@ public class LinecastPoint3D extends AbstractLinecastPoint<Vector3D,
Vector3D.Un
         super(point, normal.normalize(), line);
     }
 
-    /** {@inheritDoc}
-     *
-     * <p>
-     * Instances are considered equivalent if they have equivalent points, normals, and lines.
-     * </p>
+    /** Return true if this instance should be considered equivalent to the argument, using
the
+     * given precision context for comparison. Instances are considered equivalent if they
have
+     * equivalent points, normals, and lines.
+     * @param other other point to compare with
+     * @param precision context to use for the comparison
+     * @return true if this instance should be considered equivalent to the argument
      */
-    @Override
-    public boolean eq(final LinecastPoint3D other) {
-        if (this == other) {
-            return true;
-        }
-
-        final DoublePrecisionContext precision = getLine().getPrecision();
-
-        return getLine().eq(other.getLine()) &&
+    public boolean eq(final LinecastPoint3D other, final DoublePrecisionContext precision)
{
+        return getLine().eq(other.getLine(), precision) &&
                 getPoint().eq(other.getPoint(), precision) &&
                 getNormal().eq(other.getNormal(), precision);
     }
 
     /** Sort the given list of linecast points by increasing abscissa value and filter to
remove
-     * duplicate entries (as determined by the {@link #eq(LinecastPoint3D)} method). The
argument
-     * is modified.
+     * duplicate entries (as determined by the {@link #eq(LinecastPoint3D, DoublePrecisionContext)}
method).
+     * The argument is modified.
      * @param pts list of points to sort and filter
      */
     public static void sortAndFilter(final List<LinecastPoint3D> pts) {
@@ -111,8 +103,10 @@ public class LinecastPoint3D extends AbstractLinecastPoint<Vector3D,
Vector3D.Un
      * @return true if the given linecast point is equivalent to any of those in the given
list
      */
     private static boolean containsEq(final LinecastPoint3D pt, final List<LinecastPoint3D>
list) {
+        final DoublePrecisionContext precision = pt.getLine().getPrecision();
+
         for (LinecastPoint3D listPt : list) {
-            if (listPt.eq(pt)) {
+            if (listPt.eq(pt, precision)) {
                 return true;
             }
         }
diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Plane.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Plane.java
index 1ab2ba4..7ffe3ee 100644
--- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Plane.java
+++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Plane.java
@@ -21,7 +21,6 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.Objects;
 
-import org.apache.commons.geometry.core.Equivalency;
 import org.apache.commons.geometry.core.Transform;
 import org.apache.commons.geometry.core.partitioning.AbstractHyperplane;
 import org.apache.commons.geometry.core.partitioning.EmbeddingHyperplane;
@@ -36,7 +35,7 @@ import org.apache.commons.geometry.euclidean.twod.Vector2D;
 /** Class representing a plane in 3 dimensional Euclidean space.
  */
 public final class Plane extends AbstractHyperplane<Vector3D>
-    implements EmbeddingHyperplane<Vector3D, Vector2D>, Equivalency<Plane> {
+    implements EmbeddingHyperplane<Vector3D, Vector2D> {
     /** First normalized vector of the plane frame (in plane). */
     private final Vector3D u;
 
@@ -510,27 +509,16 @@ public final class Plane extends AbstractHyperplane<Vector3D>
     }
 
 
-    /** {@inheritDoc}
-    *
-    * <p>Instances are considered equivalent if they
-    * <ul>
-    *   <li>contain equal {@link DoublePrecisionContext precision contexts},</li>
-    *   <li>have equivalent origins (as evaluated by the precision context), and</li>
-    *   <li>have equivalent {@code u} and {@code v} vectors (as evaluated by the precision
context)</li>
-    * </ul>
-    * @param other the point to compare with
-    * @return true if this instance should be considered equivalent to the argument
-    */
-    @Override
-    public boolean eq(Plane other) {
-        if (this == other) {
-            return true;
-        }
-
-        final DoublePrecisionContext precision = getPrecision();
-
-        return precision.equals(other.getPrecision()) &&
-                getOrigin().eq(other.getOrigin(), precision) &&
+    /** Return true if this instance should be considered equivalent to the argument, using
the
+     * given precision context for comparison. Instances are considered equivalent if they
+     * have equivalent {@code origin} points and {@code u} and {@code v} vectors.
+     * @param other the point to compare with
+     * @param precision precision context to use for the comparison
+     * @return true if this instance should be considered equivalent to the argument
+     * @see Vector3D#eq(Vector3D, DoublePrecisionContext)
+     */
+    public boolean eq(final Plane other, final DoublePrecisionContext precision) {
+        return getOrigin().eq(other.getOrigin(), precision) &&
                 u.eq(other.u, precision) &&
                 v.eq(other.v, precision);
     }
diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/SubPlane.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/SubPlane.java
index e738536..2fb4e17 100644
--- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/SubPlane.java
+++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/SubPlane.java
@@ -143,7 +143,7 @@ public final class SubPlane extends AbstractSubPlane<RegionBSPTree2D>
{
     private void validatePlane(final Plane inputPlane) {
         final Plane plane = getPlane();
 
-        if (!plane.eq(inputPlane)) {
+        if (!plane.eq(inputPlane, plane.getPrecision())) {
             throw new IllegalArgumentException("Argument is not on the same " +
                     "plane. Expected " + plane + " but was " +
                     inputPlane);
diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Line.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Line.java
index adedde9..a893206 100644
--- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Line.java
+++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Line.java
@@ -18,7 +18,6 @@ package org.apache.commons.geometry.euclidean.twod;
 
 import java.util.Objects;
 
-import org.apache.commons.geometry.core.Equivalency;
 import org.apache.commons.geometry.core.Transform;
 import org.apache.commons.geometry.core.partitioning.AbstractHyperplane;
 import org.apache.commons.geometry.core.partitioning.EmbeddingHyperplane;
@@ -57,7 +56,7 @@ import org.apache.commons.numbers.arrays.LinearCombination;
  * points with positive offsets.</p>
  */
 public final class Line extends AbstractHyperplane<Vector2D>
-    implements EmbeddingHyperplane<Vector2D, Vector1D>, Equivalency<Line> {
+    implements EmbeddingHyperplane<Vector2D, Vector1D> {
     /** The direction of the line as a normalized vector. */
     private final Vector2D direction;
 
@@ -434,27 +433,16 @@ public final class Line extends AbstractHyperplane<Vector2D>
         return getPrecision().eqZero(area);
     }
 
-    /** {@inheritDoc}
-    *
-    * <p>Instances are considered equivalent if they
-    * <ul>
-    *   <li>contain equal {@link DoublePrecisionContext precision contexts},</li>
-    *   <li>have equivalent origin locations (as evaluated by the precision context),
and</li>
-    *   <li>point in the same direction (as evaluated by the precision context)</li>
-    * </ul>
-    * @param other the point to compare with
-    * @return true if this instance should be considered equivalent to the argument
-    */
-    @Override
-    public boolean eq(final Line other) {
-        if (this == other) {
-            return true;
-        }
-
-        final DoublePrecisionContext precision = getPrecision();
-
-        return precision.equals(other.getPrecision()) &&
-                getOrigin().eq(other.getOrigin(), precision) &&
+    /** Return true if this instance should be considered equivalent to the argument, using
the
+     * given precision context for comparison. Instances are considered equivalent if they
have
+     * equivalent {@code origin} points and make similar angles with the x-axis.
+     * @param other the point to compare with
+     * @param precision precision context to use for the comparison
+     * @return true if this instance should be considered equivalent to the argument
+     * @see Vector2D#eq(Vector2D, DoublePrecisionContext)
+     */
+    public boolean eq(final Line other, final DoublePrecisionContext precision) {
+        return getOrigin().eq(other.getOrigin(), precision) &&
                 precision.eq(getAngle(), other.getAngle());
     }
 
diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/LinecastPoint2D.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/LinecastPoint2D.java
index de6d6e6..d175330 100644
--- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/LinecastPoint2D.java
+++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/LinecastPoint2D.java
@@ -22,7 +22,6 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.ListIterator;
 
-import org.apache.commons.geometry.core.Equivalency;
 import org.apache.commons.geometry.core.precision.DoublePrecisionContext;
 import org.apache.commons.geometry.euclidean.AbstractLinecastPoint;
 
@@ -31,8 +30,7 @@ import org.apache.commons.geometry.euclidean.AbstractLinecastPoint;
  * of the target at the point of intersection.
  * @see Linecastable2D
  */
-public class LinecastPoint2D extends AbstractLinecastPoint<Vector2D, Vector2D.Unit, Line>
-    implements Equivalency<LinecastPoint2D> {
+public class LinecastPoint2D extends AbstractLinecastPoint<Vector2D, Vector2D.Unit, Line>
{
 
     /** Comparator that sorts intersection instances by increasing abscissa order. If two
abscissa
      * values are equal, the comparison uses {@link Vector2D#COORDINATE_ASCENDING_ORDER}
with the
@@ -55,27 +53,20 @@ public class LinecastPoint2D extends AbstractLinecastPoint<Vector2D,
Vector2D.Un
         super(point, normal.normalize(), line);
     }
 
-    /** {@inheritDoc}
-     *
-     * <p>
-     * Instances are considered equivalent if they have equivalent points, normals, and lines.
-     * </p>
+    /** Return true if this instance should be considered equivalent to the argument, using
the
+     * given precision context for comparison. Instances are considered equivalent if they
have equivalent
+     * points, normals, and lines.
+     * @param other point to compare with
+     * @param precision precision context to use for the comparison
+     * @return true if this instance should be considered equivalent to the argument
      */
-    @Override
-    public boolean eq(final LinecastPoint2D other) {
-        if (this == other) {
-            return true;
-        }
-
-        final DoublePrecisionContext precision = getLine().getPrecision();
-
-        return getLine().eq(other.getLine()) &&
-                getPoint().eq(other.getPoint(), precision) &&
+    public boolean eq(final LinecastPoint2D other, final DoublePrecisionContext precision)
{
+        return getPoint().eq(other.getPoint(), precision) &&
                 getNormal().eq(other.getNormal(), precision);
     }
 
-    /** Sort the given list of linecast points by increasing abscissa value and filter
-     * to remove duplicate entries (as determined by the {@link #eq(LinecastPoint2D)} method).
+    /** Sort the given list of linecast points by increasing abscissa value and filter to
remove
+     * duplicate entries (as determined by the {@link #eq(LinecastPoint2D, DoublePrecisionContext)}
method).
      * The argument is modified.
      * @param pts list of points to sort and filter
      */
@@ -111,8 +102,10 @@ public class LinecastPoint2D extends AbstractLinecastPoint<Vector2D,
Vector2D.Un
      * @return true if the given linecast point is equivalent to any of those in the given
list
      */
     private static boolean containsEq(final LinecastPoint2D pt, final List<LinecastPoint2D>
list) {
+        final DoublePrecisionContext precision = pt.getLine().getPrecision();
+
         for (LinecastPoint2D listPt : list) {
-            if (listPt.eq(pt)) {
+            if (listPt.eq(pt, precision)) {
                 return true;
             }
         }
diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/SubLine.java
b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/SubLine.java
index dba65a4..9462880 100644
--- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/SubLine.java
+++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/SubLine.java
@@ -164,7 +164,7 @@ public final class SubLine extends AbstractSubLine {
     private void validateLine(final Line inputLine) {
         final Line line = getLine();
 
-        if (!line.eq(inputLine)) {
+        if (!line.eq(inputLine, line.getPrecision())) {
             throw new IllegalArgumentException("Argument is not on the same " +
                     "line. Expected " + line + " but was " +
                     inputLine);
diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/OrientedPointTest.java
b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/OrientedPointTest.java
index 87038e9..a090e88 100644
--- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/OrientedPointTest.java
+++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/OrientedPointTest.java
@@ -251,22 +251,21 @@ public class OrientedPointTest {
         DoublePrecisionContext precision = new EpsilonDoublePrecisionContext(1e-3);
 
         OrientedPoint a = OrientedPoint.createPositiveFacing(0, precision);
-
         OrientedPoint b = OrientedPoint.createPositiveFacing(0, TEST_PRECISION);
-        OrientedPoint c = OrientedPoint.createNegativeFacing(0, precision);
-        OrientedPoint d = OrientedPoint.createPositiveFacing(2e-3, precision);
 
+        OrientedPoint c = OrientedPoint.createPositiveFacing(2e-3, precision);
+        OrientedPoint d = OrientedPoint.createNegativeFacing(0, precision);
         OrientedPoint e = OrientedPoint.createPositiveFacing(1e-4, precision);
 
         // act/assert
-        Assert.assertTrue(a.eq(a));
+        Assert.assertTrue(a.eq(a, precision));
+        Assert.assertTrue(a.eq(b, precision));
 
-        Assert.assertFalse(a.eq(b));
-        Assert.assertFalse(a.eq(c));
-        Assert.assertFalse(a.eq(d));
+        Assert.assertFalse(a.eq(c, precision));
+        Assert.assertFalse(a.eq(d, precision));
 
-        Assert.assertTrue(a.eq(e));
-        Assert.assertTrue(e.eq(a));
+        Assert.assertTrue(a.eq(e, precision));
+        Assert.assertTrue(e.eq(a, precision));
     }
 
     @Test
diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/Line3DTest.java
b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/Line3DTest.java
index 88c2d48..22df394 100644
--- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/Line3DTest.java
+++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/Line3DTest.java
@@ -399,36 +399,33 @@ public class Line3DTest {
     @Test
     public void testEq() {
         // arrange
-        DoublePrecisionContext precision1 = new EpsilonDoublePrecisionContext(1e-3);
-        DoublePrecisionContext precision2 = new EpsilonDoublePrecisionContext(1e-2);
+        DoublePrecisionContext precision = new EpsilonDoublePrecisionContext(1e-3);
 
         Vector3D p = Vector3D.of(1, 2, 3);
         Vector3D dir = Vector3D.of(1, 0, 0);
 
-        Line3D a = Line3D.fromPointAndDirection(p, dir, precision1);
-        Line3D b = Line3D.fromPointAndDirection(Vector3D.ZERO, dir, precision1);
-        Line3D c = Line3D.fromPointAndDirection(p, Vector3D.of(1, 1, 0), precision1);
-        Line3D d = Line3D.fromPointAndDirection(p, dir, precision2);
+        Line3D a = Line3D.fromPointAndDirection(p, dir, precision);
+        Line3D b = Line3D.fromPointAndDirection(Vector3D.ZERO, dir, precision);
+        Line3D c = Line3D.fromPointAndDirection(p, Vector3D.of(1, 1, 0), precision);
 
-        Line3D e = Line3D.fromPointAndDirection(p, dir, precision1);
-        Line3D f = Line3D.fromPointAndDirection(p.add(Vector3D.of(1e-4, 1e-4, 1e-4)), dir,
precision1);
-        Line3D g = Line3D.fromPointAndDirection(p, Vector3D.of(1 + 1e-4, 1e-4, 1e-4), precision1);
+        Line3D d = Line3D.fromPointAndDirection(p, dir, precision);
+        Line3D e = Line3D.fromPointAndDirection(p.add(Vector3D.of(1e-4, 1e-4, 1e-4)), dir,
precision);
+        Line3D f = Line3D.fromPointAndDirection(p, Vector3D.of(1 + 1e-4, 1e-4, 1e-4), precision);
 
         // act/assert
-        Assert.assertTrue(a.eq(a));
+        Assert.assertTrue(a.eq(a, precision));
 
-        Assert.assertTrue(a.eq(e));
-        Assert.assertTrue(e.eq(a));
+        Assert.assertTrue(a.eq(d, precision));
+        Assert.assertTrue(d.eq(a, precision));
 
-        Assert.assertTrue(a.eq(f));
-        Assert.assertTrue(f.eq(a));
+        Assert.assertTrue(a.eq(e, precision));
+        Assert.assertTrue(e.eq(a, precision));
 
-        Assert.assertTrue(a.eq(g));
-        Assert.assertTrue(g.eq(a));
+        Assert.assertTrue(a.eq(f, precision));
+        Assert.assertTrue(f.eq(a, precision));
 
-        Assert.assertFalse(a.eq(b));
-        Assert.assertFalse(a.eq(c));
-        Assert.assertFalse(a.eq(d));
+        Assert.assertFalse(a.eq(b, precision));
+        Assert.assertFalse(a.eq(c, precision));
     }
 
     @Test
diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/LinecastPoint3DTest.java
b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/LinecastPoint3DTest.java
index aa6784d..59c74e8 100644
--- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/LinecastPoint3DTest.java
+++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/LinecastPoint3DTest.java
@@ -134,13 +134,13 @@ public class LinecastPoint3DTest {
                 Vector3D.of(1 + 1e-3, 1 + 1e-3, 1 + 1e-3), Vector3D.Unit.from(1 + 1e-3, 1e-3,
1e-3), otherLine);
 
         // act/assert
-        Assert.assertTrue(a.eq(a));
+        Assert.assertTrue(a.eq(a, precision));
 
-        Assert.assertFalse(a.eq(b));
-        Assert.assertFalse(a.eq(c));
+        Assert.assertFalse(a.eq(b, precision));
+        Assert.assertFalse(a.eq(c, precision));
 
-        Assert.assertTrue(a.eq(d));
-        Assert.assertTrue(a.eq(e));
+        Assert.assertTrue(a.eq(d, precision));
+        Assert.assertTrue(a.eq(e, precision));
     }
 
     @Test
diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/PlaneTest.java
b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/PlaneTest.java
index ed5f027..ba51155 100644
--- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/PlaneTest.java
+++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/PlaneTest.java
@@ -1000,15 +1000,15 @@ public class PlaneTest {
         Plane f = Plane.fromPointAndPlaneVectors(ptPrime, uPrime, vPrime, new EpsilonDoublePrecisionContext(eps));
 
         // act/assert
-        Assert.assertTrue(a.eq(a));
+        Assert.assertTrue(a.eq(a, precision));
 
-        Assert.assertFalse(a.eq(b));
-        Assert.assertFalse(a.eq(c));
-        Assert.assertFalse(a.eq(d));
-        Assert.assertFalse(a.eq(e));
+        Assert.assertFalse(a.eq(b, precision));
+        Assert.assertFalse(a.eq(c, precision));
+        Assert.assertFalse(a.eq(d, precision));
 
-        Assert.assertTrue(a.eq(f));
-        Assert.assertTrue(f.eq(a));
+        Assert.assertTrue(a.eq(e, precision));
+        Assert.assertTrue(a.eq(f, precision));
+        Assert.assertTrue(f.eq(a, precision));
     }
 
     @Test
diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LineTest.java
b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LineTest.java
index 66a232f..2b36179 100644
--- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LineTest.java
+++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LineTest.java
@@ -1120,36 +1120,33 @@ public class LineTest {
     @Test
     public void testEq() {
         // arrange
-        DoublePrecisionContext precision1 = new EpsilonDoublePrecisionContext(1e-3);
-        DoublePrecisionContext precision2 = new EpsilonDoublePrecisionContext(1e-2);
+        DoublePrecisionContext precision = new EpsilonDoublePrecisionContext(1e-3);
 
         Vector2D p = Vector2D.of(1, 2);
         double angle = 1.0;
 
-        Line a = Line.fromPointAndAngle(p, angle, precision1);
-        Line b = Line.fromPointAndAngle(Vector2D.ZERO, angle, precision1);
-        Line c = Line.fromPointAndAngle(p, angle + 1.0, precision1);
-        Line d = Line.fromPointAndAngle(p, angle, precision2);
+        Line a = Line.fromPointAndAngle(p, angle, precision);
+        Line b = Line.fromPointAndAngle(Vector2D.ZERO, angle, precision);
+        Line c = Line.fromPointAndAngle(p, angle + 1.0, precision);
 
-        Line e = Line.fromPointAndAngle(p, angle, precision1);
-        Line f = Line.fromPointAndAngle(p.add(Vector2D.of(1e-4, 1e-4)), angle, precision1);
-        Line g = Line.fromPointAndAngle(p, angle + 1e-4, precision1);
+        Line d = Line.fromPointAndAngle(p, angle, precision);
+        Line e = Line.fromPointAndAngle(p.add(Vector2D.of(1e-4, 1e-4)), angle, precision);
+        Line f = Line.fromPointAndAngle(p, angle + 1e-4, precision);
 
         // act/assert
-        Assert.assertTrue(a.eq(a));
+        Assert.assertTrue(a.eq(a, precision));
 
-        Assert.assertTrue(a.eq(e));
-        Assert.assertTrue(e.eq(a));
+        Assert.assertTrue(a.eq(d, precision));
+        Assert.assertTrue(d.eq(a, precision));
 
-        Assert.assertTrue(a.eq(f));
-        Assert.assertTrue(f.eq(a));
+        Assert.assertTrue(a.eq(e, precision));
+        Assert.assertTrue(e.eq(a, precision));
 
-        Assert.assertTrue(a.eq(g));
-        Assert.assertTrue(g.eq(a));
+        Assert.assertTrue(a.eq(f, precision));
+        Assert.assertTrue(f.eq(a, precision));
 
-        Assert.assertFalse(a.eq(b));
-        Assert.assertFalse(a.eq(c));
-        Assert.assertFalse(a.eq(d));
+        Assert.assertFalse(a.eq(b, precision));
+        Assert.assertFalse(a.eq(c, precision));
     }
 
     @Test
diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LinecastPoint2DTest.java
b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LinecastPoint2DTest.java
index e000b4f..08f5184 100644
--- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LinecastPoint2DTest.java
+++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LinecastPoint2DTest.java
@@ -134,13 +134,13 @@ public class LinecastPoint2DTest {
                 Vector2D.of(1 + 1e-3, 1 + 1e-3), Vector2D.Unit.from(1 + 1e-3, 1e-3), otherLine);
 
         // act/assert
-        Assert.assertTrue(a.eq(a));
+        Assert.assertTrue(a.eq(a, precision));
 
-        Assert.assertFalse(a.eq(b));
-        Assert.assertFalse(a.eq(c));
+        Assert.assertFalse(a.eq(b, precision));
+        Assert.assertFalse(a.eq(c, precision));
 
-        Assert.assertTrue(a.eq(d));
-        Assert.assertTrue(a.eq(e));
+        Assert.assertTrue(a.eq(d, precision));
+        Assert.assertTrue(a.eq(e, precision));
     }
 
     @Test
diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/RegionBSPTree2DTest.java
b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/RegionBSPTree2DTest.java
index 6b3b109..e63b15f 100644
--- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/RegionBSPTree2DTest.java
+++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/RegionBSPTree2DTest.java
@@ -1149,7 +1149,7 @@ public class RegionBSPTree2DTest {
         Assert.assertNull(segment.getEndPoint());
 
         Line expectedLine = Line.fromPointAndAngle(Vector2D.of(-1, 0), PlaneAngleRadians.PI_OVER_TWO,
TEST_PRECISION);
-        Assert.assertTrue(expectedLine.eq(segment.getLine()));
+        Assert.assertTrue(expectedLine.eq(segment.getLine(), expectedLine.getPrecision()));
     }
 
     @Test
diff --git a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/oned/CutAngle.java
b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/oned/CutAngle.java
index 0547868..cf1735a 100644
--- a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/oned/CutAngle.java
+++ b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/oned/CutAngle.java
@@ -20,7 +20,6 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 
-import org.apache.commons.geometry.core.Equivalency;
 import org.apache.commons.geometry.core.RegionLocation;
 import org.apache.commons.geometry.core.Transform;
 import org.apache.commons.geometry.core.partitioning.AbstractHyperplane;
@@ -56,8 +55,7 @@ import org.apache.commons.geometry.core.precision.DoublePrecisionContext;
  *
  * <p>Instances of this class are guaranteed to be immutable.</p>
  */
-public final class CutAngle extends AbstractHyperplane<Point1S>
-    implements Equivalency<CutAngle> {
+public final class CutAngle extends AbstractHyperplane<Point1S> {
     /** Hyperplane location as a point. */
     private final Point1S point;
 
@@ -117,27 +115,21 @@ public final class CutAngle extends AbstractHyperplane<Point1S>
         return positiveFacing;
     }
 
-    /** {@inheritDoc}
-     *
+    /** Return true if this instance should be considered equivalent to the argument, using
the
+     * given precision context for comparison.
      * <p>The instances are considered equivalent if they
      * <ol>
-     *    <li>have equal precision contexts,</li>
-     *    <li>have equivalent point locations as evaluated by the precision
-     *          context (points separated by multiples of 2pi are considered equivalent),
and
+     *    <li>have equivalent point locations (points separated by multiples of 2pi
are
+     *      considered equivalent) and
      *    <li>point in the same direction.</li>
      * </ol>
+     * @param other point to compare with
+     * @param precision precision context to use for the comparison
+     * @return true if this instance should be considered equivalent to the argument
      * @see Point1S#eq(Point1S, DoublePrecisionContext)
      */
-    @Override
-    public boolean eq(final CutAngle other) {
-        if (this == other) {
-            return true;
-        }
-
-        final DoublePrecisionContext precision = getPrecision();
-
-        return precision.equals(other.getPrecision()) &&
-                point.eq(other.point, precision) &&
+    public boolean eq(final CutAngle other, final DoublePrecisionContext precision) {
+        return point.eq(other.point, precision) &&
                 positiveFacing == other.positiveFacing;
     }
 
@@ -496,7 +488,7 @@ public final class CutAngle extends AbstractHyperplane<Point1S>
             final CutAngle baseHyper = base.getHyperplane();
             final CutAngle inputHyper = (CutAngle) sub.getHyperplane();
 
-            if (!baseHyper.eq(inputHyper)) {
+            if (!baseHyper.eq(inputHyper, baseHyper.getPrecision())) {
                 throw new IllegalArgumentException("Argument is not on the same " +
                         "hyperplane. Expected " + baseHyper + " but was " +
                         inputHyper);
diff --git a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/GreatCircle.java
b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/GreatCircle.java
index 584cd2f..c1ffffb 100644
--- a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/GreatCircle.java
+++ b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/GreatCircle.java
@@ -18,7 +18,6 @@ package org.apache.commons.geometry.spherical.twod;
 
 import java.util.Objects;
 
-import org.apache.commons.geometry.core.Equivalency;
 import org.apache.commons.geometry.core.Transform;
 import org.apache.commons.geometry.core.partitioning.AbstractHyperplane;
 import org.apache.commons.geometry.core.partitioning.EmbeddingHyperplane;
@@ -38,7 +37,7 @@ import org.apache.commons.numbers.angle.PlaneAngleRadians;
  * <p>Instances of this class are guaranteed to be immutable.</p>
  */
 public final class GreatCircle extends AbstractHyperplane<Point2S>
-    implements EmbeddingHyperplane<Point2S, Point1S>, Equivalency<GreatCircle>
{
+    implements EmbeddingHyperplane<Point2S, Point1S> {
     /** Pole or circle center. */
     private final Vector3D.Unit pole;
 
@@ -318,17 +317,16 @@ public final class GreatCircle extends AbstractHyperplane<Point2S>
         return Point2S.from(vectorAt(point.getAzimuth()));
     }
 
-    /** {@inheritDoc} */
-    @Override
-    public boolean eq(final GreatCircle other) {
-        if (this == other) {
-            return true;
-        }
-
-        final DoublePrecisionContext precision = getPrecision();
-
-        return precision.equals(other.getPrecision()) &&
-                pole.eq(other.pole, precision) &&
+    /** Return true if this instance should be considered equivalent to the argument, using
the
+     * given precision context for comparison. Instances are considered equivalent if have
equivalent
+     * {@code pole}, {@code u}, and {@code v} vectors.
+     * @param other great circle to compare with
+     * @param precision precision context to use for the comparison
+     * @return true if this instance should be considered equivalent to the argument
+     * @see Vector3D#eq(Vector3D, DoublePrecisionContext)
+     */
+    public boolean eq(final GreatCircle other, final DoublePrecisionContext precision) {
+        return pole.eq(other.pole, precision) &&
                 u.eq(other.u, precision) &&
                 v.eq(other.v, precision);
     }
diff --git a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/SubGreatCircle.java
b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/SubGreatCircle.java
index d2f918c..49e5c20 100644
--- a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/SubGreatCircle.java
+++ b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/SubGreatCircle.java
@@ -173,7 +173,7 @@ public final class SubGreatCircle extends AbstractSubGreatCircle {
     private void validateGreatCircle(final GreatCircle inputCircle) {
         final GreatCircle circle = getCircle();
 
-        if (!circle.eq(inputCircle)) {
+        if (!circle.eq(inputCircle, circle.getPrecision())) {
             throw new IllegalArgumentException("Argument is not on the same " +
                     "great circle. Expected " + circle + " but was " +
                     inputCircle);
diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/CutAngleTest.java
b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/CutAngleTest.java
index 1bf033c..134de24 100644
--- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/CutAngleTest.java
+++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/CutAngleTest.java
@@ -291,16 +291,16 @@ public class CutAngleTest {
         CutAngle h = CutAngle.fromPointAndDirection(Point1S.of(-1e-4), true, precision);
 
         // act/assert
-        Assert.assertTrue(a.eq(a));
+        Assert.assertTrue(a.eq(a, precision));
 
-        Assert.assertFalse(a.eq(b));
-        Assert.assertFalse(a.eq(c));
-        Assert.assertFalse(a.eq(d));
+        Assert.assertFalse(a.eq(b, precision));
+        Assert.assertFalse(a.eq(c, precision));
 
-        Assert.assertTrue(a.eq(e));
-        Assert.assertTrue(a.eq(f));
-        Assert.assertTrue(a.eq(g));
-        Assert.assertTrue(a.eq(h));
+        Assert.assertTrue(a.eq(d, precision));
+        Assert.assertTrue(a.eq(e, precision));
+        Assert.assertTrue(a.eq(f, precision));
+        Assert.assertTrue(a.eq(g, precision));
+        Assert.assertTrue(a.eq(h, precision));
     }
 
     @Test
diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatCircleTest.java
b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatCircleTest.java
index a554ee8..bf95bc6 100644
--- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatCircleTest.java
+++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatCircleTest.java
@@ -640,20 +640,20 @@ public class GreatCircleTest {
                 new EpsilonDoublePrecisionContext(eps));
 
         // act/assert
-        Assert.assertTrue(a.eq(a));
+        Assert.assertTrue(a.eq(a, precision));
 
-        Assert.assertFalse(a.eq(b));
-        Assert.assertFalse(a.eq(c));
-        Assert.assertFalse(a.eq(d));
+        Assert.assertFalse(a.eq(b, precision));
+        Assert.assertFalse(a.eq(c, precision));
 
-        Assert.assertTrue(a.eq(e));
-        Assert.assertTrue(e.eq(a));
+        Assert.assertTrue(a.eq(d, precision));
+        Assert.assertTrue(a.eq(e, precision));
+        Assert.assertTrue(e.eq(a, precision));
 
-        Assert.assertTrue(a.eq(f));
-        Assert.assertTrue(f.eq(a));
+        Assert.assertTrue(a.eq(f, precision));
+        Assert.assertTrue(f.eq(a, precision));
 
-        Assert.assertTrue(g.eq(e));
-        Assert.assertTrue(e.eq(g));
+        Assert.assertTrue(g.eq(e, precision));
+        Assert.assertTrue(e.eq(g, precision));
     }
 
     @Test


Mime
View raw message