A hyperrectangular (or multidimensional) array with a value-level shape.

>>> let a = array [2,3,4] [1..24] :: Array Vector Int
>>> a
UnsafeArray [2,3,4] [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]

>>> pretty a
[[[1,2,3,4],
  [5,6,7,8],
  [9,10,11,12]],
 [[13,14,15,16],
  [17,18,19,20],
  [21,22,23,24]]]

Construct an array from a shape and a list of elements.

>>> array [2,3] [0..5]
UnsafeArray [2,3] [0,1,2,3,4,5]

Construct an array from a shape and a value without any shape validation.

>>> array [2,3] [0..5]
UnsafeArray [2,3] [0,1,2,3,4,5]

Construct an Array.

>>> pretty $ [2,3] >< [0..5]
[[0,1,2],
 [3,4,5]]

Validate the size and shape of an array.

>>> validate (array [2,3,4] [1..23] :: Array Vector Int)
False

Construct an Array, checking shape.

>>> safeArray [2,3,4] [0..23] == Just a
True

Internal smart constructor: precomputes strides for O(1) zero-allocation indexing.

Internal smart constructor from a list shape.

Unsafely modify an array shape.

>>> unsafeModifyShape (VU.map (+1)) (array [2,3] [0..5])
UnsafeArray [3,4] [0,1,2,3,4,5]

Unsafely modify an array vector.

>>> unsafeModifyVector (VG.map (+1)) (array [2,3] [0..5])
UnsafeArray [2,3] [1,2,3,4,5,6]

Representation of an index into a shape (an [Int]). The index is a dimension of the shape.

Representation of indexes into a shape (an [Int]). The indexes are dimensions of the shape.

Convert an array to its underlying vector. Drops shape information.

asVector . arrayV [size a] . asVector == a

>>> asVector (range [2,3])
[0,1,2,3,4,5]

Construct an array from a shape and an already-correctly-sized vector.

shape of an Array

>>> shape a
[2,3,4]

rank of an Array

>>> rank a
3

size of an Array, which is the total number of elements, if the Array Vector is valid.

>>> size a
24

Number of rows (first dimension size) in an Array. As a convention, a scalar value is still a single row.

>>> length a
2
>>> length (toScalar 0)
1

Is the Array Vector empty (has zero number of elements).

>>> isNull ([2,0] >< [] :: Array Vector ())
True
>>> isNull ([] >< [4] :: Array Vector Int)
False

Extract an element at an index, unsafely.

>>> index a [1,2,3]
23

Extract an element at an index, unsafely.

>>> a ! [1,2,3]
23

Extract an element at an index, safely.

>>> a !? [1,2,3]
Just 23
>>> a !? [2,3,1]
Nothing

Tabulate an array supplying a shape and a tabulation function.

>>> tabulate [2,3,4] (S.flatten (VU.fromList [2,3,4]) . VU.fromList) == a
True

backpermute is a tabulation where the contents of an array do not need to be accessed, and is thus a fulcrum for leveraging laziness and fusion via the rule:

backpermute f g (backpermute f' g' a) == backpermute (f . f') (g . g') a

Many functions in this module are examples of backpermute usage.

>>> pretty $ backpermute VU.reverse VU.reverse a
[[[0,12],
  [4,16],
  [8,20]],
 [[1,13],
  [5,17],
  [9,21]],
 [[2,14],
  [6,18],
  [10,22]],
 [[3,15],
  [7,19],
  [11,23]]]

Unwrap a scalar.

>>> let s = array [] [3] :: Array Vector Int
>>> fromScalar s
3

Wrap a scalar.

>>> :t toScalar 2
toScalar 2 :: Num a => Array Vector a

Is an array a Scalar?

>>> isScalar (toScalar (2::Int))
True

Convert a scalar to being a dimensioned array. Do nothing if not a scalar.

>>> asSingleton (toScalar 4)
UnsafeArray [1] [4]

Convert an array with shape [1] to being a scalar (Do nothing if not a shape [1] array).

>>> asScalar (singleton 3)
UnsafeArray [] [3]

An array with no elements.

>>> empty
UnsafeArray [0] []

An enumeration of row-major or lexicographic order.

