dph-prim-seq-0.3: Sequential Primitives for Data-Parallel Haskell.Source codeContentsIndex
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
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
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
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
name
versnum
date
version
copyright
disclaimer
lengthU' :: UA e => UArr e -> Int
Array classes
class HS e => UA e whereSource

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 Source
data MUArr e :: * -> *Source
Methods
lengthU :: UArr e -> IntSource
Yield the length of an unboxed array
sliceU :: UArr e -> Int -> Int -> UArr eSource
Restrict access to a subrange of the original array (no copying)
newMU :: Int -> ST s (MUArr e s)Source
Allocate a mutable unboxed array
hasAtomicWriteMU :: e -> BoolSource
Indicate whether the type supports atomic updates
copyMU :: MUArr e s -> Int -> UArr e -> ST s ()Source
Copy the contents of an immutable unboxed array into a mutable one from the specified position on
show/hide Instances
Array types
data USegd Source
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 Source

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
nullU :: UA e => UArr e -> BoolSource
Test whether the given array is empty
emptyU :: UA e => UArr eSource
Yield an empty array
singletonU :: UA e => e -> UArr eSource
Yield a singleton array
consU :: UA e => e -> UArr e -> UArr eSource
Prepend an element to an array
unitsU :: Int -> UArr ()Source

Basic operations on unboxed arrays -----------------------------------

Yield an array of units

replicateU :: UA e => Int -> e -> UArr eSource
Yield an array where all elements contain the same value
replicateEachU :: UA e => Int -> UArr Int -> UArr e -> UArr eSource
(!:) :: UA e => UArr e -> Int -> eSource
Array indexing
(+:+) :: UA e => UArr e -> UArr e -> UArr eSource
Concatenate two arrays
indexedU :: UA e => UArr e -> UArr (Int :*: e)Source

Indexing ---------

Associate each element of the array with its index

repeatU :: UA e => Int -> UArr e -> UArr eSource
Repeat an array n times
Subarrays
extractU :: UA a => UArr a -> Int -> Int -> UArr aSource
tailU :: UA e => UArr e -> UArr eSource
Yield the tail of an array
takeU :: UA e => Int -> UArr e -> UArr eSource
Extract a prefix of an array
dropU :: UA e => Int -> UArr e -> UArr eSource
Extract a suffix of an array
splitAtU :: UA e => Int -> UArr e -> (UArr e, UArr e)Source
Split an array into two halves at the given index
Permutations
permuteU :: UA e => UArr e -> UArr Int -> UArr eSource
Standard permutation
bpermuteU :: UA e => UArr e -> UArr Int -> UArr eSource
Back permutation operation (ie, the permutation vector determines for each position in the result array its origin in the input array)
bpermuteDftUSource
:: 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 eSource
Reverse the order of elements in an array
updateU :: UA e => UArr e -> UArr (Int :*: e) -> UArr eSource
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'Source
Map a function over an array
zipWithU :: (UA a, UA b, UA c) => (a -> b -> c) -> UArr a -> UArr b -> UArr cSource
zipWith3U :: (UA a, UA b, UA c, UA d) => (a -> b -> c -> d) -> UArr a -> UArr b -> UArr c -> UArr dSource
filterU :: UA e => (e -> Bool) -> UArr e -> UArr eSource
Extract all elements from an array that meet the given predicate
packU :: UA e => UArr e -> UArr Bool -> UArr eSource
Extract all elements from an array according to a given flag array
foldlU :: UA a => (b -> a -> b) -> b -> UArr a -> bSource
Array reduction proceeding from the left
foldl1U :: UA a => (a -> a -> a) -> UArr a -> aSource

Array reduction proceeding from the left for non-empty arrays

FIXME: Rewrite for Streams.

foldl1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS aSource
foldU :: UA a => (a -> a -> a) -> a -> UArr a -> aSource
Array reduction that requires an associative combination function with its unit
fold1U :: UA a => (a -> a -> a) -> UArr a -> aSource
Reduction of a non-empty array which requires an associative combination function
fold1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS aSource
scanlU :: (UA a, UA b) => (b -> a -> b) -> b -> UArr a -> UArr bSource
Prefix scan proceedings from left to right
scanl1U :: UA a => (a -> a -> a) -> UArr a -> UArr aSource
Prefix scan of a non-empty array proceeding from left to right
scanU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr aSource
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 aSource
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 :*: aSource
mapAccumLU :: (UA a, UA b) => (c -> a -> c :*: b) -> c -> UArr a -> UArr bSource

Accumulating map from left to right. Does not return the accumulator.

FIXME: Naming inconsistent with lists.

