Data.Massiv.Array.Manifest

Just like generateArrayS, except this generator will respect the supplied computation strategy, and for that reason it is restricted to IO.

Just like generateArray, except generating action will receive a row-major linear index.

Sequentially generate a pure array. Much like makeArray creates a pure array this function will use Manifest interface to generate a pure Array in the end, except that computation strategy is set to Seq. Element producing function no longer has to be pure but is a stateful action, becuase it is restricted to PrimMonad thus allows for sharing the state between computation of each element.

Examples

>>> import Data.Massiv.Array>>> import Data.IORef>>> ref <- newIORef (0 :: Int)>>> generateArrayS (Sz1 6) (\ i -> modifyIORef' ref (+i) >> print i >> pure i) :: IO (Array U Ix1 Int)012345Array U Seq (Sz1 6)  [ 0, 1, 2, 3, 4, 5 ]>>> readIORef ref15

Same as generateArray but with action that accepts row-major linear index.

Similar to makeSplitSeedArray, except it will produce a Manifest array and will return back the last unused seed together with all final seeds produced by each scheduled job. This function can be thought of as an unfolding done in parallel while iterating in a customizable manner.

Use per worker thread state while generating elements of the array. Very useful for things that are not thread safe.

Same as generateArrayWS, but use linear indexing instead.

Sequentially unfold an array from the left.

Examples

Create an array with Fibonacci numbers while performing an IO action at each iteration.

>>> import Data.Massiv.Array>>> unfoldrPrimM_ (Sz1 10) (\(f0, f1) -> (f0, (f1, f0 + f1)) <$ print f1) (0, 1) :: IO (Array P Ix1 Int)11235813213455Array P Seq (Sz1 10)  [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ]

Same as unfoldrPrimM_ but do the unfolding with index aware function.

Just like iunfoldrPrimM, but do the unfolding with index aware function.

Just like iunfoldrPrimM_, but also returns the final value of the accumulator.

Sequentially unfold an array from the left.

Examples

Create an array with Fibonacci numbers starting at the end while performing and IO action on the accumulator for each element of the array.

>>> import Data.Massiv.Array>>> unfoldlPrimM_ (Sz1 10) (\a@(f0, f1) -> let fn = f0 + f1 in print a >> return ((f1, fn), f0)) (0, 1) :: IO (Array P Ix1 Int)(0,1)(1,1)(1,2)(2,3)(3,5)(5,8)(8,13)(13,21)(21,34)(34,55)Array P Seq (Sz1 10)  [ 34, 21, 13, 8, 5, 3, 2, 1, 1, 0 ]

Same as unfoldlPrimM_ but do the unfolding with index aware function.

Just like iunfoldlPrimM, but do the unfolding with index aware function.

Just like iunfoldlPrimM_, but also returns the final value of the accumulator.

Sequentially loop over a mutable array while modifying each element with an action.

Sequentially loop over a mutable array while reading each element and applying an action to it. There is no mutation to the array, unless the action itself modifies it.

Sequentially loop over a mutable array while modifying each element with an index aware action.

Sequentially loop over a mutable array while reading each element and applying an index aware action to it. There is no mutation to the array, unless the action itself modifies it.

Sequentially loop over a mutable array while modifying each element with an index aware action.

Sequentially loop over a mutable array while reading each element and applying a linear index aware action to it. There is no mutation to the array, unless the action itself modifies it.

Sequentially loop over the intersection of two mutable arrays while reading elements from both and applying an action to it. There is no mutation to the actual arrays, unless the action itself modifies either one of them.

Same as for2PrimM_, but with index aware action.

O(n) - Perform a row-major search starting at 0 for an element. Returns the index of the first occurance of an element or Nothing if a predicate could not be satisifed after it was applyied to all elements of the array.

O(1) - Cast a strict boxed array into a lazy boxed array.

O(n) - Evaluate all elements of a boxed lazy array to weak head normal form

O(n) - Evaluate all elements of a boxed lazy array to normal form

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

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

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

O(1) - Wrap a boxed array.

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

O(n) - Wrap a boxed array and evaluate all elements to a WHNF.

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

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

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

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

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

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

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

O(1) - Converts a boxed Array into a Vector without touching any elements.

O(1) - Converts a boxed MArray into a MVector.

O(1) - Cast a boxed vector without touching any elements.

O(1) - Convert mutable boxed vector to a lazy mutable boxed array. Both keep pointing to the same memory

O(n) - Convert a boxed vector and evaluate all elements to WHNF. Computation strategy will be respected during evaluation

O(n) - Convert mutable boxed vector and evaluate all elements to WHNF sequentially. Both keep pointing to the same memory

O(n) - Ensure that the size matches the internal ByteArray. If not make a copy of the slice and return it as ByteArray

O(1) - Unwrap Ensure that the size matches the internal ByteArray.

O(1) - Extract the internal ByteArray. This will ignore any possible slicing that has been applied to the array. Use toByteArray in order to preserve slicing or unwrapByteArrayOffset to get ahold of the offset

O(1) - Extract potential linear offset into the underlying ByteArray, which can also be extracted with unwrapByteArray.

O(1) - Construct a flat Array from ByteArray

O(1) - Construct a primitive array from the ByteArray. Will return Nothing if number of elements doesn't match.

O(1) - Construct a primitive array from the ByteArray. Will return Nothing if number of elements doesn't match.

O(n) - Try to cast a mutable array to MutableByteArray, if sizes do not match make a copy. Returns True if an array was converted without a copy, in which case it means that the source at the resulting array are still pointing to the same location in memory.

O(1) - Extract the internal MutableByteArray. This will discard any possible slicing that has been applied to the array.

O(1) - Extract the linear offset into underlying MutableByteArray, which can aslo be extracted with unwrapMutableByteArray.

O(1) - Construct a flat Array from MutableByteArray

O(1) - Construct a primitive mutable array from the MutableByteArray. Will throw SizeElementsMismatchException if number of elements doesn't match.

O(1) - Construct a primitive mutable array from the MutableByteArray. Will throw SizeElementsMismatchException if number of elements doesn't match.

O(1) - Cast a primitive array to a primitive vector.

O(1) - Cast a mutable primitive array to a mutable primitive vector.

O(1) - Cast a primitive vector to a primitive array.

O(1) - Cast a mutable primitive vector to a mutable primitive array.

O(1) - Unwrap storable array and pull out the underlying storable vector.

O(1) - Unwrap storable mutable array and pull out the underlying storable mutable vector.

O(1) - Cast a storable vector to a storable array.

O(1) - Cast a mutable storable vector to a mutable storable array.

A pointer to the beginning of the mutable array.

O(1) - Unwrap unboxed array and pull out the underlying unboxed vector.

O(1) - Unwrap unboxed mutable array and pull out the underlying unboxed mutable vector.

O(1) - Wrap an unboxed vector and produce an unboxed flat array.

O(1) - Wrap an unboxed mutable vector and produce a mutable unboxed flat array.