| dph-prim-par-0.3: Parallel Primitives for Data-Parallel Haskell. | Source code | 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)
jsTest
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 | Source
updateUP :: forall a. UA a => UArr a -> UArr (Int :*: a) -> UArr a | Source
enumFromToUP :: (UA a, Enum a) => a -> a -> UArr a | Source
enumFromThenToUP :: (UA a, Enum a) => a -> a -> a -> UArr a | Source
enumFromStepLenUP :: Int -> Int -> Int -> UArr Int | Source
mapUP :: (UA a, UA b) => (a -> b) -> UArr a -> UArr b | Source
filterUP :: UA a => (a -> Bool) -> UArr a -> UArr a | Source
packUP :: UA e => UArr e -> UArr Bool -> UArr e | Source
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 | Source
foldUP :: (UA a, DT a) => (a -> a -> a) -> a -> UArr a -> a | Source
scanUP :: (DT a, UA a) => (a -> a -> a) -> a -> UArr a -> UArr a | Source
andUP :: UArr Bool -> Bool | Source
sumUP :: (UA a, DT a, Num a) => UArr a -> a | Source
mapSUP :: (UA a, UA b) => (a -> b) -> SUArr a -> SUArr b | Source
filterSUP :: UA e => (e -> Bool) -> SUArr e -> SUArr e | Source
Filter segmented array
packCUP :: UA e => UArr Bool -> SUArr e -> SUArr e | Source
zipWithSUP :: (UA a, UA b, UA c) => (a -> b -> c) -> SUArr a -> SUArr b -> SUArr c | Source
foldSUP :: (UA a, UA b) => (b -> a -> b) -> b -> SUArr a -> UArr b | Source
sumSUP :: (Num e, UA e) => SUArr e -> UArr e | Source
bpermuteSUP' :: UA a => UArr a -> SUArr Int -> SUArr a | Source
enumFromThenToSUP :: (Enum e, UA e) => UArr e -> UArr e -> UArr e -> SUArr e | Source
Yield a segmented enumerated array using a specific step (unbalanced)
replicateSUP :: UA e => UArr Int -> UArr e -> SUArr e | Source
indexedSUP :: UA e => SUArr e -> SUArr (Int :*: e) | Source
Associate each data element with its index
jsTest
indexedUP :: (DT e, UA e) => UArr e -> UArr (Int :*: e) | Source
Associate each element of the array with its index
replicateUP :: UA e => Int -> e -> UArr e | Source
Yield an array where all elements contain the same value
replicateEachUnbalancedUP :: UA e => UArr Int -> UArr e -> UArr e | Source
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 | Source
Produced by Haddock version 2.4.2