| dph-prim-seq-0.4.0: Sequential Primitives for Data-Parallel Haskell. | Contents | Index

Data.Array.Parallel.Unlifted.Sequential

Contents

Array classes
Array types
Basic operations
Subarrays
Permutations
Higher-order operations
Searching
Logical operations
Arithmetic operations
Arrays of pairs
Enumerations
Searching
Conversions to/from lists
Unlifted.Sequential arrays
I/O
Basic operations (segmented)
Higher-order operations (segmented)
Higher-order operations (regular)
Logical operations (segmented)
Arithmetic operations (segmented)
Arithmetic operations (regular segmented)
Segment descriptors
Mutable arrays
Library id

Description
(c) [2006..2007] Manuel M T Chakravarty & Roman Leshchinskiy License : see librariesndpLICENSE Maintainer : Roman Leshchinskiy rl@cse.unsw.edu.au Stability : experimental Portability : portable Description --------------------------------------------------------------- External interface to unlifted arrays. Todo ----------------------------------------------------------------------
Synopsis

class HS e => UA e where

data UArr e
data MUArr e :: * -> *
lengthU :: UArr e -> Int
sliceU :: UArr e -> Int -> Int -> UArr e
newMU :: Int -> ST s (MUArr e s)
hasAtomicWriteMU :: e -> Bool
copyMU :: MUArr e s -> Int -> UArr e -> ST s ()

data USegd
nullU :: UA e => UArr e -> Bool
emptyU :: UA e => UArr e
singletonU :: UA e => e -> UArr e
consU :: UA e => e -> UArr e -> UArr e
unitsU :: Int -> UArr ()
replicateU :: UA e => Int -> e -> UArr e
(!:) :: UA e => UArr e -> Int -> e
(+:+) :: UA e => UArr e -> UArr e -> UArr e
indexedU :: UA e => UArr e -> UArr (Int :*: e)
repeatU :: UA e => Int -> UArr e -> UArr e
extractU :: UA a => UArr a -> Int -> Int -> UArr a
tailU :: UA e => UArr e -> UArr e
takeU :: UA e => Int -> UArr e -> UArr e
dropU :: UA e => Int -> UArr e -> UArr e
splitAtU :: UA e => Int -> UArr e -> (UArr e, UArr e)
permuteU :: UA e => UArr e -> UArr Int -> UArr e
mbpermuteU :: (UA e, UA d) => (e -> d) -> UArr e -> UArr Int -> UArr d
bpermuteU :: UA e => UArr e -> UArr Int -> UArr e
bpermuteDftU :: UA e => Int -> (Int -> e) -> UArr (Int :*: e) -> UArr e
reverseU :: UA e => UArr e -> UArr e
updateU :: UA e => UArr e -> UArr (Int :*: e) -> UArr e
mapU :: (UA e, UA e') => (e -> e') -> UArr e -> UArr e'
zipWithU :: (UA a, UA b, UA c) => (a -> b -> c) -> UArr a -> UArr b -> UArr c
zipWith3U :: (UA a, UA b, UA c, UA d) => (a -> b -> c -> d) -> UArr a -> UArr b -> UArr c -> UArr d
filterU :: UA e => (e -> Bool) -> UArr e -> UArr e
packU :: UA e => UArr e -> UArr Bool -> UArr e
foldlU :: UA a => (b -> a -> b) -> b -> UArr a -> b
foldl1U :: UA a => (a -> a -> a) -> UArr a -> a
foldl1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS a
foldU :: UA a => (a -> a -> a) -> a -> UArr a -> a
fold1U :: UA a => (a -> a -> a) -> UArr a -> a
fold1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS a
scanlU :: (UA a, UA b) => (b -> a -> b) -> b -> UArr a -> UArr b
scanl1U :: UA a => (a -> a -> a) -> UArr a -> UArr a
scanU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr a
scan1U :: UA a => (a -> a -> a) -> UArr a -> UArr a
scanResU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr a :*: a
mapAccumLU :: (UA a, UA b) => (c -> a -> c :*: b) -> c -> UArr a -> UArr b
combineU :: UA a => UArr Bool -> UArr a -> UArr a -> UArr a
combineSU :: UA a => UArr Bool -> USegd -> UArr a -> USegd -> UArr a -> UArr a
elemU :: (Eq e, UA e) => e -> UArr e -> Bool
notElemU :: (Eq e, UA e) => e -> UArr e -> Bool
andU :: UArr Bool -> Bool
orU :: UArr Bool -> Bool
anyU :: UA e => (e -> Bool) -> UArr e -> Bool
allU :: UA e => (e -> Bool) -> UArr e -> Bool
sumU :: (Num e, UA e) => UArr e -> e
productU :: (Num e, UA e) => UArr e -> e
maximumU :: (Ord e, UA e) => UArr e -> e
minimumU :: (Ord e, UA e) => UArr e -> e
maximumByU :: UA e => (e -> e -> Ordering) -> UArr e -> e
minimumByU :: UA e => (e -> e -> Ordering) -> UArr e -> e
maximumIndexU :: (Ord e, UA e) => UArr e -> Int
minimumIndexU :: (Ord e, UA e) => UArr e -> Int
maximumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> Int
minimumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> Int
zipU :: (UA a, UA b) => UArr a -> UArr b -> UArr (a :*: b)
zip3U :: (UA e1, UA e2, UA e3) => UArr e1 -> UArr e2 -> UArr e3 -> UArr ((e1 :*: e2) :*: e3)
unzipU :: (UA a, UA b) => UArr (a :*: b) -> UArr a :*: UArr b
unzip3U :: (UA e1, UA e2, UA e3) => UArr ((e1 :*: e2) :*: e3) -> (UArr e1 :*: UArr e2) :*: UArr e3
fstU :: (UA a, UA b) => UArr (a :*: b) -> UArr a
sndU :: (UA a, UA b) => UArr (a :*: b) -> UArr b
enumFromToU :: Int -> Int -> UArr Int
enumFromThenToU :: Int -> Int -> Int -> UArr Int
enumFromStepLenU :: Int -> Int -> Int -> UArr Int
enumFromToEachU :: Int -> UArr (Int :*: Int) -> UArr Int
enumFromStepLenEachU :: Int -> UArr ((Int :*: Int) :*: Int) -> UArr Int
findU :: UA a => (a -> Bool) -> UArr a -> Maybe a
findIndexU :: UA a => (a -> Bool) -> UArr a -> Maybe Int
toU :: UA e => [e] -> UArr e
fromU :: UA e => UArr e -> [e]
randomU :: (UA a, Random a, RandomGen g) => Int -> g -> UArr a
randomRU :: (UA a, Random a, RandomGen g) => Int -> (a, a) -> g -> UArr a
class UA a => UIO a where

