Data.Array.BitArray.IO

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

Copyright | (c) Claude Heiland-Allen 20122018
License | BSD3
Maintainer | claude@mathr.co.uk
Stability | unstable
Portability | portable
Safe Haskell | None
Language | Haskell2010

Data.Array.BitArray.IO

Contents

- MArray-like interface.
- Conversion to/from immutable bit arrays.
- Construction
- Short-circuiting reductions.
- Aggregate operations.
- Unsafe.

Description

Unboxed mutable bit arrays in the `IO` monad.

Synopsis

- data IOBitArray i
- getBounds :: Ix i => IOBitArray i -> IO (i, i)
- newArray :: Ix i => (i, i) -> Bool -> IO (IOBitArray i)
- newArray_ :: Ix i => (i, i) -> IO (IOBitArray i)
- newListArray :: Ix i => (i, i) -> [Bool] -> IO (IOBitArray i)
- readArray :: Ix i => IOBitArray i -> i -> IO Bool
- writeArray :: Ix i => IOBitArray i -> i -> Bool -> IO ()
- mapArray :: Ix i => (Bool -> Bool) -> IOBitArray i -> IO (IOBitArray i)
- mapIndices :: (Ix i, Ix j) => (i, i) -> (i -> j) -> IOBitArray j -> IO (IOBitArray i)
- getElems :: Ix i => IOBitArray i -> IO [Bool]
- getAssocs :: Ix i => IOBitArray i -> IO [(i, Bool)]
- freeze :: Ix i => IOBitArray i -> IO (BitArray i)
- thaw :: Ix i => BitArray i -> IO (IOBitArray i)
- copy :: Ix i => IOBitArray i -> IO (IOBitArray i)
- fill :: Ix i => IOBitArray i -> Bool -> IO ()
- or :: Ix i => IOBitArray i -> IO Bool
- and :: Ix i => IOBitArray i -> IO Bool
- isUniform :: Ix i => IOBitArray i -> IO (Maybe Bool)
- elemIndex :: Bool -> IOBitArray Int -> IO (Maybe Int)
- fold :: Ix i => (Bool -> Bool -> Bool) -> IOBitArray i -> IO (Maybe Bool)
- map :: Ix i => (Bool -> Bool) -> IOBitArray i -> IO (IOBitArray i)
- zipWith :: Ix i => (Bool -> Bool -> Bool) -> IOBitArray i -> IOBitArray i -> IO (IOBitArray i)
- popCount :: Ix i => IOBitArray i -> IO Int
- unsafeReadArray :: Ix i => IOBitArray i -> i -> IO Bool
- unsafeGetElems :: Ix i => IOBitArray i -> IO [Bool]
- unsafeFreeze :: Ix i => IOBitArray i -> IO (BitArray i)
- unsafeThaw :: Ix i => BitArray i -> IO (IOBitArray i)

# Documentation

data IOBitArray i #

The type of mutable bit arrays in the `IO` monad.

# MArray-like interface.

getBounds :: Ix i => IOBitArray i -> IO (i, i) #

Get the bounds of a bit array.

newArray #

Arguments

:: Ix i |
=> (i, i) | bounds
-> Bool | initial value
-> IO (IOBitArray i) |

Create a new array filled with an initial value.

newArray_ #

Arguments

:: Ix i |
=> (i, i) | bounds
-> IO (IOBitArray i) |

Create a new array filled with unspecified initial values.

newListArray #

Arguments

:: Ix i |
=> (i, i) | bounds
-> [Bool] | elems
-> IO (IOBitArray i) |

Create a new array filled with values from a list.

readArray :: Ix i => IOBitArray i -> i -> IO Bool #

Read from an array at an index.

writeArray :: Ix i => IOBitArray i -> i -> Bool -> IO () #

Write to an array at an index.

mapArray :: Ix i => (Bool -> Bool) -> IOBitArray i -> IO (IOBitArray i) #

Alias for `map`.

mapIndices #

Arguments

:: (Ix i, Ix j) |
=> (i, i) | new bounds
-> (i -> j) | index transformation
-> IOBitArray j | source array
-> IO (IOBitArray i) |

Create a new array by reading from another.

getElems :: Ix i => IOBitArray i -> IO [Bool] #

Get a list of all elements of an array.

getAssocs :: Ix i => IOBitArray i -> IO [(i, Bool)] #

Get a list of all (index, element) pairs.

# Conversion to/from immutable bit arrays.

freeze :: Ix i => IOBitArray i -> IO (BitArray i) #

Snapshot the array into an immutable form.

thaw :: Ix i => BitArray i -> IO (IOBitArray i) #

Convert an array from immutable form.

# Construction

copy :: Ix i => IOBitArray i -> IO (IOBitArray i) #

Copy an array.

fill :: Ix i => IOBitArray i -> Bool -> IO () #

Fill an array with a uniform value.

# Short-circuiting reductions.

or :: Ix i => IOBitArray i -> IO Bool #

Short-circuit bitwise reduction: True when any bit is True.

and :: Ix i => IOBitArray i -> IO Bool #

Short-circuit bitwise reduction: False when any bit is False.

isUniform :: Ix i => IOBitArray i -> IO (Maybe Bool) #

Short-circuit bitwise reduction: `Nothing` when any bits differ, `Just` when all bits are the same.

elemIndex :: Bool -> IOBitArray Int -> IO (Maybe Int) #

Look up index of first matching bit.

Note that the index type is limited to Int because there is no `unindex` method in the `Ix` class.

# Aggregate operations.

fold #

Arguments

:: Ix i |
=> (Bool -> Bool -> Bool) | operator
-> IOBitArray i |
-> IO (Maybe Bool) |

Bitwise reduction with an associative commutative boolean operator. Implementation lifts from `Bool` to `Bits` and folds large chunks at a time. Each bit is used as a source exactly once.

map :: Ix i => (Bool -> Bool) -> IOBitArray i -> IO (IOBitArray i) #

Bitwise map. Implementation lifts from `Bool` to `Bits` and maps large chunks at a time.

zipWith :: Ix i => (Bool -> Bool -> Bool) -> IOBitArray i -> IOBitArray i -> IO (IOBitArray i) #

Bitwise zipWith. Implementation lifts from `Bool` to `Bits` and combines large chunks at a time.

The bounds of the source arrays must be identical.

popCount :: Ix i => IOBitArray i -> IO Int #

Count set bits.

# Unsafe.

unsafeReadArray :: Ix i => IOBitArray i -> i -> IO Bool #

Read from an array at an index without bounds checking. Unsafe.

unsafeGetElems :: Ix i => IOBitArray i -> IO [Bool] #

Get a list of all elements of an array. Unsafe when the source array can be modified later.

unsafeFreeze :: Ix i => IOBitArray i -> IO (BitArray i) #

Snapshot the array into an immutable form. Unsafe when the source array can be modified later.

unsafeThaw :: Ix i => BitArray i -> IO (IOBitArray i) #

Convert an array from immutable form. Unsafe to modify the result unless the source array is never used later.