Implement 'isAlmostEqual(to:tolerance:)' method for floating-point tensors. (#348)

* Implement `isAlmostEqual(to:tolerance:)` method for floating-point tensors.
* Rename `elementsApproximatelyEqual(_:tolerance:)` to `elementsAlmostEqual(_:tolerance:)`.

Author: dominikgrewe

Sources/TensorFlow/Operators/Comparison.swift

@@ -207,15 +207,15 @@ public extension Tensor where Scalar: Equatable {
 
 // TODO: infix operator ≈: ComparisonPrecedence
 
-public extension Tensor where Scalar: FloatingPoint & Equatable {
+public extension Tensor where Scalar: TensorFlowFloatingPoint & Equatable {
     /// Returns a tensor of Boolean values indicating whether the elements of `self` are
     /// approximately equal to those of `other`.
     @inlinable
-    func elementsApproximatelyEqual(
+    func elementsAlmostEqual(
         _ other: Tensor,
-        tolerance: Double = 0.00001
+        tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
     ) -> Tensor<Bool> {
-        return Raw.approximateEqual(self, other, tolerance: tolerance)
+        return Raw.approximateEqual(self, other, tolerance: Double(tolerance))
     }
 }
 
@@ -227,3 +227,16 @@ public extension StringTensor {
         return Raw.equal(self, other)
     }
 }
+
+public extension Tensor where Scalar: TensorFlowFloatingPoint {
+    /// Returns `true` if tensors are of equal shape and all pairs of scalars are approximately
+    /// equal.
+    @inlinable
+    func isAlmostEqual(
+        to other: Tensor,
+        tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
+    ) -> Bool {
+        return self.shape == other.shape &&
+            self.elementsAlmostEqual(other, tolerance: tolerance).all()
+    }
+}

Tests/TensorFlowTests/OperatorTests/ComparisonTests.swift

@@ -28,8 +28,21 @@ final class ComparisonOperatorTests: XCTestCase {
         XCTAssertTrue(x < y)
     }
 
+    func testIsAlmostEqual() {
+        let x = Tensor<Float>([0.1, 0.2, 0.3, 0.4])
+        let y = Tensor<Float>([0.0999, 0.20001, 0.2998, 0.4])
+        let z = Tensor<Float>([0.0999, 0.20001, 0.2998, 0.3])
+
+        XCTAssertTrue(x.isAlmostEqual(to: y, tolerance: 0.01))
+        XCTAssertFalse(x.isAlmostEqual(to: z))
+
+        let nanInf = Tensor<Float>([.nan, .infinity])
+        XCTAssertFalse(nanInf.isAlmostEqual(to: nanInf))
+    }
+
     static var allTests = [
         ("testElementwiseComparison", testElementwiseComparison),
-        ("testLexicographicalComparison", testLexicographicalComparison)
+        ("testLexicographicalComparison", testLexicographicalComparison),
+        ("testIsAlmostEqual", testIsAlmostEqual),
     ]
 }