hPutU :: Handle -> UArr a -> IO ()
hGetU :: Handle -> IO (UArr a)

replicateSU :: UA a => USegd -> UArr a -> UArr a
replicateRSU :: UA a => Int -> UArr a -> UArr a
appendSU :: UA a => USegd -> UArr a -> USegd -> UArr a -> UArr a
foldlSU :: (UA a, UA b) => (b -> a -> b) -> b -> USegd -> UArr a -> UArr b
foldSU :: UA a => (a -> a -> a) -> a -> USegd -> UArr a -> UArr a
fold1SU :: UA a => (a -> a -> a) -> USegd -> UArr a -> UArr a
foldlRU :: (UA a, UA b) => (b -> a -> b) -> b -> Int -> Int -> UArr a -> UArr b
andSU :: USegd -> UArr Bool -> UArr Bool
orSU :: USegd -> UArr Bool -> UArr Bool
sumSU :: (Num e, UA e) => USegd -> UArr e -> UArr e
productSU :: (Num e, UA e) => USegd -> UArr e -> UArr e
maximumSU :: (Ord e, UA e) => USegd -> UArr e -> UArr e
minimumSU :: (Ord e, UA e) => USegd -> UArr e -> UArr e
sumRU :: (Num e, UA e) => Int -> Int -> UArr e -> UArr e
lengthUSegd :: USegd -> Int
lengthsUSegd :: USegd -> UArr Int
indicesUSegd :: USegd -> UArr Int
elementsUSegd :: USegd -> Int
lengthsToUSegd :: UArr Int -> USegd
mkUSegd :: UArr Int -> UArr Int -> Int -> USegd
newU :: UA e => Int -> (forall s. MUArr e s -> ST s ()) -> UArr e
permuteMU :: UA e => MUArr e s -> UArr e -> UArr Int -> ST s ()
atomicUpdateMU :: UA e => MUArr e s -> UArr (Int :*: e) -> ST s ()
unsafeFreezeAllMU :: UA e => MUArr e s -> ST s (UArr e)
idstr :: [Char]
name :: [Char]
versnum :: [Char]
date :: [Char]
version :: [Char]
copyright :: [Char]
disclaimer :: [Char]
lengthU' :: UA e => UArr e -> Int