>>> pretty $ range [2,3]
[[0,1,2],
 [3,4,5]]

An enumeration of col-major or colexicographic order.

>>> pretty (corange [2,3,4])
[[[0,6,12,18],
  [2,8,14,20],
  [4,10,16,22]],
 [[1,7,13,19],
  [3,9,15,21],
  [5,11,17,23]]]

Indices of an array shape.

>>> pretty $ indices [3,3]
[[[0,0],[0,1],[0,2]],
 [[1,0],[1,1],[1,2]],
 [[2,0],[2,1],[2,2]]]

The identity array.

>>> pretty $ ident [3,3]
[[1,0,0],
 [0,1,0],
 [0,0,1]]

Create an array composed of a single value.

>>> pretty $ konst [3,2] 1
[[1,1],
 [1,1],
 [1,1]]

Create an array of shape [1].

>>> pretty $ singleton 1
[1]
>>> singleton 3 == toScalar 3
False

>>> asVector (singleton 3) == asVector (toScalar 3)
True

Extract the diagonal of an array.

>>> pretty $ diag (ident [3,3])
[1,1,1]

Expand the array to form a diagonal array.

>>> pretty $ undiag (range [3])
[[0,0,0],
 [0,1,0],
 [0,0,2]]

Functor-like map with an explicit vector constraint.

Foldable-like fold with an explicit vector constraint.

Convert an array to a list.

Zip two arrays at an element level.

>>> zipWith (-) v v
UnsafeArray [3] [0,0,0]

Zip two arrays at an element level, checking for shape consistency.

>>> zipWithSafe (-) (range [3]) (range [4])
Nothing

Modify a single value at an index.

>>> pretty $ modify [0,0] (const 100) (range [3,2])
[[100,1],
 [2,3],
 [4,5]]

Maps an index function at element-level.

>>> pretty $ imap (\xs x -> x - sum xs) a
[[[0,0,0,0],
  [3,3,3,3],
  [6,6,6,6]],
 [[11,11,11,11],
  [14,14,14,14],
  [17,17,17,17]]]

With a function that takes dimensions and (type-level) parameters, apply the parameters to the initial dimensions. ie

rowWise f xs = f [0..] xs

>>> rowWise indexes [1,0] a
UnsafeArray [4] [12,13,14,15]

With a function that takes dimensions and (type-level) parameters, apply the parameters to the the last dimensions. ie

colWise f xs = f (List.reverse [0 .. (rank a - 1)]) xs

>>> colWise indexes [1,0] a
UnsafeArray [2] [1,13]

With a function that takes a dimension and a parameter, fold dimensions and parameters using the function.

>>> dimsWise take [0,2] [1,2] a
UnsafeArray [1,3,2] [0,1,4,5,8,9]

Take the top-most elements across the specified dimension. Negative values take the bottom-most. No index check is performed.

take d x == takes [(d,x)]

>>> pretty $ take 2 1 a
[[[0],
  [4],
  [8]],
 [[12],
  [16],
  [20]]]
>>> pretty $ take 2 (-1) a
[[[3],
  [7],
  [11]],
 [[15],
  [19],
  [23]]]

Drop the top-most elements across the specified dimension. Negative values take the bottom-most.

>>> pretty $ drop 2 1 a
[[[1,2,3],
  [5,6,7],
  [9,10,11]],
 [[13,14,15],
  [17,18,19],
  [21,22,23]]]
>>> pretty $ drop 2 (-1) a
[[[0,1,2],
  [4,5,6],
  [8,9,10]],
 [[12,13,14],
  [16,17,18],
  [20,21,22]]]

Select an index along a dimension.

>>> let s = select 2 3 a
>>> pretty s
[[3,7,11],
 [15,19,23]]

Insert along a dimension at a position.

>>> pretty $ insert 2 0 a (konst [2,3] 0)
[[[0,0,1,2,3],
  [0,4,5,6,7],
  [0,8,9,10,11]],
 [[0,12,13,14,15],
  [0,16,17,18,19],
  [0,20,21,22,23]]]
>>> insert 0 0 (toScalar 1) (toScalar 2)
UnsafeArray [2] [2,1]

