Data.Massiv.Array.Unsafe

Creation

unsafeMakeLoadArray

Arguments

:: forall ix e. Index ix

=> Comp

Computation strategy to use. Directly affects the scheduler that gets created for the loading function.

-> Sz ix

Size of the array

-> Maybe e

An element to use for initialization of the mutable array that will be created in the future

-> (forall m. Monad m => Scheduler m () -> Ix1 -> (Ix1 -> e -> m ()) -> m ())

This function accepts:

• A scheduler that can be used for parallelization of loading
• Linear index at which this load array will start (an offset that should be added to the linear writng function)
• Linear element writing function

-> Array DL ix e

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.

Since: 0.3.1

unsafeMakeLoadArrayAdjusted :: forall ix e. Index ix => Comp -> Sz ix -> Maybe e -> (forall m. Monad m => Scheduler m () -> (Ix1 -> e -> m ()) -> m ()) -> Array DL ix e

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

Since: 0.5.2

Indexing

newtype Sz ix

Sz provides type safety guarantees preventing mixup with index, which is used for looking into array cells, from the size, that describes total number of elements along each dimension in the array. Moreover the Sz constructor will prevent creation of invalid sizes with negative numbers.

Since: 0.3.0

Constructors

SafeSz ix

Safe size constructor. It is unsafe to use it without making sure that it does not contain negative components. Use Sz pattern instead.

Since: 0.3.0

Instances

Eq ix => Eq (Sz ix)

Defined in Data.Massiv.Core.Index.Internal

Methods

(==) :: Sz ix -> Sz ix -> Bool

(/=) :: Sz ix -> Sz ix -> Bool

(Num ix, Index ix) => Num (Sz ix)

Defined in Data.Massiv.Core.Index.Internal

Methods

(+) :: Sz ix -> Sz ix -> Sz ix

(-) :: Sz ix -> Sz ix -> Sz ix

(*) :: Sz ix -> Sz ix -> Sz ix

negate :: Sz ix -> Sz ix

abs :: Sz ix -> Sz ix

signum :: Sz ix -> Sz ix

fromInteger :: Integer -> Sz ix

Ord ix => Ord (Sz ix)

Defined in Data.Massiv.Core.Index.Internal

Methods

compare :: Sz ix -> Sz ix -> Ordering

(<) :: Sz ix -> Sz ix -> Bool

(<=) :: Sz ix -> Sz ix -> Bool

(>) :: Sz ix -> Sz ix -> Bool

(>=) :: Sz ix -> Sz ix -> Bool

max :: Sz ix -> Sz ix -> Sz ix

min :: Sz ix -> Sz ix -> Sz ix

Index ix => Show (Sz ix)

Defined in Data.Massiv.Core.Index.Internal

Methods

showsPrec :: Int -> Sz ix -> ShowS

show :: Sz ix -> String

showList :: [Sz ix] -> ShowS

NFData ix => NFData (Sz ix)

Defined in Data.Massiv.Core.Index.Internal

Methods

rnf :: Sz ix -> ()

newtype Stride ix

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

Since: 0.2.1

Constructors

SafeStride ix

Instances