Array classes
class HS e => UA e where

Basic operations on representation types ----------------------------------------- This type class determines the types that can be elements immutable unboxed arrays. The representation type of these arrays is defined by way of an associated type. All representation-dependent functions are methods of this class.
Associated Types

data UArr e
data MUArr e :: * -> *

Methods

lengthU :: UArr e -> Int
Yield the length of an unboxed array
sliceU :: UArr e -> Int -> Int -> UArr e
Restrict access to a subrange of the original array (no copying)
newMU :: Int -> ST s (MUArr e s)
Allocate a mutable unboxed array
hasAtomicWriteMU :: e -> Bool
Indicate whether the type supports atomic updates
copyMU :: MUArr e s -> Int -> UArr e -> ST s ()
Copy the contents of an immutable unboxed array into a mutable one from the specified position on

Instances

UA Bool
UA Char
UA Double
UA Float
UA Int
UA Word8
UA ()
(UA a, UA b) => UA (:*: a b)

Array types
data USegd

Segment descriptors represent the structure of nested arrays. For each segment, it stores the length and the starting index in the flat data array.
Instances

Show USegd

Basic operations
nullU :: UA e => UArr e -> Bool
Test whether the given array is empty
emptyU :: UA e => UArr e
Yield an empty array
singletonU :: UA e => e -> UArr e
Yield a singleton array
consU :: UA e => e -> UArr e -> UArr e
Prepend an element to an array
unitsU :: Int -> UArr ()
Basic operations on unboxed arrays ----------------------------------- Yield an array of units
replicateU :: UA e => Int -> e -> UArr e
Yield an array where all elements contain the same value
(!:) :: UA e => UArr e -> Int -> e
Array indexing
(+:+) :: UA e => UArr e -> UArr e -> UArr e
Concatenate two arrays
indexedU :: UA e => UArr e -> UArr (Int :*: e)
Indexing --------- Associate each element of the array with its index
repeatU :: UA e => Int -> UArr e -> UArr e
Repeat an array `n` times
Subarrays
extractU :: UA a => UArr a -> Int -> Int -> UArr a
tailU :: UA e => UArr e -> UArr e
Yield the tail of an array
takeU :: UA e => Int -> UArr e -> UArr e
Extract a prefix of an array
dropU :: UA e => Int -> UArr e -> UArr e
Extract a suffix of an array
splitAtU :: UA e => Int -> UArr e -> (UArr e, UArr e)
Split an array into two halves at the given index
Permutations
permuteU :: UA e => UArr e -> UArr Int -> UArr e
Standard permutation
mbpermuteU :: (UA e, UA d) => (e -> d) -> UArr e -> UArr Int -> UArr d
bpermuteU :: UA e => UArr e -> UArr Int -> UArr e
Back permutation operation (ie, the permutation vector determines for each position in the result array its origin in the input array) WARNING: DO NOT rewrite this as unstreamU . bpermuteUS es . streamU because GHC won't be able to figure out its strictness.
bpermuteDftU

:: UA e |
=> Int | length of result array
-> Int -> e | initialiser function
-> UArr (Int :*: e) | index-value pairs
-> UArr e |

Default back permute

- The values of the index-value pairs are written into the position in the result array that is indicated by the corresponding index.
- All positions not covered by the index-value pairs will have the value determined by the initialiser function for that index position.

