hw-excess 0.2.0.3 → 0.2.1.0

raw patch · 10 files changed

+277/−27 lines, 10 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• bench/Main.hs +26/−0
• hw-excess.cabal +5/−1
• src/HaskellWorks/Data/Excess/Internal/Partial/Table.hs +75/−0
• src/HaskellWorks/Data/Excess/Internal/Triplet8.hs +11/−0
• src/HaskellWorks/Data/Excess/MinMaxExcess0.hs +5/−10
• src/HaskellWorks/Data/Excess/MinMaxExcess1.hs +5/−10
• src/HaskellWorks/Data/Excess/PartialMinMaxExcess0.hs +48/−0
• src/HaskellWorks/Data/Excess/PartialMinMaxExcess1.hs +48/−0
• test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs +27/−3
• test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs +27/−3

@@ -10,6 +10,8 @@ import Foreign import HaskellWorks.Data.Excess.MinMaxExcess0 import HaskellWorks.Data.Excess.MinMaxExcess1+import HaskellWorks.Data.Excess.PartialMinMaxExcess0+import HaskellWorks.Data.Excess.PartialMinMaxExcess1 import HaskellWorks.Data.Excess.Triplet import HaskellWorks.Data.Vector.AsVector64 @@ -23,6 +25,26 @@   lbs <- LBS.readFile "/dev/random"   return (asVector64 (LBS.toStrict (LBS.take (fromIntegral n) lbs))) +runPartialMinMaxExcess0Vector :: DVS.Vector Word64 -> IO ()+runPartialMinMaxExcess0Vector v = do+  let !_ = DVS.foldl go 0 v++  return ()+  where go :: Int -> Word64 -> Int+        go a b = a + lo + ex + hi+          where c = fromIntegral b :: Word64+                Triplet lo ex hi = partialMinMaxExcess0 64 c++runPartialMinMaxExcess1Vector :: DVS.Vector Word64 -> IO ()+runPartialMinMaxExcess1Vector v = do+  let !_ = DVS.foldl go 0 v++  return ()+  where go :: Int -> Word64 -> Int+        go a b = a + lo + ex + hi+          where c = fromIntegral b :: Word64+                Triplet lo ex hi = partialMinMaxExcess1 64 c+ runMinMaxExcess0VectorElems :: DVS.Vector Word64 -> IO () runMinMaxExcess0VectorElems v = do   let !_ = DVS.foldl go 0 v@@ -60,6 +82,10 @@     , bench "MinMaxExcess1" (whnfIO (runMinMaxExcess1VectorElems v))     , bench "MinMaxExcess0" (whnfIO (runMinMaxExcess0Vector      v))     , bench "MinMaxExcess1" (whnfIO (runMinMaxExcess1Vector      v))+    ]+  , env (setupEnvExcess (1024 * 1024)) $ \v -> bgroup "PartialMinMaxExcess Vector"+    [ bench "PartialMinMaxExcess0" (whnfIO (runPartialMinMaxExcess0Vector v))+    , bench "PartialMinMaxExcess1" (whnfIO (runPartialMinMaxExcess1Vector v))     ]   ] 

@@ -1,7 +1,7 @@ cabal-version:        2.2  name:                 hw-excess-version:              0.2.0.3+version:              0.2.1.0 synopsis:             Excess description:          Please see README.md category:             Data, Succinct Data Structures, Data Structures@@ -50,9 +50,13 @@     HaskellWorks.Data.Excess.Excess0     HaskellWorks.Data.Excess.Excess1     HaskellWorks.Data.Excess.Internal.Branchless+    HaskellWorks.Data.Excess.Internal.Partial.Table     HaskellWorks.Data.Excess.Internal.Table+    HaskellWorks.Data.Excess.Internal.Triplet8     HaskellWorks.Data.Excess.MinMaxExcess0     HaskellWorks.Data.Excess.MinMaxExcess1+    HaskellWorks.Data.Excess.PartialMinMaxExcess0+    HaskellWorks.Data.Excess.PartialMinMaxExcess1     HaskellWorks.Data.Excess.Triplet   autogen-modules:      Paths_hw_excess   other-modules:        Paths_hw_excess

