bitwise-0.1.0.1: fast multi-dimensional unboxed bit packed Bool arrays

Portability portable unstable claude@mathr.co.uk Safe-Inferred

Data.Bits.Bitwise

Contents

Description

Lifting boolean operations on `Bool` to bitwise operations on `Bits`.

Packing bits into words, and unpacking words into bits.

Synopsis

# Boolean operations lifted to bitwise operations.

repeat :: (Num b, Bits b) => Bool -> bSource

Lift a boolean constant to a bitwise constant.

Arguments

 :: (Num b, Bits b) => (Bool -> Bool) operation -> b -> b

Lift a unary boolean operation to a bitwise operation.

The implementation is by exhaustive input/output case analysis: thus the operation provided must be total.

Arguments

 :: (Num b, Bits b) => (Bool -> Bool -> Bool) operation -> b -> b -> b

Lift a binary boolean operation to a bitwise operation.

The implementation is by exhaustive input/output case analysis: thus the operation provided must be total.

or :: (Num b, Bits b) => b -> BoolSource

True when any bit is set.

and :: (Num b, Bits b) => b -> BoolSource

True when all bits are set.

Arguments

 :: (Num b, Bits b) => (Bool -> Bool) predicate -> b -> Bool

True when the predicate is true for any bit.

Arguments

 :: (Num b, Bits b) => (Bool -> Bool) predicate -> b -> Bool

True when the predicate is true for all bits.

isUniform :: (Num b, Bits b) => b -> Maybe BoolSource

Determine if a `Bits` is all 1s, all 0s, or neither.

# Splitting/joining `Bits` to/from (lsb, msb).

Arguments

 :: (Num b, Bits b) => Int count -> b

A mask with count least significant bits set.

Arguments

 :: (Num b, Bits b) => Int split point -> b word -> (b, b) (lsb, msb)

Split a word into (lsb, msb). Ensures lsb has no set bits above the split point.

Arguments

 :: (Num b, Bits b) => Int join point -> b least significant bits -> b most significant bits -> b word

Join lsb with msb to make a word. Assumes lsb has no set bits above the join point.

fromBool :: (Num b, Bits b) => Bool -> bSource

The least significant bit.

# (Un)packing `Bits` to/from lists of `Bool`.

Arguments

 :: (Num b, Bits b) => [Bool] [least significant bit, ..., most significant bit] -> b

Convert a little-endian list of bits to `Bits`.

Arguments

 :: (Num b, Bits b) => b -> [Bool] [least significant bit, ..., most significant bit]

Convert a `Bits` (with a defined `bitSize`) to a list of bits, in little-endian order.

Arguments

 :: (Num b, Bits b) => [Bool] [most significant bit, ..., least significant bit] -> b

Convert a big-endian list of bits to `Bits`.

Arguments

 :: (Num b, Bits b) => b -> [Bool] [most significant bit, ..., least significant bit]

Convert a `Bits` (with a defined `bitSize`) to a list of bits, in big-endian order.

# (Un)packing `Word8` to/from 8-tuples of `Bool`.

Arguments

 :: Bool least significant bit -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool most significant bit -> Word8

Pack bits into a byte in little-endian order.

Arguments

 :: Word8 -> (Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool) (least significant bit, ..., most significant bit)

Extract the bits from a byte in little-endian order.

Arguments

 :: Bool most significant bit -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool least significant bit -> Word8

Pack bits into a byte in big-endian order.

Arguments

 :: Word8 -> (Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool) (most significant bit, ..., least significant bit)

Extract the bits from a byte in big-endian order.