![](haskell_icon.gif) | dph-prim-par-0.3: Parallel Primitives for Data-Parallel Haskell. | Contents | Index |
|
Data.Array.Parallel.Unlifted.Parallel | Portability | portable | Stability | experimental | Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au> |
|
|
|
Description |
Description ---------------------------------------------------------------
Parallel operations on unlifted arrays
|
|
Synopsis |
|
bpermuteUP :: UA a => UArr a -> UArr Int -> UArr a | | updateUP :: forall a. UA a => UArr a -> UArr (Int :*: a) -> UArr a | | enumFromToUP :: (UA a, Enum a) => a -> a -> UArr a | | enumFromThenToUP :: (UA a, Enum a) => a -> a -> a -> UArr a | | enumFromStepLenUP :: Int -> Int -> Int -> UArr Int | | mapUP :: (UA a, UA b) => (a -> b) -> UArr a -> UArr b | | filterUP :: UA a => (a -> Bool) -> UArr a -> UArr a | | packUP :: UA e => UArr e -> UArr Bool -> UArr e | | zipWithUP :: (UA a, UA b, UA c) => (a -> b -> c) -> UArr a -> UArr b -> UArr c | | foldUP :: (UA a, DT a) => (a -> a -> a) -> a -> UArr a -> a | | scanUP :: (DT a, UA a) => (a -> a -> a) -> a -> UArr a -> UArr a | | andUP :: UArr Bool -> Bool | | sumUP :: (UA a, DT a, Num a) => UArr a -> a | | mapSUP :: (UA a, UA b) => (a -> b) -> SUArr a -> SUArr b | | filterSUP :: UA e => (e -> Bool) -> SUArr e -> SUArr e | | packCUP :: UA e => UArr Bool -> SUArr e -> SUArr e | | zipWithSUP :: (UA a, UA b, UA c) => (a -> b -> c) -> SUArr a -> SUArr b -> SUArr c | | foldSUP :: (UA a, UA b) => (b -> a -> b) -> b -> SUArr a -> UArr b | | sumSUP :: (Num e, UA e) => SUArr e -> UArr e | | bpermuteSUP' :: UA a => UArr a -> SUArr Int -> SUArr a | | enumFromThenToSUP :: (Enum e, UA e) => UArr e -> UArr e -> UArr e -> SUArr e | | replicateSUP :: UA e => UArr Int -> UArr e -> SUArr e | | indexedSUP :: UA e => SUArr e -> SUArr (Int :*: e) | | indexedUP :: (DT e, UA e) => UArr e -> UArr (Int :*: e) | | replicateUP :: UA e => Int -> e -> UArr e | | replicateEachUnbalancedUP :: UA e => UArr Int -> UArr e -> UArr e | | dropUP :: Int -> UArr Int -> UArr Int |
|
|
Documentation |
|
bpermuteUP :: UA a => UArr a -> UArr Int -> UArr a |
|
updateUP :: forall a. UA a => UArr a -> UArr (Int :*: a) -> UArr a |
|
enumFromToUP :: (UA a, Enum a) => a -> a -> UArr a |
|
enumFromThenToUP :: (UA a, Enum a) => a -> a -> a -> UArr a |
|
enumFromStepLenUP :: Int -> Int -> Int -> UArr Int |
|
mapUP :: (UA a, UA b) => (a -> b) -> UArr a -> UArr b |
|
filterUP :: UA a => (a -> Bool) -> UArr a -> UArr a |
|
packUP :: UA e => UArr e -> UArr Bool -> UArr e |
Extract all elements from an array according to a given flag array
|
|
zipWithUP :: (UA a, UA b, UA c) => (a -> b -> c) -> UArr a -> UArr b -> UArr c |
|
foldUP :: (UA a, DT a) => (a -> a -> a) -> a -> UArr a -> a |
|
scanUP :: (DT a, UA a) => (a -> a -> a) -> a -> UArr a -> UArr a |
|
andUP :: UArr Bool -> Bool |
|
sumUP :: (UA a, DT a, Num a) => UArr a -> a |
|
mapSUP :: (UA a, UA b) => (a -> b) -> SUArr a -> SUArr b |
|
filterSUP :: UA e => (e -> Bool) -> SUArr e -> SUArr e |
Filter segmented array
|
|
packCUP :: UA e => UArr Bool -> SUArr e -> SUArr e |
|
zipWithSUP :: (UA a, UA b, UA c) => (a -> b -> c) -> SUArr a -> SUArr b -> SUArr c |
|
foldSUP :: (UA a, UA b) => (b -> a -> b) -> b -> SUArr a -> UArr b |
|
sumSUP :: (Num e, UA e) => SUArr e -> UArr e |
|
bpermuteSUP' :: UA a => UArr a -> SUArr Int -> SUArr a |
|
enumFromThenToSUP :: (Enum e, UA e) => UArr e -> UArr e -> UArr e -> SUArr e |
Yield a segmented enumerated array using a specific step (unbalanced)
|
|
replicateSUP :: UA e => UArr Int -> UArr e -> SUArr e |
|
indexedSUP :: UA e => SUArr e -> SUArr (Int :*: e) |
Associate each data element with its index
|
|
indexedUP :: (DT e, UA e) => UArr e -> UArr (Int :*: e) |
Associate each element of the array with its index
|
|
replicateUP :: UA e => Int -> e -> UArr e |
Yield an array where all elements contain the same value
|
|
replicateEachUnbalancedUP :: UA e => UArr Int -> UArr e -> UArr e |
Expand every element in the argument array by the factor given in the
corresponding array. The resulting array is unbalanced.
TODO: do we need a balanced version? Will probably provide no performance benefit
|
|
dropUP :: Int -> UArr Int -> UArr Int |
|
Produced by Haddock version 2.3.0 |