hw-excess 0.2.1.0 → 0.2.2.0

raw patch · 14 files changed

+719/−29 lines, 14 filesdep ~QuickCheckPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: QuickCheck

API changes (from Hackage documentation)

Files

• hw-excess.cabal +12/−1
• src/HaskellWorks/Data/Excess/MinExcess.hs +25/−0
• src/HaskellWorks/Data/Excess/MinExcess0.hs +111/−0
• src/HaskellWorks/Data/Excess/MinExcess1.hs +111/−0
• src/HaskellWorks/Data/Excess/PartialMinExcess0.hs +44/−0
• src/HaskellWorks/Data/Excess/PartialMinExcess1.hs +44/−0
• test/HaskellWorks/Data/Excess/MinExcess0Spec.hs +122/−0
• test/HaskellWorks/Data/Excess/MinExcess1Spec.hs +122/−0
• test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs +0/−14
• test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs +0/−14
• test/HaskellWorks/Data/Excess/PartialMinExcess0Spec.hs +32/−0
• test/HaskellWorks/Data/Excess/PartialMinExcess1Spec.hs +32/−0
• test/HaskellWorks/Data/Excess/PartialMinMaxExcess0Spec.hs +32/−0
• test/HaskellWorks/Data/Excess/PartialMinMaxExcess1Spec.hs +32/−0

@@ -1,7 +1,7 @@ cabal-version:        2.2  name:                 hw-excess-version:              0.2.1.0+version:              0.2.2.0 synopsis:             Excess description:          Please see README.md category:             Data, Succinct Data Structures, Data Structures@@ -53,8 +53,13 @@     HaskellWorks.Data.Excess.Internal.Partial.Table     HaskellWorks.Data.Excess.Internal.Table     HaskellWorks.Data.Excess.Internal.Triplet8+    HaskellWorks.Data.Excess.MinExcess+    HaskellWorks.Data.Excess.MinExcess0+    HaskellWorks.Data.Excess.MinExcess1     HaskellWorks.Data.Excess.MinMaxExcess0     HaskellWorks.Data.Excess.MinMaxExcess1+    HaskellWorks.Data.Excess.PartialMinExcess0+    HaskellWorks.Data.Excess.PartialMinExcess1     HaskellWorks.Data.Excess.PartialMinMaxExcess0     HaskellWorks.Data.Excess.PartialMinMaxExcess1     HaskellWorks.Data.Excess.Triplet@@ -81,8 +86,14 @@   autogen-modules:      Paths_hw_excess   other-modules:     HaskellWorks.Data.Excess.Internal.BranchlessSpec+    HaskellWorks.Data.Excess.MinExcess0Spec+    HaskellWorks.Data.Excess.MinExcess1Spec     HaskellWorks.Data.Excess.MinMaxExcess0Spec     HaskellWorks.Data.Excess.MinMaxExcess1Spec+    HaskellWorks.Data.Excess.PartialMinExcess0Spec+    HaskellWorks.Data.Excess.PartialMinExcess1Spec+    HaskellWorks.Data.Excess.PartialMinMaxExcess0Spec+    HaskellWorks.Data.Excess.PartialMinMaxExcess1Spec     Paths_hw_excess  benchmark bench

