diff --git a/ChangeLog.md b/ChangeLog.md new file mode 100644 --- /dev/null +++ b/ChangeLog.md @@ -0,0 +1,3 @@ +# Changelog for approx + +## Unreleased changes diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright Author name here (c) 2020 + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Author name here nor the names of other + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,97 @@ +# approx + +## Motivation + +The library is created to allow for a easy-to-use reasonable way of emulating approx in *Haskell*. The codes are all in *pure* Haskell. The idea is to have a natural feel in writing mathematical code, with operators which just works when working with **Double** and **Float** and their composite types like lists, vectors etc. + +The **Approx** module defines 2 operators **=~** and **/~**, which are for checking *nearly equal to* and *not nearly equal to* respectively. + +## Features +Both the operators **=~** and **/~** are put under the class **Approx**. + +At least one of the operators have to be defined and the other gets automatically defined. + +The library already defines the functions for some of the basic / common types. + +For types where **Eq** is defined like **Char, Bool, Int, Day, Text** the approx is simply replaced with **==**. + +For **Float** and **Double**, the following formula is used, + +``` +if max ( |x|, |y| ) < epsilon_Zero +then True +else + if |x - y| / max ( |x|, |y| ) < epsilon_Eq + then True + else False +``` + +The motivation for defining Approx for classes for which Eq is also defined is to allow for composite types where both Eq and Approx would be present. For example, the following code evaluates to True, even though the tuple is of type **```(Int,Double,Text,[Int],[[Char]],[Double])```**. +``` +((2,5.35,"happ",[1,2],["ret","we"],[6.78,3.5]) + :: (Int,Double,Text,[Int],[[Char]],[Double])) + + =~ (2,5.35,"happ",[1,2],["ret","we"],[6.78,3.5]) + ``` + +For UTCTime, the approx operator checks for equality to the nearest minute. The following expression evaluates to **True**. + +``` +(parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:02:15" + :: Maybe UTCTime) + + =~ parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:01:50" +``` + +The library also provides approx for Complex and common structures like list, boxed and unboxed vector, hashmap, tuples and Maybe. For all lists, tuples, hashmaps and vectors, the approximation is checked right down to the elements and the order for lists and vectors are important. + +For lists, only finite lists are supported. Any use of infinite lists would cause a runtime error. + +## Code examples +The following all expressions evaluate as True +``` +(1.0e+7 :: Double) =~ 10000000.05 + +((1.2, 3.4) :: (Double, Double)) =~ (1.20000008, 3.399999999) +((1.2, 3.5) :: (Double, Double)) /~ (1.20000008, 3.399999999) + +([1.2, 3.4, 5.6] :: [Double]) /~ [1.2, 3.4, 5.65] + +("star"::Text) =~ ("star"::Text) +("star"::Text) /~ ("start"::Text) + +Just (10.00000000000007 :: Double) =~ Just 10.0 +Just (10 :: Double) /~ Just 1.0 + +``` + + +## Installation +Add the library in build-depends and import Data.Approx. + +## Author(s) +Kishaloy Neogi + +## License +The library is distributed under the MIT License. + +Copyright (c) 2020 Kishaloy Neogi + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/app/Main.hs b/app/Main.hs new file mode 100644 --- /dev/null +++ b/app/Main.hs @@ -0,0 +1,4 @@ +module Main where + +main :: IO () +main = putStrLn "Hello, world" diff --git a/approx.cabal b/approx.cabal new file mode 100644 --- /dev/null +++ b/approx.cabal @@ -0,0 +1,79 @@ +cabal-version: 1.12 + +-- This file has been generated from package.yaml by hpack version 0.33.0. +-- +-- see: https://github.com/sol/hpack +-- +-- hash: 8ddc422b21726681ba9185afab2b6793789579f7d2f0ecf809ca88c5826e6d20 + +name: approx +version: 0.1.0.0 +synopsis: Easy-to-use reasonable way of emulating approx in Haskell. +description: Please see the README on GitHub at +category: Numeric +homepage: https://github.com/n-kishaloy/approx#readme +bug-reports: https://github.com/n-kishaloy/approx/issues +author: Kishaloy Neogi +maintainer: nkishaloy@yahoo.com +copyright: 2020 Kishaloy Neogi +license: MIT +license-file: LICENSE +build-type: Simple +extra-source-files: + README.md + ChangeLog.md + +library + exposed-modules: + Data.Approx + other-modules: + Paths_approx + hs-source-dirs: + src + build-depends: + base >=4.7 && <5 + , containers <=0.6.4.1 + , hashable <=1.3.0.0 + , text <=1.2.4.0 + , time <=1.11 + , unordered-containers <=0.2.13.0 + , vector <=0.12.1.2 + default-language: Haskell2010 + +executable approx-exe + main-is: Main.hs + other-modules: + Paths_approx + hs-source-dirs: + app + ghc-options: -threaded -rtsopts -with-rtsopts=-N + build-depends: + approx + , base >=4.7 && <5 + , containers <=0.6.4.1 + , hashable <=1.3.0.0 + , text <=1.2.4.0 + , time <=1.11 + , unordered-containers <=0.2.13.0 + , vector <=0.12.1.2 + default-language: Haskell2010 + +test-suite approx-test + type: exitcode-stdio-1.0 + main-is: Spec.hs + other-modules: + Paths_approx + hs-source-dirs: + test + ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N + build-depends: + QuickCheck + , approx + , base >=4.7 && <5 + , containers <=0.6.4.1 + , hashable <=1.3.0.0 + , text <=1.2.4.0 + , time <=1.11 + , unordered-containers <=0.2.13.0 + , vector <=0.12.1.2 + default-language: Haskell2010 diff --git a/src/Data/Approx.hs b/src/Data/Approx.hs new file mode 100644 --- /dev/null +++ b/src/Data/Approx.hs @@ -0,0 +1,271 @@ +{-| +Module : Approx +Description : Implement Approx for Double, Floats and structures +Copyright : (c) 2020 Kishaloy Neogi +License : MIT +Maintainer : Kishaloy Neogi +Email : nkishaloy@yahoo.com + +The library is created to allow for a easy-to-use reasonable way of emulating approx in Haskell. The codes are all in /pure/ Haskell. The idea is to have a natural mathematical feel in writing code, with operators which just works when working with Double and Float and their composite types like lists, vectors etc. + +The __Approx__ module defines 2 operators __@=~@__ and __@/~@__, which are for checking /nearly equal to/ and /not nearly equal to/ respectively. + +Both the operators __=~__ and __/~__ are put under the class __Approx__. + +At least one of the operators have to be defined and the other gets automatically defined. + +The library already defines the functions for some of the basic / common types. + +For types where __Eq__ is defined like __Char, Bool, Int, Day, Text__ the approx is simply replaced with __==__. + +For __Float__ and __Double__, the following formula is used, + +@ +if max ( |x|, |y| ) < epsilon_Zero +then True +else + if |x - y| / max ( |x|, |y| ) < epsilon_Eq + then True + else False +@ + +The motivation for defining Approx for classes for which Eq is also defined is to allow for composite types where both Eq and Approx would be present. For example, the following code evaluates to __@True@__, even though the tuple is of type @(Int,Double,Text,[Int],[[Char]],[Double])@. + +@ +((2,5.35,"happ",[1,2],["ret","we"],[6.78,3.5]) + :: (Int,Double,Text,[Int],[[Char]],[Double])) + + =~ (2,5.35,"happ",[1,2],["ret","we"],[6.78,3.5]) +@ + +For UTCTime, the approx operator checks for equality to the nearest minute. The following expression evaluates to __@True@__. + +@ +(parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:02:15" + :: Maybe UTCTime) + + =~ parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:01:50" +@ + +The library also provides approx for Complex and common structures like __List, Boxed and Unboxed Vector, Hashmap, Tuples__ and __Maybe__. For all lists, tuples, hashmaps and vectors, the approximation is checked right down to the elements and the order for lists and vectors are important. + +For lists, only finite lists are supported. Any use of infinite lists would cause a runtime error. + +You may see the github repository at + +-} + +{-# LANGUAGE Strict #-} + +module Data.Approx +( +-- *How to use this library +-- |Add @approx@ to build-depends and @import Data.Approx@ + +-- *Documentation + Approx (..) + +) where + +import Data.List (foldl') +import qualified Data.Vector.Unboxed as U +import qualified Data.Vector.Unboxed.Mutable as M +import qualified Data.Vector as V +import Data.Time (Day, UTCTime) +import Data.Time.Clock (diffUTCTime) +import qualified Data.HashMap.Strict as Hm +import Data.Hashable + +import Data.Text (Text) +import qualified Data.Complex as Cx +import Data.Complex (Complex ( (:+) ) ) + +epsZeroDouble :: Double +epsZeroDouble = 1e-8; {-# INLINE epsZeroDouble #-} + +epsEqDouble :: Double +epsEqDouble = 1e-7; {-# INLINE epsEqDouble #-} + +epsZeroFloat :: Float +epsZeroFloat = 1e-6; {-# INLINE epsZeroFloat #-} + +epsEqFloat :: Float +epsEqFloat = 1e-5; {-# INLINE epsEqFloat #-} + +infix 4 =~, /~ + +-- |The class @Approx@ defines 2 operators __@=~@__ and __@/~@__, which are for checking /nearly equal to/ and /not nearly equal to/ respectively. +class Approx a where + (=~), (/~) :: a -> a -> Bool + + (=~) x y = not (x /~ y) + {-# INLINE (=~) #-} + (/~) x y = not (x =~ y) + {-# INLINE (/~) #-} + + {-# MINIMAL (=~) | (/~) #-} + +instance Approx Day where x =~ y = x == y; {-# INLINE (=~) #-} + +instance Approx Char where x =~ y = x == y; {-# INLINE (=~) #-} + +instance Approx Bool where x =~ y = x == y; {-# INLINE (=~) #-} + +instance Approx Text where x =~ y = x == y; {-# INLINE (=~) #-} + +instance Approx Int where x =~ y = x == y; {-# INLINE (=~) #-} + +instance Approx Integer where x =~ y = x == y; {-# INLINE (=~) #-} + + +instance Approx UTCTime where + x =~ y = (round . (/60.0) . realToFrac $ x `diffUTCTime` y) == 0 + {-# INLINE (=~) #-} + +instance Approx a => Approx (Cx.Complex a) where + (a :+ b) =~ (x :+ y) = (a =~ x) && (b =~ y); {-# INLINE (=~) #-} + +instance Approx Float where + x =~ y = if (mx < epsZeroFloat) || (abs (x-y)) / mx < epsEqFloat then True else False + where mx = (max (abs x) (abs y)) + {-# INLINE (=~) #-} + +instance Approx Double where + x =~ y = if (mx < epsZeroDouble) || (abs (x-y)) / mx < epsEqDouble then True else False + where mx = (max (abs x) (abs y)) + {-# INLINE (=~) #-} + +instance Approx a => Approx (Maybe a) where + Nothing =~ Nothing = True + Just x =~ Just y = x =~ y + _ =~ _ = False + {-# INLINE (=~) #-} + +instance Approx a => Approx [a] where + x =~ y = (length x == length y) && (foldr (&&) True $ zipWith (=~) x y) + +instance (Approx a, Approx b) => Approx (a, b) where + (x,y) =~ (a,b) = + ( (x =~ a) + && (y =~ b) + ) + {-# INLINE (=~) #-} + +instance (Approx a, Approx b, Approx c) => Approx (a, b, c) where + (x,y,z) =~ (a,b,c) = + ( (x =~ a) + && (y =~ b) + && (z =~ c) + ) + {-# INLINE (=~) #-} + +instance (Approx a,Approx b,Approx c,Approx d) => Approx (a,b,c,d) where + (x,y,z,u) =~ (a,b,c,d) = + ( (x =~ a) + && (y =~ b) + && (z =~ c) + && (u =~ d) + ) + {-# INLINE (=~) #-} + +instance (Approx a,Approx b,Approx c,Approx d, Approx e) => Approx (a,b,c,d,e) where + (x,y,z,u,v) =~ (a,b,c,d,e) = + ( (x =~ a) + && (y =~ b) + && (z =~ c) + && (u =~ d) + && (v =~ e) + ) + {-# INLINE (=~) #-} + +instance (Approx a,Approx b,Approx c,Approx d, Approx e, Approx f) => Approx (a,b,c,d,e,f) where + (x,y,z,u,v,w) =~ (a,b,c,d,e,f) = + ( (x =~ a) + && (y =~ b) + && (z =~ c) + && (u =~ d) + && (v =~ e) + && (w =~ f) + ) + {-# INLINE (=~) #-} + +instance (Approx a,Approx b,Approx c,Approx d, Approx e, Approx f, Approx g) => Approx (a,b,c,d,e,f,g) where + (x,y,z,u,v,w,p) =~ (a,b,c,d,e,f,g) = + ( (x =~ a) + && (y =~ b) + && (z =~ c) + && (u =~ d) + && (v =~ e) + && (w =~ f) + && (p =~ g) + ) + {-# INLINE (=~) #-} + +instance (Approx a,Approx b,Approx c,Approx d, Approx e, Approx f, Approx g, Approx h) => Approx (a,b,c,d,e,f,g,h) where + (x,y,z,u,v,w,p,q) =~ (a,b,c,d,e,f,g,h) = + ( (x =~ a) + && (y =~ b) + && (z =~ c) + && (u =~ d) + && (v =~ e) + && (w =~ f) + && (p =~ g) + && (q =~ h) + ) + {-# INLINE (=~) #-} + +instance (Approx a,Approx b,Approx c,Approx d, Approx e, Approx f, Approx g, Approx h, Approx i) => Approx (a,b,c,d,e,f,g,h,i) where + (x,y,z,u,v,w,p,q,r) =~ (a,b,c,d,e,f,g,h,i) = + ( (x =~ a) + && (y =~ b) + && (z =~ c) + && (u =~ d) + && (v =~ e) + && (w =~ f) + && (p =~ g) + && (q =~ h) + && (r =~ i) + ) + {-# INLINE (=~) #-} + +instance (Approx a,Approx b,Approx c,Approx d, Approx e, Approx f, Approx g, Approx h, Approx i, Approx j) => Approx (a,b,c,d,e,f,g,h,i,j) where + (x,y,z,u,v,w,p,q,r,s) =~ (a,b,c,d,e,f,g,h,i,j) = + ( (x =~ a) + && (y =~ b) + && (z =~ c) + && (u =~ d) + && (v =~ e) + && (w =~ f) + && (p =~ g) + && (q =~ h) + && (r =~ i) + && (s =~ j) + ) + {-# INLINE (=~) #-} + +instance (Approx a,Approx b,Approx c,Approx d, Approx e, Approx f, Approx g, Approx h, Approx i, Approx j, Approx k) => Approx (a,b,c,d,e,f,g,h,i,j,k) where + (x,y,z,u,v,w,p,q,r,s,t) =~ (a,b,c,d,e,f,g,h,i,j,k) = + ( (x =~ a) + && (y =~ b) + && (z =~ c) + && (u =~ d) + && (v =~ e) + && (w =~ f) + && (p =~ g) + && (q =~ h) + && (r =~ i) + && (s =~ j) + && (t =~ k) + ) + {-# INLINE (=~) #-} + +instance (M.Unbox a, Approx a) => Approx (U.Vector a) where + x =~ y = (U.length x==U.length y) && (U.foldr (&&) True $ U.zipWith (=~) x y) + +instance (Approx a) => Approx (V.Vector a) where + x =~ y = (V.length x==V.length y) && (V.foldr (&&) True $ V.zipWith (=~) x y) + +instance (Eq a, Hashable a, Approx b) => Approx (Hm.HashMap a b) where + x =~ y = (fz x y) && (fz y x) where + fz p q = foldl' (f p) True $ Hm.toList q + f p t z = t && ((Hm.lookup k p) =~ (Just v)) where (k,v) = z diff --git a/test/Spec.hs b/test/Spec.hs new file mode 100644 --- /dev/null +++ b/test/Spec.hs @@ -0,0 +1,127 @@ +{-# LANGUAGE NumericUnderscores, OverloadedStrings #-} + +module Main where + +import Test.QuickCheck + + +import qualified Data.Vector.Unboxed as U +import qualified Data.Vector as V +-- import Data.Vector.Unboxed ((!)) +import Data.Time (fromGregorian, UTCTime) +import Data.Time.Format (parseTimeM, defaultTimeLocale) +import qualified Data.HashMap.Strict as Hm +import Data.Text (Text) +import qualified Data.Complex as Cx +import Data.Complex (Complex ( (:+) ) ) + +import Data.Approx + + + +main :: IO () +main = do + + -- print "Float equality test" + quickCheck $ (0.0 :: Float) =~ (-1e-9) + quickCheck $ (0.0 :: Double) =~ (-0.0) + quickCheck $ (1.0e+7 :: Double) =~ 10_000_000.05 + + quickCheck $ Just (10.0000000000000007 :: Double) =~ Just 10.0 + quickCheck $ Just (10 :: Double) /~ Just 1.0 + quickCheck $ Just (10 :: Double) /~ Nothing + quickCheck $ (Nothing :: Maybe Double) /~ Just 1.0 + quickCheck $ (Nothing :: Maybe Double) =~ Nothing + + quickCheck $ ([1.2, 3.4, 5.6] :: [Double]) /~ [1.2, 3.4, 5.65] + quickCheck $ ([2.3, 1,2, 1000] :: [Double]) =~ [2.3, 1,2, 1e+3] + quickCheck $ ([1.0,1.0,1.0,1.0] :: [Double]) /~ [1.0,1.0,1.0,1.0,2.0] + + quickCheck $ ((1.2, 3.4) :: (Double, Double)) =~ (1.20000008, 3.399999999) + quickCheck $ ((1.2, 3.5) :: (Double, Double)) /~ (1.20000008, 3.399999999) + + quickCheck $ ((1.2, 3.4, 2.5) :: (Double, Double, Double)) =~ (1.20000008, 3.399999999, 2.5000001) + quickCheck $ ((1.2, 3.4, 2.5) :: (Double, Double, Double)) /~ (1.2, 3.399999999, 2.4) + + quickCheck $ ((1.2, 3.4, 2.5) :: (Float, Float, Float)) =~ (1.20000008, 3.399999999, 2.5000001) + quickCheck $ ((1.2, 3.4, 2.5) :: (Float, Float, Float)) /~ (1.2, 3.399999999, 2.4) + + quickCheck $ ((1, 3, 2) :: (Int, Int, Int)) =~ (1, 3, 2) + quickCheck $ ((1, 3, 2) :: (Int, Int, Int)) /~ (1, 3, 5) + + quickCheck $ ((2,5.35) :: (Int,Double)) =~ (2,5.35) + + quickCheck $ ((3.0 :+ 5.0)::(Cx.Complex Float)) =~ (3.0 :+ 5.0) + + quickCheck $ ((2,5.35,"happ",[1,2],["ret","we"],[6.78,3.5]) + :: (Int,Double,Text,[Int],[[Char]],[Double])) + + =~ (2,5.35,"happ",[1,2],["ret","we"],[6.78,3.5]) + + quickCheck $ ((1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0) :: (Double,Double,Double,Double,Double,Double,Double,Double,Double,Double,Double)) =~ (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0) + + quickCheck $ ((1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.1) :: (Double,Double,Double,Double,Double,Double,Double,Double,Double,Double,Double)) /~ (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0) + + quickCheck $ ((1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0) :: (Double,Double,Double,Double,Double,Double,Double,Double,Double,Double)) =~ (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0) + + quickCheck $ ((1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0) :: (Double,Double,Double,Double,Double,Double,Double,Double,Double,Double)) /~ (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.1) + + quickCheck $ False /~ True + quickCheck $ True =~ True + quickCheck $ False =~ False + + quickCheck $ ("star"::Text) =~ ("star"::Text) + quickCheck $ ("star"::Text) /~ ("start"::Text) + quickCheck $ ("start"::Text) /~ ("star"::Text) + + quickCheck $ ("star"::String) =~ ("star"::String) + quickCheck $ ("star"::String) /~ ("start"::String) + quickCheck $ ("start"::String) /~ ("star"::String) + + quickCheck $ fromGregorian 2018 3 30 =~ fromGregorian 2018 3 30 + quickCheck $ fromGregorian 2018 3 31 /~ fromGregorian 2018 3 30 + + quickCheck $ (parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:02:15" :: Maybe UTCTime) /~ parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 14:02:15" + + quickCheck $ (parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:02:15" :: Maybe UTCTime) =~ parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:01:50" + + quickCheck $ (parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:02:15" :: Maybe UTCTime) =~ parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:01:50" + + quickCheck $ (parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-16 15:02:15" :: Maybe UTCTime) /~ parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:02:15" + + quickCheck $ (parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2019-01-15 15:02:15" :: Maybe UTCTime) /~ parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:02:15" + + quickCheck $ (parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:02:15" :: Maybe UTCTime) =~ parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" "2020-01-15 15:02:15" + + let rb = Hm.fromList [("Cash", 10.23), ("CurrentAdvances", 56.25), ("AccountPayables", 0.0)] :: Hm.HashMap String Double + let tb = Hm.fromList [("Cash", 10.23), ("CurrentAdvances", 56.25)] :: Hm.HashMap String Double + + quickCheck $ rb /~ tb + quickCheck $ tb /~ rb + + let rb = Hm.fromList [("Cash", 10.23), ("CurrentAdvances", 56.25)] :: Hm.HashMap String Double + + quickCheck $ rb =~ tb + quickCheck $ tb =~ rb + + let rb = Hm.fromList [("Cash", Just 10.23), ("CurrentAdvances", Just 56.25), ("AccountPayables", Just 0.0)] :: Hm.HashMap String (Maybe Double) + let tb = Hm.fromList [("Cash", Just 10.23), ("CurrentAdvances", Just 56.25)] :: Hm.HashMap String (Maybe Double) + + quickCheck $ rb /~ tb + quickCheck $ tb /~ rb + + let rb = Hm.fromList [("Cash", Just 10.23), ("CurrentAdvances", Just 56.25)] :: Hm.HashMap String (Maybe Double) + + quickCheck $ rb =~ tb + quickCheck $ tb =~ rb + + let rb = V.fromList [("Cash", Just 10.23), ("CurrentAdvances", Just 56.25), ("AccountPayables", Just 0.0)] :: V.Vector (String, Maybe Double) + let tb = V.fromList [("Cash", Just 10.23), ("CurrentAdvances", Just 56.25)] :: V.Vector (String, Maybe Double) + + quickCheck $ rb /~ tb + + let rb = V.fromList [("Cash", Just 10.24), ("CurrentAdvances", Just 56.25)] :: V.Vector (String, Maybe Double) + + quickCheck $ rb /~ tb + + quickCheck $ U.fromList ([2.5, 1.5, 3.56] :: [Double]) =~ U.fromList [2.500000001, 1.5, 3.56]