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

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]

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]

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]]]

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

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

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

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

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]]]

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.

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]

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]

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]]

Add a new row

>>> pretty $ cons (array [2] [0,1]) (array [2,2] [2,3,4,5])
[[0,1],
 [2,3],
 [4,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] sumA (expand (*) m (transpose m))
[[5,14],
 [14,50]]

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]]]

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]]

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]

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]]]

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]]]

Extract the diagonal of an array.

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

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]]]

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]

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]

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]]]

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

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

Insert a single dimension at the supplied position.

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

An array with no elements.

>>> empty
UnsafeArray [0] []

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])]]]]

Extracts dimensions to an outer layer.

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

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]

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]]

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 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]]

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]]

Make an Array Vector single dimensional.

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

Functor-like map with an explicit vector constraint.

Foldable-like fold with an explicit vector constraint.

Unwrap a scalar.

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

Select the first element along the supplied dimensions.

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

The identity array.

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

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]]]

Extract an element at an index, unsafely.

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

Select by dimensions and indexes.

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

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]]]

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]]

Select the init elements along the supplied dimensions.

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

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]

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]]]

Vector specialisation of range

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

Check if the first array is an infix of the second

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

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

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

Check if the first array is a prefix of the second

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

Is an array a Scalar?

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

Check if the first array is a suffix of the second

>>> isSuffixOf (array [2,2] [18,19,22,23]) a
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])

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

Create an array composed of a single value.

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

Select the last element along the supplied dimensions.

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

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

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]]

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]]]

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]]]

Modify a single value at an index.

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

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]

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]

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]

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]]]

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)

An enumeration of row-major or lexicographic order.

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

rank of an Array

>>> rank a
3

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]]

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]]]

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

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

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]]]

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 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]]]

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]]]

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]

Select an index along a dimension.

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

shape of an Array

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

Create an array of shape [1].

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

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

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

>>> size a
24

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]]]

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]]]

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]]

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]

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)
[]

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

Select the tail elements along the supplied dimensions.

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

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]]]

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]]]

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

Convert an array to a list.

Wrap a scalar.

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

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]]

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 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

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]]]

Traverse along specified dimensions.

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

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])

Expand the array to form a diagonal array.

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

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]]]

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]

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])

windows xs are xs-sized windows of an array

>>> shape $ windows [2,2] (range [4,3,2])
[3,2,2,2,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

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

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.

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

Construct an Array.

Validate the size and shape of an array.

Construct an Array, checking shape.

Unsafely modify an array vector.

Conversion to and from a unboxed Vector.

Conversion to and from an Array.