{-|

Copyright   : © 2020 Alex Washburn
License     : BSD-3-Clause
Maintainer  : github@recursion.ninja
Stability   : Stable

-}

{-# Language BangPatterns #-}

module Main
    ( main
    ) where

import Control.DeepSeq
import Criterion.Main
import Data.BitVector.LittleEndian
import Data.BitVector.LittleEndian.Instances ()
import Data.Bits
import Data.Hashable
import Data.List (nubBy)
import Data.MonoTraversable
import Operator.Binary.Logical
import Operator.Unary.Logical


{-|
Complete /runtime/ benchmarking suite for the 'BitVector' type.
-}
main :: IO ()
IO ()
main = [Benchmark] -> IO ()
defaultMain [Benchmark
benchmarks]


benchmarks :: Benchmark
benchmarks :: Benchmark
benchmarks = String -> [Benchmark] -> Benchmark
bgroup
    String
"BitVector"
    [ Benchmark
toBitsBench
    , Benchmark
fromBitsBench
    , Benchmark
fromNumberBench
    , Benchmark
toSignedNumberBench
    , Benchmark
toUnsignedNumberBench
    , Benchmark
dimensionBench
    , Benchmark
isZeroVectorBench
    , Benchmark
zeroPopCountBench
    , Benchmark
subRangeBench
    , Benchmark
bitsBench
    , Benchmark
finiteBitsBench
    , Benchmark
hashableBench
    , Benchmark
semigroupBench
    , Benchmark
monoFoldableBench
    ]


-- |
-- This number is the first 10-digit prime in e. It is used as a "no trick up my sleeve" arbitrary large number.
--
-- ceiling ( log_2 (prime) ) === 33
tinyNumber :: Integer
tinyNumber :: Integer
tinyNumber = Integer
7427466391


-- |
-- This number is phi * 10^20. It is used as a "no trick up my sleeve" arbitrary large number.
--
-- ceiling ( log_2 (phi * 10^20) ) === 68
smallNumber :: Integer
smallNumber :: Integer
smallNumber = Integer
161803398874989484820


-- |
-- This number is e * 10^50. It is used as a "no trick up my sleeve" arbitrary large number.
--
-- ceiling ( log_2 (e * 10^50) ) === 168
mediumNumber :: Integer
mediumNumber :: Integer
mediumNumber = Integer
271828182845904523536028747135266249775724709369995


-- |
-- This number is pi * 10^100. It is used as a "no trick up my sleeve" arbitrary large number.
--
-- ceiling ( log_2 (pi * 10^100) ) === 334
largeNumber :: Integer
largeNumber :: Integer
largeNumber =
    Integer
31415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679


-- |
-- This number is -1 * √2 * 10^200. It is used as a "no trick up my sleeve" arbitrary large negative number.
--
-- ceiling ( log_2 (√2 * 10^200) ) === 665
hugeNumber :: Integer
hugeNumber :: Integer
hugeNumber =
    Integer
14142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350138462309122970249248360558507372126441214970999358314132226659275055927557999505011527820605715


toBitsBench :: Benchmark
toBitsBench :: Benchmark
toBitsBench = String -> (BitVector -> [Bool]) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"toBitsNumber" BitVector -> [Bool]
toBits


fromBitsBench :: Benchmark
fromBitsBench :: Benchmark
fromBitsBench = String
-> (Integer -> Integer)
-> (Integer -> Integer -> BitVector)
-> Benchmark
forall a b.
(NFData a, NFData b) =>
String -> (Integer -> a) -> (Integer -> a -> b) -> Benchmark
constantNumberTimeBenchmark String
"fromBits" Integer -> Integer
forall a. a -> a
id Integer -> Integer -> BitVector
forall b. Bits b => Integer -> b -> BitVector
g
    where
        g :: Bits b => Integer -> b -> BitVector
        g :: forall b. Bits b => Integer -> b -> BitVector
g Integer
int b
n =
            let !bitCount :: Int
bitCount = Word -> Int
forall a. Enum a => a -> Int
fromEnum (Word -> Int) -> Word -> Int
forall a b. (a -> b) -> a -> b
$ Integer -> Word
logBase2Word Integer
int
                bitStream :: [Bool]
bitStream = [Bool] -> [Bool]
forall a. NFData a => a -> a
force ([Bool] -> [Bool]) -> [Bool] -> [Bool]
forall a b. (a -> b) -> a -> b
$ (Int -> [Bool]) -> [Int] -> [Bool]
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\Int
i -> [b -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit b
n Int
i]) [Int
0 .. Int
bitCount Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1]
            in  [Bool] -> BitVector