reverseU :: UA e => UArr e -> UArr e
Reverse the order of elements in an array
updateU :: UA e => UArr e -> UArr (Int :*: e) -> UArr e
Yield an array constructed by updating the first array by the associations from the second array (which contains index/value pairs).
Higher-order operations
mapU :: (UA e, UA e') => (e -> e') -> UArr e -> UArr e'
Map a function over an array
zipWithU :: (UA a, UA b, UA c) => (a -> b -> c) -> UArr a -> UArr b -> UArr c
zipWith3U :: (UA a, UA b, UA c, UA d) => (a -> b -> c -> d) -> UArr a -> UArr b -> UArr c -> UArr d
filterU :: UA e => (e -> Bool) -> UArr e -> UArr e
Extract all elements from an array that meet the given predicate
packU :: UA e => UArr e -> UArr Bool -> UArr e
Extract all elements from an array according to a given flag array
foldlU :: UA a => (b -> a -> b) -> b -> UArr a -> b
Array reduction proceeding from the left
foldl1U :: UA a => (a -> a -> a) -> UArr a -> a
Array reduction proceeding from the left for non-empty arrays FIXME: Rewrite for `Stream`s.
foldl1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS a
foldU :: UA a => (a -> a -> a) -> a -> UArr a -> a
Array reduction that requires an associative combination function with its unit
fold1U :: UA a => (a -> a -> a) -> UArr a -> a
Reduction of a non-empty array which requires an associative combination function
fold1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS a
scanlU :: (UA a, UA b) => (b -> a -> b) -> b -> UArr a -> UArr b
Prefix scan proceedings from left to right
scanl1U :: UA a => (a -> a -> a) -> UArr a -> UArr a
Prefix scan of a non-empty array proceeding from left to right
scanU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr a
Prefix scan proceeding from left to right that needs an associative combination function with its unit
scan1U :: UA a => (a -> a -> a) -> UArr a -> UArr a
Prefix scan of a non-empty array proceeding from left to right that needs an associative combination function
scanResU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr a :*: a
mapAccumLU :: (UA a, UA b) => (c -> a -> c :*: b) -> c -> UArr a -> UArr b
Accumulating map from left to right. Does not return the accumulator. FIXME: Naming inconsistent with lists.
combineU :: UA a => UArr Bool -> UArr a -> UArr a -> UArr a
combineSU :: UA a => UArr Bool -> USegd -> UArr a -> USegd -> UArr a -> UArr a
Merge two segmented arrays according to flag array
Searching
elemU :: (Eq e, UA e) => e -> UArr e -> Bool
Determine whether the given element is in an array
notElemU :: (Eq e, UA e) => e -> UArr e -> Bool
Negation of `elemU`
Logical operations
andU :: UArr Bool -> Bool
orU :: UArr Bool -> Bool
anyU :: UA e => (e -> Bool) -> UArr e -> Bool
allU :: UA e => (e -> Bool) -> UArr e -> Bool
Arithmetic operations
sumU :: (Num e, UA e) => UArr e -> e
Compute the sum of an array of numerals
productU :: (Num e, UA e) => UArr e -> e
Compute the product of an array of numerals
maximumU :: (Ord e, UA e) => UArr e -> e
Determine the maximum element in an array
minimumU :: (Ord e, UA e) => UArr e -> e
Determine the minimum element in an array
maximumByU :: UA e => (e -> e -> Ordering) -> UArr e -> e
Determine the maximum element in an array under the given ordering
minimumByU :: UA e => (e -> e -> Ordering) -> UArr e -> e
Determine the minimum element in an array under the given ordering
maximumIndexU :: (Ord e, UA e) => UArr e -> Int
Determine the index of the maximum element in an array
minimumIndexU :: (Ord e, UA e) => UArr e -> Int
Determine the index of the minimum element in an array
maximumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> Int
Determine the index of the maximum element in an array under the given ordering
minimumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> Int
Determine the index of the minimum element in an array under the given ordering
Arrays of pairs
zipU :: (UA a, UA b) => UArr a -> UArr b -> UArr (a :*: b)
Elementwise pairing of array elements.
zip3U :: (UA e1, UA e2, UA e3) => UArr e1 -> UArr e2 -> UArr e3 -> UArr ((e1 :*: e2) :*: e3)
unzipU :: (UA a, UA b) => UArr (a :*: b) -> UArr a :*: UArr b
Elementwise unpairing of array elements.
unzip3U :: (UA e1, UA e2, UA e3) => UArr ((e1 :*: e2) :*: e3) -> (UArr e1 :*: UArr e2) :*: UArr e3
fstU :: (UA a, UA b) => UArr (a :*: b) -> UArr a
Yield the first components of an array of pairs.
sndU :: (UA a, UA b) => UArr (a :*: b) -> UArr b
Yield the second components of an array of pairs.
Enumerations
enumFromToU :: Int -> Int -> UArr Int
Yield an enumerated array FIXME: See comments about enumFromThenToS
enumFromThenToU :: Int -> Int -> Int -> UArr Int
Yield an enumerated array using a specific step FIXME: See comments about enumFromThenToS
enumFromStepLenU :: Int -> Int -> Int -> UArr Int
enumFromToEachU :: Int -> UArr (Int :*: Int) -> UArr Int
enumFromStepLenEachU :: Int -> UArr ((Int :*: Int) :*: Int) -> UArr Int
Searching
findU :: UA a => (a -> Bool) -> UArr a -> Maybe a
findIndexU :: UA a => (a -> Bool) -> UArr a -> Maybe Int
Conversions to/from lists
toU :: UA e => [e] -> UArr e
Conversion ----------- Turn a list into a parallel array
fromU :: UA e => UArr e -> [e]
Collect the elements of a parallel array in a list
Unlifted.Sequential arrays
randomU :: (UA a, Random a, RandomGen g) => Int -> g -> UArr a
randomRU :: (UA a, Random a, RandomGen g) => Int -> (a, a) -> g -> UArr a
I/O
class UA a => UIO a where

