Class of array representations that we can read elements from.

O(1). Alias for index

O(n). Convert an array to a list.

Apply deepSeqArray to up to four arrays.

Parallel computation of array elements.

• The source array must have a delayed representation like D, C or P, and the result a manifest representation like U or F.
• If you want to copy data between manifest representations then use copyP instead.
• If you want to convert a manifest array back to a delayed representation then use delay instead.

Sequential computation of array elements.

Parallel copying of arrays.

• This is a wrapper that delays an array before calling computeP.
• You can use it to copy manifest arrays between representations.

Sequential copying of arrays.

Delayed arrays are represented as functions from the index to element value.

Every time you index into a delayed array the element at that position is recomputed.

O(1). Wrap a function as a delayed array.

O(1). Produce the extent of an array, and a function to retrieve an arbitrary element.

O(1). Delay an array. This wraps the internal representation to be a function from indices to elements, so consumers don't need to worry about what the previous representation was.

Unboxed arrays are represented as unboxed vectors.

The implementation uses Data.Vector.Unboxed which is based on type families and picks an efficient, specialised representation for every element type. In particular, unboxed vectors of pairs are represented as pairs of unboxed vectors. This is the most efficient representation for numerical data.

Parallel computation of array elements.

• This is an alias for computeP with a more specific type.

Sequential computation of array elements..

• This is an alias for computeS with a more specific type.

O(n). Convert a list to an unboxed vector array.

• This is an alias for fromList with a more specific type.

O(1). Wrap an unboxed vector as an array.

O(1). Unpack an unboxed vector from an array.

Impose a new shape on the elements of an array. The new extent must be the same size as the original, else error.

Append two arrays.

Append two arrays.

Extract a sub-range of elements from an array.

Transpose the lowest two dimensions of an array. Transposing an array twice yields the original.

Backwards permutation of an array's elements.

Default backwards permutation of an array's elements. If the function returns Nothing then the value at that index is taken from the default array (arrDft)

Take a slice from an array, according to a given specification.

For example, to take a row from a matrix use the following:

slice arr (Any :. (5::Int) :. All)

To take a column use:

slice arr (Any :. (5::Int))

Extend an array, according to a given slice specification.

For example, to replicate the rows of an array use the following:

extend (Any :. (5::Int) :. All) arr

Apply a worker function to each element of an array, yielding a new array with the same extent.

Combine two arrays, element-wise, with a binary operator. If the extent of the two array arguments differ, then the resulting array's extent is their intersection.

Structured versions of map and zipWith that preserve the representation of cursored and partitioned arrays.

For cursored (C) arrays, the cursoring of the source array is preserved.

For partitioned (P) arrays, the worker function is fused with each array partition separately, instead of treating the whole array as a single bulk object.

Preserving the cursored and/or paritioned representation of an array is will make follow-on computation more efficient than if the array was converted to a vanilla Delayed (D) array as with plain map and zipWith.

If the source array is not cursored or partitioned then smap and szipWith are identical to the plain functions.

Unstructured traversal.

Unstructured traversal over two arrays at once.

Unstructured traversal over three arrays at once.

Unstructured traversal over four arrays at once.

Interleave the elements of two arrays. All the input arrays must have the same extent, else error. The lowest dimension of the result array is twice the size of the inputs.

 interleave2 a1 a2   b1 b2  =>  a1 b1 a2 b2
             a3 a4   b3 b4      a3 b3 a4 b4

Interleave the elements of three arrays.

Interleave the elements of four arrays.

Parallel reduction of the innermost dimension of an arbitray rank array.

The first argument needs to be an associative sequential operator. The starting element must be neutral with respect to the operator, for example 0 is neutral with respect to (+) as 0 + a = a. These restrictions are required to support parallel evaluation, as the starting element may be used multiple times depending on the number of threads.

Elements are reduced in the order of their indices, from lowest to highest. Applications of the operator are associatied arbitrarily.

>>> let c 0 x = x; c x 0 = x; c x y = y
>>> let a = fromListUnboxed (Z :. 2 :. 2) [1,2,3,4] :: Array U (Z :. Int :. Int) Int
>>> foldP c 0 a
AUnboxed (Z :. 2) (fromList [2,4])

Sequential reduction of the innermost dimension of an arbitrary rank array.

Combine this with transpose to fold any other dimension.

Elements are reduced in the order of their indices, from lowest to highest. Applications of the operator are associatied arbitrarily.

>>> let c 0 x = x; c x 0 = x; c x y = y
>>> let a = fromListUnboxed (Z :. 2 :. 2) [1,2,3,4] :: Array U (Z :. Int :. Int) Int
>>> foldS c 0 a
AUnboxed (Z :. 2) (fromList [2,4])

Parallel reduction of an array of arbitrary rank to a single scalar value.

The first argument needs to be an associative sequential operator. The starting element must be neutral with respect to the operator, for example 0 is neutral with respect to (+) as 0 + a = a. These restrictions are required to support parallel evaluation, as the starting element may be used multiple times depending on the number of threads.

Elements are reduced in row-major order. Applications of the operator are associated arbitrarily.

Sequential reduction of an array of arbitrary rank to a single scalar value.

Elements are reduced in row-major order. Applications of the operator are associated arbitrarily.

Parallel sum the innermost dimension of an array.

Sequential sum the innermost dimension of an array.

Parallel sum all the elements of an array.

Sequential sum of all the elements of an array.

Check whether two arrays have the same shape and contain equal elements, in parallel.

Check whether two arrays have the same shape and contain equal elements, sequentially.

Produce an array by applying a predicate to a range of integers. If the predicate matches, then use the second function to generate the element.

• This is a low-level function helpful for writing filtering operations on arrays.
• Use the integer as the index into the array you're filtering.