hw-bits 0.7.0.3 → 0.7.0.4

raw patch · 4 files changed

+200/−6 lines, 4 filesdep +hedgehogdep +hw-hspec-hedgehogdep ~hspecPVP: minor bump suggested

API additions: PVP suggests at least a minor version bump

Dependencies added: hedgehog, hw-hspec-hedgehog

Dependency ranges changed: hspec

API changes (from Hackage documentation)

Files

• README.md +1/−1
• hw-bits.cabal +9/−5
• src/HaskellWorks/Data/Bits/Writer/Storable.hs +74/−0
• test/HaskellWorks/Data/Bits/Writer/StorableSpec.hs +116/−0

@@ -1,5 +1,5 @@ # hw-bits-[![CircleCI](https://circleci.com/gh/haskell-works/hw-bits/tree/0-branch.svg?style=svg)](https://circleci.com/gh/haskell-works/hw-bits/tree/0-branch)+[![CircleCI](https://circleci.com/gh/haskell-works/hw-bits.svg?style=svg)](https://circleci.com/gh/haskell-works/hw-bits) [![Travis](https://travis-ci.org/haskell-works/hw-bits.svg?branch=master)](https://travis-ci.org/haskell-works/hw-bits)  Facilities for manipulating bits.

@@ -3,7 +3,7 @@ -- see: https://github.com/sol/hpack  name:           hw-bits-version:        0.7.0.3+version:        0.7.0.4 synopsis:       Bit manipulation description:    Please see README.md category:       Data, Bit@@ -69,6 +69,7 @@       HaskellWorks.Data.Bits.Types.Broadword       HaskellWorks.Data.Bits.Types.Builtin       HaskellWorks.Data.Bits.Word+      HaskellWorks.Data.Bits.Writer.Storable   other-modules:       Paths_hw_bits   default-language: Haskell2010@@ -82,16 +83,19 @@   build-depends:       base        >= 4.8        && < 5     , vector      >= 0.12       && < 0.13-    , bytestring    >= 0.9        && < 0.11-    , hspec         >= 2.4        && < 2.6+    , bytestring              >= 0.9        && < 0.11+    , hedgehog                >= 0.5        && < 0.7+    , hspec                   >= 2.4        && < 3+    , hw-hspec-hedgehog       >= 0.1.0.4    && < 0.2     , hw-bits-    , hw-prim       >= 0.4.0.3    && < 0.7-    , QuickCheck    >= 2.10       && < 2.12+    , hw-prim                 >= 0.4.0.3    && < 0.7+    , QuickCheck              >= 2.10       && < 2.12   other-modules:       HaskellWorks.Data.Bits.BitReadSpec       HaskellWorks.Data.Bits.BitWiseSpec       HaskellWorks.Data.Bits.FromBitTextByteStringSpec       HaskellWorks.Data.Bits.Log2Spec+      HaskellWorks.Data.Bits.Writer.StorableSpec   default-language: Haskell2010  benchmark bench

