diff --git a/bench/Main.hs b/bench/Main.hs
--- a/bench/Main.hs
+++ b/bench/Main.hs
@@ -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))
     ]
   ]
 
diff --git a/hw-excess.cabal b/hw-excess.cabal
--- a/hw-excess.cabal
+++ b/hw-excess.cabal
@@ -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
diff --git a/src/HaskellWorks/Data/Excess/Internal/Partial/Table.hs b/src/HaskellWorks/Data/Excess/Internal/Partial/Table.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/Internal/Partial/Table.hs
@@ -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 #-}
diff --git a/src/HaskellWorks/Data/Excess/Internal/Triplet8.hs b/src/HaskellWorks/Data/Excess/Internal/Triplet8.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/Internal/Triplet8.hs
@@ -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)
diff --git a/src/HaskellWorks/Data/Excess/MinMaxExcess0.hs b/src/HaskellWorks/Data/Excess/MinMaxExcess0.hs
--- a/src/HaskellWorks/Data/Excess/MinMaxExcess0.hs
+++ b/src/HaskellWorks/Data/Excess/MinMaxExcess0.hs
@@ -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 #-}
 
diff --git a/src/HaskellWorks/Data/Excess/MinMaxExcess1.hs b/src/HaskellWorks/Data/Excess/MinMaxExcess1.hs
--- a/src/HaskellWorks/Data/Excess/MinMaxExcess1.hs
+++ b/src/HaskellWorks/Data/Excess/MinMaxExcess1.hs
@@ -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 #-}
 
diff --git a/src/HaskellWorks/Data/Excess/PartialMinMaxExcess0.hs b/src/HaskellWorks/Data/Excess/PartialMinMaxExcess0.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/PartialMinMaxExcess0.hs
@@ -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 #-}
diff --git a/src/HaskellWorks/Data/Excess/PartialMinMaxExcess1.hs b/src/HaskellWorks/Data/Excess/PartialMinMaxExcess1.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/PartialMinMaxExcess1.hs
@@ -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 #-}
diff --git a/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs b/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs
--- a/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs
+++ b/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs
@@ -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
diff --git a/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs b/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs
--- a/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs
+++ b/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs
@@ -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