forall (f :: * -> *). Foldable f => f Bool -> BitVector
fromBits [Bool]
bitStream


fromNumberBench :: Benchmark
fromNumberBench :: Benchmark
fromNumberBench = String
-> (Integer -> Integer)
-> (Integer -> Integer -> BitVector)
-> Benchmark
forall a b.
(NFData a, NFData b) =>
String -> (Integer -> a) -> (Integer -> a -> b) -> Benchmark
constantNumberTimeBenchmark String
"fromNumber" Integer -> Integer
forall a. a -> a
id Integer -> Integer -> BitVector
forall i. Integral i => Integer -> i -> BitVector
g
    where
        g :: Integral i => Integer -> i -> BitVector
        g :: forall i. Integral i => Integer -> i -> BitVector
g Integer
int = let !bitCount :: Word
bitCount = Integer -> Word
logBase2Word Integer
int in Word -> i -> BitVector
forall v. Integral v => Word -> v -> BitVector
fromNumber Word
bitCount


toSignedNumberBench :: Benchmark
toSignedNumberBench :: Benchmark
toSignedNumberBench = String -> (BitVector -> Integer) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"toSignedNumber" (BitVector -> Integer
forall a. Num a => BitVector -> a
toSignedNumber :: BitVector -> Integer)


toUnsignedNumberBench :: Benchmark
toUnsignedNumberBench :: Benchmark
toUnsignedNumberBench = String -> (BitVector -> Integer) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"toUnsignedNumber" (BitVector -> Integer
forall a. Num a => BitVector -> a
toUnsignedNumber :: BitVector -> Integer)


dimensionBench :: Benchmark
dimensionBench :: Benchmark
dimensionBench = String
-> (Integer -> Integer)
-> (Integer -> Integer -> Word)
-> Benchmark
forall a b.
(NFData a, NFData b) =>
String -> (Integer -> a) -> (Integer -> a -> b) -> Benchmark
constantNumberTimeBenchmark String
"dimension" Integer -> Integer
forall a. a -> a
id Integer -> Integer -> Word
forall a. Integer -> a -> Word
g
    where
        g :: Integer -> a -> Word
        g :: forall a. Integer -> a -> Word
g Integer
int a
_ =
            let !bitCount :: Word
bitCount  = Integer -> Word
logBase2Word Integer
int
                !bitVector :: BitVector
bitVector = Word -> Integer -> BitVector
forall v. Integral v => Word -> v -> BitVector
fromNumber Word
bitCount Integer
int
            in  BitVector -> Word
dimension BitVector
bitVector


isZeroVectorBench :: Benchmark
isZeroVectorBench :: Benchmark
isZeroVectorBench = String
-> (Integer -> Integer)
-> (Integer -> Integer -> Bool)
-> Benchmark
forall a b.
(NFData a, NFData b) =>
String -> (Integer -> a) -> (Integer -> a -> b) -> Benchmark
constantNumberTimeBenchmark String
"isZeroVector" Integer -> Integer
forall a. a -> a
id Integer -> Integer -> Bool
forall a. Integer -> a -> Bool
g
    where
        g :: Integer -> a -> Bool
        g :: forall a. Integer -> a -> Bool
g Integer
int a
_ =
            let !bitCount :: Word
bitCount  = Integer -> Word
logBase2Word Integer
int
                !bitVector :: BitVector
bitVector = Word -> Integer -> BitVector
forall v. Integral v => Word -> v -> BitVector
fromNumber Word
bitCount Integer
int
            in  BitVector -> Bool
isZeroVector BitVector
bitVector