@@ -0,0 +1,74 @@+{-# LANGUAGE ScopedTypeVariables #-}++module HaskellWorks.Data.Bits.Writer.Storable where++import Control.Monad.ST+import Data.Word+import HaskellWorks.Data.Bits.BitWise++import qualified Data.STRef                   as ST+import qualified Data.Vector.Storable.Mutable as DVSM++{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}++data Writer s = Writer+  { vector   :: DVSM.MVector s Word64+  , position :: ST.STRef s Int+  }++full :: Writer s -> ST s Bool+full writer = do+  p <- ST.readSTRef $ position writer+  return $ p * 64 >= DVSM.length (vector writer)+{-# INLINE full #-}++newWriter :: Int -> ST s (Writer s)+newWriter size = do+  v <- DVSM.new size+  p <- ST.newSTRef 0+  return $ Writer v p+{-# INLINE newWriter #-}++unsafeWriteBit :: Writer s -> Word64 -> ST s ()+unsafeWriteBit writer w = do+  let v = vector   writer             -- vector+  p <- ST.readSTRef $ position writer -- position+  let i = p .>. 6                     -- index into vector+  let o = p .&. 0x3f                  -- offset within a word+  e <- DVSM.unsafeRead v i+  DVSM.unsafeWrite v i (((w .&. 1) .<. fromIntegral o) .|. e)+  ST.writeSTRef (position writer) (p + 1)+{-# INLINE unsafeWriteBit #-}++unsafeWriteLoBits :: Writer s -> Int -> Word64 -> ST s ()+unsafeWriteLoBits writer c w = do+  let u = w .&. ((1 .<. fromIntegral c) - 1)+  let v = vector   writer             -- vector+  p <- ST.readSTRef $ position writer -- position+  let i = p .>. 6                     -- index into vector+  let o = p .&. 0x3f                  -- offset within a word+  lo <- DVSM.unsafeRead v i+  DVSM.unsafeWrite v i $ lo .|. (u .<. fromIntegral o)+  ST.writeSTRef (position writer) (p + c)+{-# INLINE unsafeWriteLoBits #-}++unsafeWriteBits :: Writer s -> Int -> Word64 -> ST s ()+unsafeWriteBits writer c w = do+  let u = w .&. ((1 .<. fromIntegral c) - 1)  -- masked word+  let v = vector writer                       -- vector+  p <- ST.readSTRef $ position writer         -- position+  let i = p .>. 6                             -- index into vector for lo part+  let j = i + 1                               -- index into vector for hi part+  let o = p .&. 0x3f                          -- offset within a word+  lo <- DVSM.unsafeRead v i+  DVSM.unsafeWrite v i $ lo .|. (u .<. fromIntegral o)+  hi <- DVSM.unsafeRead v j+  DVSM.unsafeWrite v j $ hi .|. (u .>. fromIntegral (64 - o))+  ST.writeSTRef (position writer) (p + c)+{-# INLINE unsafeWriteBits #-}++written :: Writer s -> ST s (DVSM.MVector s Word64)+written writer = do+  p <- ST.readSTRef $ position writer         -- position+  return $ DVSM.take ((p + 63) `div` 64) (vector writer)+{-# INLINE written #-}

@@ -0,0 +1,116 @@+{-# LANGUAGE BinaryLiterals      #-}+{-# LANGUAGE ScopedTypeVariables #-}++module HaskellWorks.Data.Bits.Writer.StorableSpec where++import Data.Word+import HaskellWorks.Hspec.Hedgehog+import Hedgehog+import Test.Hspec++import qualified Data.Vector.Storable                   as DVS+import qualified HaskellWorks.Data.Bits.Writer.Storable as WS++{-# ANN module ("HLint: Ignore Redundant do" :: String) #-}++spec :: Spec+spec = describe "HaskellWorks.Data.Bits.Writer.StorableSpec" $ do+  it "unsafeWriteBit" $ requireTest $ do+    let v :: DVS.Vector Word64 = DVS.create $ do+          mw <- WS.newWriter 10+          WS.unsafeWriteBit mw 1+          WS.unsafeWriteBit mw 0+          WS.unsafeWriteBit mw 1+          WS.unsafeWriteBit mw 1+          WS.unsafeWriteBit mw 0+          WS.unsafeWriteBit mw 0+          WS.unsafeWriteBit mw 1+          WS.unsafeWriteBit mw 1+          WS.unsafeWriteBit mw 1+          WS.unsafeWriteBit mw 0+          WS.unsafeWriteBit mw 0+          WS.unsafeWriteBit mw 0+          WS.written mw++    v === DVS.fromList [0b111001101]+  it "unsafeWriteBits 1" $ requireTest $ do+    let v :: DVS.Vector Word64 = DVS.create $ do+          mw <- WS.newWriter 10+          WS.unsafeWriteBits mw 1 1+          WS.unsafeWriteBits mw 1 0+          WS.unsafeWriteBits mw 1 1+          WS.unsafeWriteBits mw 1 1+          WS.unsafeWriteBits mw 1 0+          WS.unsafeWriteBits mw 1 0+          WS.unsafeWriteBits mw 1 1+          WS.unsafeWriteBits mw 1 1+          WS.unsafeWriteBits mw 1 1+          WS.unsafeWriteBits mw 1 0+          WS.unsafeWriteBits mw 1 0+          WS.unsafeWriteBits mw 1 0+          WS.written mw++    v === DVS.fromList [0b111001101]+  it "unsafeWriteBits 2" $ requireTest $ do+    let v :: DVS.Vector Word64 = DVS.create $ do+          mw <- WS.newWriter 10+          WS.unsafeWriteBits mw 1 0b1+          WS.unsafeWriteBits mw 1 0b0+          WS.unsafeWriteBits mw 2 0b11+          WS.unsafeWriteBits mw 2 0b00+          WS.unsafeWriteBits mw 3 0b111+          WS.unsafeWriteBits mw 3 0b000+          WS.written mw+    v === DVS.fromList [0b111001101]+  it "unsafeWriteBits 2" $ requireTest $ do+    let v :: DVS.Vector Word64 = DVS.create $ do+          mw <- WS.newWriter 10+          WS.unsafeWriteBits mw 1 0b1+          WS.unsafeWriteBits mw 1 0b0+          WS.unsafeWriteBits mw 2 0b11+          WS.unsafeWriteBits mw 2 0b00+          WS.unsafeWriteBits mw 3 0b111+          WS.unsafeWriteBits mw 3 0b000+          WS.unsafeWriteBits mw 4 0b1111+          WS.unsafeWriteBits mw 4 0b0000+          WS.unsafeWriteBits mw 5 0b11111+          WS.unsafeWriteBits mw 5 0b00000+          WS.unsafeWriteBits mw 6 0b111111+          WS.unsafeWriteBits mw 6 0b000000+          WS.unsafeWriteBits mw 7 0b1111111+          WS.unsafeWriteBits mw 7 0b0000000+          WS.unsafeWriteBits mw 8 0b11111111+          WS.unsafeWriteBits mw 8 0b00000000+          WS.unsafeWriteBits mw 9 0b111111111+          WS.unsafeWriteBits mw 9 0b000000000+          WS.written mw+    v === DVS.fromList+      [ 0b1111111100000001111111000000111111000001111100001111000111001101+      , 0b0000000000000000000000000000000000000000000000011111111100000000+      ]+  it "unsafeWriteBits 2" $ requireTest $ do+    let v :: DVS.Vector Word64 = DVS.create $ do+          mw <- WS.newWriter 10+          WS.unsafeWriteBits mw 9 0b111111111+          WS.unsafeWriteBits mw 9 0b000000000+          WS.unsafeWriteBits mw 8 0b11111111+          WS.unsafeWriteBits mw 8 0b00000000+          WS.unsafeWriteBits mw 7 0b1111111+          WS.unsafeWriteBits mw 7 0b0000000+          WS.unsafeWriteBits mw 6 0b111111+          WS.unsafeWriteBits mw 6 0b000000+          WS.unsafeWriteBits mw 5 0b11111+          WS.unsafeWriteBits mw 5 0b00000+          WS.unsafeWriteBits mw 4 0b1111+          WS.unsafeWriteBits mw 4 0b0000+          WS.unsafeWriteBits mw 3 0b111+          WS.unsafeWriteBits mw 3 0b000+          WS.unsafeWriteBits mw 2 0b11+          WS.unsafeWriteBits mw 2 0b00+          WS.unsafeWriteBits mw 1 0b1+          WS.unsafeWriteBits mw 1 0b0+          WS.written mw+    v === DVS.fromList+      [ 0b1111000000111111000000011111110000000011111111000000000111111111+      , 0b0000000000000000000000000000000000000001001100011100001111000001+      ]