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

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

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