Data.Massiv.Array.Unsafe

Specify how an array can be loaded/computed through creation of a DL array. Unlike makeLoadArrayS or makeLoadArray this function is unsafe, since there is no guarantee that all elements will be initialized and the supplied element writing function does not perform any bounds checking.

Same as unsafeMakeLoadArray, except will ensure that starting index is correctly adjusted. Which means the writing function gets one less argument.

Sz is the size of the array. It describes total number of elements along each dimension in the array. It is a wrapper around an index of the same dimension, however it provides type safety preventing mixup with index. Moreover the Sz constructor and others such as Sz1, Sz2, ... that are specialized to specific dimensions, prevent creation of invalid sizes with negative values by clamping them to zero.

Examples

>>> import Data.Massiv.Array>>> Sz (1 :> 2 :. 3)Sz (1 :> 2 :. 3)

Sz has a Num instance, which is very convenient:

>>> Sz (1 :> 2 :. 3) + 5Sz (6 :> 7 :. 8)

However subtraction can sometimes lead to surprising behavior, because size is not allowed to take negative values it will be clamped at 0.

>>> Sz (1 :> 2 :. 3) - 2Sz (0 :> 0 :. 1)

Warning: It is always wrong to negate a size, thus it will result in an error. For that reason also watch out for partially applied (- sz), which is deugared into negate sz. See more info about it in #114.

Stride provides a way to ignore elements of an array if an index is divisible by a corresponding value in a stride. So, for a Stride (i :. j) only elements with indices will be kept around:

( 0 :. 0) ( 0 :. j) ( 0 :. 2j) ( 0 :. 3j) ...
( i :. 0) ( i :. j) ( i :. 2j) ( i :. 3j) ...
(2i :. 0) (2i :. j) (2i :. 2j) (2i :. 3j) ...
...

Only positive strides make sense, so Stride pattern synonym constructor will prevent a user from creating a stride with negative or zero values, thus promoting safety of the library.

Examples:

• Default and minimal stride of Stride (pureIndex 1) will have no affect and all elements will kept.

• If stride is Stride 2, then every 2nd element (i.e. with index 1, 3, 5, ..) will be skipped and only elemnts with indices divisible by 2 will be kept around.

• In case of two dimensions, if what you want is to keep all rows divisible by 5, but keep every column intact then you'd use Stride (5 :. 1).

Lookup element in the array. No bounds check is performed and access of arbitrary memory is possible when invalid index is supplied.

Alternative indexing function that can choose an index that is most efficient for underlying representation

Lookup element in the array using flat index in a row-major fashion. No bounds check is performed

O(1) - Change the size of an array. Total number of elements should be the same, but it is not validated.

O(1) - Extract a portion of an array. Staring index and new size are not validated.

Same Data.Array.transform', except no bounds checking is performed, thus making it faster, but unsafe.

Same Data.Array.transform2', except no bounds checking is performed, thus making it faster, but unsafe.

O(1) - Take a slice out of an array from within

O(1) - Take a slice out of an array from the outside

O(1) - Take a slice out of an array from the inside

O(1) - Source arrays also give us ability to look at their linear slices in constant time

O(1) - Change the size of a mutable array. The actual number of elements should stay the same.

O(1) - Take a linear slice out of a mutable array.

Convert immutable array into a mutable array without copy.

Convert mutable array into an immutable array without copy.

Create new mutable array, leaving it's elements uninitialized. Size isn't validated either.

Load into a supplied mutable array sequentially. Returned array does not have to be the same.

Same as unsafeLoadIntoST, but respecting computation strategy.

Load into a supplied mutable vector sequentially. Returned array is not necesserally the same vector as the one that was supplied. It will be the same only if it had enough space to load all the elements in.

Same as unsafeLoadIntoS, but respecting computation strategy.

Same as createArray, but memory will not be initialized and for unboxed types might contain garbage.

Same as createArray_, but memory will not be initialized and for unboxed types might contain garbage.

Same as createArrayS, but memory will not be initialized and for unboxed types might contain garbage.

Allocate memory using malloc on C heap, instead of on Haskell heap. Memory is left uninitialized

A pointer to the beginning of the storable array. It is unsafe since, if mutated, it can break referential transparency.

O(1) - Yield the underlying ForeignPtr together with its length.

O(1) - Yield the underlying ForeignPtr together with its length.

O(1) - Wrap a ForeignPtr, an offset and it's size into a pure storable array.

O(1) - Wrap a ForeignPtr and it's size into a pure storable array.

O(1) - Wrap a ForeignPtr, an offset and it's size into a mutable storable array. It is still safe to modify the pointer, unless the array gets frozen prior to modification.

O(1) - Wrap a ForeignPtr and it's size into a mutable storable array. It is still safe to modify the pointer, unless the array gets frozen prior to modification.

The array family. Representations r describe how data is arranged or computed. All arrays have a common property that each index ix always maps to the same unique element e, even if that element does not yet exist in memory and the array has to be computed in order to get the value of that element. Data is always arranged in a nested row-major fashion. Rank of an array is specified by Dimensions ix.

Mutable version of a Manifest Array. The extra type argument s is for the state token used by IO and ST.