Delete along a dimension at a position.

>>> pretty $ delete 2 0 a
[[[1,2,3],
  [5,6,7],
  [9,10,11]],
 [[13,14,15],
  [17,18,19],
  [21,22,23]]]

Insert along a dimension at the end.

>>> pretty $ append 2 a (konst [2,3] 0)
[[[0,1,2,3,0],
  [4,5,6,7,0],
  [8,9,10,11,0]],
 [[12,13,14,15,0],
  [16,17,18,19,0],
  [20,21,22,23,0]]]

Insert along a dimension at the beginning.

>>> pretty $ prepend 2 (konst [2,3] 0) a
[[[0,0,1,2,3],
  [0,4,5,6,7],
  [0,8,9,10,11]],
 [[0,12,13,14,15],
  [0,16,17,18,19],
  [0,20,21,22,23]]]

Concatenate along a dimension.

>>> shape $ concatenate 1 a a
[2,6,4]
>>> concatenate 0 (toScalar 1) (toScalar 2)
UnsafeArray [2] [1,2]
>>> concatenate 0 (toScalar 0) (asArray [1..3])
UnsafeArray [4] [0,1,2,3]

Combine two arrays as a new dimension of a new array.

>>> pretty $ couple 0 (asArray [1,2,3]) (asArray [4,5,6::Int])
[[1,2,3],
 [4,5,6]]

Slice along a dimension with the supplied offset & length.

>>> let s = slice 2 1 2 a
>>> pretty s
[[[1,2],
  [5,6],
  [9,10]],
 [[13,14],
  [17,18],
  [21,22]]]

Rotate an array along a dimension.

>>> pretty $ rotate 1 2 a
[[[8,9,10,11],
  [0,1,2,3],
  [4,5,6,7]],
 [[20,21,22,23],
  [12,13,14,15],
  [16,17,18,19]]]

Takes the top-most elements across the supplied dimension,n tuples. Negative values take the bottom-most.

takes == dimsWise take

>>> pretty $ takes [0,2] [1,-3] a
[[[1,2,3],
  [5,6,7],
  [9,10,11]]]

Drops the top-most elements. Negative values drop the bottom-most.

>>> pretty $ drops [0,1,2] [1,2,-3] a
[[[20]]]

Select by dimensions and indexes.

>>> let s = indexes [0,1] [1,1] a
>>> pretty s
[16,17,18,19]

Slice along dimensions with the supplied offsets and lengths.

>>> let s = slices [2,0] [1,1] [2,1] a
>>> pretty s
[[[13,14],
  [17,18],
  [21,22]]]

Select the first element along the supplied dimensions.

>>> pretty $ heads [0,2] a
[0,4,8]

Select the last element along the supplied dimensions.

>>> pretty $ lasts [0,2] a
[15,19,23]

Select the tail elements along the supplied dimensions.

>>> pretty $ tails [0,2] a
[[[13,14,15],
  [17,18,19],
  [21,22,23]]]

Select the init elements along the supplied dimensions.

>>> pretty $ inits [0,2] a
[[[0,1,2],
  [4,5,6],
  [8,9,10]]]

Extracts dimensions to an outer layer.

>>> pretty $ fmapA shape (extracts [0] a)
[[3,4],[3,4]]

Reduce along specified dimensions, using the supplied fold.

>>> pretty $ reduces [0] sumA a
[66,210]
>>> pretty $ reduces [0,2] sumA a
[[12,15,18,21],
 [48,51,54,57]]

Join inner and outer dimension layers by supplied dimensions. No checks on shape.

>>> let e = extracts [1,0] a
>>> let j = joins [1,0] e
>>> a == j
True

Join inner and outer dimension layers by supplied dimensions. Check inner layer shape.

>>> let e = extracts [1,0] a
>>> (Just j) = joinsSafe [1,0] e
>>> a == j
True

Join inner and outer dimension layers in outer dimension order.

>>> a == join (extracts [0,1] a)
True

Join inner and outer dimension layers in outer dimension order, checking for consistent inner dimension shape.

>>> joinSafe (extracts [0,1] a)
Just (UnsafeArray [2,3,4] [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23])