filterSU :: UA e => (e -> Bool) -> SUArr e -> SUArr eSource
Filter segmented array
packCU :: UA e => UArr Bool -> SUArr e -> SUArr eSource
combineU :: UA a => UArr Bool -> UArr a -> UArr a -> UArr aSource
combineSU :: UA a => UArr Bool -> SUArr a -> SUArr a -> UArr aSource
Merge two segmented arrays according to flag array
combineCU :: UA e => UArr Bool -> SUArr e -> SUArr e -> SUArr eSource
Segmented Subarrays
sliceSU :: UA e => SUArr e -> Int -> Int -> SUArr eSource
Extract a subrange of the segmented array without copying the elements.
extractSU :: UA e => SUArr e -> Int -> Int -> SUArr eSource
Extract a subrange of the segmented array (elements are copied).
takeCU :: UA e => Int -> SUArr e -> SUArr eSource
dropCU :: UA e => Int -> SUArr e -> SUArr eSource
Searching
elemU :: (Eq e, UA e) => e -> UArr e -> BoolSource
Determine whether the given element is in an array
notElemU :: (Eq e, UA e) => e -> UArr e -> BoolSource
Negation of elemU
Logical operations
andU :: UArr Bool -> BoolSource
orU :: UArr Bool -> BoolSource
anyU :: UA e => (e -> Bool) -> UArr e -> BoolSource
allU :: UA e => (e -> Bool) -> UArr e -> BoolSource
Arithmetic operations
sumU :: (Num e, UA e) => UArr e -> eSource
Compute the sum of an array of numerals
productU :: (Num e, UA e) => UArr e -> eSource
Compute the product of an array of numerals
maximumU :: (Ord e, UA e) => UArr e -> eSource
Determine the maximum element in an array
minimumU :: (Ord e, UA e) => UArr e -> eSource
Determine the minimum element in an array
maximumByU :: UA e => (e -> e -> Ordering) -> UArr e -> eSource
Determine the maximum element in an array under the given ordering
minimumByU :: UA e => (e -> e -> Ordering) -> UArr e -> eSource
Determine the minimum element in an array under the given ordering
maximumIndexU :: (Ord e, UA e) => UArr e -> IntSource
Determine the index of the maximum element in an array
minimumIndexU :: (Ord e, UA e) => UArr e -> IntSource
Determine the index of the minimum element in an array
maximumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> IntSource
Determine the index of the maximum element in an array under the given ordering
minimumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> IntSource
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)Source
Elementwise pairing of array elements.
zip3U :: (UA e1, UA e2, UA e3) => UArr e1 -> UArr e2 -> UArr e3 -> UArr ((e1 :*: e2) :*: e3)Source
unzipU :: (UA a, UA b) => UArr (a :*: b) -> UArr a :*: UArr bSource
Elementwise unpairing of array elements.
unzip3U :: (UA e1, UA e2, UA e3) => UArr ((e1 :*: e2) :*: e3) -> (UArr e1 :*: UArr e2) :*: UArr e3Source
fstU :: (UA a, UA b) => UArr (a :*: b) -> UArr aSource
Yield the first components of an array of pairs.
sndU :: (UA a, UA b) => UArr (a :*: b) -> UArr bSource
Yield the second components of an array of pairs.
Enumerations
enumFromToU :: Int -> Int -> UArr IntSource

Yield an enumerated array

FIXME: See comments about enumFromThenToS

enumFromThenToU :: Int -> Int -> Int -> UArr IntSource

Yield an enumerated array using a specific step

FIXME: See comments about enumFromThenToS

enumFromStepLenU :: Int -> Int -> Int -> UArr IntSource
enumFromToEachU :: Int -> UArr (Int :*: Int) -> UArr IntSource
Searching
findU :: UA a => (a -> Bool) -> UArr a -> Maybe aSource
findIndexU :: UA a => (a -> Bool) -> UArr a -> Maybe IntSource
Conversions to/from lists
toU :: UA e => [e] -> UArr eSource

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

Turn a list into a parallel array

fromU :: UA e => UArr e -> [e]Source
Collect the elements of a parallel array in a list
Unlifted.Sequential arrays
randomU :: (UA a, Random a, RandomGen g) => Int -> g -> UArr aSource
randomRU :: (UA a, Random a, RandomGen g) => Int -> (a, a) -> g -> UArr aSource
I/O
class UA a => UIO a whereSource
Methods
hPutU :: Handle -> UArr a -> IO ()Source
hGetU :: Handle -> IO (UArr a)Source
show/hide Instances
UIO Double
UIO Int
(UIO a, UIO b) => UIO (a :*: b)
Segmentation
concatSU :: UA e => SUArr e -> UArr eSource
Concatenate the subarrays of an array of arrays
flattenSU :: UA e => SUArr e -> UArr eSource
Yield the flat data array
(>:) :: UA a => USegd -> UArr a -> SUArr aSource
Compose a nested array.
segmentU :: (UA e', UA e) => SUArr e' -> UArr e -> SUArr eSource
Segment an array according to the segmentation of the first argument
segmentArrU :: UA e => UArr Int -> UArr e -> SUArr eSource
Segment an array according to the segmentation of the first argument
segdSU :: UA e => SUArr e -> USegdSource

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

Yield the segment descriptor

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

Concatenate two arrays

FIXME: rename

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

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

Yield a segmented enumerated array

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

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

Turn a nested list into a segmented parallel array

fromSU :: UA e => SUArr e -> [[e]]Source
Turn a segmented array into a nested list
Segment descriptors
lengthsUSegd :: USegd -> UArr IntSource
Yield the segment lengths of a segment descriptor
lengthsToUSegd :: UArr Int -> USegdSource
Convert a length array into a segment descriptor.
toUSegd :: UArr (Int :*: Int) -> USegdSource
Convert an array of length/index pairs to a segment descriptor.
fromUSegd :: USegd -> UArr (Int :*: Int)Source
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 eSource
Creating unboxed arrays ------------------------
permuteMU :: UA e => MUArr e s -> UArr e -> UArr Int -> ST s ()Source
Permutations -------------
atomicUpdateMU :: UA e => MUArr e s -> UArr (Int :*: e) -> ST s ()Source
unsafeFreezeAllMU :: UA e => MUArr e s -> ST s (UArr e)Source
Library id
idstr
name
versnum
date
version
copyright
disclaimer
lengthU' :: UA e => UArr e -> IntSource
FIXME: A fuseable version of lengthU, should go away
Produced by Haddock version 2.4.2