Merge https://github.com/haskell/bytestring
authorSean <burton.seanr@gmail.com>
Mon, 2 Nov 2015 15:33:27 +0000 (15:33 +0000)
committerSean <burton.seanr@gmail.com>
Mon, 2 Nov 2015 15:33:27 +0000 (15:33 +0000)
Conflicts:
Data/ByteString.hs
bench/BenchAll.hs

1  2 
Data/ByteString.hs
bench/BenchAll.hs

Simple merge
@@@ -38,10 -38,8 +38,9 @@@ import qualified "bytestring" Data.Byte
  
  import           Foreign
  
- import           Paths_bench_bytestring
+ import System.Random
  
- import           System.Random
 +
  ------------------------------------------------------------------------------
  -- Benchmark support
  ------------------------------------------------------------------------------
@@@ -153,42 -151,30 +152,64 @@@ benchIntEncodingB n0 
        | n <= 0    = return op
        | otherwise = PI.runB w n op >>= loop (n - 1)
  
- easySubstrings, randomSubstrings :: Int -> Int -> (S.ByteString, S.ByteString)
- hardSubstrings, pathologicalSubstrings :: Int ->
-                                           Int -> (S.ByteString, S.ByteString)
+ hashInt :: Int -> Int
+ hashInt x = iterate step x !! 10
+   where
+     step a = e
+       where b = (a `xor` 61) `xor` (a `shiftR` 16)
+             c = b + (b `shiftL` 3)
+             d = c `xor` (c `shiftR` 4)
+             e = d * 0x27d4eb2d
+             f = e `xor` (e `shiftR` 15)
  
 -hashWord8 :: Word8 -> Word8
 -hashWord8 = fromIntegral . hashInt . fromIntegral
 -
  w :: Int -> Word8
  w = fromIntegral
  
 -  where  step (k, g)
 -           | k >= 10000 = Nothing
 -           | otherwise  = let (x, g') = random g in Just (x, (k + 1, g'))
 -         randomLazy = L.unfoldr step
++hashWord8 :: Word8 -> Word8
++hashWord8 = fromIntegral . hashInt . w
++
+ partitionStrict p = nf (S.partition p) . randomStrict $ mkStdGen 98423098
+   where randomStrict = fst . S.unfoldrN 10000 (Just . random)
+ partitionLazy p = nf (L.partition p) . randomLazy $ (0, mkStdGen 98423098)
++  where step (k, g)
++          | k >= 10000 = Nothing
++          | otherwise  = let (x, g') = random g in Just (x, (k + 1, g'))
++        randomLazy = L.unfoldr step
++
++easySubstrings, randomSubstrings :: Int -> Int -> (S.ByteString, S.ByteString)
++hardSubstrings, pathologicalSubstrings :: Int ->
++                                          Int -> (S.ByteString, S.ByteString)
++
 +{-# INLINE easySubstrings #-}
 +easySubstrings n h = (S.replicate n $ w 1,
 +                      S.replicate h $ w 0)
 +
 +{-# INLINE randomSubstrings #-}
 +randomSubstrings n h = (f 48278379 n, f 98403980 h)
 +  where
 +    next' g = let (x, g') = next g in (w x, g')
 +    f g l = fst $ S.unfoldrN l (Just . next') (mkStdGen g)
 +
 +{-# INLINE hardSubstrings #-}
 +hardSubstrings n h = (f 48278379 n, f 98403980 h)
 +  where
 +    next' g = let (x, g') = next g
 +              in (w $ x `mod` 4, g')
 +    f g l = fst $ S.unfoldrN l (Just . next') (mkStdGen g)
 +
 +{-# INLINE pathologicalSubstrings #-}
 +pathologicalSubstrings n h =
 +  (S.replicate n (w 0),
 +   S.concat . replicate (h `div` n) $ S.replicate (n - 1) (w 0) `S.snoc` w 1)
 +
 +htmlSubstrings :: S.ByteString -> Int -> Int -> IO (S.ByteString, S.ByteString)
 +htmlSubstrings s n h =
 +    do i <- randomRIO (0, l - n)
 +       return (S.take n . S.drop i $ s', s')
 +  where
 +    s' = S.take h s
 +    l  = S.length s'
  
  -- benchmarks
  -------------