zeroPopCountBench :: Benchmark
zeroPopCountBench :: Benchmark
zeroPopCountBench = String
-> (Integer -> Integer)
-> (Integer -> Integer -> Bool)
-> Benchmark
forall a b.
(NFData a, NFData b) =>
String -> (Integer -> a) -> (Integer -> a -> b) -> Benchmark
constantNumberTimeBenchmark String
"popCount is zero" Integer -> Integer
forall a. a -> a
id Integer -> Integer -> Bool
forall a. Integer -> a -> Bool
g
    where
        g :: Integer -> a -> Bool
        g :: forall a. Integer -> a -> Bool
g Integer
int a
_ =
            let !bitCount :: Word
bitCount  = Integer -> Word
logBase2Word Integer
int
                !bitVector :: BitVector
bitVector = Word -> Integer -> BitVector
forall v. Integral v => Word -> v -> BitVector
fromNumber Word
bitCount Integer
int
            in  ((Int
0 ==) (Int -> Bool) -> (BitVector -> Int) -> BitVector -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BitVector -> Int
forall a. Bits a => a -> Int
popCount) BitVector
bitVector


subRangeBench :: Benchmark
subRangeBench :: Benchmark
subRangeBench = String
-> (Integer -> Integer)
-> (Integer -> Integer -> BitVector)
-> Benchmark
forall a b.
(NFData a, NFData b) =>
String -> (Integer -> a) -> (Integer -> a -> b) -> Benchmark
constantNumberTimeBenchmark String
"subRange" Integer -> Integer
forall a. a -> a
id Integer -> Integer -> BitVector
forall a. Integer -> a -> BitVector
g
    where
        g :: Integer -> a -> BitVector
        g :: forall a. Integer -> a -> BitVector
g Integer
int a
_ =
            let !bitCount :: Word
bitCount   = Integer -> Word
logBase2Word Integer
int
                !bitVector :: BitVector
bitVector  = Word -> Integer -> BitVector
forall v. Integral v => Word -> v -> BitVector
fromNumber Word
bitCount Integer
int
                !lowerBound :: Word
lowerBound = Word
bitCount Word -> Word -> Word
forall a. Integral a => a -> a -> a
`div` Word
4
                !upperBound :: Word
upperBound = (Word
bitCount Word -> Word -> Word
forall a. Num a => a -> a -> a
* Word
3) Word -> Word -> Word
forall a. Integral a => a -> a -> a
`div` Word
4
            in  (Word
lowerBound, Word
upperBound) (Word, Word) -> BitVector -> BitVector
`subRange` BitVector
bitVector


bitsBench :: Benchmark
bitsBench :: Benchmark
bitsBench = String -> [Benchmark] -> Benchmark
bgroup
    String