@@ -0,0 +1,75 @@+module HaskellWorks.Data.Excess.Internal.Partial.Table+  ( genWord8Excess0+  , genWord8Excess1++  , tableWord8Excess0Lo+  , tableWord8Excess0Ex+  , tableWord8Excess0Hi+  , tableWord8Excess1Lo+  , tableWord8Excess1Ex+  , tableWord8Excess1Hi+  ) where++import Data.Int+import Data.Word+import HaskellWorks.Data.Bits.BitWise+import HaskellWorks.Data.Excess.Internal.Triplet8 (Triplet8 (Triplet8))++import qualified Data.Vector.Storable                       as DVS+import qualified HaskellWorks.Data.Excess.Internal.Triplet8 as T8++tableWord8Excess0Lo :: DVS.Vector Int8+tableWord8Excess0Lo = DVS.constructN (256 * 9) go+  where go :: DVS.Vector Int8 -> Int8+        go u =  let ui = DVS.length u in T8.triplet8Lo (genWord8Excess0 (ui `div` 256) (fromIntegral ui))+{-# NOINLINE tableWord8Excess0Lo #-}++tableWord8Excess0Ex :: DVS.Vector Int8+tableWord8Excess0Ex = DVS.constructN (256 * 9) go+  where go :: DVS.Vector Int8 -> Int8+        go u =  let ui = DVS.length u in T8.triplet8Ex (genWord8Excess0 (ui `div` 256) (fromIntegral ui))+{-# NOINLINE tableWord8Excess0Ex #-}++tableWord8Excess0Hi :: DVS.Vector Int8+tableWord8Excess0Hi = DVS.constructN (256 * 9) go+  where go :: DVS.Vector Int8 -> Int8+        go u =  let ui = DVS.length u in T8.triplet8Hi (genWord8Excess0 (ui `div` 256) (fromIntegral ui))+{-# NOINLINE tableWord8Excess0Hi #-}++tableWord8Excess1Lo :: DVS.Vector Int8+tableWord8Excess1Lo = DVS.constructN (256 * 9) go+  where go :: DVS.Vector Int8 -> Int8+        go u =  let ui = DVS.length u in T8.triplet8Lo (genWord8Excess1 (ui `div` 256) (fromIntegral ui))+{-# NOINLINE tableWord8Excess1Lo #-}++tableWord8Excess1Ex :: DVS.Vector Int8+tableWord8Excess1Ex = DVS.constructN (256 * 9) go+  where go :: DVS.Vector Int8 -> Int8+        go u =  let ui = DVS.length u in T8.triplet8Ex (genWord8Excess1 (ui `div` 256) (fromIntegral ui))+{-# NOINLINE tableWord8Excess1Ex #-}++tableWord8Excess1Hi :: DVS.Vector Int8+tableWord8Excess1Hi = DVS.constructN (256 * 9) go+  where go :: DVS.Vector Int8 -> Int8+        go u =  let ui = DVS.length u in T8.triplet8Hi (genWord8Excess1 (ui `div` 256) (fromIntegral ui))+{-# NOINLINE tableWord8Excess1Hi #-}++genWord8Excess0 :: Int -> Word8 -> Triplet8+genWord8Excess0 = go 0 0 0+  where go :: Int8 -> Int8 -> Int8 -> Int -> Word8 -> Triplet8+        go lo ex hi n w = if n > 0+          then if w .&. 1 /= 1+            then let fx = ex + 1 in go      lo     fx (max hi fx) (n - 1) (w .>. 1)+            else let fx = ex - 1 in go (min lo fx) fx      hi     (n - 1) (w .>. 1)+          else Triplet8 lo ex hi+{-# INLINE genWord8Excess0 #-}++genWord8Excess1 :: Int -> Word8 -> Triplet8+genWord8Excess1 = go 0 0 0+  where go :: Int8 -> Int8 -> Int8 -> Int -> Word8 -> Triplet8+        go lo ex hi n w = if n > 0+          then if w .&. 1 /= 0+            then let fx = ex + 1 in go      lo     fx (max hi fx) (n - 1) (w .>. 1)+            else let fx = ex - 1 in go (min lo fx) fx      hi     (n - 1) (w .>. 1)+          else Triplet8 lo ex hi+{-# INLINE genWord8Excess1 #-}

@@ -0,0 +1,11 @@+module HaskellWorks.Data.Excess.Internal.Triplet8+  ( Triplet8(..)+  ) where++import Data.Int++data Triplet8 = Triplet8+  { triplet8Lo :: {-# UNPACK #-} !Int8+  , triplet8Ex :: {-# UNPACK #-} !Int8+  , triplet8Hi :: {-# UNPACK #-} !Int8+  } deriving (Eq, Show)

@@ -2,8 +2,6 @@  module HaskellWorks.Data.Excess.MinMaxExcess0   ( MinMaxExcess0(..)-  , MaxExcess-  , MinExcess   ) where  import Data.Word@@ -16,44 +14,41 @@ import qualified Data.Vector.Storable                         as DVS import qualified HaskellWorks.Data.Excess.Internal.Branchless as BL -type MinExcess = Int-type MaxExcess = Int- class MinMaxExcess0 a where   minMaxExcess0 :: a -> Triplet  instance MinMaxExcess0 [Bool] where   minMaxExcess0 = go 0 0 0     where go minE maxE allE (x:xs)                    = let ne = if x then allE - 1 else allE + 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne xs+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne xs           go minE maxE allE _                         = Triplet minE allE maxE   {-# INLINE minMaxExcess0 #-}  instance MinMaxExcess0 (Naive Word8) where   minMaxExcess0 = go 0 0 0 0 . naive     where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne (n + 1) w+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne (n + 1) w           go minE maxE allE _ _                       = Triplet minE allE maxE   {-# INLINE minMaxExcess0 #-}  instance MinMaxExcess0 (Naive Word16) where   minMaxExcess0 = go 0 0 0 0 . naive     where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne (n + 1) w+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne (n + 1) w           go minE maxE allE _ _                       = Triplet minE allE maxE   {-# INLINE minMaxExcess0 #-}  instance MinMaxExcess0 (Naive Word32) where   minMaxExcess0 = go 0 0 0 0 . naive     where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne (n + 1) w+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne (n + 1) w           go minE maxE allE _ _                       = Triplet minE allE maxE   {-# INLINE minMaxExcess0 #-}  instance MinMaxExcess0 (Naive Word64) where   minMaxExcess0 = go 0 0 0 0 . naive     where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne (n + 1) w+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne (n + 1) w           go minE maxE allE _ _                       = Triplet minE allE maxE   {-# INLINE minMaxExcess0 #-} 

@@ -2,8 +2,6 @@  module HaskellWorks.Data.Excess.MinMaxExcess1   ( MinMaxExcess1(..)-  , MaxExcess-  , MinExcess   ) where  import Data.Word@@ -16,44 +14,41 @@ import qualified Data.Vector.Storable                         as DVS import qualified HaskellWorks.Data.Excess.Internal.Branchless as BL -type MinExcess = Int-type MaxExcess = Int- class MinMaxExcess1 a where   minMaxExcess1 :: a -> Triplet  instance MinMaxExcess1 [Bool] where   minMaxExcess1 = go 0 0 0     where go minE maxE allE (x:xs)                    = let ne = if x then allE + 1 else allE - 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne xs+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne xs           go minE maxE allE _                         = Triplet minE allE maxE   {-# INLINE minMaxExcess1 #-}  instance MinMaxExcess1 (Naive Word8) where   minMaxExcess1 = go 0 0 0 0 . naive     where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne (n + 1) w+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne (n + 1) w           go minE maxE allE _ _                       = Triplet minE allE maxE   {-# INLINE minMaxExcess1 #-}  instance MinMaxExcess1 (Naive Word16) where   minMaxExcess1 = go 0 0 0 0 . naive     where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne (n + 1) w+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne (n + 1) w           go minE maxE allE _ _                       = Triplet minE allE maxE   {-# INLINE minMaxExcess1 #-}  instance MinMaxExcess1 (Naive Word32) where   minMaxExcess1 = go 0 0 0 0 . naive     where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne (n + 1) w+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne (n + 1) w           go minE maxE allE _ _                       = Triplet minE allE maxE   {-# INLINE minMaxExcess1 #-}  instance MinMaxExcess1 (Naive Word64) where   minMaxExcess1 = go 0 0 0 0 . naive     where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in-                                                        go (minE `min` ne) (maxE `max` ne) ne (n + 1) w+                                                        go (BL.minInt minE ne) (BL.maxInt maxE ne) ne (n + 1) w           go minE maxE allE _ _                       = Triplet minE allE maxE   {-# INLINE minMaxExcess1 #-} 

@@ -0,0 +1,48 @@+module HaskellWorks.Data.Excess.PartialMinMaxExcess0+  ( PartialMinMaxExcess0(..)+  ) where++import Data.Word+import HaskellWorks.Data.Bits.BitWise+import HaskellWorks.Data.Excess.Triplet++import qualified Data.Vector.Storable                            as DVS+import qualified HaskellWorks.Data.Excess.Internal.Branchless    as BL+import qualified HaskellWorks.Data.Excess.Internal.Partial.Table as T++class PartialMinMaxExcess0 a where+  partialMinMaxExcess0 :: Int -> a -> Triplet++instance PartialMinMaxExcess0 Word8 where+  partialMinMaxExcess0 n w = Triplet partialMinMaxExcessMin partialMinMaxExcessAll partialMinMaxExcessMax+    where partialMinMaxExcessMin = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess0Lo (n * 256 + fromIntegral w)+          partialMinMaxExcessAll = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess0Ex (n * 256 + fromIntegral w)+          partialMinMaxExcessMax = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess0Hi (n * 256 + fromIntegral w)+  {-# INLINE partialMinMaxExcess0 #-}++instance PartialMinMaxExcess0 Word16 where+  partialMinMaxExcess0 n w = Triplet partialMinMaxExcessMin partialMinMaxExcessAll partialMinMaxExcessMax+    where Triplet aMin aAll aMax = partialMinMaxExcess0 8       (fromIntegral  w        :: Word8)+          Triplet bMin bAll bMax = partialMinMaxExcess0 (n - 8) (fromIntegral (w .>. 8) :: Word8)+          partialMinMaxExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinMaxExcessAll = if n <= 8 then aAll else aAll + bAll+          partialMinMaxExcessMax = if n <= 8 then aMax else BL.maxInt aMax (aAll + bMax)+  {-# INLINE partialMinMaxExcess0 #-}++instance PartialMinMaxExcess0 Word32 where+  partialMinMaxExcess0 n w = Triplet partialMinMaxExcessMin partialMinMaxExcessAll partialMinMaxExcessMax+    where Triplet aMin aAll aMax = partialMinMaxExcess0 16       (fromIntegral  w         :: Word16)+          Triplet bMin bAll bMax = partialMinMaxExcess0 (n - 16) (fromIntegral (w .>. 16) :: Word16)+          partialMinMaxExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinMaxExcessAll = if n <= 8 then aAll else aAll + bAll+          partialMinMaxExcessMax = if n <= 8 then aMax else BL.maxInt aMax (aAll + bMax)+  {-# INLINE partialMinMaxExcess0 #-}++instance PartialMinMaxExcess0 Word64 where+  partialMinMaxExcess0 n w = Triplet partialMinMaxExcessMin partialMinMaxExcessAll partialMinMaxExcessMax+    where Triplet aMin aAll aMax = partialMinMaxExcess0 32       (fromIntegral  w         :: Word32)+          Triplet bMin bAll bMax = partialMinMaxExcess0 (n - 32) (fromIntegral (w .>. 32) :: Word32)+          partialMinMaxExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinMaxExcessAll = if n <= 8 then aAll else aAll + bAll+          partialMinMaxExcessMax = if n <= 8 then aMax else BL.maxInt aMax (aAll + bMax)+  {-# INLINE partialMinMaxExcess0 #-}

@@ -0,0 +1,48 @@+module HaskellWorks.Data.Excess.PartialMinMaxExcess1+  ( PartialMinMaxExcess1(..)+  ) where++import Data.Word+import HaskellWorks.Data.Bits.BitWise+import HaskellWorks.Data.Excess.Triplet++import qualified Data.Vector.Storable                            as DVS+import qualified HaskellWorks.Data.Excess.Internal.Branchless    as BL+import qualified HaskellWorks.Data.Excess.Internal.Partial.Table as T++class PartialMinMaxExcess1 a where+  partialMinMaxExcess1 :: Int -> a -> Triplet++instance PartialMinMaxExcess1 Word8 where+  partialMinMaxExcess1 n w = Triplet partialMinMaxExcessMin partialMinMaxExcessAll partialMinMaxExcessMax+    where partialMinMaxExcessMin = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess1Lo (n * 256 + fromIntegral w)+          partialMinMaxExcessAll = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess1Ex (n * 256 + fromIntegral w)+          partialMinMaxExcessMax = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess1Hi (n * 256 + fromIntegral w)+  {-# INLINE partialMinMaxExcess1 #-}++instance PartialMinMaxExcess1 Word16 where+  partialMinMaxExcess1 n w = Triplet partialMinMaxExcessMin partialMinMaxExcessAll partialMinMaxExcessMax+    where Triplet aMin aAll aMax = partialMinMaxExcess1 8       (fromIntegral  w        :: Word8)+          Triplet bMin bAll bMax = partialMinMaxExcess1 (n - 8) (fromIntegral (w .>. 8) :: Word8)+          partialMinMaxExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinMaxExcessAll = if n <= 8 then aAll else aAll + bAll+          partialMinMaxExcessMax = if n <= 8 then aMax else BL.maxInt aMax (aAll + bMax)+  {-# INLINE partialMinMaxExcess1 #-}++instance PartialMinMaxExcess1 Word32 where+  partialMinMaxExcess1 n w = Triplet partialMinMaxExcessMin partialMinMaxExcessAll partialMinMaxExcessMax+    where Triplet aMin aAll aMax = partialMinMaxExcess1 16       (fromIntegral  w         :: Word16)+          Triplet bMin bAll bMax = partialMinMaxExcess1 (n - 16) (fromIntegral (w .>. 16) :: Word16)+          partialMinMaxExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinMaxExcessAll = if n <= 8 then aAll else aAll + bAll+          partialMinMaxExcessMax = if n <= 8 then aMax else BL.maxInt aMax (aAll + bMax)+  {-# INLINE partialMinMaxExcess1 #-}++instance PartialMinMaxExcess1 Word64 where+  partialMinMaxExcess1 n w = Triplet partialMinMaxExcessMin partialMinMaxExcessAll partialMinMaxExcessMax+    where Triplet aMin aAll aMax = partialMinMaxExcess1 32       (fromIntegral  w         :: Word32)+          Triplet bMin bAll bMax = partialMinMaxExcess1 (n - 32) (fromIntegral (w .>. 32) :: Word32)+          partialMinMaxExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinMaxExcessAll = if n <= 8 then aAll else aAll + bAll+          partialMinMaxExcessMax = if n <= 8 then aMax else BL.maxInt aMax (aAll + bMax)+  {-# INLINE partialMinMaxExcess1 #-}

@@ -4,16 +4,19 @@ module HaskellWorks.Data.Excess.MinMaxExcess0Spec (spec) where  import HaskellWorks.Data.Bits.Word+import HaskellWorks.Data.Excess.Internal.Triplet8 (Triplet8 (Triplet8)) import HaskellWorks.Data.Excess.MinMaxExcess0+import HaskellWorks.Data.Excess.PartialMinMaxExcess0 import HaskellWorks.Data.Excess.Triplet import HaskellWorks.Data.Naive import HaskellWorks.Hspec.Hedgehog import Hedgehog import Test.Hspec -import qualified Data.Vector.Storable as DVS-import qualified Hedgehog.Gen         as G-import qualified Hedgehog.Range       as R+import qualified Data.Vector.Storable                            as DVS+import qualified HaskellWorks.Data.Excess.Internal.Partial.Table as T+import qualified Hedgehog.Gen                                    as G+import qualified Hedgehog.Range                                  as R  {-# ANN module ("HLint: Ignore Redundant do" :: String) #-} {-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}@@ -169,3 +172,24 @@     it "For Word64" $ requireProperty $ do       w <- forAll $ G.word64 R.constantBounded       minMaxExcess0 w === minMaxExcess0 (Naive w)+  describe "Equivalent to word8Excess0' implementation" $ do+    it "For word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      let Triplet  lo0 ex0 hi0 = minMaxExcess0       w+      let Triplet8 lo1 ex1 hi1 = T.genWord8Excess0 8 w+      lo0 === fromIntegral lo1+      ex0 === fromIntegral ex1+      hi0 === fromIntegral hi1+  describe "Equivalent to partialMinMaxExcess1 implementation" $ do+    it "For word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      minMaxExcess0 w === partialMinMaxExcess0 8 w+    it "For word16" $ requireProperty $ do+      w <- forAll $ G.word16 R.constantBounded+      minMaxExcess0 w === partialMinMaxExcess0 16 w+    it "For word32" $ requireProperty $ do+      w <- forAll $ G.word32 R.constantBounded+      minMaxExcess0 w === partialMinMaxExcess0 32 w+    it "For word64" $ requireProperty $ do+      w <- forAll $ G.word64 R.constantBounded+      minMaxExcess0 w === partialMinMaxExcess0 64 w

@@ -4,16 +4,19 @@ module HaskellWorks.Data.Excess.MinMaxExcess1Spec (spec) where  import HaskellWorks.Data.Bits.Word+import HaskellWorks.Data.Excess.Internal.Triplet8 (Triplet8 (Triplet8)) import HaskellWorks.Data.Excess.MinMaxExcess1+import HaskellWorks.Data.Excess.PartialMinMaxExcess1 import HaskellWorks.Data.Excess.Triplet import HaskellWorks.Data.Naive import HaskellWorks.Hspec.Hedgehog import Hedgehog import Test.Hspec -import qualified Data.Vector.Storable as DVS-import qualified Hedgehog.Gen         as G-import qualified Hedgehog.Range       as R+import qualified Data.Vector.Storable                            as DVS+import qualified HaskellWorks.Data.Excess.Internal.Partial.Table as T+import qualified Hedgehog.Gen                                    as G+import qualified Hedgehog.Range                                  as R  {-# ANN module ("HLint: Ignore Redundant do" :: String) #-} {-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}@@ -169,3 +172,24 @@     it "For Word64" $ requireProperty $ do       w <- forAll $ G.word64 R.constantBounded       minMaxExcess1 w === minMaxExcess1 (Naive w)+  describe "Equivalent to word8Excess1' implementation" $ do+    it "For word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      let Triplet  lo0 ex0 hi0 = minMaxExcess1     w+      let Triplet8 lo1 ex1 hi1 = T.genWord8Excess1 8 w+      lo0 === fromIntegral lo1+      ex0 === fromIntegral ex1+      hi0 === fromIntegral hi1+  describe "Equivalent to partialMinMaxExcess1 implementation" $ do+    it "For word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      minMaxExcess1 w === partialMinMaxExcess1 8 w+    it "For word16" $ requireProperty $ do+      w <- forAll $ G.word16 R.constantBounded+      minMaxExcess1 w === partialMinMaxExcess1 16 w+    it "For word32" $ requireProperty $ do+      w <- forAll $ G.word32 R.constantBounded+      minMaxExcess1 w === partialMinMaxExcess1 32 w+    it "For word64" $ requireProperty $ do+      w <- forAll $ G.word64 R.constantBounded+      minMaxExcess1 w === partialMinMaxExcess1 64 w