Remove Approximate in favor of an approximately-equals relation

Author: sharkdp

README.md

@@ -4,11 +4,10 @@ Functions for working with PureScript's builtin `Number` type.
 ## Example
 
 ``` purs
-> 0.1 + 0.2 == 0.3  
+> 0.1 + 0.2 == 0.3
 false
 
-> import Data.Number.Approximate 
-
-> Approximate 0.1 + Approximate 0.2 == Approximate 0.3
+> import Data.Number
+> 0.1 + 0.2 ≅ 0.3
 true
 ```

src/Data/Number.purs

@@ -2,6 +2,11 @@
 module Data.Number
   ( Fraction
   , eqRelative
+  , eqApproximate
+  , (~=)
+  , (≅)
+  , neqApproximate
+  , (≇)
   , Precision
   , eqAbsolute
   ) where
@@ -20,19 +25,55 @@ type Fraction = Number
 -- | `eqRelative frac (s * x) (s * y)` for a given scale factor `s > 0.0`
 -- | (unless one of x, y is exactly `0.0`).
 -- |
+-- | Note that the relation that `eqRelative frac` induces on `Number` is
+-- | not an equivalence relation. It is reflexive and symmetric, but not
+-- | transitive.
+-- |
 -- | Example:
 -- | ``` purs
 -- | > (eqRelative 0.01) 133.7 133.0
 -- | true
 -- |
 -- | > (eqRelative 0.001) 133.7 133.0
 -- | false
+-- |
+-- | > (eqRelative 0.01) (0.1 + 0.2) 0.3
+-- | true
 -- | ```
 eqRelative ∷ Fraction → Number → Number → Boolean
 eqRelative fraction 0.0   y =       abs y <= fraction
 eqRelative fraction   x 0.0 =       abs x <= fraction
 eqRelative fraction   x   y = abs (x - y) <= fraction * abs (x + y) / 2.0
 
+-- | Test if two numbers are approximately equal, up to a relative difference
+-- | of one part in a million:
+-- | ``` purs
+-- | eqApproximate = eqRelative 1.0e-6
+-- | ```
+-- |
+-- | Example
+-- | ``` purs
+-- | > 0.1 + 0.2 == 0.3
+-- | false
+-- |
+-- | > 0.1 + 0.2 ≅ 0.3
+-- | true
+-- | ```
+eqApproximate ∷ Number → Number → Boolean
+eqApproximate = eqRelative onePPM
+  where
+    onePPM ∷ Fraction
+    onePPM = 1.0e-6
+
+infix 4 eqApproximate as ~=
+infix 4 eqApproximate as ≅
+
+-- | The complement of `eqApproximate`.
+neqApproximate ∷ Number → Number → Boolean
+neqApproximate x y = not (x ≅ y)
+
+infix 4 neqApproximate as ≇
+
 -- | A(nother) type alias for (small) numbers.
 type Precision = Number
 

src/Data/Number/Approximate.purs

@@ -2,8 +2,7 @@ module Test.Main where
 
 import Prelude
 
-import Data.Number (eqRelative, eqAbsolute)
-import Data.Number.Approximate (Approximate(..))
+import Data.Number (eqRelative, eqAbsolute, (≅), (≇))
 
 import Control.Monad.Aff.AVar (AVAR)
 import Control.Monad.Eff (Eff)
@@ -111,23 +110,14 @@ main = runTest do
         eqRelative 3.0 10.0 29.5
 
 
-  suite "Approximate" do
-    let x = Approximate 0.3
-        y = Approximate 0.2999999999
-        a = Approximate 0.1
-        b = Approximate 0.2
+  suite "eqApproximate" do
+    test "0.1 + 0.2 ≅ 0.3" do
+      assert "0.1 + 0.2 should be approximately equal to 0.3" $
+        0.1 + 0.2 ≅ 0.3
 
-    test "Eq instance" do
-      assert "should treat them as equal" $
-        x == y
+      assert "0.1 + 0.200001 should not be approximately equal to 0.3" $
+        0.1 + 0.200001 ≇ 0.3
 
-    test "Ord instance" do
-      assert "should also treat them as equal" $
-        x >= y && y >= x
-
-    test "Addition" do
-      assert "0.1 + 0.2 should be equal to 0.3 (with Approximate)" $
-        a + b == x
 
   suite "eqAbsolute" do
     test "eqAbsolute" do