"Bits"
    [ String -> (BitVector -> BitVector -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> BitVector -> a) -> Benchmark
binaryBenchmark String
"(.|.)" BitVector -> BitVector -> BitVector
forall a. Bits a => a -> a -> a
(.|.)
    , String -> (BitVector -> BitVector -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> BitVector -> a) -> Benchmark
binaryBenchmark String
"(.&.)" BitVector -> BitVector -> BitVector
forall a. Bits a => a -> a -> a
(.&.)
    , String -> (BitVector -> BitVector -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> BitVector -> a) -> Benchmark
binaryBenchmark String
"xor"   BitVector -> BitVector -> BitVector
forall a. Bits a => a -> a -> a
xor
    , String -> (BitVector -> BitVector) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"complement"   BitVector -> BitVector
forall a. Bits a => a -> a
complement
--    ,    unaryBenchmark "bitSize"       bitSize
    , String -> (BitVector -> Maybe Int) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"bitSizeMaybe" BitVector -> Maybe Int
forall a. Bits a => a -> Maybe Int
bitSizeMaybe
    , String -> (BitVector -> Bool) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"isSigned"     BitVector -> Bool
forall a. Bits a => a -> Bool
isSigned
    , String -> (BitVector -> Int) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"popCount"     BitVector -> Int
forall a. Bits a => a -> Int
popCount
    , String -> (BitVector -> Int -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"shift"         BitVector -> Int -> BitVector
forall a. Bits a => a -> Int -> a
shift
    , String -> (BitVector -> Int -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"shiftL"        BitVector -> Int -> BitVector
forall a. Bits a => a -> Int -> a
shiftL
    , String -> (BitVector -> Int -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"shiftR"        BitVector -> Int -> BitVector
forall a. Bits a => a -> Int -> a
shiftR
    , String -> (BitVector -> Int -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"rotate"        BitVector -> Int -> BitVector
forall a. Bits a => a -> Int -> a
rotate
    , String -> (BitVector -> Int -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"rotateL"       BitVector -> Int -> BitVector
forall a. Bits a => a -> Int -> a
rotateL
    , String -> (BitVector -> Int -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"rotateR"       BitVector -> Int -> BitVector
forall a. Bits a => a -> Int -> a
rotateR
    , String -> (BitVector -> Int -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"setBit"        BitVector -> Int -> BitVector
forall a. Bits a => a -> Int -> a
setBit
    , String -> (BitVector -> Int -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"clearBit"      BitVector -> Int -> BitVector
forall a. Bits a => a -> Int -> a
clearBit
    , String -> (BitVector -> Int -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"complementBit" BitVector -> Int -> BitVector
forall a. Bits a => a -> Int -> a
complementBit
    , String -> (BitVector -> Int -> Bool) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"testBit"       BitVector -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit
    ]


finiteBitsBench :: Benchmark
finiteBitsBench :: Benchmark
finiteBitsBench = String -> [Benchmark] -> Benchmark
bgroup
    String
"FiniteBits"
    [ String -> (BitVector -> Int) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"finiteBitSize"      BitVector -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize
    , String -> (BitVector -> Int) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"countLeadingZeros"  BitVector -> Int
forall b. FiniteBits b => b -> Int
countLeadingZeros
    , String -> (BitVector -> Int) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"countTrailingZeros" BitVector -> Int
forall b. FiniteBits b => b -> Int
countLeadingZeros
    ]


hashableBench :: Benchmark
hashableBench :: Benchmark
hashableBench =
    String -> [Benchmark] -> Benchmark
bgroup String
"Hashable" [String -> (BitVector -> Int) -> Benchmark
forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
"hash" BitVector -> Int
forall a. Hashable a => a -> Int
hash, String -> (BitVector -> Int -> Int) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
"hashWithSalt" ((Int -> BitVector -> Int) -> BitVector -> Int -> Int
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> BitVector -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt)]


semigroupBench :: Benchmark
semigroupBench :: Benchmark
semigroupBench = String -> [Benchmark] -> Benchmark
bgroup String
"Semigroup" [String -> (BitVector -> BitVector -> BitVector) -> Benchmark
forall a.
NFData a =>
String -> (BitVector -> BitVector -> a) -> Benchmark
binaryBenchmark String
"(<>)" BitVector -> BitVector -> BitVector
forall a. Semigroup a => a -> a -> a
(<>)]


monoFoldableBench :: Benchmark
monoFoldableBench :: Benchmark
monoFoldableBench = String -> [Benchmark] -> Benchmark
bgroup
    String
"MonoFoldable"
    [ String
-> ((Bool -> Bool -> Bool) -> BitVector -> Bool) -> Benchmark
fold1Benchmark String
"ofoldr1Ex"  (Bool -> Bool -> Bool) -> BitVector -> Bool
(Element BitVector -> Element BitVector -> Element BitVector)
-> BitVector -> Element BitVector
forall mono.
MonoFoldable mono =>
(Element mono -> Element mono -> Element mono)
-> mono -> Element mono
ofoldr1Ex
    , String
-> ((Bool -> Bool -> Bool) -> BitVector -> Bool) -> Benchmark
fold1Benchmark String
"ofoldl1Ex'" (Bool -> Bool -> Bool) -> BitVector -> Bool
(Element BitVector -> Element BitVector -> Element BitVector)
-> BitVector -> Element BitVector
forall mono.
MonoFoldable mono =>
(Element mono -> Element mono -> Element mono)
-> mono -> Element mono
ofoldl1Ex'
    , String -> ((Bool -> Bool) -> BitVector -> BitVector) -> Benchmark
mapBenchmark String
"omap" (Bool -> Bool) -> BitVector -> BitVector
(Element BitVector -> Element BitVector) -> BitVector -> BitVector
forall mono.
MonoFunctor mono =>
(Element mono -> Element mono) -> mono -> mono
omap
    , String -> ((Bool -> Bool) -> BitVector -> Bool) -> Benchmark
queryBenchmark String
"oall" (Bool -> Bool) -> BitVector -> Bool
(Element BitVector -> Bool) -> BitVector -> Bool
forall mono.
MonoFoldable mono =>
(Element mono -> Bool) -> mono -> Bool
oall
    , String -> ((Bool -> Bool) -> BitVector -> Bool) -> Benchmark
queryBenchmark String
"oany" (Bool -> Bool) -> BitVector -> Bool
(Element BitVector -> Bool) -> BitVector -> Bool
forall mono.
MonoFoldable mono =>
(Element mono -> Bool) -> mono -> Bool
oany
    ]


constantNumberTimeBenchmark
    :: (NFData a, NFData b) => String -> (Integer -> a) -> (Integer -> a -> b) -> Benchmark
constantNumberTimeBenchmark :: forall a b.
(NFData a, NFData b) =>
String -> (Integer -> a) -> (Integer -> a -> b) -> Benchmark
constantNumberTimeBenchmark String
label Integer -> a
f Integer -> a -> b
g = String -> [Benchmark] -> Benchmark
bgroup String
label ([Benchmark] -> Benchmark) -> [Benchmark] -> Benchmark
forall a b. (a -> b) -> a -> b
$ (String, Integer) -> Benchmark
generateBenchmark ((String, Integer) -> Benchmark)
-> [(String, Integer)] -> [Benchmark]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, Integer)]
magicNumbers
    where
        generateBenchmark :: (String, Integer) -> Benchmark
generateBenchmark (String
intLabel, Integer
intValue) = String -> Benchmarkable -> Benchmark
bench String
intLabel (Benchmarkable -> Benchmark) -> Benchmarkable -> Benchmark
forall a b. (a -> b) -> a -> b
$ (a -> b) -> a -> Benchmarkable
forall b a. NFData b => (a -> b) -> a -> Benchmarkable
nf a -> b
app a
target
            where
                !target :: a
target = a -> a
forall a. NFData a => a -> a
force (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ Integer -> a
f Integer
intValue
                !app :: a -> b
app    = Integer -> a -> b
g Integer
intValue


unaryBenchmark :: NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark :: forall a. NFData a => String -> (BitVector -> a) -> Benchmark
unaryBenchmark String
label BitVector -> a
f = String -> [Benchmark] -> Benchmark
bgroup String
label ([Benchmark] -> Benchmark) -> [Benchmark] -> Benchmark
forall a b. (a -> b) -> a -> b
$ (String, Integer) -> Benchmark
generateBenchmark ((String, Integer) -> Benchmark)
-> [(String, Integer)] -> [Benchmark]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, Integer)]
magicNumbers
    where
        generateBenchmark :: (String, Integer) -> Benchmark
generateBenchmark (String
intLabel, Integer
intValue) = String -> Benchmarkable -> Benchmark
bench String
intLabel (Benchmarkable -> Benchmark) -> Benchmarkable -> Benchmark
forall a b. (a -> b) -> a -> b
$ (BitVector -> a) -> BitVector -> Benchmarkable
forall b a. NFData b => (a -> b) -> a -> Benchmarkable
nf BitVector -> a
f BitVector
target where !target :: BitVector
target = Integer -> BitVector
bvGen Integer
intValue


binaryBenchmark :: NFData a => String -> (BitVector -> BitVector -> a) -> Benchmark
binaryBenchmark :: forall a.
NFData a =>
String -> (BitVector -> BitVector -> a) -> Benchmark
binaryBenchmark String
label BitVector -> BitVector -> a
op = String -> [Benchmark] -> Benchmark
bgroup String
label ([Benchmark] -> Benchmark) -> [Benchmark] -> Benchmark
forall a b. (a -> b) -> a -> b
$ (String, Integer, String, Integer) -> Benchmark
generateBenchmark ((String, Integer, String, Integer) -> Benchmark)
-> [(String, Integer, String, Integer)] -> [Benchmark]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, Integer, String, Integer)]
combinations
    where
        generateBenchmark :: (String, Integer, String, Integer) -> Benchmark
generateBenchmark (String
intLabel1, Integer
intValue1, String
intLabel2, Integer
intValue2) = String -> Benchmarkable -> Benchmark
bench String
message (Benchmarkable -> Benchmark) -> Benchmarkable -> Benchmark
forall a b. (a -> b) -> a -> b
$ (a -> a) -> a -> Benchmarkable
forall b a. NFData b => (a -> b) -> a -> Benchmarkable
nf a -> a
forall a. a -> a
id a
target
            where
                message :: String
message = [String] -> String
unwords [String
intLabel1, String
"`op`", String
intLabel2]
                !lhs :: BitVector
lhs    = Integer -> BitVector
bvGen Integer
intValue1
                !rhs :: BitVector
rhs    = Integer -> BitVector
bvGen Integer
intValue2
                target :: a
target  = BitVector
lhs BitVector -> BitVector -> a
`op` BitVector
rhs
        combinations :: [(String, Integer, String, Integer)]
combinations = [ (String
a, Integer
b, String
c, Integer
d) | (String
a, Integer
b) <- [(String, Integer)]
magicNumbers, (String
c, Integer
d) <- [(String, Integer)]
magicNumbers, Integer
b Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
d ]


indexingBenchmark :: NFData a => String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark :: forall a.
NFData a =>
String -> (BitVector -> Int -> a) -> Benchmark
indexingBenchmark String
label BitVector -> Int -> a
op = String -> [Benchmark] -> Benchmark
bgroup String
label ([Benchmark] -> Benchmark) -> [Benchmark] -> Benchmark
forall a b. (a -> b) -> a -> b
$ (String, Integer, String, Int) -> Benchmark
generateBenchmark ((String, Integer, String, Int) -> Benchmark)
-> [(String, Integer, String, Int)] -> [Benchmark]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, Integer, String, Int)]
combinations
    where
        generateBenchmark :: (String, Integer, String, Int) -> Benchmark
generateBenchmark (String
intLabel, Integer
intValue, String
idxLabel, Int
idxValue) = String -> Benchmarkable -> Benchmark
bench String
message (Benchmarkable -> Benchmark) -> Benchmarkable -> Benchmark
forall a b. (a -> b) -> a -> b
$ (BitVector -> a) -> BitVector -> Benchmarkable
forall b a. NFData b => (a -> b) -> a -> Benchmarkable
nf BitVector -> a
app BitVector
target
            where
                message :: String
message = [String] -> String
unwords [String
intLabel, String
"@", String
idxLabel String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
":" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
idxValue]
                !target :: BitVector
target = Integer -> BitVector
bvGen Integer
intValue
                app :: BitVector -> a
app     = (BitVector -> Int -> a
`op` Int
idxValue)

        combinations :: [(String, Integer, String, Int)]
combinations = do
            (String
a, Integer
b) <- [(String, Integer)]
magicNumbers
            let bitCount :: Int
bitCount = Word -> Int
forall a. Enum a => a -> Int
fromEnum (Word -> Int) -> Word -> Int
forall a b. (a -> b) -> a -> b
$ Integer -> Word
logBase2Word Integer
b
            (String
c, Int
d) <- ((String, Int) -> (String, Int) -> Bool)
-> [(String, Int)] -> [(String, Int)]
forall a. (a -> a -> Bool) -> [a] -> [a]
nubBy
                (\(String, Int)
x (String, Int)
y -> (String, Int) -> Int
forall a b. (a, b) -> b
snd (String, Int)
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== (String, Int) -> Int
forall a b. (a, b) -> b
snd (String, Int)
y)
                [(String
"first", Int
0), (String
"middle", Int
bitCount Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2), (String
"last", Int
bitCount Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)]
            let e :: (String, Integer, String, Int)
e = (String, Integer, String, Int) -> (String, Integer, String, Int)
forall a. NFData a => a -> a
force (String
a, Integer
b, String
c, Int
d)
            [(String, Integer, String, Int)
e]


fold1Benchmark :: String -> ((Bool -> Bool -> Bool) -> BitVector -> Bool) -> Benchmark
fold1Benchmark :: String
-> ((Bool -> Bool -> Bool) -> BitVector -> Bool) -> Benchmark
fold1Benchmark String
label (Bool -> Bool -> Bool) -> BitVector -> Bool
fold1Fun = String -> [Benchmark] -> Benchmark
bgroup String
label ([Benchmark] -> Benchmark) -> [Benchmark] -> Benchmark
forall a b. (a -> b) -> a -> b
$ (String, Integer, BinaryLogicalOperator) -> Benchmark
generateBenchmark ((String, Integer, BinaryLogicalOperator) -> Benchmark)
-> [(String, Integer, BinaryLogicalOperator)] -> [Benchmark]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, Integer, BinaryLogicalOperator)]
combinations
    where
        generateBenchmark :: (String, Integer, BinaryLogicalOperator) -> Benchmark
