Data.Array.Parallel.Unlifted.Sequential

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 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

Read USegd

Show USegd

data SUArr e

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

Segmented arrays (only one level of segmentation)

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 -> 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

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
=> 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 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)

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 ------------------------

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

name

versnum

date

version

disclaimer

lengthU' :: UA e => UArr e -> Int

FIXME: A fuseable version of lengthU, should go away

Produced by Haddock version 2.4.2