hw-bits 0.7.0.9 → 0.7.1.0

raw patch · 15 files changed

+180/−2 lines, 15 filesdep +bitvecdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: bitvec

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• hw-bits.cabal +4/−1
• src/HaskellWorks/Data/Bits/AllExcess/AllExcess0.hs +11/−0
• src/HaskellWorks/Data/Bits/AllExcess/AllExcess1.hs +11/−0
• src/HaskellWorks/Data/Bits/BitLength.hs +11/−0
• src/HaskellWorks/Data/Bits/BitParse.hs +11/−0
• src/HaskellWorks/Data/Bits/BitRead.hs +9/−0
• src/HaskellWorks/Data/Bits/BitShow.hs +9/−0
• src/HaskellWorks/Data/Bits/BitWise.hs +11/−0
• src/HaskellWorks/Data/Bits/ElemFixedBitSize.hs +11/−0
• src/HaskellWorks/Data/Bits/FromBitTextByteString.hs +23/−0
• src/HaskellWorks/Data/Bits/PopCount/PopCount0.hs +11/−0
• src/HaskellWorks/Data/Bits/PopCount/PopCount1.hs +11/−0
• test/HaskellWorks/Data/Bits/BitReadSpec.hs +18/−1
• test/HaskellWorks/Data/Bits/BitWiseSpec.hs +8/−0
• test/HaskellWorks/Data/Bits/FromBitTextByteStringSpec.hs +21/−0

@@ -1,7 +1,7 @@ cabal-version:  2.2  name:                   hw-bits-version:                0.7.0.9+version:                0.7.1.0 synopsis:               Bit manipulation description:            Please see README.md category:               Data, Bit@@ -28,6 +28,7 @@  common base                 { build-depends: base                 >= 4          && < 5      } +common bitvec               { build-depends: bitvec               >= 1.0        && < 1.1    } common bytestring           { build-depends: bytestring           >= 0.9        && < 0.11   } common criterion            { build-depends: criterion            >= 1.2        && < 1.6    } common deepseq              { build-depends: deepseq              >= 1.4        && < 1.5    }@@ -48,6 +49,7 @@ library   import:               base                       , common+                      , bitvec                       , bytestring                       , deepseq                       , hw-int@@ -84,6 +86,7 @@ test-suite hw-bits-test   import:               base                       , common+                      , bitvec                       , bytestring                       , hedgehog                       , hspec