generateBenchmark (String
intLabel, Integer
intValue, BinaryLogicalOperator
lOp) = String -> Benchmarkable -> Benchmark
bench String
message (Benchmarkable -> Benchmark) -> Benchmarkable -> Benchmark
forall a b. (a -> b) -> a -> b
$ (Bool -> Bool) -> Bool -> Benchmarkable
forall b a. NFData b => (a -> b) -> a -> Benchmarkable
nf Bool -> Bool
forall a. a -> a
id Bool
target
            where
                message :: String
message = [String] -> String
unwords [String
"fold1", BinaryLogicalOperator -> String
getBinaryLogicalSymbol BinaryLogicalOperator
lOp, String
intLabel]
                !op :: Bool -> Bool -> Bool
op     = BinaryLogicalOperator -> Bool -> Bool -> Bool
getBinaryLogicalOperator BinaryLogicalOperator
lOp
                !bv :: BitVector
bv     = Integer -> BitVector
bvGen Integer
intValue
                target :: Bool
target  = (Bool -> Bool -> Bool) -> BitVector -> Bool
fold1Fun Bool -> Bool -> Bool
op BitVector
bv
        combinations :: [(String, Integer, BinaryLogicalOperator)]
combinations = [ (String
a, Integer
b, BinaryLogicalOperator
op) | (String
a, Integer
b) <- [(String, Integer)]
magicNumbers, BinaryLogicalOperator
op <- [BinaryLogicalOperator
forall a. Bounded a => a
minBound .. BinaryLogicalOperator
forall a. Bounded a => a
maxBound] ]


