dph-prim-seq-0.3: Sequential Primitives for Data-Parallel Haskell.ContentsIndex
Data.Array.Parallel.Unlifted.Sequential
Contents
Array classes
Array types
Basic operations
Subarrays
Permutations
Higher-order operations
Segmented Subarrays
Searching
Logical operations
Arithmetic operations
Arrays of pairs
Enumerations
Searching
Conversions to/from lists
Unlifted.Sequential arrays
I/O
Segmentation
Basic operations (segmented)
Basic operations lifted
Zipping (segmented)
Permutations (segmented)
Higher-order operations (segmented)
Logical operations (segmented)
Arithmetic operations (segmented)
Enumerations (segmented)
Conversions to/from lists (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
data SUArr e
lengthU :: UA e => UArr e -> Int
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
replicateEachU :: UA e => Int -> UArr Int -> UArr 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
sliceU :: UA e => UArr e -> Int -> Int -> 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
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
filterSU :: UA e => (e -> Bool) -> SUArr e -> SUArr e
packCU :: UA e => UArr Bool -> SUArr e -> SUArr e
combineU :: UA a => UArr Bool -> UArr a -> UArr a -> UArr a
combineSU :: UA a => UArr Bool -> SUArr a -> SUArr a -> UArr a
combineCU :: UA e => UArr Bool -> SUArr e -> SUArr e -> SUArr e
sliceSU :: UA e => SUArr e -> Int -> Int -> SUArr e
extractSU :: UA e => SUArr e -> Int -> Int -> SUArr e
takeCU :: UA e => Int -> SUArr e -> SUArr e
dropCU :: UA e => Int -> SUArr e -> SUArr e
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
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)
concatSU :: UA e => SUArr e -> UArr e
flattenSU :: UA e => SUArr e -> UArr e
(>:) :: UA a => USegd -> UArr a -> SUArr a
segmentU :: (UA e', UA e) => SUArr e' -> UArr e -> SUArr e
segmentArrU :: UA e => UArr Int -> UArr e -> SUArr e
segdSU :: UA e => SUArr e -> USegd
lengthSU :: UA e => SUArr e -> Int
singletonSU :: UA e => UArr e -> SUArr e
replicateSU :: UA e => UArr Int -> UArr e -> SUArr e
replicateCU :: UA e => Int -> UArr e -> SUArr e
(+:+^) :: UA e => SUArr e -> SUArr e -> SUArr e
indexedSU :: UA e => SUArr e -> SUArr (Int :*: e)
(^+:+^) :: UA a => SUArr a -> SUArr a -> SUArr a
(!:^) :: UA e => SUArr e -> UArr Int -> UArr e
lengthsSU :: UA e => SUArr e -> UArr Int
indicesSU :: UA e => SUArr e -> UArr Int
fstSU :: (UA a, UA b) => SUArr (a :*: b) -> SUArr a
sndSU :: (UA a, UA b) => SUArr (a :*: b) -> SUArr b
zipSU :: (UA a, UA b) => SUArr a -> SUArr b -> SUArr (a :*: b)
bpermuteSU :: UA e => SUArr e -> SUArr Int -> SUArr e
bpermuteSU' :: UA e => UArr e -> SUArr Int -> SUArr e
mapSU :: (UA a, UA b) => (a -> b) -> SUArr a -> SUArr b
zipWithSU :: (UA a, UA b, UA c) => (a -> b -> c) -> SUArr a -> SUArr b -> SUArr c
foldlSU :: (UA a, UA b) => (b -> a -> b) -> b -> SUArr a -> UArr b
foldSU :: UA a => (a -> a -> a) -> a -> SUArr a -> UArr a
fold1SU :: UA a => (a -> a -> a) -> SUArr a -> UArr a
andSU :: SUArr Bool -> UArr Bool
orSU :: SUArr Bool -> UArr Bool
sumSU :: (Num e, UA e) => SUArr e -> UArr e
productSU :: (Num e, UA e) => SUArr e -> UArr e
maximumSU :: (Ord e, UA e) => SUArr e -> UArr e
minimumSU :: (Ord e, UA e) => SUArr e -> UArr e
enumFromToSU :: (Enum e, UA e) => UArr e -> UArr e -> SUArr e
enumFromThenToSU :: (Enum e, UA e) => UArr e -> UArr e -> UArr e -> SUArr e
toSU :: UA e => [[e]] -> SUArr e
fromSU :: UA e => SUArr e -> [[e]]
lengthsUSegd :: USegd -> UArr Int
lengthsToUSegd :: UArr Int -> USegd
toUSegd :: UArr (Int :*: Int) -> USegd
fromUSegd :: USegd -> UArr (Int :*: Int)
newU :: UA e => Int -> (forall s. MUArr e s -> ST s ()) -> UArr e
newMU :: UA e => Int -> ST s (MUArr e s)
copyMU :: UA e => MUArr e s -> Int -> UArr e -> ST s ()
permuteMU :: UA e => MUArr e s -> UArr e -> UArr Int -> ST s ()
hasAtomicWriteMU :: UA e => e -> Bool
atomicUpdateMU :: UA e => MUArr e s -> UArr (Int :*: e) -> ST s ()
unsafeFreezeAllMU :: UA e => MUArr e s -> ST s (UArr e)
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
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 ()
show/hide Instances
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.
show/hide Instances
data SUArr e

Segmented arrays -----------------

Segmented arrays (only one level of segmentation)

show/hide Instances
(Eq e, UA e) => Eq (SUArr e)
(Read e, UA e) => Read (SUArr e)
(Show e, UA e) => Show (SUArr e)
Basic operations
lengthU :: UA e => UArr e -> Int
Yield the length of an unboxed array
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
replicateEachU :: UA e => Int -> UArr Int -> UArr e -> UArr e
(!:) :: 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
sliceU :: UA e => UArr e -> Int -> Int -> UArr e
Restrict access to a subrange of the original array (no copying)
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
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)
bpermuteDftU
:: UA e
=> Intlength of result array
-> Int -> einitialiser 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 Streams.

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.

