Class of array representations that we can read elements from in a random-access manner.

Constraint synonym that requires an integer index space.

O(1). Alias for index.

O(1). Get the number of elements in an array.

O(1). Take the first element of an array, if there is one.

Compute all elements defined by a delayed array and write them to a manifest target representation.

The instances of this class require that the source array has a delayed representation. If you want to use a pre-existing manifest array as the source then delay it first.

Class of manifest array representations that can be constructed in a random-access manner.

Constraint synonym that requires an integer index space.

Sequential computation of delayed array elements.

Elements of the source array are computed sequentially and written to a new array of the specified layout.

Like computeS but use the provided desination layout.

The size of the destination layout must match the size of the source array, else Nothing.

O(1). An empty array of the given layout.

O(1). Create a new empty array containing a single element.

Generate an array of the given length by applying a function to every index, sequentially. If any element returns Nothing, then Nothing for the whole array.

Apply a function to every element of an array, if any application returns Nothing, then Nothing for the whole result.

Generate an array of the given length by applying a function to every index, sequentially. If any element returns Left, then Left for the whole array.

Apply a function to every element of an array, if any application returns Left, then Left for the whole result.

O(length src). Construct a linear array from a list of elements.

O(length src). Construct an array from a list of elements, and give it the provided layout.

The length of the provided shape must match the length of the list, else Nothing.

Convert an array to a list.

O(1). Constant time conversion of one array representation to another.

O(n). Linear time copy of one array representation to another.

This function must be used instead of convert when the bit-wise layout of the two array representations are different.

Segmented replicate.

Like map, but immediately computeS the result.

Like map2, but immediately computeS the result.

Merge two sorted key-value streams.

Like merge, but only produce the elements where the worker functions return Just.

Combination of fold and filter.

We walk over the stream front to back, maintaining an accumulator. At each point we can chose to emit an element (or not).

Like compact but use the first value of the stream as the initial state, and add the final state to the end of the output.

Apply a generic stream process to an array.

Apply a generic stream process to an array.

Keep the elements of an array that match the given predicate.

Insert elements produced by the given function in to an array.

O(len src) Yield Just the index of the first element matching the predicate or Nothing if no such element exists.

O(len result) Concatenate nested arrays.

> import Data.Repa.Array.Material
> let arrs = fromList B [fromList U [1, 2, 3], fromList U [5, 6, 7 :: Int]]
> toList $ concat U arrs
[1,2,3,5,6,7]

O(len result) Concatenate the elements of some nested vector, inserting a copy of the provided separator array between each element.

> import Data.Repa.Array.Material
> let sep  = fromList U [0, 0, 0]
> let arrs = fromList B [fromList U [1, 2, 3], fromList U [5, 6, 7 :: Int]]
> toList $ concatWith U sep arrs
[1,2,3,0,0,0,5,6,7,0,0,0]

O(len result). Perform a concatWith, adding a newline character to the end of each inner array.

O(len result) Insert a copy of the separator array between the elements of the second and concatenate the result.

> import Data.Repa.Array.Material
> let sep  = fromList U [0, 0, 0]
> let arrs = fromList B [fromList U [1, 2, 3], fromList U [5, 6, 7 :: Int]]
> toList $ intercalate U sep arrs
[1,2,3,0,0,0,5,6,7]

Dictionaries needed to perform a concatenation.

From a stream of values which has consecutive runs of idential values, produce a stream of the lengths of these runs.

> import Data.Repa.Array.Material
> import Data.Repa.Nice
> nice $ groups U U (fromList U "waaabllle")
([(w,1),(a,3),(b,1),(l,3)],Just (e,1))

Like groups, but use the given function to determine whether two consecutive elements should be in the same group. Also take an initial starting group and count.

> import Data.Repa.Array.Material
> import Data.Repa.Nice
> nice $ groupsWith U U (==) (Just (w, 5)) (fromList U "waaabllle")
([(w,6),(a,3),(b,1),(l,3)],Just (e,1))

Dictionaries need to perform a grouping.

Left fold of all elements in an array, sequentially.

Yield the sum of the elements of an array.

Yield the product of the elements of an array.

Yield the mean value of the elements of an array.

Yield the standard deviation of the elements of an array

Compute the Pearson correlation of two arrays.

If the arrays differ in length then only the common prefix is correlated.

Segmented fold over vectors of segment lengths and input values.

• The total lengths of all segments need not match the length of the input elements vector. The returned Folds state can be inspected to determine whether all segments were completely folded, or the vector of segment lengths or elements was too short relative to the other.

> import Data.Repa.Array.Material
> import Data.Repa.Nice
> let segs  = fromList B [("red", 3), ("green", 5)]
> let vals  = fromList U [0..100 :: Int]
> nice $ fst $ folds B U (+) 0 segs vals
[("red",3),("green",25)]

Like folds, but take an initial state for the first segment.

> import Data.Repa.Array.Material
> import Data.Repa.Nice
> let state = Just ("white", 4, 100)
> let segs  = fromList B [("red", 3), ("green", 5)]
> let vals  = fromList U [0..100 :: Int]
> nice $ fst $ foldsWith B U (+) 0  state segs vals
[("white",106),("red",15),("green",45)]

Return state of a folds operation.

Dictionaries need to perform a segmented fold.