Methods

hPutU :: Handle -> UArr a -> IO ()
hGetU :: Handle -> IO (UArr a)

Instances

UIO Double
UIO Int
(UIO a, UIO b) => UIO (:*: a b)

Basic operations (segmented)
replicateSU :: UA a => USegd -> UArr a -> UArr a
replicateRSU :: UA a => Int -> UArr a -> UArr a
appendSU :: UA a => USegd -> UArr a -> USegd -> UArr a -> UArr a
Higher-order operations (segmented)
foldlSU :: (UA a, UA b) => (b -> a -> b) -> b -> USegd -> UArr a -> UArr b
Segmented array reduction proceeding from the left
foldSU :: UA a => (a -> a -> a) -> a -> USegd -> UArr a -> UArr a
Segmented array reduction that requires an associative combination function with its unit
fold1SU :: UA a => (a -> a -> a) -> USegd -> UArr a -> UArr a
Segmented array reduction with non-empty subarrays and an associative combination function
Higher-order operations (regular)
foldlRU :: (UA a, UA b) => (b -> a -> b) -> b -> Int -> Int -> UArr a -> UArr b
Regular arrar reduction
Logical operations (segmented)
andSU :: USegd -> UArr Bool -> UArr Bool
orSU :: USegd -> UArr Bool -> UArr Bool
Arithmetic operations (segmented)
sumSU :: (Num e, UA e) => USegd -> UArr e -> UArr e
Compute the segmented sum of an array of numerals
productSU :: (Num e, UA e) => USegd -> UArr e -> UArr e
Compute the segmented product of an array of numerals
maximumSU :: (Ord e, UA e) => USegd -> UArr e -> UArr e
Determine the maximum element in each subarray
minimumSU :: (Ord e, UA e) => USegd -> UArr e -> UArr e
Determine the minimum element in each subarray
Arithmetic operations (regular segmented)
sumRU :: (Num e, UA e) => Int -> Int -> UArr e -> UArr e
Compute the segmented sum of an array of numerals
Segment descriptors
lengthUSegd :: USegd -> Int
Operations on segment descriptors ---------------------------------- Yield the overall number of segments
lengthsUSegd :: USegd -> UArr Int
Yield the segment lengths of a segment descriptor
indicesUSegd :: USegd -> UArr Int
Yield the segment indices of a segment descriptor
elementsUSegd :: USegd -> Int
Yield the number of data elements
lengthsToUSegd :: UArr Int -> USegd
Convert a length array into a segment descriptor.
mkUSegd :: UArr Int -> UArr Int -> Int -> USegd
Mutable arrays
newU :: UA e => Int -> (forall s. MUArr e s -> ST s ()) -> UArr e
Creating unboxed arrays ------------------------
permuteMU :: UA e => MUArr e s -> UArr e -> UArr Int -> ST s ()
Permutations -------------
atomicUpdateMU :: UA e => MUArr e s -> UArr (Int :*: e) -> ST s ()
unsafeFreezeAllMU :: UA e => MUArr e s -> ST s (UArr e)
Library id
idstr :: [Char]
name :: [Char]
versnum :: [Char]
date :: [Char]
version :: [Char]
copyright :: [Char]
disclaimer :: [Char]
lengthU' :: UA e => UArr e -> Int
FIXME: A fuseable version of lengthU, should go away
Produced by Haddock version 2.6.1