forM package:massiv

forM_ :: (Source r a, Index ix, Monad m) => Array r ix a -> (a -> m b) -> m ()

Same as mapM except with arguments flipped.

iforM :: forall r ix b r' a m . (Source r' a, Manifest r b, Index ix, Monad m) => Array r' ix a -> (ix -> a -> m b) -> m (Array r ix b)

Just like mapM_, except with flipped arguments.

Examples

Here is a common way of iterating N times using a for loop in an imperative language with mutation being an obvious side effect:

>>> import Data.Massiv.Array as A

>>> import Data.IORef

>>> ref <- newIORef 0 :: IO (IORef Int)

>>> A.forM_ (range Seq (Ix1 0) 1000) $ \ i -> modifyIORef' ref (+i)

>>> readIORef ref
499500

iforM_ :: (Source r a, Index ix, Monad m) => Array r ix a -> (ix -> a -> m b) -> m ()

Same as forM, except with an index aware action.

transform' :: forall ix e r' ix' e' a . (HasCallStack, Source r' e', Index ix', Index ix) => (Sz ix' -> (Sz ix, a)) -> (a -> (ix' -> e') -> ix -> e) -> Array r' ix' e' -> Array D ix e

Just like imapM_, except with flipped arguments.

transform2' :: (HasCallStack, Source r1 e1, Source r2 e2, Index ix, Index ix1, Index ix2) => (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

General array transformation

transform2M :: (Manifest r e, Index ix, Source r1 e1, Source r2 e2, Index ix1, Index ix2, MonadUnliftIO m, PrimMonad m, MonadThrow m) => (Sz ix1 -> Sz ix2 -> m (Sz ix, a)) -> (a -> (ix1 -> m e1) -> (ix2 -> m e2) -> ix -> m e) -> Array r1 ix1 e1 -> Array r2 ix2 e2 -> m (Array r ix e)

Same as transform', but operates on two arrays

transformM :: forall r ix e r' ix' e' a m . (Manifest r e, Index ix, Source r' e', Index ix', MonadUnliftIO m, PrimMonad m, MonadThrow m) => (Sz ix' -> m (Sz ix, a)) -> (a -> (ix' -> m e') -> ix -> m e) -> Array r' ix' e' -> m (Array r ix e)

Same as transformM, but operates on two arrays

uniformArray :: forall ix e g . (Index ix, RandomGen g, Uniform e) => g -> Comp -> Sz ix -> Array DL ix e

General array transformation, that forces computation and produces a manifest array.

uniformRangeArray :: forall ix e g . (Index ix, RandomGen g, UniformRange e) => g -> (e, e) -> Comp -> Sz ix -> Array DL ix e

Generate a random array where all elements are sampled from a uniform distribution.

evalNormalForm :: (Index ix, NFData e) => Array B ix e -> Array N ix e

Same as uniformArray, but will generate values in a supplied range.

evalNormalFormArray :: NFData e => Comp -> Array e -> Array N Ix1 e

O(n) - Compute all elements of a boxed array to NF (normal form)

evalNormalFormMutableArray :: (PrimMonad m, NFData e) => MutableArray (PrimState m) e -> m (MArray (PrimState m) N Ix1 e)

O(n) - Wrap a boxed array and evaluate all elements to a Normal Form (NF).

unwrapNormalForm :: Array N ix e -> Array B ix e

O(n) - Wrap mutable boxed array and evaluate all elements to NF.

unwrapNormalFormArray :: Array N ix e -> Array e

O(1) - Converts array from N to B representation.

unwrapNormalFormMutableArray :: MArray s N ix e -> MutableArray s e

O(1) - Unwrap a fully evaluated boxed array. This will discard any possible slicing that has been applied to the array.

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

O(1) - Unwrap a fully evaluated mutable boxed array. This will discard any possible slicing that has been applied to the array.

massiv Data.Massiv.Array.Unsafe

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

unsafeTransform2 :: (Index ix1, Source r1 e1, Index ix2, Source r2 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

massiv Data.Massiv.Array.Unsafe

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

unsafeTransformStencil :: (Sz ix' -> Sz ix) -> (ix' -> ix) -> (((ix' -> e) -> (ix' -> e) -> ix' -> a) -> (ix -> e) -> (ix -> e) -> ix -> a) -> Stencil ix' e a -> Stencil ix e a

massiv Data.Massiv.Array.Unsafe

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

sforM :: forall r ix a b m . (Stream r ix a, Monad m) => Array r ix a -> (a -> m b) -> m (Vector DS b)

sforM_ :: (Stream r ix a, Monad m) => Array r ix a -> (a -> m b) -> m ()

Same as smapM, but with arguments flipped.

Examples

siforM :: forall r ix a b m . (Stream r ix a, Monad m) => Array r ix a -> (ix -> a -> m b) -> m (Vector DS b)

Same as smapM_, but with arguments flipped.

Examples

siforM_ :: forall r ix a b m . (Stream r ix a, Monad m) => Array r ix a -> (ix -> a -> m b) -> m ()

Same as simapM, but with arguments flipped.

Examples