dph-prim-par-0.4.0: Parallel Primitives for Data-Parallel Haskell. Source code Contents Index

Data.Array.Parallel.Unlifted

Synopsis

data a :*: b = !a :*: !b class (UA a, DT a) => Elt a type Array = UArr type Segd = USegd length :: Elt a => Array a -> Int empty :: Elt a => Array a replicate :: Elt a => Int -> a -> Array a repeat :: Elt a => Int -> Int -> Array a -> Array a (+:+) :: Elt a => Array a -> Array a -> Array a (!:) :: Elt a => Array a -> Int -> a extract :: Elt a => Array a -> Int -> Int -> Array a drop :: Elt a => Int -> Array a -> Array a permute :: Elt a => Array a -> Array Int -> Array a mbpermute :: (Elt a, Elt b) => (a -> b) -> Array a -> Array Int -> Array b bpermute :: Elt a => Array a -> Array Int -> Array a bpermuteDft :: Elt e => Int -> (Int -> e) -> Array (Int :*: e) -> Array e update :: Elt a => Array a -> Array (Int :*: a) -> Array a pack :: Elt a => Array a -> Array Bool -> Array a combine :: Elt a => Array Bool -> Array a -> Array a -> Array a enumFromTo :: Int -> Int -> Array Int enumFromThenTo :: Int -> Int -> Int -> Array Int enumFromToEach :: Int -> Array (Int :*: Int) -> Array Int enumFromStepLen :: Int -> Int -> Int -> Array Int enumFromStepLenEach :: Int -> Array ((Int :*: Int) :*: Int) -> Array Int indexed :: Elt a => Array a -> Array (Int :*: a) zip :: (Elt a, Elt b) => Array a -> Array b -> Array (a :*: b) zip3 :: (Elt a, Elt b, Elt c) => Array a -> Array b -> Array c -> Array ((a :*: b) :*: c) unzip :: (Elt a, Elt b) => Array (a :*: b) -> Array a :*: Array b unzip3 :: (Elt a, Elt b, Elt c) => Array ((a :*: b) :*: c) -> (Array a :*: Array b) :*: Array c fsts :: (Elt a, Elt b) => Array (a :*: b) -> Array a snds :: (Elt a, Elt b) => Array (a :*: b) -> Array b map :: (Elt a, Elt b) => (a -> b) -> Array a -> Array b zipWith :: (Elt a, Elt b, Elt c) => (a -> b -> c) -> Array a -> Array b -> Array c zipWith3 :: (Elt a, Elt b, Elt c, Elt d) => (a -> b -> c -> d) -> Array a -> Array b -> Array c -> Array d filter :: Elt a => (a -> Bool) -> Array a -> Array a fold :: Elt a => (a -> a -> a) -> a -> Array a -> a fold1 :: Elt a => (a -> a -> a) -> Array a -> a and :: Array Bool -> Bool sum :: (Num a, Elt a) => Array a -> a scan :: Elt a => (a -> a -> a) -> a -> Array a -> Array a replicate_s :: Elt a => Segd -> Array a -> Array a replicate_rs :: Elt a => Int -> Array a -> Array a append_s :: Elt a => Segd -> Array a -> Segd -> Array a -> Array a repeat_c :: Elt a => Int -> Array Int -> Segd -> Array a -> Array a fold_s :: Elt a => (a -> a -> a) -> a -> Segd -> Array a -> Array a fold1_s :: Elt a => (a -> a -> a) -> Segd -> Array a -> Array a sum_s :: (Num a, Elt a) => Segd -> Array a -> Array a indices_s :: Int -> Segd -> Int -> Array Int sum_r :: (Num a, Elt a) => Int -> Int -> Array a -> Array a lengthSegd :: Segd -> Int lengthsSegd :: Segd -> Array Int indicesSegd :: Segd -> Array Int elementsSegd :: Segd -> Int lengthsToSegd :: Array Int -> Segd mkSegd :: Array Int -> Array Int -> Int -> Segd selectorToIndices2 :: Array Int -> Array Int pick :: (Elt a, Eq a) => Array a -> a -> Array Bool count :: (Elt a, Eq a) => Array a -> a -> Int randoms :: (Elt a, Random a, RandomGen g) => Int -> g -> Array a randomRs :: (Elt a, Random a, RandomGen g) => Int -> (a, a) -> g -> Array a class UIO a => IOElt a hGet :: IOElt a => Handle -> IO (Array a) hPut :: IOElt a => Handle -> Array a -> IO () toList :: Elt a => Array a -> [a] fromList :: Elt a => [a] -> Array a

Documentation

data a :*: b Source

Strict pair Constructors !a :*: !b Instances (Eq a, Eq b) => Eq (:*: a b) (Ord a, Ord b) => Ord (:*: a b) (Read a, Read b) => Read (:*: a b) (Show a, Show b) => Show (:*: a b) (HS a, HS b) => HS (:*: a b) (UA a, UA b) => UA (:*: a b) (UIO a, UIO b) => UIO (:*: a b) (DT a, DT b) => DT (:*: a b) (IOElt a, IOElt b) => IOElt (:*: a b) (Elt a, Elt b) => Elt (:*: a b)

class (UA a, DT a) => Elt a Source