Traverse along specified dimensions.

traverses [1] print (range [2,3]) 0 3 1 4 2 5 UnsafeArray [2,3] [(),(),(),(),(),()]

Maps a function along specified dimensions.

>>> pretty $ maps [1] transpose a
[[[0,12],
  [4,16],
  [8,20]],
 [[1,13],
  [5,17],
  [9,21]],
 [[2,14],
  [6,18],
  [10,22]],
 [[3,15],
  [7,19],
  [11,23]]]

Filters along specified dimensions (which are flattened).

>>> pretty $ filters [0,1] (anyA ((==0) . (`mod` 7))) a
[[0,1,2,3],
 [4,5,6,7],
 [12,13,14,15],
 [20,21,22,23]]

Zips two arrays with a function along specified dimensions.

>>> pretty $ zips [0,1] (zipWith (,)) a (reverses [0] a)
[[[(0,12),(1,13),(2,14),(3,15)],
  [(4,16),(5,17),(6,18),(7,19)],
  [(8,20),(9,21),(10,22),(11,23)]],
 [[(12,0),(13,1),(14,2),(15,3)],
  [(16,4),(17,5),(18,6),(19,7)],
  [(20,8),(21,9),(22,10),(23,11)]]]

Zips two arrays with a function along specified dimensions, checking shapes.

>>> zipsSafe [0] (zipWith (,)) (asArray [1::Int]) (asArray [1,2::Int])
Nothing

Modify using the supplied function along dimensions & positions.

>>> pretty $ modifies (fmapA (100+)) [2] [0] a
[[[100,1,2,3],
  [104,5,6,7],
  [108,9,10,11]],
 [[112,13,14,15],
  [116,17,18,19],
  [120,21,22,23]]]

Apply a binary function between successive slices, across dimensions and lags.

>>> pretty $ diffs [1] [1] (zipWith (-)) a
[[[4,4,4,4],
  [4,4,4,4]],
 [[4,4,4,4],
  [4,4,4,4]]]

Product two arrays using the supplied binary function.

For context, if the function is multiply, and the arrays are tensors, then this can be interpreted as a tensor product. The concept of a tensor product is a dense crossroad, and a complete treatment is elsewhere. To quote the wiki article:

... the tensor product can be extended to other categories of mathematical objects in addition to vector spaces, such as to matrices, tensors, algebras, topological vector spaces, and modules. In each such case the tensor product is characterized by a similar universal property: it is the freest bilinear operation. The general concept of a "tensor product" is captured by monoidal categories; that is, the class of all things that have a tensor product is a monoidal category.

>>> x = array [3] [1,2,3]
>>> pretty $ expand (*) x x
[[1,2,3],
 [2,4,6],
 [3,6,9]]

Alternatively, expand can be understood as representing the permutation of element pairs of two arrays, so like the Applicative List instance.

>>> i2 = indices [2,2]
>>> pretty $ expand (,) i2 i2
[[[[([0,0],[0,0]),([0,0],[0,1])],
   [([0,0],[1,0]),([0,0],[1,1])]],
  [[([0,1],[0,0]),([0,1],[0,1])],
   [([0,1],[1,0]),([0,1],[1,1])]]],
 [[[([1,0],[0,0]),([1,0],[0,1])],
   [([1,0],[1,0]),([1,0],[1,1])]],
  [[([1,1],[0,0]),([1,1],[0,1])],
   [([1,1],[1,0]),([1,1],[1,1])]]]]

Like expand, but permutes the first array first, rather than the second.

>>> pretty $ expand (,) v (fmapA (+3) v)
[[(0,3),(0,4),(0,5)],
 [(1,3),(1,4),(1,5)],
 [(2,3),(2,4),(2,5)]]

>>> pretty $ coexpand (,) v (fmapA (+3) v)
[[(0,3),(1,3),(2,3)],
 [(0,4),(1,4),(2,4)],
 [(0,5),(1,5),(2,5)]]

The output shape is shape b ++ shape a, so the first array's axes occupy the suffix of the product shape rather than the prefix. Equivalently, it is expand followed by the block-swap permutation that exchanges the two operand shapes.

Contract an array by applying the supplied (folding) function on diagonal elements of the dimensions.

