Delayed arrays wrap functions from an index to element value. The index space is specified by an inner layout, l.

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

Wrap a function as a delayed array.

> toList $ fromFunction (Linear 10) (* 2)
    = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Produce the extent of an array, and a function to retrieve an arbitrary element.

Wrap an existing array in a delayed one.

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

The resulting array is delayed, meaning every time you index into it the element at that index is recomputed.

A delayed array formed from two source arrays. The source arrays can have different layouts but must have the same extent.

Wrap two existing arrays in a delayed array.

Combine two arrays element-wise using the given worker function.

The two source arrays must have the same extent, else Nothing.

A linear layout with the elements indexed by integers.

• Indexing is not bounds checked. Indexing outside the extent yields the corresponding index.

Construct a linear array that produces the corresponding index for every element.

> toList $ linear 10
   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

A row-wise layout that maps higher rank indices to linear ones in a row-major order.

Indices are ordered so the inner-most coordinate varies most frequently:

> Prelude.map (fromIndex (RowWise (ish2 2 3))) [0..5]
   [(Z :. 0) :. 0, (Z :. 0) :. 1, (Z :. 0) :. 2, 
    (Z :. 1) :. 0, (Z :. 1) :. 1, (Z :. 1) :. 2]

• Indexing is not bounds checked. Indexing outside the extent yields the corresponding index.

Construct a rowWise array that produces the corresponding index for every element.

> toList $ rowWise (ish2 3 2) 
   [(Z :. 0) :. 0, (Z :. 0) :. 1,
    (Z :. 1) :. 0, (Z :. 1) :. 1,
    (Z :. 2) :. 0, (Z :. 2) :. 1]

Class of array representations that can be windowed directly.

The underlying representation can encode the window, without needing to add a wrapper to the existing layout.

Wrap a window around an exiting array.

Wrap a window around an existing array that encompases the entire array.

O(1). Take the tail of an array, or Nothing if it's empty.

O(1). Take the initial elements of an array, or Nothing if it's empty.

The Dense layout maps a higher-ranked index space to some underlying linear index space.

For example, we can create a dense 2D row-wise array where the elements are stored in a flat unboxed vector:

> import Data.Repa.Array.Material
> let Just arr  = fromListInto (matrix U 10 10) [1000..1099 :: Float]

> :type arr
arr :: Array (E U (RW DIM2) Float

> arr ! (Z :. 5 :. 4)
> 1054.0

Yield a layout for a dense vector of the given length.

The first argument is the name of the underlying linear layout which stores the elements.

Yield a layout for a matrix with the given number of rows and columns.

Yield a layout for a cube with the given number of planes, rows, and columns.

Tupled arrays where the components are unpacked and can have separate representations.

Tuple two arrays into an array of pairs.

The two argument arrays must have the same index type, but can have different extents. The extent of the result is the intersection of the extents of the two argument arrays.

Untuple an array of tuples in to a tuple of arrays.

• The two returned components may have different extents, though they are guaranteed to be at least as big as the argument array. This is the key property that makes untup2 different from unzip.