Instances Elt Bool Elt Double Elt Int Elt Word8 (Elt a, Elt b) => Elt (:*: a b)

type Array = UArr Source

type Segd = USegd Source

length :: Elt a => Array a -> Int Source

empty :: Elt a => Array a Source

replicate :: Elt a => Int -> a -> Array a Source

repeat :: Elt a => Int -> Int -> Array a -> Array a Source

(+:+) :: Elt a => Array a -> Array a -> Array a Source

(!:) :: Elt a => Array a -> Int -> a Source

extract :: Elt a => Array a -> Int -> Int -> Array a Source

drop :: Elt a => Int -> Array a -> Array a Source

permute :: Elt a => Array a -> Array Int -> Array a Source

mbpermute :: (Elt a, Elt b) => (a -> b) -> Array a -> Array Int -> Array b Source

bpermute :: Elt a => Array a -> Array Int -> Array a Source

bpermuteDft :: Elt e => Int -> (Int -> e) -> Array (Int :*: e) -> Array e Source

update :: Elt a => Array a -> Array (Int :*: a) -> Array a Source

pack :: Elt a => Array a -> Array Bool -> Array a Source

combine :: Elt a => Array Bool -> Array a -> Array a -> Array a Source

enumFromTo :: Int -> Int -> Array Int Source

enumFromThenTo :: Int -> Int -> Int -> Array Int Source

enumFromToEach :: Int -> Array (Int :*: Int) -> Array Int Source

enumFromStepLen :: Int -> Int -> Int -> Array Int Source

enumFromStepLenEach :: Int -> Array ((Int :*: Int) :*: Int) -> Array Int Source

indexed :: Elt a => Array a -> Array (Int :*: a) Source

zip :: (Elt a, Elt b) => Array a -> Array b -> Array (a :*: b) Source

zip3 :: (Elt a, Elt b, Elt c) => Array a -> Array b -> Array c -> Array ((a :*: b) :*: c) Source

unzip :: (Elt a, Elt b) => Array (a :*: b) -> Array a :*: Array b Source

unzip3 :: (Elt a, Elt b, Elt c) => Array ((a :*: b) :*: c) -> (Array a :*: Array b) :*: Array c Source

fsts :: (Elt a, Elt b) => Array (a :*: b) -> Array a Source

snds :: (Elt a, Elt b) => Array (a :*: b) -> Array b Source

map :: (Elt a, Elt b) => (a -> b) -> Array a -> Array b Source

zipWith :: (Elt a, Elt b, Elt c) => (a -> b -> c) -> Array a -> Array b -> Array c Source

zipWith3 :: (Elt a, Elt b, Elt c, Elt d) => (a -> b -> c -> d) -> Array a -> Array b -> Array c -> Array d Source

filter :: Elt a => (a -> Bool) -> Array a -> Array a Source

fold :: Elt a => (a -> a -> a) -> a -> Array a -> a Source

fold1 :: Elt a => (a -> a -> a) -> Array a -> a Source

and :: Array Bool -> Bool Source

sum :: (Num a, Elt a) => Array a -> a Source

scan :: Elt a => (a -> a -> a) -> a -> Array a -> Array a Source

replicate_s :: Elt a => Segd -> Array a -> Array a Source

replicate_rs :: Elt a => Int -> Array a -> Array a Source

append_s Source

:: Elt a => Segd segment descriptor of first array -> Array a data of first array -> Segd segment descriptor of second array -> Array a data of first array -> Array a

repeat_c Source

:: Elt a => Int length of the result array -> Array Int number of time a segment is repeated -> Segd segment descriptor -> Array a data array -> Array a

fold_s :: Elt a => (a -> a -> a) -> a -> Segd -> Array a -> Array a Source

fold1_s :: Elt a => (a -> a -> a) -> Segd -> Array a -> Array a Source

sum_s :: (Num a, Elt a) => Segd -> Array a -> Array a Source

indices_s Source

:: Int number of segments -> Segd segment descriptor -> Int overall number of indices -> Array Int

sum_r :: (Num a, Elt a) => Int -> Int -> Array a -> Array a Source

lengthSegd :: Segd -> Int Source

lengthsSegd :: Segd -> Array Int Source

indicesSegd :: Segd -> Array Int Source

elementsSegd :: Segd -> Int Source

lengthsToSegd :: Array Int -> Segd Source

mkSegd :: Array Int -> Array Int -> Int -> Segd Source

selectorToIndices2 :: Array Int -> Array Int Source

pick :: (Elt a, Eq a) => Array a -> a -> Array Bool Source

count :: (Elt a, Eq a) => Array a -> a -> Int Source

randoms :: (Elt a, Random a, RandomGen g) => Int -> g -> Array a Source

randomRs :: (Elt a, Random a, RandomGen g) => Int -> (a, a) -> g -> Array a Source

class UIO a => IOElt a Source

Instances IOElt Double IOElt Int (IOElt a, IOElt b) => IOElt (:*: a b)

hGet :: IOElt a => Handle -> IO (Array a) Source

hPut :: IOElt a => Handle -> Array a -> IO () Source

toList :: Elt a => Array a -> [a] Source

fromList :: Elt a => [a] -> Array a Source

Produced by Haddock version 2.6.1