diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,6 @@ # Changelog for approx -## Unreleased changes +## 0.1.0.1 + +Some refactoring. API remains same. +Added functions, **inRange**, **safeInRange** and **inTol** diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ 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, +For **Float** and **Double**, the following formula is used, ``` if max ( |x|, |y| ) < epsilon_Zero @@ -27,6 +27,7 @@ ``` 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])) @@ -43,10 +44,13 @@ =~ 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. +There are addtional functions **inRange**, **safeInRange** and **inTol**, which checks for values within Ranges either *explictily* defined as in **inRange** and **safeInRange** or through tolerances as in **inTol**. + ## Code examples The following all expressions evaluate as True ``` @@ -67,7 +71,7 @@ ## Installation -Add the library in build-depends and import Data.Approx. +Add the library in build-depends and ```import Data.Approx```. ## Author(s) Kishaloy Neogi @@ -75,7 +79,7 @@ ## License The library is distributed under the MIT License. -Copyright (c) 2020 Kishaloy Neogi +Copyright (c) 2021 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 diff --git a/approx.cabal b/approx.cabal --- a/approx.cabal +++ b/approx.cabal @@ -4,11 +4,11 @@ -- -- see: https://github.com/sol/hpack -- --- hash: 8ddc422b21726681ba9185afab2b6793789579f7d2f0ecf809ca88c5826e6d20 +-- hash: 9b7ad2629f9b53a8f710a24c69023ee54eeda43f2af2bac2eab8ec82331b722d name: approx -version: 0.1.0.0 -synopsis: Easy-to-use reasonable way of emulating approx in Haskell. +version: 0.1.0.1 +synopsis: Easy-to-use reasonable way of emulating approximate in Haskell. description: Please see the README on GitHub at category: Numeric homepage: https://github.com/n-kishaloy/approx#readme @@ -34,10 +34,10 @@ base >=4.7 && <5 , containers <=0.6.4.1 , hashable <=1.3.0.0 - , text <=1.2.4.0 - , time <=1.11 + , text <=1.2.4.1 + , time <=1.11.1.1 , unordered-containers <=0.2.13.0 - , vector <=0.12.1.2 + , vector <=0.12.2.0 default-language: Haskell2010 executable approx-exe @@ -52,10 +52,10 @@ , base >=4.7 && <5 , containers <=0.6.4.1 , hashable <=1.3.0.0 - , text <=1.2.4.0 - , time <=1.11 + , text <=1.2.4.1 + , time <=1.11.1.1 , unordered-containers <=0.2.13.0 - , vector <=0.12.1.2 + , vector <=0.12.2.0 default-language: Haskell2010 test-suite approx-test @@ -72,8 +72,8 @@ , base >=4.7 && <5 , containers <=0.6.4.1 , hashable <=1.3.0.0 - , text <=1.2.4.0 - , time <=1.11 + , text <=1.2.4.1 + , time <=1.11.1.1 , unordered-containers <=0.2.13.0 - , vector <=0.12.1.2 + , vector <=0.12.2.0 default-language: Haskell2010 diff --git a/src/Data/Approx.hs b/src/Data/Approx.hs --- a/src/Data/Approx.hs +++ b/src/Data/Approx.hs @@ -51,6 +51,8 @@ For lists, only finite lists are supported. Any use of infinite lists would cause a runtime error. +There are addtional functions __inRange__, __safeInRange__ and __inTol__, which checks for values within Ranges either /explictily/ defined as in __inRange__ and __safeInRange__ or through tolerances as in __inTol__. + You may see the github repository at -} @@ -64,6 +66,7 @@ -- *Documentation Approx (..) +, inRange, safeInRange, inTol ) where @@ -80,17 +83,17 @@ import qualified Data.Complex as Cx import Data.Complex (Complex ( (:+) ) ) -epsZeroDouble :: Double -epsZeroDouble = 1e-8; {-# INLINE epsZeroDouble #-} +eZerD :: Double +eZerD = 1e-8; {-# INLINE eZerD #-} -epsEqDouble :: Double -epsEqDouble = 1e-7; {-# INLINE epsEqDouble #-} +eEqD :: Double +eEqD = 1e-7; {-# INLINE eEqD #-} -epsZeroFloat :: Float -epsZeroFloat = 1e-6; {-# INLINE epsZeroFloat #-} +eZerF :: Float +eZerF = 1e-6; {-# INLINE eZerF #-} -epsEqFloat :: Float -epsEqFloat = 1e-5; {-# INLINE epsEqFloat #-} +eEqF :: Float +eEqF = 1e-5; {-# INLINE eEqF #-} infix 4 =~, /~ @@ -126,13 +129,11 @@ (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)) + x =~ y = (mx < eZerF) || abs (x-y) / mx < eEqF 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)) + x =~ y = (mx < eZerD) || abs (x-y) / mx < eEqD where mx = max (abs x) (abs y) {-# INLINE (=~) #-} instance Approx a => Approx (Maybe a) where @@ -142,7 +143,7 @@ {-# INLINE (=~) #-} instance Approx a => Approx [a] where - x =~ y = (length x == length y) && (foldr (&&) True $ zipWith (=~) x y) + x =~ y = (length x == length y) && and (zipWith (=~) x y) instance (Approx a, Approx b) => Approx (a, b) where (x,y) =~ (a,b) = @@ -260,12 +261,37 @@ {-# 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) + x =~ y = (U.length x == U.length y) && U.and (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) + x =~ y = (V.length x == V.length y) && V.and (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 + x =~ y = fz x y && fz y x where + fz p q = and $ (\(k,v) -> Hm.lookup k p =~ Just v) <$> Hm.toList q + +infix 4 `inRange`, `safeInRange`, `inTol` + +{-|@inRange (u,v) x = check if x is inside the range (u,v)@ + +Note: The function __assumes @u < v@__. This is done to ensure speed of operations. Use safeInRange, otherwise. +-} +inRange :: Ord a => (a,a) -> a -> Bool +inRange (u,v) x = (u <= x) && (x <= v) +{-# INLINE inRange #-} + +{-|@safeInRange (u,v) x = check if x is inside the range (u,v)@ + +Note: The function works even if u>v. However, it has addtional checks and is more expensive. Use only if you are not sure that u < v for your use-case. +-} +safeInRange :: Ord a => (a,a) -> a -> Bool +safeInRange (u,v) = inRange $ if u a -> a -> a -> Bool +inTol t a = inRange (a - t, a + t) +{-# INLINE inTol #-} diff --git a/test/Spec.hs b/test/Spec.hs --- a/test/Spec.hs +++ b/test/Spec.hs @@ -78,15 +78,14 @@ quickCheck $ ("star"::String) /~ ("start"::String) quickCheck $ ("start"::String) /~ ("star"::String) - quickCheck $ fromGregorian 2018 3 30 =~ fromGregorian 2018 3 30 + 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-15 15:01:50" :: 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-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" @@ -104,6 +103,11 @@ quickCheck $ rb =~ tb quickCheck $ tb =~ rb + let rb = Hm.fromList [("Cash", 10.21), ("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) @@ -125,3 +129,18 @@ quickCheck $ rb /~ tb quickCheck $ U.fromList ([2.5, 1.5, 3.56] :: [Double]) =~ U.fromList [2.500000001, 1.5, 3.56] + + quickCheck $ (2,4) `inRange` (3::Int) + quickCheck $ not $ (2,4) `inRange` (5::Int) + + quickCheck $ (2.5, 2.75) `inRange` (2.62::Double) + quickCheck $ not $ (2.5, 2.75) `inRange` (2.8::Double) + + quickCheck $ (4,2) `safeInRange` (3::Int) + quickCheck $ not $ (2,4) `safeInRange` (5::Int) + + quickCheck $ (2.5, 2.75) `safeInRange` (2.62::Double) + quickCheck $ not $ (2.75, 2.5) `safeInRange` (2.8::Double) + + quickCheck $ inTol 0.25 6.25 (6.1::Double) + quickCheck $ not $ inTol 0.125 6.25 (6.1::Double)