![](haskell_icon.gif) | dph-base-0.3: Basic Definitions for Data-Parallel Haskell. | Contents | Index |
|
Data.Array.Parallel.Arr | Portability | non-portable (unboxed values and GHC libraries) | Stability | internal | Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au> |
|
|
|
|
|
Description |
Interface to the Arr modules
|
|
Synopsis |
|
|
|
|
Types
|
|
data BBArr e |
Immutable boxed arrays
| Instances | |
|
|
data MBBArr s e |
|
|
Operations on immutable arrays
|
|
lengthBB :: BBArr e -> Int |
Length of an immutable boxed array
|
|
indexBB :: BBArr e -> Int -> e |
Access an element in an immutable, boxed array
|
|
extractBB :: BBArr e -> Int -> Int -> BBArr e |
Extract a slice from an array (given by its start index and length)
|
|
Operations on mutable arrays
|
|
newMBB :: Int -> ST s (MBBArr s e) |
Allocate a boxed array
|
|
lengthMBB :: MBBArr s e -> Int |
Length of a mutable boxed array
|
|
readMBB :: MBBArr s e -> Int -> ST s e |
Access an element in an mutable, boxed array
|
|
writeMBB :: MBBArr s e -> Int -> e -> ST s () |
Update an element in an mutable, boxed array
|
|
unsafeFreezeMBB :: MBBArr s e -> Int -> ST s (BBArr e) |
Turn a mutable into an immutable array WITHOUT copying its contents, which
implies that the mutable array must not be mutated anymore after this
operation has been executed.
- The explicit size parameter supports partially filled arrays (and must be
less than or equal the size used when allocating the mutable array)
|
|
unsafeFreezeAllMBB :: MBBArr s e -> ST s (BBArr e) |
Turn a mutable into an immutable array WITHOUT copying its contents, which
implies that the mutable array must not be mutated anymore after this
operation has been executed.
- In contrast to unsafeFreezeMBB, this operation always freezes the
entire array.
|
|
extractMBB :: MBBArr s e -> Int -> Int -> ST s (BBArr e) |
Extract a slice from a mutable array (the slice is immutable)
|
|
copyMBB :: MBBArr s e -> Int -> BBArr e -> ST s () |
Copy a the contents of an immutable array into a mutable array from the
specified position on
|
|
Types
|
|
data BUArr e |
Immutable unboxed arrays
| Instances | |
|
|
data MBUArr s e |
Mutable unboxed arrays
| Instances | |
|
|
Elements of unboxed arrays
|
|
class HS e => UAE e where |
Class of elements that can be stored in unboxed arrays
| | Methods | | | Instances | |
|
|
Operations on mutable arrays
|
|
lengthMBU :: MBUArr s e -> Int |
Number of elements of a mutable unboxed array
|
|
newMBU :: forall s e. UAE e => Int -> ST s (MBUArr s e) |
Allocate an uninitialised unboxed array
|
|
readMBU :: UAE e => MBUArr s e -> Int -> ST s e |
Read the element at the given position of a mutable array.
|
|
writeMBU :: UAE e => MBUArr s e -> Int -> e -> ST s () |
Write the element at the given position of a mutable array.
|
|
extractMBU :: UAE e => MBUArr s e -> Int -> Int -> ST s (BUArr e) |
Extract a slice from a mutable array (the slice is immutable)
|
|
copyMBU :: UAE e => MBUArr s e -> Int -> BUArr e -> ST s () |
Copy a the contents of an immutable array into a mutable array from the
specified position on
|
|
unsafeFreezeMBU :: MBUArr s e -> Int -> ST s (BUArr e) |
Turn a mutable into an immutable array WITHOUT copying its contents, which
implies that the mutable array must not be mutated anymore after this
operation has been executed.
- The explicit size parameter supports partially filled arrays (and must be
less than or equal the size used when allocating the mutable array)
|
|
unsafeFreezeAllMBU :: MBUArr s e -> ST s (BUArr e) |
Turn a mutable into an immutable array WITHOUT copying its contents, which
implies that the mutable array must not be mutated anymore after this
operation has been executed.
- In contrast to unsafeFreezeMBU, this operation always freezes the
entire array.
|
|
Operations on immutable arrays
|
|
Basic operations
|
|
lengthBU :: BUArr e -> Int |
Number of elements of an immutable unboxed array
|
|
emptyBU :: UAE e => BUArr e |
Empty array
|
|
replicateBU :: UAE e => Int -> e -> BUArr e |
Combinators for unboxed arrays
-
Replicate combinator for unboxed arrays
|
|
indexBU :: UAE e => BUArr e -> Int -> e |
Yield the element at the given position of an immutable array.
|
|
sliceBU :: BUArr e -> Int -> Int -> BUArr e |
Produces an array that consists of a subrange of the original one without
copying any elements.
|
|
extractBU :: UAE e => BUArr e -> Int -> Int -> BUArr e |
Extract a slice from an array (given by its start index and length)
|
|
Streaming
|
|
streamBU :: UAE e => BUArr e -> Stream e |
Stream of unboxed arrays
-------------------------
Generate a stream from an array, from left to right
|
|
unstreamBU :: UAE e => Stream e -> BUArr e |
Construct an array from a stream, filling it from left to right
|
|
Higher-order and arithmetic operations
|
|
mapBU :: (UAE a, UAE b) => (a -> b) -> BUArr a -> BUArr b |
Map a function over an unboxed array
|
|
foldlBU :: UAE b => (a -> b -> a) -> a -> BUArr b -> a |
Reduce an unboxed array
|
|
foldBU :: UAE a => (a -> a -> a) -> a -> BUArr a -> a |
Reduce an unboxed array using an *associative* combining operator
|
|
scanlBU :: (UAE a, UAE b) => (a -> b -> a) -> a -> BUArr b -> BUArr a |
Prefix reduction of an unboxed array
|
|
scanBU :: UAE a => (a -> a -> a) -> a -> BUArr a -> BUArr a |
Prefix reduction of an unboxed array using an *associative* combining
operator
|
|
sumBU :: (UAE a, Num a) => BUArr a -> a |
Summation of an unboxed array
|
|
Conversions to/from lists
|
|
toBU :: UAE e => [e] -> BUArr e |
Convert a list to an array
|
|
fromBU :: UAE e => BUArr e -> [e] |
Convert an array to a list
|
|
I/O
|
|
hPutBU :: forall e. UAE e => Handle -> BUArr e -> IO () |
|
hGetBU :: forall e. UAE e => Handle -> IO (BUArr e) |
|
Produced by Haddock version 2.3.0 |