This generalises a tensor contraction by allowing the number of contracting diagonals to be other than 2.

>>> pretty $ contract [1,2] sumA (expand (*) m (transpose m))
[[5,14],
 [14,50]]

Product two arrays using the supplied function and then contract the result using the supplied matching dimensions and function.

>>> pretty $ prod [1] [0] sumA (*) (range [2,3]) (range [3,2])
[[10,13],
 [28,40]]

With full laziness, this computation would be equivalent to:

f . diag <$> extracts ds' (expand g a b)

A generalisation of a dot operation, which is a multiplicative expansion of two arrays and sum contraction along the middle two dimensions.

matrix multiplication

>>> pretty $ dot sumA (*) m (transpose m)
[[5,14],
 [14,50]]

inner product

>>> pretty $ dot sumA (*) v v
5

matrix-vector multiplication Note that an Array Vector with shape [3] is neither a row vector nor column vector.

>>> pretty $ dot sumA (*) v (transpose m)
[5,14]

>>> pretty $ dot sumA (*) m v
[5,14]

Array Vector multiplication.

matrix multiplication

>>> pretty $ mult m (transpose m)
[[5,14],
 [14,50]]

inner product

>>> pretty $ mult v v
5

matrix-vector multiplication

>>> pretty $ mult v (transpose m)
[5,14]

>>> pretty $ mult m v
[5,14]

windows xs are xs-sized windows of an array

>>> shape $ windows [2,2] (range [4,3,2])
[3,2,2,2,2]

Find the starting positions of occurences of one array in another.

>>> a = cycle [4,4] (range [3]) :: Array Vector Int
>>> i = array [2,2] [1,2,2,0] :: Array Vector Int
>>> pretty $ find i a
[[False,True,False],
 [True,False,False],
 [False,False,True]]

Find the ending positions of one array in another except where the array overlaps with another copy.

>>> a = konst [5,5] 1 :: Array Vector Int
>>> i = konst [2,2] 1 :: Array Vector Int
>>> pretty $ findNoOverlap i a
[[True,False,True,False],
 [False,False,False,False],
 [True,False,True,False],
 [False,False,False,False]]

Find the indices of the starting location of one array in another.

>>> b = cycle [4,4] (range [3]) :: Array Vector Int
>>> i = array [2,2] [1,2,2,0] :: Array Vector Int
>>> pretty $ findIndices i b
[[0,1],[1,0],[2,2]]

Check if the first array is a prefix of the second

>>> isPrefixOf (array [2,2] [0,1,4,5]) a
True

Check if the first array is a suffix of the second

>>> isSuffixOf (array [2,2] [18,19,22,23]) a
True

Check if the first array is an infix of the second

>>> isInfixOf (array [2,2] [18,19,22,23]) a
True

Fill an array with the supplied value without regard to the original shape or cut the array values to match array size.

validate (def x a) == True

>>> pretty $ fill 0 (array [3] [])
[0,0,0]
>>> pretty $ fill 0 (array [3] [1..4])
[1,2,3]

Cut an array to form a new (smaller) shape. Errors if the new shape is larger. The old array is reranked to the rank of the new shape first.

>>> cut [2] (array [4] [0..3] :: Array Vector Int)
UnsafeArray [2] [0,1]

Cut an array to form a new (smaller) shape, using suffix elements. Errors if the new shape is larger. The old array is reranked to the rank of the new shape first.

>>> cutSuffix [2,2] a
UnsafeArray [2,2] [18,19,22,23]

Pad an array to form a new shape, supplying a default value for elements outside the shape of the old array. The old array is reranked to the rank of the new shape first.

>>> pad 0 [5] (array [4] [0..3] :: Array Vector Int)
UnsafeArray [5] [0,1,2,3,0]

Left pad an array to form a new shape, supplying a default value for elements outside the shape of the old array.

>>> lpad 0 [5] (array [4] [0..3] :: Array Vector Int)
UnsafeArray [5] [0,0,1,2,3]
>>> pretty $ lpad 0 [3,3] (range [2,2] :: Array Vector Int)
[[0,0,0],
 [0,0,1],
 [0,2,3]]