mapBenchmark :: String -> ((Bool -> Bool) -> BitVector -> BitVector) -> Benchmark
mapBenchmark :: String -> ((Bool -> Bool) -> BitVector -> BitVector) -> Benchmark
mapBenchmark String
label (Bool -> Bool) -> BitVector -> BitVector
mapFun = String -> [Benchmark] -> Benchmark
bgroup String
label ([Benchmark] -> Benchmark) -> [Benchmark] -> Benchmark
forall a b. (a -> b) -> a -> b
$ (String, Integer, UnaryLogicalOperator) -> Benchmark
generateBenchmark ((String, Integer, UnaryLogicalOperator) -> Benchmark)
-> [(String, Integer, UnaryLogicalOperator)] -> [Benchmark]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, Integer, UnaryLogicalOperator)]
combinations
    where
        generateBenchmark :: (String, Integer, UnaryLogicalOperator) -> Benchmark
generateBenchmark (String
intLabel, Integer
intValue, UnaryLogicalOperator
lOp) = String -> Benchmarkable -> Benchmark
bench String
message (Benchmarkable -> Benchmark) -> Benchmarkable -> Benchmark
forall a b. (a -> b) -> a -> b
$ (BitVector -> BitVector) -> BitVector -> Benchmarkable
forall b a. NFData b => (a -> b) -> a -> Benchmarkable
nf BitVector -> BitVector
forall a. a -> a
id BitVector
target
            where
                message :: String