Eq ix => Eq (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

(==) :: Stride ix -> Stride ix -> Bool

(/=) :: Stride ix -> Stride ix -> Bool

Ord ix => Ord (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

compare :: Stride ix -> Stride ix -> Ordering

(<) :: Stride ix -> Stride ix -> Bool

(<=) :: Stride ix -> Stride ix -> Bool

(>) :: Stride ix -> Stride ix -> Bool

(>=) :: Stride ix -> Stride ix -> Bool

max :: Stride ix -> Stride ix -> Stride ix

min :: Stride ix -> Stride ix -> Stride ix

Index ix => Show (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

showsPrec :: Int -> Stride ix -> ShowS

show :: Stride ix -> String

showList :: [Stride ix] -> ShowS

NFData ix => NFData (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

rnf :: Stride ix -> ()

unsafeIndex :: Source r ix e => Array r ix e -> ix -> e

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

Since: 0.1.0

unsafeLinearIndex :: Source r ix e => Array r ix e -> Int -> e

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

Since: 0.1.0

unsafeLinearIndexM :: Manifest r ix e => Array r ix e -> Int -> e

Manipulations

unsafeBackpermute :: (Source r' ix' e, Index ix) => Sz ix -> (ix -> ix') -> Array r' ix' e -> Array D ix e

unsafeResize :: (Resize r ix, Index ix') => Sz ix' -> Array r ix e -> Array r ix' e

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

unsafeExtract :: Extract r ix e => ix -> Sz ix -> Array r ix e -> Array (R r) ix e

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

unsafeTransform :: (Source r' ix' e', Index ix) => (Sz ix' -> (Sz ix, a)) -> (a -> (ix' -> e') -> ix -> e) -> Array r' ix' e' -> Array D ix e

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

Since: 0.3.0

unsafeTransform2 :: (Source r1 ix1 e1, Source r2 ix2 e2, Index ix) => (Sz ix1 -> Sz ix2 -> (Sz ix, a)) -> (a -> (ix1 -> e1) -> (ix2 -> e2) -> ix -> e) -> Array r1 ix1 e1 -> Array r2 ix2 e2 -> Array D ix e

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

Since: 0.3.0

Slicing

unsafeSlice :: (Slice r ix e, MonadThrow m) => Array r ix e -> ix -> Sz ix -> Dim -> m (Elt r ix e)

unsafeOuterSlice :: OuterSlice r ix e => Array r ix e -> Int -> Elt r ix e

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

unsafeInnerSlice :: InnerSlice r ix e => Array r ix e -> (Sz (Lower ix), Sz Int) -> Int -> Elt r ix e

unsafeLinearSlice :: Source r ix e => Ix1 -> Sz1 -> Array r ix e -> Array r Ix1 e

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

Since: 0.5.0

Mutable interface

unsafeThaw :: (Mutable r ix e, PrimMonad m) => Array r ix e -> m (MArray (PrimState m) r ix e)

Convert immutable array into a mutable array without copy.

Since: 0.1.0

unsafeFreeze :: (Mutable r ix e, PrimMonad m) => Comp -> MArray (PrimState m) r ix e -> m (Array r ix e)

Convert mutable array into an immutable array without copy.

Since: 0.1.0

unsafeNew :: (Mutable r ix e, PrimMonad m) => Sz ix -> m (MArray (PrimState m) r ix e)

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

Since: 0.1.0

unsafeLoadIntoS :: (Load r ix e, Mutable r' ix e, PrimMonad m) => MArray (PrimState m) r' ix e -> Array r ix e -> m (MArray (PrimState m) r' ix e)

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

Since: 0.5.7

unsafeLoadIntoM :: (Load r ix e, Mutable r' ix e, MonadIO m) => MArray RealWorld r' ix e -> Array r ix e -> m (MArray RealWorld r' ix e)

Same as unsafeLoadIntoS, but respecting computation strategy.

Since: 0.5.7

unsafeCreateArray

Arguments

:: forall r ix e a m b. (Mutable r ix e, PrimMonad m, MonadUnliftIO m)

=> Comp

Computation strategy to use after MArray gets frozen and onward.

-> Sz ix

Size of the newly created array

-> (Scheduler m a -> MArray (PrimState m) r ix e -> m b)

An action that should fill all elements of the brand new mutable array

-> m ([a], Array r ix e)

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

Since: 0.5.0

unsafeCreateArray_

Arguments

:: forall r ix e a m b. (Mutable r ix e, PrimMonad m, MonadUnliftIO m)

=> Comp

Computation strategy to use after MArray gets frozen and onward.

-> Sz ix

Size of the newly created array

-> (Scheduler m a -> MArray (PrimState m) r ix e -> m b)

An action that should fill all elements of the brand new mutable array

-> m (Array r ix e)

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

Since: 0.5.0

unsafeCreateArrayS

Arguments

:: forall r ix e a m. (Mutable r ix e, PrimMonad m)

=> Sz ix

Size of the newly created array

-> (MArray (PrimState m) r ix e -> m a)

An action that should fill all elements of the brand new mutable array

-> m (a, Array r ix e)

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

Since: 0.5.0

Read

unsafeRead :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> m e

Read an array element

Since: 0.1.0

unsafeLinearRead :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> Int -> m e

Read an element at linear row-major index

Since: 0.1.0

Write

unsafeWrite :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> e -> m ()

Write an element into array

Since: 0.1.0

unsafeLinearWrite :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> Int -> e -> m ()

Write an element into mutable array with linear row-major index

Since: 0.1.0

Modify

unsafeModify :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m e) -> ix -> m e

Modify an element in the array with a monadic action. Returns the previous value.

Since: 0.4.0

unsafeLinearModify :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m e) -> Int -> m e

Modify an element in the array with a monadic action. Returns the previous value.

Since: 0.4.0

Swap

unsafeSwap :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m (e, e)

Swap two elements in a mutable array under the supplied indices. Returns the previous values.

Since: 0.4.0

unsafeLinearSwap :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> Int -> Int -> m (e, e)

Swap two elements in a mutable array under the supplied linear indices. Returns the previous values.

Since: 0.4.0

Range modification

unsafeLinearSet :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> Ix1 -> Sz1 -> e -> m ()

Set all cells in the mutable array within the range to a specified value.

Since: 0.3.0

unsafeLinearCopy

Arguments

:: (Mutable r ix e, Mutable r ix' e, PrimMonad m)

=> MArray (PrimState m) r ix' e

Source mutable array

-> Ix1

Starting index at source array

-> MArray (PrimState m) r ix e

Target mutable array

-> Ix1

Starting index at target array

-> Sz1

Number of elements to copy

-> m ()

Copy part of one mutable array into another

Since: 0.3.6

unsafeArrayLinearCopy

Arguments

:: (Mutable r ix e, Mutable r ix' e, PrimMonad m)

=> Array r ix' e

Source pure array

-> Ix1

Starting index at source array

-> MArray (PrimState m) r ix e

Target mutable array

-> Ix1

Starting index at target array

-> Sz1

Number of elements to copy

-> m ()

Copy a part of a pure array into a mutable array

Since: 0.3.6

Resizing

unsafeLinearShrink :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> Sz ix -> m (MArray (PrimState m) r ix e)

Linearly reduce the size of an array. Total number of elements should be smaller or equal. There is no guarantee that the original array is left unchanged, so it should no longer be used.

Since: 0.3.6

unsafeLinearGrow :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> Sz ix -> m (MArray (PrimState m) r ix e)

Linearly increase the size of an array. Total number of elements should be larger or equal. There is no guarantee that the original array is left unchanged, so it should no longer be used.

Since: 0.3.6

Pointer access

unsafeMallocMArray :: forall ix e m. (Index ix, Storable e, MonadIO m) => Sz ix -> m (MArray RealWorld S ix e)

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

Since: 0.5.9

unsafeWithPtr :: (MonadUnliftIO m, Storable a) => Array S ix a -> (Ptr a -> m b) -> m b

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

Since: 0.1.3

unsafeArrayToForeignPtr :: Storable e => Array S ix e -> (ForeignPtr e, Int)

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

Since: 0.3.0

unsafeMArrayToForeignPtr :: Storable e => MArray s S ix e -> (ForeignPtr e, Int)

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

Since: 0.3.0

unsafeArrayFromForeignPtr :: Storable e => Comp -> ForeignPtr e -> Int -> Sz1 -> Array S Ix1 e

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

Since: 0.3.0

unsafeArrayFromForeignPtr0 :: Storable e => Comp -> ForeignPtr e -> Sz1 -> Array S Ix1 e

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

Since: 0.3.0

unsafeMArrayFromForeignPtr :: Storable e => ForeignPtr e -> Int -> Sz1 -> MArray s S Ix1 e

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.

Since: 0.3.0

unsafeMArrayFromForeignPtr0 :: Storable e => ForeignPtr e -> Sz1 -> MArray s S Ix1 e

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.

Since: 0.3.0

Atomic Operations

unsafeAtomicReadIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> m Int

Atomically read an Int element from the array

Since: 0.3.0

unsafeAtomicWriteIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m ()

Atomically write an Int element int the array

Since: 0.3.0

unsafeAtomicModifyIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> (Int -> Int) -> m Int

Atomically modify an Int element of the array. Returns the old value.

Since: 0.3.0

unsafeAtomicAddIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int

Atomically add to an Int element in the array. Returns the old value.

Since: 0.3.0

unsafeAtomicSubIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int

Atomically subtract from an Int element in the array. Returns the old value.

Since: 0.3.0

unsafeAtomicAndIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int

Atomically AND an Int element in the array. Returns the old value.

Since: 0.3.0

unsafeAtomicNandIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int

Atomically NAND an Int element in the array. Returns the old value.

Since: 0.3.0

unsafeAtomicOrIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int

Atomically OR an Int element in the array. Returns the old value.

Since: 0.3.0

unsafeAtomicXorIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int

Atomically XOR an Int element in the array. Returns the old value.

Since: 0.3.0

unsafeCasIntArray :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> Int -> m Int

Atomically CAS an Int in the array. Returns the old value.

Since: 0.3.0

Other operations

coerceBoxedArray :: Array BL ix e -> Array B ix e

O(1) - Cast a boxed lazy array. It is unsafe because it can violate the invariant that all elements of B array are in WHNF.

Since: 0.6.0

coerceNormalBoxedArray :: Array BL ix e -> Array N ix e

O(1) - Cast a boxed lazy array. It is unsafe because it can violate the invariant that all elements of N array are in NF.

Since: 0.6.0

unsafeUnstablePartitionRegionM

Arguments

:: forall r e m. (Mutable r Ix1 e, PrimMonad m)

=> MVector (PrimState m) r e

-> (e -> Bool)

-> Ix1

Start index of the region

-> Ix1

End index of the region

-> m Ix1

Partition a segment of a vector. Starting and ending indices are unchecked.

Since: 0.3.2

Vector

Accessors

Indexing

unsafeHead :: Source r Ix1 e => Vector r e -> e

Since: 0.5.0

unsafeLast :: Source r Ix1 e => Vector r e -> e

Since: 0.5.0

Monadic Indexing

unsafeIndexM :: (Source r Ix1 e, Monad m) => Vector r e -> Ix1 -> m e

Since: 0.5.0

unsafeHeadM :: Monad m => Source r Ix1 e => Vector r e -> m e

Since: 0.5.0

unsafeLastM :: Monad m => Source r Ix1 e => Vector r e -> m e

Since: 0.5.0

Slicing

unsafeInit :: Source r Ix1 e => Vector r e -> Vector r e

Since: 0.5.0

unsafeTail :: Source r Ix1 e => Vector r e -> Vector r e

Since: 0.5.0

unsafeTake :: Source r Ix1 e => Sz1 -> Vector r e -> Vector r e

Since: 0.5.0

unsafeDrop :: Source r Ix1 e => Sz1 -> Vector r e -> Vector r e

Since: 0.5.0

Unbounded streams

unsafeUnfoldrN

Arguments

:: Sz1

n - maximum number of elements that the vector will have

-> (s -> Maybe (e, s))

Unfolding function. Stops when Nothing is returned or maximum number of elements is reached.

-> s

Inititial element.

-> Vector DS e

O(n) - Right unfolding function with at most n number of elements.

Unsafe - This function is unsafe because it will allocate enough space in memory for n elements ahead of time, regardless of when unfolding function returns a Nothing. Supplying n that is too big will result in an asynchronous HeapOverflow exception.

Since: 0.5.1

unsafeUnfoldrNM :: Monad m => Sz1 -> (s -> m (Maybe (e, s))) -> s -> m (Vector DS e)

O(n) - Same as unsafeUnfoldrN, but with monadic generating function.

Unsafe - This function is unsafe because it will allocate enough space in memory for n elements ahead of time, regardless of when unfolding function returns a Nothing. Supplying n that is too big will result in an asynchronous HeapOverflow exception.

Since: 0.5.1

unsafeFromListN :: Sz1 -> [e] -> Vector DS e

O(n) - Convert a list of a known length to a delayed stream vector.

Unsafe - This function is unsafe because it will allocate enough space in memory for n elements ahead of time, regardless of the actual size of the list. Supplying n that is too big will result in an asynchronous HeapOverflow exception.

Since: 0.5.1

Stencil

makeUnsafeStencil

Arguments

:: Index ix

=> Sz ix

Size of the stencil

-> ix

Center of the stencil

-> (ix -> (ix -> e) -> a)

Stencil function.

-> Stencil ix e a

Similar to makeStencil, but there are no guarantees that the stencil will not read out of bounds memory. This stencil is also a bit more powerful in sense it gets an extra peice of information, namely the exact index for the element it is constructing.

Since: 0.3.0

makeUnsafeConvolutionStencil :: (Index ix, Num e) => Sz ix -> ix -> ((ix -> e -> e -> e) -> e -> e) -> Stencil ix e e

Same as makeConvolutionStencil, but will result in reading memory out of bounds and potential segfaults if supplied arguments are not valid.

Since: 0.6.0

makeUnsafeCorrelationStencil :: (Index ix, Num e) => Sz ix -> ix -> ((ix -> e -> e -> e) -> e -> e) -> Stencil ix e e

Same as makeCorrelationStencil, but will result in reading memory out of bounds and potential segfaults if supplied arguments are not valid.

Since: 0.6.0

unsafeTransformStencil

Arguments

:: (Sz ix' -> Sz ix)

Forward modifier for the size

-> (ix' -> ix)

Forward index modifier

-> (((ix' -> e) -> (ix' -> e) -> ix' -> a) -> (ix -> e) -> (ix -> e) -> ix -> a)

Inverse stencil function modifier

-> Stencil ix' e a

Original stencil.

-> Stencil ix e a

Perform an arbitrary transformation of a stencil. This stencil modifier can be used for example to turn a vector stencil into a matrix stencil implement, or transpose a matrix stencil. It is really easy to get this wrong, so be extremely careful.

Examples

Convert a 1D stencil into a row or column 2D stencil:

>>> import Data.Massiv.Array
>>> import Data.Massiv.Array.Unsafe
>>> let arr = compute $ iterateN 3 succ 0 :: Array P Ix2 Int
>>> arr
Array P Seq (Sz (3 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  , [ 7, 8, 9 ]
  ]
>>> let rowStencil = unsafeTransformStencil (\(Sz n) -> Sz (1 :. n)) (0 :.) $ \ f uget getVal (i :. j) -> f (uget  . (i :.)) (getVal . (i :.)) j
>>> applyStencil noPadding (rowStencil (sumStencil (Sz1 3))) arr
Array DW Seq (Sz (3 :. 1))
  [ [ 6 ]
  , [ 15 ]
  , [ 24 ]
  ]
>>> let columnStencil = unsafeTransformStencil (\(Sz n) -> Sz (n :. 1)) (:. 0) $ \ f uget getVal (i :. j) -> f (uget . (:. j)) (getVal . (:. j)) i
>>> applyStencil noPadding (columnStencil (sumStencil (Sz1 3))) arr
Array DW Seq (Sz (1 :. 3))
  [ [ 12, 15, 18 ]
  ]

Since: 0.5.4

Deprecated

unsafeMapStencil :: Manifest r ix e => Border e -> Sz ix -> ix -> (ix -> (ix -> e) -> a) -> Array r ix e -> Array DW ix a

Deprecated: In favor of mapStencil that is applied to stencil created with makeUnsafeStencil

This is an unsafe version of mapStencil, which does not take a Stencil, but instead accepts all necessary information as separate arguments.

Since: 0.5.0