filterSU :: UA e => (e -> Bool) -> SUArr e -> SUArr e
Filter segmented array
packCU :: UA e => UArr Bool -> SUArr e -> SUArr e
combineU :: UA a => UArr Bool -> UArr a -> UArr a -> UArr a
combineSU :: UA a => UArr Bool -> SUArr a -> SUArr a -> UArr a
Merge two segmented arrays according to flag array
combineCU :: UA e => UArr Bool -> SUArr e -> SUArr e -> SUArr e
Segmented Subarrays
sliceSU :: UA e => SUArr e -> Int -> Int -> SUArr e
Extract a subrange of the segmented array without copying the elements.
extractSU :: UA e => SUArr e -> Int -> Int -> SUArr e
Extract a subrange of the segmented array (elements are copied).
takeCU :: UA e => Int -> SUArr e -> SUArr e
dropCU :: UA e => Int -> SUArr e -> SUArr e
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
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)
show/hide Instances
UIO Double
UIO Int
(UIO a, UIO b) => UIO (a :*: b)
Segmentation
concatSU :: UA e => SUArr e -> UArr e
Concatenate the subarrays of an array of arrays
flattenSU :: UA e => SUArr e -> UArr e
Yield the flat data array
(>:) :: UA a => USegd -> UArr a -> SUArr a
Compose a nested array.
segmentU :: (UA e', UA e) => SUArr e' -> UArr e -> SUArr e
Segment an array according to the segmentation of the first argument
segmentArrU :: UA e => UArr Int -> UArr e -> SUArr e
Segment an array according to the segmentation of the first argument
segdSU :: UA e => SUArr e -> USegd

Operations on segmented arrays -------------------------------

Yield the segment descriptor

Basic operations (segmented)
lengthSU :: UA e => SUArr e -> Int
Yield the number of segments.
singletonSU :: UA e => UArr e -> SUArr e
Segmentation -------------
replicateSU :: UA e => UArr Int -> UArr e -> SUArr e
replicateCU :: UA e => Int -> UArr e -> SUArr e
Yield a segmented array, where each element contains the same array value
(+:+^) :: UA e => SUArr e -> SUArr e -> SUArr e

Concatenate two arrays

FIXME: rename

indexedSU :: UA e => SUArr e -> SUArr (Int :*: e)
Associate each data element with its index
(^+:+^) :: UA a => SUArr a -> SUArr a -> SUArr a
Concatenation --------------
(!:^) :: UA e => SUArr e -> UArr Int -> UArr e
Array indexing
Basic operations lifted
lengthsSU :: UA e => SUArr e -> UArr Int
Yield the lengths of the segments.
indicesSU :: UA e => SUArr e -> UArr Int
Yield the starting indices of the segments.
Zipping (segmented)
fstSU :: (UA a, UA b) => SUArr (a :*: b) -> SUArr a
Zipping --------
sndSU :: (UA a, UA b) => SUArr (a :*: b) -> SUArr b
zipSU :: (UA a, UA b) => SUArr a -> SUArr b -> SUArr (a :*: b)
Permutations (segmented)
bpermuteSU :: UA e => SUArr e -> SUArr Int -> SUArr e
Segmented back permute
bpermuteSU' :: UA e => UArr e -> SUArr Int -> SUArr e
Higher-order operations (segmented)
mapSU :: (UA a, UA b) => (a -> b) -> SUArr a -> SUArr b
zipWithSU :: (UA a, UA b, UA c) => (a -> b -> c) -> SUArr a -> SUArr b -> SUArr c
foldlSU :: (UA a, UA b) => (b -> a -> b) -> b -> SUArr a -> UArr b
Segmented array reduction proceeding from the left
foldSU :: UA a => (a -> a -> a) -> a -> SUArr a -> UArr a
Segmented array reduction that requires an associative combination function with its unit
fold1SU :: UA a => (a -> a -> a) -> SUArr a -> UArr a
Segmented array reduction with non-empty subarrays and an associative combination function
Logical operations (segmented)
andSU :: SUArr Bool -> UArr Bool
orSU :: SUArr Bool -> UArr Bool
Arithmetic operations (segmented)
sumSU :: (Num e, UA e) => SUArr e -> UArr e
Compute the segmented sum of an array of numerals
productSU :: (Num e, UA e) => SUArr e -> UArr e
Compute the segmented product of an array of numerals
maximumSU :: (Ord e, UA e) => SUArr e -> UArr e
Determine the maximum element in each subarray
minimumSU :: (Ord e, UA e) => SUArr e -> UArr e
Determine the minimum element in each subarray
Enumerations (segmented)
enumFromToSU :: (Enum e, UA e) => UArr e -> UArr e -> SUArr e

Enumeration functions ----------------------

Yield a segmented enumerated array

enumFromThenToSU :: (Enum e, UA e) => UArr e -> UArr e -> UArr e -> SUArr e
Yield a segmented enumerated array using a specific step
Conversions to/from lists (segmented)
toSU :: UA e => [[e]] -> SUArr e

Conversion -----------

Turn a nested list into a segmented parallel array

fromSU :: UA e => SUArr e -> [[e]]
Turn a segmented array into a nested list
Segment descriptors
lengthsUSegd :: USegd -> UArr Int
Yield the segment lengths of a segment descriptor
lengthsToUSegd :: UArr Int -> USegd
Convert a length array into a segment descriptor.
toUSegd :: UArr (Int :*: Int) -> USegd
Convert an array of length/index pairs to a segment descriptor.
fromUSegd :: USegd -> UArr (Int :*: Int)
Convert a segment descriptor to an array of length/index pairs.
Mutable arrays
newU :: UA e => Int -> (forall s. MUArr e s -> ST s ()) -> UArr e
Creating unboxed arrays ------------------------
newMU :: UA e => Int -> ST s (MUArr e s)
Allocate a mutable unboxed array
copyMU :: UA e => 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
permuteMU :: UA e => MUArr e s -> UArr e -> UArr Int -> ST s ()
Permutations -------------
hasAtomicWriteMU :: UA e => e -> Bool
Indicate whether the type supports atomic updates
atomicUpdateMU :: UA e => MUArr e s -> UArr (Int :*: e) -> ST s ()
unsafeFreezeAllMU :: UA e => MUArr e s -> ST s (UArr e)
Library id
lengthU' :: UA e => UArr e -> Int
FIXME: A fuseable version of lengthU, should go away
Produced by Haddock version 2.3.0