message = [String] -> String
unwords [String
"map", UnaryLogicalOperator -> String
getUnaryLogicalSymbol UnaryLogicalOperator
lOp, String
intLabel]
                !op :: Bool -> Bool
op     = UnaryLogicalOperator -> Bool -> Bool
getUnaryLogicalOperator UnaryLogicalOperator
lOp
                !bv :: BitVector
bv     = Integer -> BitVector
bvGen Integer
intValue
                target :: BitVector
target  = (Bool -> Bool) -> BitVector -> BitVector
mapFun Bool -> Bool
op BitVector
bv
        combinations :: [(String, Integer, UnaryLogicalOperator)]
combinations = [ (String
a, Integer
b, UnaryLogicalOperator
op) | (String
a, Integer
b) <- [(String, Integer)]
magicNumbers, UnaryLogicalOperator
op <- [UnaryLogicalOperator
forall a. Bounded a => a
minBound .. UnaryLogicalOperator
forall a. Bounded a => a
maxBound] ]


queryBenchmark :: String -> ((Bool -> Bool) -> BitVector -> Bool) -> Benchmark
queryBenchmark :: String -> ((Bool -> Bool) -> BitVector -> Bool) -> Benchmark
queryBenchmark String
label (Bool -> Bool) -> BitVector -> Bool
mapFun = String -> [Benchmark] -> Benchmark
bgroup String
label ([Benchmark] -> Benchmark) -> [Benchmark] -> Benchmark
forall a b. (a -> b) -> a -> b
$ (String, Integer, UnaryLogicalOperator) -> Benchmark
generateBenchmark ((String, Integer, UnaryLogicalOperator) -> Benchmark)
-> [(String, Integer, UnaryLogicalOperator)] -> [Benchmark]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, Integer, UnaryLogicalOperator)]
combinations
    where
        generateBenchmark :: (String, Integer, UnaryLogicalOperator) -> Benchmark