@@ -0,0 +1,25 @@+{-# OPTIONS_GHC-funbox-strict-fields #-}++module HaskellWorks.Data.Excess.MinExcess+  ( MinExcess(..)+  ) where++import Control.Applicative (pure)+import Foreign.Ptr         (castPtr)+import Foreign.Storable    (Storable (..))++data MinExcess = MinExcess+  { minExcessMin :: !Int+  , minExcessAll :: !Int+  } deriving (Eq, Show)++instance Storable MinExcess where+  sizeOf _    = sizeOf (0 :: Int) * 3+  alignment _ = alignment (0 :: Int)+  peek p      = do let q = castPtr p+                   a <- peek q+                   b <- peekElemOff q 1+                   pure (MinExcess a b)+  poke p t    = do let q = castPtr p+                   poke q (minExcessMin t)+                   pokeElemOff q 1 (minExcessAll t)

@@ -0,0 +1,111 @@+{-# LANGUAGE FlexibleInstances #-}++module HaskellWorks.Data.Excess.MinExcess0+  ( MinExcess0(..)+  ) where++import Data.Word+import HaskellWorks.Data.Bits.BitWise+import HaskellWorks.Data.Bits.FixedBitSize+import HaskellWorks.Data.Excess.Internal.Table+import HaskellWorks.Data.Excess.MinExcess+import HaskellWorks.Data.Naive++import qualified Data.Vector.Storable                         as DVS+import qualified HaskellWorks.Data.Excess.Internal.Branchless as BL++class MinExcess0 a where+  minExcess0 :: a -> MinExcess++instance MinExcess0 [Bool] where+  minExcess0 = go 0 0+    where go minE allE (x:xs)                    = let ne = if x then allE - 1 else allE + 1 in+                                                        go (BL.minInt minE ne) ne xs+          go minE allE _                         = MinExcess minE allE+  {-# INLINE minExcess0 #-}++instance MinExcess0 (Naive Word8) where+  minExcess0 = go 0 0 0 . naive+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in+                                                        go (BL.minInt minE ne) ne (n + 1) w+          go minE allE _ _                       = MinExcess minE allE+  {-# INLINE minExcess0 #-}++instance MinExcess0 (Naive Word16) where+  minExcess0 = go 0 0 0 . naive+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in+                                                        go (BL.minInt minE ne) ne (n + 1) w+          go minE allE _ _                       = MinExcess minE allE+  {-# INLINE minExcess0 #-}++instance MinExcess0 (Naive Word32) where+  minExcess0 = go 0 0 0 . naive+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in+                                                        go (BL.minInt minE ne) ne (n + 1) w+          go minE allE _ _                       = MinExcess minE allE+  {-# INLINE minExcess0 #-}++instance MinExcess0 (Naive Word64) where+  minExcess0 = go 0 0 0 . naive+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in+                                                        go (BL.minInt minE ne) ne (n + 1) w+          go minE allE _ _                       = MinExcess minE allE+  {-# INLINE minExcess0 #-}++instance MinExcess0 Word8 where+  minExcess0 w = MinExcess (DVS.unsafeIndex word8Excess0Min (fromIntegral w))+                            (DVS.unsafeIndex word8Excess0    (fromIntegral w))+  {-# INLINE minExcess0 #-}++instance MinExcess0 Word16 where+  minExcess0 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))+                            (allExcessA + allExcessB)+    where MinExcess minExcessA allExcessA = minExcess0 (fromIntegral  w        :: Word8)+          MinExcess minExcessB allExcessB = minExcess0 (fromIntegral (w .>. 8) :: Word8)+  {-# INLINE minExcess0 #-}++instance MinExcess0 Word32 where+  minExcess0 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))+                            (allExcessA + allExcessB)+    where MinExcess minExcessA allExcessA = minExcess0 (fromIntegral  w         :: Word16)+          MinExcess minExcessB allExcessB = minExcess0 (fromIntegral (w .>. 16) :: Word16)+  {-# INLINE minExcess0 #-}++instance MinExcess0 Word64 where+  minExcess0 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))+                            (allExcessA + allExcessB)+    where MinExcess minExcessA allExcessA = minExcess0 (fromIntegral  w         :: Word32)+          MinExcess minExcessB allExcessB = minExcess0 (fromIntegral (w .>. 32) :: Word32)+  {-# INLINE minExcess0 #-}++instance MinExcess0 (DVS.Vector Word8) where+  minExcess0 = DVS.foldl' gen (MinExcess 0 0)+    where gen :: MinExcess -> Word8 -> MinExcess+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess0 w  in+                                            MinExcess (BL.minInt minE (wMinE + allE))+                                                    (                wAllE + allE )+  {-# INLINE minExcess0 #-}++instance MinExcess0 (DVS.Vector Word16) where+  minExcess0 = DVS.foldl' gen (MinExcess 0 0)+    where gen :: MinExcess -> Word16 -> MinExcess+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess0 w  in+                                            MinExcess (BL.minInt minE (wMinE + allE))+                                                    (                wAllE + allE )+  {-# INLINE minExcess0 #-}++instance MinExcess0 (DVS.Vector Word32) where+  minExcess0 = DVS.foldl' gen (MinExcess 0 0)+    where gen :: MinExcess -> Word32 -> MinExcess+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess0 w  in+                                            MinExcess (BL.minInt minE (wMinE + allE))+                                                    (                wAllE + allE )+  {-# INLINE minExcess0 #-}++instance MinExcess0 (DVS.Vector Word64) where+  minExcess0 = DVS.foldl' gen (MinExcess 0 0)+    where gen :: MinExcess -> Word64 -> MinExcess+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess0 w  in+                                            MinExcess (BL.minInt minE (wMinE + allE))+                                                    (                wAllE + allE )+  {-# INLINE minExcess0 #-}

@@ -0,0 +1,111 @@+{-# LANGUAGE FlexibleInstances #-}++module HaskellWorks.Data.Excess.MinExcess1+  ( MinExcess1(..)+  ) where++import Data.Word+import HaskellWorks.Data.Bits.BitWise+import HaskellWorks.Data.Bits.FixedBitSize+import HaskellWorks.Data.Excess.Internal.Table+import HaskellWorks.Data.Excess.MinExcess+import HaskellWorks.Data.Naive++import qualified Data.Vector.Storable                         as DVS+import qualified HaskellWorks.Data.Excess.Internal.Branchless as BL++class MinExcess1 a where+  minExcess1 :: a -> MinExcess++instance MinExcess1 [Bool] where+  minExcess1 = go 0 0+    where go minE allE (x:xs)                    = let ne = if x then allE + 1 else allE - 1 in+                                                        go (BL.minInt minE ne) ne xs+          go minE allE _                         = MinExcess minE allE+  {-# INLINE minExcess1 #-}++instance MinExcess1 (Naive Word8) where+  minExcess1 = go 0 0 0 . naive+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in+                                                        go (BL.minInt minE ne) ne (n + 1) w+          go minE allE _ _                       = MinExcess minE allE+  {-# INLINE minExcess1 #-}++instance MinExcess1 (Naive Word16) where+  minExcess1 = go 0 0 0 . naive+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in+                                                        go (BL.minInt minE ne) ne (n + 1) w+          go minE allE _ _                       = MinExcess minE allE+  {-# INLINE minExcess1 #-}++instance MinExcess1 (Naive Word32) where+  minExcess1 = go 0 0 0 . naive+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in+                                                        go (BL.minInt minE ne) ne (n + 1) w+          go minE allE _ _                       = MinExcess minE allE+  {-# INLINE minExcess1 #-}++instance MinExcess1 (Naive Word64) where+  minExcess1 = go 0 0 0 . naive+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in+                                                        go (BL.minInt minE ne) ne (n + 1) w+          go minE allE _ _                       = MinExcess minE allE+  {-# INLINE minExcess1 #-}++instance MinExcess1 Word8 where+  minExcess1 w = MinExcess (DVS.unsafeIndex word8Excess1Min  (fromIntegral w))+                            (DVS.unsafeIndex word8Excess1     (fromIntegral w))+  {-# INLINE minExcess1 #-}++instance MinExcess1 Word16 where+  minExcess1 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))+                            (allExcessA + allExcessB)+    where MinExcess minExcessA allExcessA = minExcess1 (fromIntegral  w        :: Word8)+          MinExcess minExcessB allExcessB = minExcess1 (fromIntegral (w .>. 8) :: Word8)+  {-# INLINE minExcess1 #-}++instance MinExcess1 Word32 where+  minExcess1 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))+                            (allExcessA + allExcessB)+    where MinExcess minExcessA allExcessA = minExcess1 (fromIntegral  w         :: Word16)+          MinExcess minExcessB allExcessB = minExcess1 (fromIntegral (w .>. 16) :: Word16)+  {-# INLINE minExcess1 #-}++instance MinExcess1 Word64 where+  minExcess1 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))+                            (allExcessA + allExcessB)+    where MinExcess minExcessA allExcessA = minExcess1 (fromIntegral  w         :: Word32)+          MinExcess minExcessB allExcessB = minExcess1 (fromIntegral (w .>. 32) :: Word32)+  {-# INLINE minExcess1 #-}++instance MinExcess1 (DVS.Vector Word8) where+  minExcess1 = DVS.foldl' gen (MinExcess 0 0)+    where gen :: MinExcess -> Word8 -> MinExcess+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess1 w  in+                                            MinExcess (BL.minInt minE (wMinE + allE))+                                                    (                wAllE + allE )+  {-# INLINE minExcess1 #-}++instance MinExcess1 (DVS.Vector Word16) where+  minExcess1 = DVS.foldl' gen (MinExcess 0 0)+    where gen :: MinExcess -> Word16 -> MinExcess+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess1 w  in+                                            MinExcess (BL.minInt minE (wMinE + allE))+                                                    (                wAllE + allE )+  {-# INLINE minExcess1 #-}++instance MinExcess1 (DVS.Vector Word32) where+  minExcess1 = DVS.foldl' gen (MinExcess 0 0)+    where gen :: MinExcess -> Word32 -> MinExcess+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess1 w  in+                                            MinExcess (BL.minInt minE (wMinE + allE))+                                                    (                wAllE + allE )+  {-# INLINE minExcess1 #-}++instance MinExcess1 (DVS.Vector Word64) where+  minExcess1 = DVS.foldl' gen (MinExcess 0 0)+    where gen :: MinExcess -> Word64 -> MinExcess+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess1 w  in+                                            MinExcess (BL.minInt minE (wMinE + allE))+                                                    (                wAllE + allE )+  {-# INLINE minExcess1 #-}

@@ -0,0 +1,44 @@+module HaskellWorks.Data.Excess.PartialMinExcess0+  ( PartialMinExcess0(..)+  ) where++import Data.Word+import HaskellWorks.Data.Bits.BitWise+import HaskellWorks.Data.Excess.MinExcess++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 PartialMinExcess0 a where+  partialMinExcess0 :: Int -> a -> MinExcess++instance PartialMinExcess0 Word8 where+  partialMinExcess0 n w = MinExcess partialMinExcessMin partialMinExcessAll+    where partialMinExcessMin = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess0Lo (n * 256 + fromIntegral w)+          partialMinExcessAll = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess0Ex (n * 256 + fromIntegral w)+  {-# INLINE partialMinExcess0 #-}++instance PartialMinExcess0 Word16 where+  partialMinExcess0 n w = MinExcess partialMinExcessMin partialMinExcessAll+    where MinExcess aMin aAll = partialMinExcess0 8       (fromIntegral  w        :: Word8)+          MinExcess bMin bAll = partialMinExcess0 (n - 8) (fromIntegral (w .>. 8) :: Word8)+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll+  {-# INLINE partialMinExcess0 #-}++instance PartialMinExcess0 Word32 where+  partialMinExcess0 n w = MinExcess partialMinExcessMin partialMinExcessAll+    where MinExcess aMin aAll = partialMinExcess0 16       (fromIntegral  w         :: Word16)+          MinExcess bMin bAll = partialMinExcess0 (n - 16) (fromIntegral (w .>. 16) :: Word16)+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll+  {-# INLINE partialMinExcess0 #-}++instance PartialMinExcess0 Word64 where+  partialMinExcess0 n w = MinExcess partialMinExcessMin partialMinExcessAll+    where MinExcess aMin aAll = partialMinExcess0 32       (fromIntegral  w         :: Word32)+          MinExcess bMin bAll = partialMinExcess0 (n - 32) (fromIntegral (w .>. 32) :: Word32)+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll+  {-# INLINE partialMinExcess0 #-}

@@ -0,0 +1,44 @@+module HaskellWorks.Data.Excess.PartialMinExcess1+  ( PartialMinExcess1(..)+  ) where++import Data.Word+import HaskellWorks.Data.Bits.BitWise+import HaskellWorks.Data.Excess.MinExcess++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 PartialMinExcess1 a where+  partialMinExcess1 :: Int -> a -> MinExcess++instance PartialMinExcess1 Word8 where+  partialMinExcess1 n w = MinExcess partialMinExcessMin partialMinExcessAll+    where partialMinExcessMin = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess1Lo (n * 256 + fromIntegral w)+          partialMinExcessAll = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess1Ex (n * 256 + fromIntegral w)+  {-# INLINE partialMinExcess1 #-}++instance PartialMinExcess1 Word16 where+  partialMinExcess1 n w = MinExcess partialMinExcessMin partialMinExcessAll+    where MinExcess aMin aAll = partialMinExcess1 8       (fromIntegral  w        :: Word8)+          MinExcess bMin bAll = partialMinExcess1 (n - 8) (fromIntegral (w .>. 8) :: Word8)+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll+  {-# INLINE partialMinExcess1 #-}++instance PartialMinExcess1 Word32 where+  partialMinExcess1 n w = MinExcess partialMinExcessMin partialMinExcessAll+    where MinExcess aMin aAll = partialMinExcess1 16       (fromIntegral  w         :: Word16)+          MinExcess bMin bAll = partialMinExcess1 (n - 16) (fromIntegral (w .>. 16) :: Word16)+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll+  {-# INLINE partialMinExcess1 #-}++instance PartialMinExcess1 Word64 where+  partialMinExcess1 n w = MinExcess partialMinExcessMin partialMinExcessAll+    where MinExcess aMin aAll = partialMinExcess1 32       (fromIntegral  w         :: Word32)+          MinExcess bMin bAll = partialMinExcess1 (n - 32) (fromIntegral (w .>. 32) :: Word32)+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll+  {-# INLINE partialMinExcess1 #-}

@@ -0,0 +1,122 @@+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}+{-# LANGUAGE ScopedTypeVariables #-}++module HaskellWorks.Data.Excess.MinExcess0Spec (spec) where++import HaskellWorks.Data.Bits.Word+import HaskellWorks.Data.Excess.Internal.Triplet8 (Triplet8 (Triplet8))+import HaskellWorks.Data.Excess.MinExcess+import HaskellWorks.Data.Excess.MinExcess0+import HaskellWorks.Data.Naive+import HaskellWorks.Hspec.Hedgehog+import Hedgehog+import Test.Hspec++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) #-}++spec :: Spec+spec = describe "HaskellWorks.Data.Excess.MinExcess0Spec" $ do+  describe "For Word8" $ do+    it "Excess should be between min excess and max excess" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      let MinExcess minE e = minExcess0 w+      assert $ minE <= e+    it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do+      w0 <- forAll $ G.word8 R.constantBounded+      w1 <- forAll $ G.word8 R.constantBounded+      let w2 = leConcat w0 w1+      let MinExcess minE0 e0 = minExcess0 w0+      let MinExcess minE1 _  = minExcess0 w1+      let MinExcess minE2 _  = minExcess0 w2+      minE2 === minE0 `min` (minE1 + e0)+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do+      w0 <- forAll $ G.word8 R.constantBounded+      w1 <- forAll $ G.word8 R.constantBounded+      let w2 = DVS.fromList [w0, w1]+      let MinExcess minE0 e0 = minExcess0 w0+      let MinExcess minE1 _  = minExcess0 w1+      let MinExcess minE2 _  = minExcess0 w2+      minE2 === minE0 `min` (minE1 + e0)+  describe "For Word16" $ do+    it "Excess should be between min excess and max excess" $ requireProperty $ do+      w <- forAll $ G.word16 R.constantBounded+      let MinExcess minE e = minExcess0 w+      assert $ minE <= e+    it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do+      w0 <- forAll $ G.word16 R.constantBounded+      w1 <- forAll $ G.word16 R.constantBounded+      let w2 = leConcat w0 w1+      let MinExcess minE0 e0 = minExcess0 w0+      let MinExcess minE1 _  = minExcess0 w1+      let MinExcess minE2 _  = minExcess0 w2+      minE2 === minE0 `min` (minE1 + e0)+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do+      w0 <- forAll $ G.word16 R.constantBounded+      w1 <- forAll $ G.word16 R.constantBounded+      let w2 = DVS.fromList [w0, w1]+      let MinExcess minE0 e0 = minExcess0 w0+      let MinExcess minE1 _  = minExcess0 w1+      let MinExcess minE2 _  = minExcess0 w2+      minE2 === minE0 `min` (minE1 + e0)+    describe "For Word32" $ do+      it "Excess should be between min excess and max excess" $ requireProperty $ do+        w <- forAll $ G.word32 R.constantBounded+        let MinExcess minE e = minExcess0 w+        assert $ minE <= e+      it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do+        w0 <- forAll $ G.word32 R.constantBounded+        w1 <- forAll $ G.word32 R.constantBounded++        let w2 = leConcat w0 w1+        let MinExcess minE0 e0 = minExcess0 w0+        let MinExcess minE1 _  = minExcess0 w1+        let MinExcess minE2 _  = minExcess0 w2+        minE2 === minE0 `min` (minE1 + e0)+      it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do+        w0 <- forAll $ G.word32 R.constantBounded+        w1 <- forAll $ G.word32 R.constantBounded++        let w2 = DVS.fromList [w0, w1]+        let MinExcess minE0 e0 = minExcess0 w0+        let MinExcess minE1 _  = minExcess0 w1+        let MinExcess minE2 _  = minExcess0 w2+        minE2 === minE0 `min` (minE1 + e0)+  describe "For Word64" $ do+    it "Excess should be between min excess and max excess" $ requireProperty $ do+      w <- forAll $ G.word64 R.constantBounded+      let MinExcess minE e = minExcess0 w+      assert $ minE <= e+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do+      w0 <- forAll $ G.word64 R.constantBounded+      w1 <- forAll $ G.word64 R.constantBounded+      let w2 = DVS.fromList [w0, w1]+      let MinExcess minE0 e0 = minExcess0 w0+      let MinExcess minE1 _  = minExcess0 w1+      let MinExcess minE2 _  = minExcess0 w2+      minE2 === minE0 `min` (minE1 + e0)+  describe "Equivalent to native implementation" $ do+    it "For Word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      minExcess0 w === minExcess0 (Naive w)+    it "For Word16" $ requireProperty $ do+      w <- forAll $ G.word16 R.constantBounded+      minExcess0 w === minExcess0 (Naive w)+    it "For Word32" $ requireProperty $ do+      w <- forAll $ G.word32 R.constantBounded+      minExcess0 w === minExcess0 (Naive w)+    it "For Word64" $ requireProperty $ do+      w <- forAll $ G.word64 R.constantBounded+      minExcess0 w === minExcess0 (Naive w)+  describe "Equivalent to word8Excess0' implementation" $ do+    it "For word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      let MinExcess lo0 ex0   = minExcess0          w+      let Triplet8  lo1 ex1 _ = T.genWord8Excess0 8 w+      lo0 === fromIntegral lo1+      ex0 === fromIntegral ex1

@@ -0,0 +1,122 @@+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}+{-# LANGUAGE ScopedTypeVariables #-}++module HaskellWorks.Data.Excess.MinExcess1Spec (spec) where++import HaskellWorks.Data.Bits.Word+import HaskellWorks.Data.Excess.Internal.Triplet8 (Triplet8 (Triplet8))+import HaskellWorks.Data.Excess.MinExcess+import HaskellWorks.Data.Excess.MinExcess1+import HaskellWorks.Data.Naive+import HaskellWorks.Hspec.Hedgehog+import Hedgehog+import Test.Hspec++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) #-}++spec :: Spec+spec = describe "HaskellWorks.Data.Excess.MinExcess1Spec" $ do+  describe "For Word8" $ do+    it "Excess should be between min excess and max excess" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      let MinExcess minE e = minExcess1 w+      assert $ minE <= e+    it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do+      w0 <- forAll $ G.word8 R.constantBounded+      w1 <- forAll $ G.word8 R.constantBounded++      let w2 = leConcat w0 w1+      let MinExcess minE0 e0 = minExcess1 w0+      let MinExcess minE1 _  = minExcess1 w1+      let MinExcess minE2 _  = minExcess1 w2+      minE2 === minE0 `min` (minE1 + e0)+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do+      w0 <- forAll $ G.word8 R.constantBounded+      w1 <- forAll $ G.word8 R.constantBounded++      let w2 = DVS.fromList [w0, w1]+      let MinExcess minE0 e0 = minExcess1 w0+      let MinExcess minE1 _  = minExcess1 w1+      let MinExcess minE2 _  = minExcess1 w2+      minE2 === minE0 `min` (minE1 + e0)+  describe "For Word16" $ do+    it "Excess should be between min excess and max excess" $ requireProperty $ do+      w <- forAll $ G.word16 R.constantBounded+      let MinExcess minE e = minExcess1 w+      assert $ minE <= e+    it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do+      w0 <- forAll $ G.word16 R.constantBounded+      w1 <- forAll $ G.word16 R.constantBounded+      let w2 = leConcat w0 w1+      let MinExcess minE0 e0 = minExcess1 w0+      let MinExcess minE1 _  = minExcess1 w1+      let MinExcess minE2 _  = minExcess1 w2+      minE2 === minE0 `min` (minE1 + e0)+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do+      w0 <- forAll $ G.word16 R.constantBounded+      w1 <- forAll $ G.word16 R.constantBounded+      let w2 = DVS.fromList [w0, w1]+      let MinExcess minE0 e0 = minExcess1 w0+      let MinExcess minE1 _  = minExcess1 w1+      let MinExcess minE2 _  = minExcess1 w2+      minE2 === minE0 `min` (minE1 + e0)+    describe "For Word32" $ do+      it "Excess should be between min excess and max excess" $ requireProperty $ do+        w <- forAll $ G.word32 R.constantBounded+        let MinExcess minE e = minExcess1 w+        assert $ minE <= e+      it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do+        w0 <- forAll $ G.word32 R.constantBounded+        w1 <- forAll $ G.word32 R.constantBounded+        let w2 = leConcat w0 w1+        let MinExcess minE0 e0 = minExcess1 w0+        let MinExcess minE1 _  = minExcess1 w1+        let MinExcess minE2 _  = minExcess1 w2+        minE2 === minE0 `min` (minE1 + e0)+      it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do+        w0 <- forAll $ G.word32 R.constantBounded+        w1 <- forAll $ G.word32 R.constantBounded+        let w2 = DVS.fromList [w0, w1]+        let MinExcess minE0 e0 = minExcess1 w0+        let MinExcess minE1 _  = minExcess1 w1+        let MinExcess minE2 _  = minExcess1 w2+        minE2 === minE0 `min` (minE1 + e0)+  describe "For Word64" $ do+    it "Excess should be between min excess and max excess" $ requireProperty $ do+      w <- forAll $ G.word64 R.constantBounded+      let MinExcess minE e = minExcess1 w+      assert $ minE <= e+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do+      w0 <- forAll $ G.word64 R.constantBounded+      w1 <- forAll $ G.word64 R.constantBounded+      let w2 = DVS.fromList [w0, w1]+      let MinExcess minE0 e0 = minExcess1 w0+      let MinExcess minE1 _  = minExcess1 w1+      let MinExcess minE2 _  = minExcess1 w2+      minE2 === minE0 `min` (minE1 + e0)+  describe "Equivalent to native implementation" $ do+    it "For Word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      minExcess1 w === minExcess1 (Naive w)+    it "For Word16" $ requireProperty $ do+      w <- forAll $ G.word16 R.constantBounded+      minExcess1 w === minExcess1 (Naive w)+    it "For Word32" $ requireProperty $ do+      w <- forAll $ G.word32 R.constantBounded+      minExcess1 w === minExcess1 (Naive w)+    it "For Word64" $ requireProperty $ do+      w <- forAll $ G.word64 R.constantBounded+      minExcess1 w === minExcess1 (Naive w)+  describe "Equivalent to word8Excess1' implementation" $ do+    it "For word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      let MinExcess lo0 ex0   = minExcess1          w+      let Triplet8  lo1 ex1 _ = T.genWord8Excess1 8 w+      lo0 === fromIntegral lo1+      ex0 === fromIntegral ex1

@@ -6,7 +6,6 @@ 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@@ -180,16 +179,3 @@       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

@@ -6,7 +6,6 @@ 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@@ -180,16 +179,3 @@       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

@@ -0,0 +1,32 @@+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}+{-# LANGUAGE ScopedTypeVariables #-}++module HaskellWorks.Data.Excess.PartialMinExcess0Spec (spec) where++import HaskellWorks.Data.Excess.MinExcess0+import HaskellWorks.Data.Excess.PartialMinExcess0+import HaskellWorks.Hspec.Hedgehog+import Hedgehog+import Test.Hspec++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) #-}++spec :: Spec+spec = describe "HaskellWorks.Data.Excess.PartialMinExcess0Spec" $ do+  describe "Equivalent to partialMinExcess1 implementation" $ do+    it "For word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      minExcess0 w === partialMinExcess0 8 w+    it "For word16" $ requireProperty $ do+      w <- forAll $ G.word16 R.constantBounded+      minExcess0 w === partialMinExcess0 16 w+    it "For word32" $ requireProperty $ do+      w <- forAll $ G.word32 R.constantBounded+      minExcess0 w === partialMinExcess0 32 w+    it "For word64" $ requireProperty $ do+      w <- forAll $ G.word64 R.constantBounded+      minExcess0 w === partialMinExcess0 64 w

@@ -0,0 +1,32 @@+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}+{-# LANGUAGE ScopedTypeVariables #-}++module HaskellWorks.Data.Excess.PartialMinExcess1Spec (spec) where++import HaskellWorks.Data.Excess.MinExcess1+import HaskellWorks.Data.Excess.PartialMinExcess1+import HaskellWorks.Hspec.Hedgehog+import Hedgehog+import Test.Hspec++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) #-}++spec :: Spec+spec = describe "HaskellWorks.Data.Excess.PartialMinExcess1Spec" $ do+  describe "Equivalent to partialMinExcess1 implementation" $ do+    it "For word8" $ requireProperty $ do+      w <- forAll $ G.word8 R.constantBounded+      minExcess1 w === partialMinExcess1 8 w+    it "For word16" $ requireProperty $ do+      w <- forAll $ G.word16 R.constantBounded+      minExcess1 w === partialMinExcess1 16 w+    it "For word32" $ requireProperty $ do+      w <- forAll $ G.word32 R.constantBounded+      minExcess1 w === partialMinExcess1 32 w+    it "For word64" $ requireProperty $ do+      w <- forAll $ G.word64 R.constantBounded+      minExcess1 w === partialMinExcess1 64 w

@@ -0,0 +1,32 @@+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}+{-# LANGUAGE ScopedTypeVariables #-}++module HaskellWorks.Data.Excess.PartialMinMaxExcess0Spec (spec) where++import HaskellWorks.Data.Excess.MinMaxExcess0+import HaskellWorks.Data.Excess.PartialMinMaxExcess0+import HaskellWorks.Hspec.Hedgehog+import Hedgehog+import Test.Hspec++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) #-}++spec :: Spec+spec = describe "HaskellWorks.Data.Excess.PartialMinMaxExcess0Spec" $ do+  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

@@ -0,0 +1,32 @@+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}+{-# LANGUAGE ScopedTypeVariables #-}++module HaskellWorks.Data.Excess.PartialMinMaxExcess1Spec (spec) where++import HaskellWorks.Data.Excess.MinMaxExcess1+import HaskellWorks.Data.Excess.PartialMinMaxExcess1+import HaskellWorks.Hspec.Hedgehog+import Hedgehog+import Test.Hspec++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) #-}++spec :: Spec+spec = describe "HaskellWorks.Data.Excess.PartialMinMaxExcess1Spec" $ do+  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