Data.Array.Parallel.PArray

Parallel Arrays.

Documentation

data PArray a

Lifted/bulk parallel arrays This contains the array length, along with the element data.

Instances

(PA a, Show a) => Show (PArray a)

PR a => PR (PArray a)

PA a => PA (PArray a)

class PR (PRepr a) => PA a

A PA dictionary contains the functions that we use to convert a representable type to and from its generic representation. The conversion methods should all be O(1).

Instances

PA Bool

PA Double

PA Float

PA Int

PA Word8

PA ()

PA Void

PA a => PA (PArray a)

(PA a, PA b) => PA (a, b)

(PA a, PA b) => PA (:-> a b)

(PA a, PA b, PA c) => PA (a, b, c)

(PA a, PA b, PA c, PA d) => PA (a, b, c, d)

(PA a, PA b, PA c, PA d, PA e) => PA (a, b, c, d, e)

(PA a, PA b, PA c, PA d, PA e, PA f) => PA (a, b, c, d, e, f)

(PA a, PA b, PA c, PA d, PA e, PA f, PA g) => PA (a, b, c, d, e, f, g)

(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h) => PA (a, b, c, d, e, f, g, h)

(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i) => PA (a, b, c, d, e, f, g, h, i)

(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j) => PA (a, b, c, d, e, f, g, h, i, j)

(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k) => PA (a, b, c, d, e, f, g, h, i, j, k)

(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k, PA l) => PA (a, b, c, d, e, f, g, h, i, j, k, l)

(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k, PA l, PA m) => PA (a, b, c, d, e, f, g, h, i, j, k, l, m)

(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k, PA l, PA m, PA n) => PA (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k, PA l, PA m, PA n, PA o) => PA (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Random a where

Methods

randoms :: RandomGen g => Int -> g -> PArray a

randomRs :: RandomGen g => Int -> (a, a) -> g -> PArray a

Instances

Random Double

Random Int

Evaluation

nf :: PA a => PArray a -> ()

Ensure an array is fully evaluated.

Constructors

empty :: PA a => PArray a

O(1). An empty array, with no elements.

singleton :: PA a => a -> PArray a

O(1). Produce an array containing a single element.

replicate :: PA a => Int -> a -> PArray a

O(n). Produce an array containing copies of a given element.

(+:+) :: PA a => PArray a -> PArray a -> PArray a

Append two arrays

concat :: PA a => PArray (PArray a) -> PArray a

Concatenate an array of arrays into a single array.

nestUSegd

Arguments

:: Segd

segment descriptor

-> PArray a

array of data elements.

-> PArray (PArray a)

O(1). Create a nested array.

Projections

length :: PA a => PArray a -> Int

O(1). Yield the length of an array.

(!:) :: PA a => PArray a -> Int -> a

O(1). Retrieve a numbered element from an array.

slice :: PA a => Int -> Int -> PArray a -> PArray a

Extract a subrange of elements from an array. The first argument is the starting index, while the second is the length of the slice.

Update

update :: PA a => PArray a -> PArray (Int, a) -> PArray a

Copy the source array in the destination, using new values for the given indices.

Pack and Combine

pack :: PA a => PArray a -> PArray Bool -> PArray a

Select the elements of an array that have their tag set as True.

 packPA [12, 24, 42, 93] [True, False, False, True]
  = [24, 42]

bpermute :: PA a => PArray a -> PArray Int -> PArray a

O(n). Backwards permutation of array elements.

bpermute [50, 60, 20, 30] [0, 3, 2]  = [50, 30, 20]

Enumerations

enumFromTo :: Int -> Int -> PArray Int

O(n). Generate a range of Ints.

indexed :: PA a => PArray a -> PArray (Int, a)

O(n). Tag each element of an array with its index.

indexed [42, 93, 13] = [(0, 42), (1, 93), (2, 13)]

Tuples

zip :: (PA a, PA b) => PArray a -> PArray b -> PArray (a, b)

O(1). Takes two arrays and returns an array of corresponding pairs. If one array is short, excess elements of the longer array are discarded.

unzip :: (PA a, PA b) => PArray (a, b) -> (PArray a, PArray b)

O(1). Transform an array into an array of the first components, and an array of the second components.

Conversions

fromList :: PA a => [a] -> PArray a

Create a PArray from a list.

toList :: PA a => PArray a -> [a]

Create a list from a PArray.

fromUArray :: Scalar a => Array a -> PArray a

Create a PArray out of a scalar U.Array, the first argument is the array length.

TODO: ditch this version, just use fromUArrPA'

toUArray :: Scalar a => PArray a -> Array a

Convert a PArray back to a plain U.Array.

fromUArray2 :: (Scalar a, Scalar b) => Array (a, b) -> PArray (a, b)

Convert an U.Array of pairs to a PArray.

fromUArray3 :: (Scalar a, Scalar b, Scalar c) => Array ((a, b), c) -> PArray (a, b, c)

Convert a U.Array of triples to a PArray.