@@ -6,7 +6,10 @@ import HaskellWorks.Data.Bits.PopCount.PopCount0 import HaskellWorks.Data.Bits.PopCount.PopCount1 +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  class AllExcess0 a where   -- | Number of 0-bits minues the number of 1-bits.@@ -48,5 +51,13 @@   {-# INLINE allExcess0 #-}  instance AllExcess0 (DVS.Vector Word64) where+  allExcess0 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)+  {-# INLINE allExcess0 #-}++instance AllExcess0 (DVU.Vector Bit.Bit) where+  allExcess0 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)+  {-# INLINE allExcess0 #-}++instance AllExcess0 (DVU.Vector BitTS.Bit) where   allExcess0 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)   {-# INLINE allExcess0 #-}

@@ -6,8 +6,11 @@ import HaskellWorks.Data.Bits.PopCount.PopCount0 import HaskellWorks.Data.Bits.PopCount.PopCount1 +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.Vector          as DV import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  class AllExcess1 a where   -- | Number of 1-bits minues the number of 0-bits.@@ -66,4 +69,12 @@  instance AllExcess1 (DVS.Vector Word64) where   allExcess1 w = fromIntegral (popCount1 w) - fromIntegral (popCount0 w)+  {-# INLINE allExcess1 #-}++instance AllExcess1 (DVU.Vector Bit.Bit) where+  allExcess1 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)+  {-# INLINE allExcess1 #-}++instance AllExcess1 (DVU.Vector BitTS.Bit) where+  allExcess1 w = fromIntegral (popCount0 w) - fromIntegral (popCount1 w)   {-# INLINE allExcess1 #-}

@@ -15,8 +15,11 @@ import HaskellWorks.Data.Positioning import Prelude                       hiding (length) +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.Vector          as DV import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  class BitLength v where   -- | Number of bits in a value including ones and zeros.@@ -127,4 +130,12 @@  instance BitLength (DVS.Vector Word64) where   bitLength v = length v * bitLength (v !!! 0)+  {-# INLINE bitLength #-}++instance BitLength (DVU.Vector Bit.Bit) where+  bitLength = fromIntegral . DVU.length+  {-# INLINE bitLength #-}++instance BitLength (DVU.Vector BitTS.Bit) where+  bitLength = fromIntegral . DVU.length   {-# INLINE bitLength #-}

@@ -12,9 +12,12 @@ import HaskellWorks.Data.Bits.BitWise import HaskellWorks.Data.String.Parse +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.ByteString      as BS import qualified Data.Vector          as DV import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  -- | Parsers for bit strings class BitParse a where@@ -126,3 +129,11 @@ instance BitParse (DVS.Vector Word64) where   bitParse0 = bitParse1 <|> return DVS.empty   bitParse1 = fromList `fmap` bitParse0++instance BitParse (DVU.Vector Bit.Bit) where+  bitParse0 = bitParse1 <|> return DVU.empty+  bitParse1 = fromList . map Bit.Bit <$> many bitParse1++instance BitParse (DVU.Vector BitTS.Bit) where+  bitParse0 = bitParse1 <|> return DVU.empty+  bitParse1 = fromList . map BitTS.Bit <$> many bitParse1

@@ -11,9 +11,12 @@ import HaskellWorks.Data.Bits.BitParse import HaskellWorks.Data.String.Parse +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.ByteString      as BS import qualified Data.Vector          as DV import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  -- | Bit string reader that produces a value of a type class BitRead a where@@ -77,6 +80,12 @@   bitRead = bitRead'  instance BitRead (DVS.Vector Word64) where+  bitRead = bitRead'++instance BitRead (DVU.Vector Bit.Bit) where+  bitRead = bitRead'++instance BitRead (DVU.Vector BitTS.Bit) where   bitRead = bitRead'  instance BitRead [Bool] where

@@ -11,10 +11,13 @@ import HaskellWorks.Data.Bits.BitWise import HaskellWorks.Data.Bits.Word +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.ByteString      as BS import qualified Data.ByteString.Lazy as BSL import qualified Data.Vector          as DV import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  -- | Shower of a value as a bit string class BitShow a where@@ -104,6 +107,12 @@  instance BitShow (DVS.Vector Word64) where   bitShows = bitShows . toList++instance BitShow (DVU.Vector Bit.Bit) where+  bitShows = bitShows . fmap Bit.unBit . toList++instance BitShow (DVU.Vector BitTS.Bit) where+  bitShows = bitShows . fmap BitTS.unBit . toList  bitShow :: BitShow a => a -> String bitShow a = bitShows a ""

@@ -17,9 +17,12 @@ import HaskellWorks.Data.Positioning import Prelude                          as P +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.Bits            as B import qualified Data.Vector          as DV import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  -- We pervasively use precedence to avoid excessive parentheses, and we use -- the same precedence conventions of the C programming language: arithmetic@@ -139,6 +142,14 @@  instance TestBit (DVS.Vector Word64) where   (.?.) v n = let (q, r) = n `quotRem` elemBitEnd v in (v !!! q) .?. r+  {-# INLINE (.?.) #-}++instance TestBit (DVU.Vector Bit.Bit) where+  (.?.) v n = Bit.unBit (v DVU.! fromIntegral n)+  {-# INLINE (.?.) #-}++instance TestBit (DVU.Vector BitTS.Bit) where+  (.?.) v n = BitTS.unBit (v DVU.! fromIntegral n)   {-# INLINE (.?.) #-}  instance BitWise Int where

@@ -8,8 +8,11 @@ import Data.Word import HaskellWorks.Data.Positioning +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.Vector          as DV import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  -- | Class of values that have elements of a fixed bit size --@@ -83,3 +86,11 @@ instance ElemFixedBitSize (DVS.Vector Word64) where   type Elem (DVS.Vector Word64) = Word64   elemFixedBitSize _ = 64++instance ElemFixedBitSize (DVU.Vector Bit.Bit) where+  type Elem (DVU.Vector Bit.Bit) = Bit.Bit+  elemFixedBitSize _ = 1++instance ElemFixedBitSize (DVU.Vector BitTS.Bit) where+  type Elem (DVU.Vector BitTS.Bit) = BitTS.Bit+  elemFixedBitSize _ = 1

@@ -8,8 +8,11 @@ import Data.Word import HaskellWorks.Data.Bits +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.ByteString      as BS import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  class FromBitTextByteString a where   -- | Convert a binary byte string to a value of type @a@@ -86,6 +89,26 @@                 Just (d, ds) | d == w1  -> gen' (n + 1) (w .|. (1 .<. fromIntegral n)) ds                 Just (_, ds) -> gen' n w ds                 Nothing      -> Just (w, cs)++instance FromBitTextByteString (DVU.Vector Bit.Bit) where+  fromBitTextByteString :: BS.ByteString -> DVU.Vector Bit.Bit+  fromBitTextByteString bs = DVU.unfoldrN (BS.length bs) gen bs+    where gen :: BS.ByteString -> Maybe (Bit.Bit, BS.ByteString)+          gen cs = case BS.uncons cs of+            Just (d, ds) | d == w0  -> Just (Bit.Bit False, ds)+            Just (d, ds) | d == w1  -> Just (Bit.Bit True,  ds)+            Just (_, ds) -> gen ds+            Nothing      -> Nothing++instance FromBitTextByteString (DVU.Vector BitTS.Bit) where+  fromBitTextByteString :: BS.ByteString -> DVU.Vector BitTS.Bit+  fromBitTextByteString bs = DVU.unfoldrN (BS.length bs) gen bs+    where gen :: BS.ByteString -> Maybe (BitTS.Bit, BS.ByteString)+          gen cs = case BS.uncons cs of+            Just (d, ds) | d == w0  -> Just (BitTS.Bit False, ds)+            Just (d, ds) | d == w1  -> Just (BitTS.Bit True,  ds)+            Just (_, ds) -> gen ds+            Nothing      -> Nothing  w0 :: Word8 w0 = 48

@@ -14,8 +14,11 @@ import HaskellWorks.Data.Positioning import Prelude                                   as P +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.Vector          as DV import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  class PopCount0 v where   -- | The number of 0-bits in the value.@@ -176,4 +179,12 @@  instance PopCount0 (DVS.Vector (Broadword Word64)) where   popCount0 = DVS.foldl' (\c -> (c +) . popCount0) 0+  {-# INLINE popCount0 #-}++instance PopCount0 (DVU.Vector Bit.Bit) where+  popCount0 v = fromIntegral $ DVU.length v - Bit.countBits v+  {-# INLINE popCount0 #-}++instance PopCount0 (DVU.Vector BitTS.Bit) where+  popCount0 v = fromIntegral $ DVU.length v - BitTS.countBits v   {-# INLINE popCount0 #-}

@@ -12,9 +12,12 @@ import HaskellWorks.Data.Positioning import Prelude                                as P +import qualified Data.Bit             as Bit+import qualified Data.Bit.ThreadSafe  as BitTS import qualified Data.Bits            as DB import qualified Data.Vector          as DV import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  type FastWord a = Builtin a @@ -197,4 +200,12 @@  instance PopCount1 (DVS.Vector (Broadword Word64)) where   popCount1 = DVS.foldl' (\c -> (c +) . popCount1) 0+  {-# INLINE popCount1 #-}++instance PopCount1 (DVU.Vector Bit.Bit) where+  popCount1 = fromIntegral . Bit.countBits+  {-# INLINE popCount1 #-}++instance PopCount1 (DVU.Vector BitTS.Bit) where+  popCount1 = fromIntegral . BitTS.countBits   {-# INLINE popCount1 #-}

@@ -11,7 +11,9 @@ import Hedgehog import Test.Hspec -import qualified Data.Vector as DV+import qualified Data.Bit            as Bit+import qualified Data.Vector         as DV+import qualified Data.Vector.Unboxed as DVU  {-# ANN module ("HLint: Ignore Redundant do" :: String) #-} @@ -29,6 +31,7 @@   it "bitRead \"\" :: Maybe [Word8]" . requireTest $ do     let ws = bitRead "" :: Maybe [Word8]     ws === Just []+   it "bitRead \"10000000 101\" :: Maybe (DV.Vector Word8)" . requireTest $ do     let v = bitRead "10000000 101" :: Maybe (DV.Vector Word8)     v === Just [1, 5]@@ -41,6 +44,20 @@   it "bitRead \"\" :: Maybe (DV.Vector Word8)" . requireTest $ do     let v = bitRead "" :: Maybe (DV.Vector Word8)     v === Just []++  it "bitRead \"10000000 101\" :: Maybe (DVU.Vector Bit.Bit)" . requireTest $ do+    let v = bitRead "10000000 101" :: Maybe (DVU.Vector Bit.Bit)+    v === Just [1,0,0,0,0,0,0,0, 1,0,1]+  it "bitRead \"11100100 10101111 1\" :: Maybe (DVU.Vector Bit.Bit)" . requireTest $ do+    let v = bitRead "11100100 10101111 1" :: Maybe (DVU.Vector Bit.Bit)+    v === Just [1,1,1,0,0,1,0,0, 1,0,1,0,1,1,1,1, 1]+  it "bitRead \"11100100 10101111 1\" :: Maybe (DVU.Vector Bit.Bit)" . requireTest $ do+    let v = bitRead "11100100 10101111 1" :: Maybe (DVU.Vector Bit.Bit)+    v === Just [1,1,1,0,0,1,0,0, 1,0,1,0,1,1,1,1, 1]+  it "bitRead \"\" :: Maybe (DVU.Vector Bit.Bit)" . requireTest $ do+    let v = bitRead "" :: Maybe (DVU.Vector Bit.Bit)+    v === Just []+   it "bitShow (8 :: Word8)" . requireTest $ do     let bs = bitShow (8 :: Word8)     bs === "00010000"

@@ -10,8 +10,10 @@ import Hedgehog import Test.Hspec +import qualified Data.Bit             as Bit import qualified Data.Bits            as B import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU import qualified Hedgehog.Gen         as G import qualified Hedgehog.Range       as R @@ -56,6 +58,9 @@     it "for [Word64] matches Data.Bits implementation" $ requireProperty $ do       w <- forAll $ G.list (R.constant 0 10) (G.word64 R.constantBounded)       popCount0 w === popCount0 (DVS.fromList w)+    it "for [Bool] matches DVU Bit.Bit" $ requireProperty $ do+      w <- forAll $ G.list (R.constant 0 1000) G.bool+      popCount0 w === popCount0 (DVU.fromList (fmap Bit.Bit w))   describe "for popCount1" $ do     it "for Word8 matches Data.Bits implementation" $ requireProperty $ do       w <- forAll $ G.word8 R.constantBounded@@ -93,3 +98,6 @@     it "for [Word64] matches Data.Bits implementation" $ requireProperty $ do       w <- forAll $ G.list (R.constant 0 10) (G.word64 R.constantBounded)       popCount1 w === popCount1 (DVS.fromList w)+    it "for [Bool] matches DVU Bit.Bit" $ requireProperty $ do+      w <- forAll $ G.list (R.constant 0 1000) G.bool+      popCount1 w === popCount1 (DVU.fromList (fmap Bit.Bit w))

@@ -12,8 +12,10 @@ import Hedgehog import Test.Hspec +import qualified Data.Bit             as Bit import qualified Data.ByteString      as BS import qualified Data.Vector.Storable as DVS+import qualified Data.Vector.Unboxed  as DVU  {-# ANN module ("HLint: Ignore Redundant do" :: String) #-} @@ -95,3 +97,22 @@     it "fromBitTextByteString (BS.unpack \"11110000111100001111000011110000111100001111000011110000111100001\") :: DVS.Vector Word64" . requireTest $ do       let w = fromBitTextByteString "11110000111100001111000011110000111100001111000011110000111100001" :: DVS.Vector Word64       w === DVS.fromList [0x0f0f0f0f0f0f0f0f, 0x1]+  describe "For (DVU.Vector Bit.Bit)" $ do+    it "fromBitTextByteString (BS.unpack []) :: DVU.Vector Bit.Bit" . requireTest $ do+      let w = fromBitTextByteString (BS.pack []) :: DVU.Vector Bit.Bit+      w === DVU.fromList []+    it "fromBitTextByteString (BS.unpack \"0\") :: DVU.Vector Bit.Bit" . requireTest $ do+      let w = fromBitTextByteString "0" :: DVU.Vector Bit.Bit+      w === DVU.fromList [0]+    it "fromBitTextByteString (BS.unpack \"1\") :: DVU.Vector Bit.Bit" . requireTest $ do+      let w = fromBitTextByteString "1" :: DVU.Vector Bit.Bit+      w === DVU.fromList [1]+    it "fromBitTextByteString (BS.unpack \"1111000011110000111100001111000011110000111100001111000011110000\") :: DVU.Vector Bit.Bit" . requireTest $ do+      let w = fromBitTextByteString "1111000011110000111100001111000011110000111100001111000011110000" :: DVU.Vector Bit.Bit+      w === DVU.fromList [1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0]+    it "fromBitTextByteString (BS.unpack \"11110000111100001111000011110000111100001111000011110000111100000\") :: DVU.Vector Bit.Bit" . requireTest $ do+      let w = fromBitTextByteString "11110000111100001111000011110000111100001111000011110000111100000" :: DVU.Vector Bit.Bit+      w === DVU.fromList [1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0]+    it "fromBitTextByteString (BS.unpack \"11110000111100001111000011110000111100001111000011110000111100001\") :: DVU.Vector Bit.Bit" . requireTest $ do+      let w = fromBitTextByteString "11110000111100001111000011110000111100001111000011110000111100001" :: DVU.Vector Bit.Bit+      w === DVU.fromList [1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1]