Reshape an array (with the same or less number of elements).

>>> pretty $ reshape [4,3,2] a
[[[0,1],
  [2,3],
  [4,5]],
 [[6,7],
  [8,9],
  [10,11]],
 [[12,13],
  [14,15],
  [16,17]],
 [[18,19],
  [20,21],
  [22,23]]]

Make an Array Vector single dimensional.

>>> pretty $ flat (range [2,2])
[0,1,2,3]
>>> pretty (flat $ toScalar 0)
[0]

Reshape an array, repeating the original array. The shape of the array should be a suffix of the new shape.

>>> pretty $ repeat [2,2,2] (array [2] [1,2])
[[[1,2],
  [1,2]],
 [[1,2],
  [1,2]]]

repeat ds (toScalar x) == konst ds x

Reshape an array, cycling through the elements without regard to the original shape.

>>> pretty $ cycle [2,2,2] (array [3] [1,2,3])
[[[1,2],
  [3,1]],
 [[2,3],
  [1,2]]]

Change rank by adding new dimensions at the front, if the new rank is greater, or combining dimensions (from left to right) into rows, if the new rank is lower.

>>> shape (rerank 4 a)
[1,2,3,4]
>>> shape (rerank 2 a)
[6,4]

flat == rerank 1

Change the order of dimensions.

>>> pretty $ reorder [2,0,1] a
[[[0,4,8],
  [12,16,20]],
 [[1,5,9],
  [13,17,21]],
 [[2,6,10],
  [14,18,22]],
 [[3,7,11],
  [15,19,23]]]

Remove single dimensions.

>>> let sq = array [2,1,3,4,1] [1..24] :: Array Vector Int
>>> shape $ squeeze sq
[2,3,4]

>>> shape $ squeeze (singleton 0)
[]

Insert a single dimension at the supplied position.

>>> shape $ elongate 1 a
[2,1,3,4]
>>> elongate 0 (toScalar 1)
UnsafeArray [1] [1]

Reverse indices eg transposes the element Aijk to Akji.

>>> index (transpose a) [1,0,0] == index a [0,0,1]
True
>>> pretty $ transpose (array [2,2,2] [1..8])
[[[1,5],
  [3,7]],
 [[2,6],
  [4,8]]]

Inflate an array by inserting a new dimension given a supplied dimension and size.

alt name: replicate

>>> pretty $ inflate 0 2 (array [3] [0,1,2])
[[0,1,2],
 [0,1,2]]

Intercalate an array along dimensions.

>>> pretty $ intercalate 2 (konst [2,3] 0) a
[[[0,0,1,0,2,0,3],
  [4,0,5,0,6,0,7],
  [8,0,9,0,10,0,11]],
 [[12,0,13,0,14,0,15],
  [16,0,17,0,18,0,19],
  [20,0,21,0,22,0,23]]]

Intersperse an element along dimensions.

>>> pretty $ intersperse 2 0 a
[[[0,0,1,0,2,0,3],
  [4,0,5,0,6,0,7],
  [8,0,9,0,10,0,11]],
 [[12,0,13,0,14,0,15],
  [16,0,17,0,18,0,19],
  [20,0,21,0,22,0,23]]]

Concatenate and replace dimensions, creating a new dimension at the supplied postion.

>>> pretty $ concats [0,1] 1 a
[[0,4,8,12,16,20],
 [1,5,9,13,17,21],
 [2,6,10,14,18,22],
 [3,7,11,15,19,23]]

Reverses element order along specified dimensions.

>>> pretty $ reverses [0,1] a
[[[20,21,22,23],
  [16,17,18,19],
  [12,13,14,15]],
 [[8,9,10,11],
  [4,5,6,7],
  [0,1,2,3]]]

Rotate an array by/along dimensions & offsets.

>>> pretty $ rotates [1] [2] a
[[[8,9,10,11],
  [0,1,2,3],
  [4,5,6,7]],
 [[20,21,22,23],
  [12,13,14,15],
  [16,17,18,19]]]

Sort an array along the supplied dimensions.

