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.