Change equals() to approximatelyEquals()

Because it was not an equivalence relation and it was not compatible
with the hashCode() method.  Also to make it like the Vertex class.

Author: Ferenc Gerlits

app/src/main/java/ferenc_gerlits/hypercube_viewer/FourMatrix.java

@@ -2,8 +2,6 @@
 
 import androidx.annotation.NonNull;
 
-import java.util.Arrays;
-
 public class FourMatrix {
     private double[][] elements;
 
@@ -62,20 +60,17 @@ public double get(int i, int j) {
         }
     }
 
-    @Override
-    public int hashCode() {
-        return Arrays.hashCode(elements);
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        FourMatrix that = (FourMatrix) o;
+    public boolean approximatelyEquals(FourMatrix other) {
+        if (this == other) {
+            return true;
+        }
+        if (other == null) {
+            return false;
+        }
 
         for (int i = 0; i < 4; ++i) {
             for (int j = 0; j < 4; ++j) {
-                double diff = this.elements[i][j] - that.elements[i][j];
+                double diff = this.elements[i][j] - other.elements[i][j];
                 if (Math.abs(diff) >= Utility.EPSILON) {
                     return false;
                 }

app/src/test/java/ferenc_gerlits/hypercube_viewer/FourMatrixTest.java

@@ -3,6 +3,7 @@
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 public class FourMatrixTest {
 
@@ -11,37 +12,41 @@ public class FourMatrixTest {
 
     @Test
     public void fromTwoMatrixWithFixedCoordinates() {
-        assertEquals(createMatrix(
-                row(1, 0, 0, 0),
-                row(0, 1, 0, 0),
-                row(0, 0, SQRT_3_PER_2, -0.5),
-                row(0, 0, 0.5, SQRT_3_PER_2)),
+        assertTrue(matricesAreEqual(
+                createMatrix(
+                        row(1, 0, 0, 0),
+                        row(0, 1, 0, 0),
+                        row(0, 0, SQRT_3_PER_2, -0.5),
+                        row(0, 0, 0.5, SQRT_3_PER_2)),
                 FourMatrix.fromTwoMatrixWithFixedCoordinates(TwoMatrix.rotationBy(Math.PI / 6), 0, 1)
-        );
-
-        assertEquals(createMatrix(
-                row(SQRT_2_PER_2, 0, 0, -SQRT_2_PER_2),
-                row(0, 1, 0, 0),
-                row(0, 0, 1, 0),
-                row(SQRT_2_PER_2, 0, 0, SQRT_2_PER_2)),
+        ));
+
+        assertTrue(matricesAreEqual(
+                createMatrix(
+                        row(SQRT_2_PER_2, 0, 0, -SQRT_2_PER_2),
+                        row(0, 1, 0, 0),
+                        row(0, 0, 1, 0),
+                        row(SQRT_2_PER_2, 0, 0, SQRT_2_PER_2)),
                 FourMatrix.fromTwoMatrixWithFixedCoordinates(TwoMatrix.rotationBy(Math.PI / 4), 1, 2)
-        );
-
-        assertEquals(createMatrix(
-                row(1, 0, 0, 0),
-                row(0, 0.5, -SQRT_3_PER_2, 0),
-                row(0, SQRT_3_PER_2, 0.5, 0),
-                row(0, 0, 0, 1)),
+        ));
+
+        assertTrue(matricesAreEqual(
+                createMatrix(
+                        row(1, 0, 0, 0),
+                        row(0, 0.5, -SQRT_3_PER_2, 0),
+                        row(0, SQRT_3_PER_2, 0.5, 0),
+                        row(0, 0, 0, 1)),
                 FourMatrix.fromTwoMatrixWithFixedCoordinates(TwoMatrix.rotationBy(Math.PI / 3), 0, 3)
-        );
-
-        assertEquals(createMatrix(
-                row(0, -1, 0, 0),
-                row(1, 0, 0, 0),
-                row(0, 0, 1, 0),
-                row(0, 0, 0, 1)),
+        ));
+
+        assertTrue(matricesAreEqual(
+                createMatrix(
+                        row(0, -1, 0, 0),
+                        row(1, 0, 0, 0),
+                        row(0, 0, 1, 0),
+                        row(0, 0, 0, 1)),
                 FourMatrix.fromTwoMatrixWithFixedCoordinates(TwoMatrix.rotationBy(Math.PI / 2), 2, 3)
-        );
+        ));
     }
 
     private FourMatrix createMatrix(double[]... rows) {
@@ -52,6 +57,10 @@ private double[] row(double... elements) {
         return elements;
     }
 
+    private boolean matricesAreEqual(FourMatrix first, FourMatrix second) {
+        return first.approximatelyEquals(second);
+    }
+
     @Test
     public void times() {
         FourMatrix unitMatrix = createMatrix(
@@ -60,7 +69,7 @@ public void times() {
                 row(0, 0, 1, 0),
                 row(0, 0, 0, 1));
 
-        assertEquals(unitMatrix, unitMatrix.times(unitMatrix));
+        assertTrue(matricesAreEqual(unitMatrix, unitMatrix.times(unitMatrix)));
 
         FourMatrix someMatrix = createMatrix(
                 row(1, 1, 1, 1),
@@ -74,16 +83,18 @@ public void times() {
                 row(3, 0, 3, 0),
                 row(4, 0, 4, 0));
 
-        assertEquals(someMatrix, someMatrix.times(unitMatrix));
+        assertTrue(matricesAreEqual(someMatrix, someMatrix.times(unitMatrix)));
 
-        assertEquals(someOtherMatrix, unitMatrix.times(someOtherMatrix));
+        assertTrue(matricesAreEqual(someOtherMatrix, unitMatrix.times(someOtherMatrix)));
 
-        assertEquals(createMatrix(
-                row(7, 3, 7, 3),
-                row(14, 6, 14, 6),
-                row(21, 9, 21, 9),
-                row(28, 12, 28, 12)),
-                someMatrix.times(someOtherMatrix));
+        assertTrue(matricesAreEqual(
+                createMatrix(
+                        row(7, 3, 7, 3),
+                        row(14, 6, 14, 6),
+                        row(21, 9, 21, 9),
+                        row(28, 12, 28, 12)),
+                someMatrix.times(someOtherMatrix)
+        ));
     }
 
     @Test