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

>>> let a = array [2,3,4] [1..24] :: Array 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 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 Int)
False

Construct an Array, checking shape.

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

Unsafely modify an array shape.

>>> unsafeModifyShape (fmap (+1) :: [Int] -> [Int]) (array [2,3] [0..5])
UnsafeArray [3,4] [0,1,2,3,4,5]

Unsafely modify an array vector.

>>> unsafeModifyVector (V.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.

Conversion to and from a Vector

Note that conversion of an Array to a vector drops shape information, so that:

vectorAs . asVector == id
asVector . vectorAs == flat

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

>>> vectorAs (V.fromList [0..5]) :: Array Int
UnsafeArray [6] [0,1,2,3,4,5]

Conversion to and from an Array

Note that conversion of an Array to a FromArray likely drops shape information, so that:

arrayAs . asArray == flat
asArray . arrayAs == id

>>> asArray ([0..5::Int])
UnsafeArray [6] [0,1,2,3,4,5]

>>> arrayAs (range [2,3]) :: [Int]
[0,1,2,3,4,5]

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 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 empty (has zero number of elements).

>>> isNull ([2,0] >< [] :: Array ())
True
>>> isNull ([] >< [4] :: Array 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 [2,3,4]) == 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 List.reverse List.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 Int
>>> fromScalar s
3

Wrap a scalar.

>>> :t toScalar 2
toScalar 2 :: Num a => Array 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]]

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 $ shape <$> extracts [0] a
[[3,4],[3,4]]

Reduce along specified dimensions, using the supplied fold.

>>> pretty $ reduces [0] sum a
[66,210]
>>> pretty $ reduces [0,2] sum 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] (any ((==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 (fmap (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 (fmap (+3) v)
[[(0,3),(0,4),(0,5)],
 [(1,3),(1,4),(1,5)],
 [(2,3),(2,4),(2,5)]]

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

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] sum (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] sum (*) (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 sum (*) m (transpose m)
[[5,14],
 [14,50]]

inner product

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

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

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

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

Array 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 Int
>>> i = array [2,2] [1,2,2,0] :: Array 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 Int
>>> i = konst [2,2] 1 :: Array 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 Int
>>> i = array [2,2] [1,2,2,0] :: Array 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 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 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 Int)
UnsafeArray [5] [0,0,1,2,3]
>>> pretty $ lpad 0 [3,3] (range [2,2] :: Array 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 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 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] (fmap 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] (fmap 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]]]

Inversion of a Triangular Matrix

>>> t = array [3,3] ([1,0,1,0,1,2,0,0,1] :: [Double]) :: Array Double
>>> pretty (invtri t)
[[1.0,0.0,-1.0],
 [0.0,1.0,-2.0],
 [0.0,0.0,1.0]]
>>> ident (shape t) == mult t (invtri t)
True

Inverse of a square matrix.

>>> e = array [3,3] [4,12,-16,12,37,-43,-16,-43,98] :: Array Double
>>> pretty (inverse e)
[[49.36111111111111,-13.555555555555554,2.1111111111111107],
 [-13.555555555555554,3.7777777777777772,-0.5555555555555555],
 [2.1111111111111107,-0.5555555555555555,0.1111111111111111]]

mult (inverse a) a == a

Cholesky decomposition using the Cholesky-Crout algorithm.

>>> e = array [3,3] [4,12,-16,12,37,-43,-16,-43,98] :: Array Double
>>> pretty (chol e)
[[2.0,0.0,0.0],
 [6.0,1.0,0.0],
 [-8.0,5.0,3.0]]
>>> mult (chol e) (transpose (chol e)) == e
True