>>> sorts [0] (array [2,2] [2,3,1,4])
UnsafeArray [2,2] [1,4,2,3]
>>> sorts [1] (array [2,2] [2,3,1,4])
UnsafeArray [2,2] [2,3,1,4]
>>> sorts [0,1] (array [2,2] [2,3,1,4])
UnsafeArray [2,2] [1,2,3,4]

The indices into the array if it were sorted by a comparison function along the dimensions supplied.

>>> import Data.Ord (Down (..))
>>> sortsBy [0] (fmapA Down) (array [2,2] [2,3,1,4])
UnsafeArray [2,2] [2,3,1,4]

The indices into the array if it were sorted along the dimensions supplied.

>>> orders [0] (array [2,2] [2,3,1,4])
UnsafeArray [2] [1,0]

The indices into the array if it were sorted by a comparison function along the dimensions supplied.

>>> import Data.Ord (Down (..))
>>> ordersBy [0] (fmapA Down) (array [2,2] [2,3,1,4])
UnsafeArray [2] [0,1]

Apply a binary array function to two arrays where the shape of the first array is a prefix of the second array. No checks on shape.

>>> a = array [2,3] [0..5]
>>> pretty $ transmit (zipWith (+)) (toScalar 1) a
[[1,2,3],
 [4,5,6]]

Apply a binary array function to two arrays where the shape of the first array is a prefix of the second array. Checks shape.

>>> a = array [2,3] [0..5]
>>> transmitSafe (zipWith (+)) (array [3] [1,2,3]) a
Nothing

Transmit an operation if the first array is a prefix of the second or vice versa.

>>> pretty $ transmitOp (*) a (asArray [1,2])
[[[0,1,2,3],
  [4,5,6,7],
  [8,9,10,11]],
 [[24,26,28,30],
  [32,34,36,38],
  [40,42,44,46]]]

Apply a binary array function to two arrays with matching shapes across the supplied dimensions. No check on shapes.

>>> a = array [2,3] [0..5]
>>> b = array [3] [0..2]
>>> pretty $ telecasts [1] [0] (concatenate 0) a b
[[0,1,2],
 [3,4,5],
 [0,1,2]]

Apply a binary array function to two arrays with matching shapes across the supplied dimensions. Checks shape.

>>> a = array [2,3] [0..5]
>>> b = array [1] [1]
>>> telecastsSafe [0] [0] (zipWith (+)) a b
Nothing

Convenience pattern for row extraction and consolidation at the beginning of an Array.

>>> (x:<xs) = array [4] [0..3]
>>> x
UnsafeArray [] [0]
>>> xs
UnsafeArray [3] [1,2,3]
>>> (x:<xs)
UnsafeArray [4] [0,1,2,3]

Add a new row

>>> pretty $ cons (array [2] [0,1]) (array [2,2] [2,3,4,5])
[[0,1],
 [2,3],
 [4,5]]

split an array into the first row and the remaining rows.

>>> uncons (array [3,2] [0..5])
(UnsafeArray [2] [0,1],UnsafeArray [2,2] [2,3,4,5])

Convenience pattern for row extraction and consolidation at the end of an Array.

>>> (xs:>x) = array [4] [0..3]
>>> x
UnsafeArray [] [3]
>>> xs
UnsafeArray [3] [0,1,2]
>>> (xs:>x)
UnsafeArray [4] [0,1,2,3]

Add a new row at the end

>>> pretty $ snoc (array [2,2] [0,1,2,3]) (array [2] [4,5])
[[0,1],
 [2,3],
 [4,5]]

split an array into the initial rows and the last row.

>>> unsnoc (array [3,2] [0..5])
(UnsafeArray [2,2] [0,1,2,3],UnsafeArray [2] [4,5])

Vector specialisation of range

>>> iota 5
UnsafeArray [5] [0,1,2,3,4]

Generate an array of uniform random variates between a range.

>>> import System.Random.Stateful hiding (uniform)
>>> g <- newIOGenM (mkStdGen 42)
>>> u <- uniform g [2,3,4] (0,9 :: Int)
>>> pretty u
[[[0,7,0,2],
  [1,7,4,2],
  [5,9,8,2]],
 [[9,8,1,0],
  [2,2,8,2],
  [2,8,0,6]]]