Safe Haskell | None |
---|

Parallel combinators for unlifted arrays.

- mapUP :: (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
- filterUP :: Unbox a => (a -> Bool) -> Vector a -> Vector a
- packUP :: Unbox e => Vector e -> Vector Bool -> Vector e
- combineUP :: Unbox a => Vector Bool -> Vector a -> Vector a -> Vector a
- combine2UP :: Unbox a => Vector Tag -> UPSelRep2 -> Vector a -> Vector a -> Vector a
- zipWithUP :: (Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c
- foldUP :: (Unbox a, DT a) => (a -> a -> a) -> a -> Vector a -> a
- foldlUP :: (DT a, Unbox a) => (a -> a -> a) -> a -> Vector a -> a
- fold1UP :: (DT a, Unbox a) => (a -> a -> a) -> Vector a -> a
- foldl1UP :: (DT a, Unbox a) => (a -> a -> a) -> Vector a -> a
- scanUP :: (DT a, Unbox a) => (a -> a -> a) -> a -> Vector a -> Vector a

# Documentation

mapUP :: (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector bSource

Apply a worker to all elements of an array.

filterUP :: Unbox a => (a -> Bool) -> Vector a -> Vector aSource

Keep elements that match the given predicate.

packUP :: Unbox e => Vector e -> Vector Bool -> Vector eSource

Take elements of an array where a flag value is true, and pack them into the result.

- The souce and flag arrays must have the same length, but this is not checked.

combineUP :: Unbox a => Vector Bool -> Vector a -> Vector a -> Vector aSource

Combine two vectors based on a selector. If the selector is true then take the element from the first vector, otherwise take it from the second.

- The data vectors must have enough elements to satisfy the flag vector, but this is not checked.

combine2UP :: Unbox a => Vector Tag -> UPSelRep2 -> Vector a -> Vector a -> Vector aSource

Combine two vectors based on a selector.

- The data vectors must have enough elements to satisfy the selector, but this is not checked.

zipWithUP :: (Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Vector a -> Vector b -> Vector cSource

Apply a worker function to correponding elements of two arrays.

foldUP :: (Unbox a, DT a) => (a -> a -> a) -> a -> Vector a -> aSource

Undirected fold. Note that this function has more constraints on its parameters than the standard fold function from the Haskell Prelude.

- The worker function must be associative.
- The provided starting element must be neutral with respect to the worker. For example 0 is neutral wrt (+) and 1 is neutral wrt (*).

We need these constraints so that we can partition the fold across several threads. Each thread folds a chunk of the input vector, then we fold together all the results in the main thread.

foldlUP :: (DT a, Unbox a) => (a -> a -> a) -> a -> Vector a -> aSource

Left fold over an array.

- If the vector is empty then this returns the provided neural element.
- The worker function must be associative.
- The provided starting element must be neutral with respect to the worker,
see
`foldUP`

for discussion.

foldl1UP :: (DT a, Unbox a) => (a -> a -> a) -> Vector a -> aSource

Left fold over an array, using the first element of the vector as the neural element.

- If the vector contains no elements then you'll get a bounds-check error.
- The worker function must be associative.
- The provided starting element must be neutral with respect to the worker,
see
`foldUP`

for discussion.