generateBenchmark (String
intLabel, Integer
intValue, UnaryLogicalOperator
lOp) = String -> Benchmarkable -> Benchmark
bench String
message (Benchmarkable -> Benchmark) -> Benchmarkable -> Benchmark
forall a b. (a -> b) -> a -> b
$ (Bool -> Bool) -> Bool -> Benchmarkable
forall b a. NFData b => (a -> b) -> a -> Benchmarkable
nf Bool -> Bool
forall a. a -> a
id Bool
target
            where
                message :: String
message = [String] -> String
unwords [String
"query", UnaryLogicalOperator -> String
getUnaryLogicalSymbol UnaryLogicalOperator
lOp, String
intLabel]
                !op :: Bool -> Bool
op     = UnaryLogicalOperator -> Bool -> Bool
getUnaryLogicalOperator UnaryLogicalOperator
lOp
                !bv :: BitVector
bv     = Integer -> BitVector
bvGen Integer
intValue
                target :: Bool
target  = (Bool -> Bool) -> BitVector -> Bool
mapFun Bool -> Bool
op BitVector
bv
        combinations :: [(String, Integer, UnaryLogicalOperator)]
combinations = [ (String
a, Integer
b, UnaryLogicalOperator
op) | (String
a, Integer
b) <- [(String, Integer)]
magicNumbers, UnaryLogicalOperator
op <- [UnaryLogicalOperator
forall a. Bounded a => a
minBound .. UnaryLogicalOperator
forall a. Bounded a => a
maxBound] ]


bvGen :: Integer -> BitVector
bvGen :: Integer -> BitVector
bvGen Integer
x = BitVector -> BitVector
forall a. NFData a => a -> a
force (BitVector -> BitVector) -> BitVector -> BitVector
forall a b. (a -> b) -> a -> b
$ Word -> Integer -> BitVector
forall v. Integral v => Word -> v -> BitVector
fromNumber (Integer -> Word
logBase2Word Integer
x) Integer
x


logBase2Word :: Integer -> Word
logBase2Word :: Integer -> Word
logBase2Word = Word -> Word
forall a. Enum a => a -> a
succ (Word -> Word) -> (Integer -> Word) -> Integer -> Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Word
forall a. Enum a => a -> a
succ (Word -> Word) -> (Integer -> Word) -> Integer -> Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Word
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
ceiling (Double -> Word) -> (Integer -> Double) -> Integer -> Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Double -> Double
forall a. Floating a => a -> a -> a
logBase (Double
2.0 :: Double) (Double -> Double) -> (Integer -> Double) -> Integer -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Double) -> (Integer -> Integer) -> Integer -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer
forall a. Num a => a -> a
abs


magicNumbers :: [(String, Integer)]
magicNumbers :: [(String, Integer)]
magicNumbers =
    [ (String
"zero"  , Integer
0)
    , (String
"tiny"  , Integer
tinyNumber)
    , (String
"small" , Integer
smallNumber)
    , (String
"medium", Integer
mediumNumber)
    , (String
"large" , Integer
largeNumber)
    , (String
"huge"  , Integer
hugeNumber)
    ]