Data.Massiv.Array.Mutable

O(n) - Make a mutable copy of a pure array. Keep in mind that both freeze and thaw trigger a copy of the full array.

Example

>>> import Data.Massiv.Array>>> :set -XTypeApplications>>> arr <- fromListsM @U @Ix2 @Double Par [[12,21],[13,31]]>>> marr <- thaw arr>>> modify marr (pure . (+ 10)) (1 :. 0)Just 13.0>>> freeze Par marrArray U Par (Sz (2 :. 2))  [ [ 12.0, 21.0 ]  , [ 23.0, 31.0 ]  ]

Same as thaw, but restrict computation to sequential only.

Example

>>> import Data.Massiv.Array>>> :set -XOverloadedLists>>> thawS @P @Ix1 @Double [1..10]>>> marr <- thawS @P @Ix1 @Double [1..10]>>> writeM marr 5 100>>> freezeS marrArray P Seq (Sz1 10)  [ 1.0, 2.0, 3.0, 4.0, 5.0, 100.0, 7.0, 8.0, 9.0, 10.0 ]

O(n) - Yield an immutable copy of the mutable array. Note that mutable representations have to be the same.

Example

>>> import Data.Massiv.Array>>> marr <- newMArray @P (Sz2 2 6) (0 :: Int)>>> forM_ (range Seq 0 (Ix2 1 4)) $ \ix -> write marr ix 9>>> freeze Seq marrArray P Seq (Sz (2 :. 6))  [ [ 9, 9, 9, 9, 0, 0 ]  , [ 0, 0, 0, 0, 0, 0 ]  ]

Same as freeze, but do the copy of supplied muable array sequentially. Also, unlike freeze that has to be done in IO, freezeS can be used with ST.

Create new mutable array while initializing all elements to the specified value.

O(n) - Initialize a new mutable array. All elements will be set to some default value. For boxed arrays it will be a thunk with Uninitialized exception, while for others it will be simply zeros.

Examples

>>> import Data.Massiv.Array>>> marr <- newMArray' (Sz2 2 6) :: IO (MArray RealWorld P Ix2 Int)>>> freeze Seq marrArray P Seq (Sz (2 :. 6))  [ [ 0, 0, 0, 0, 0, 0 ]  , [ 0, 0, 0, 0, 0, 0 ]  ]

Or using TypeApplications:

>>> :set -XTypeApplications>>> newMArray' @P @Ix2 @Int (Sz2 2 6) >>= freezeSArray P Seq (Sz (2 :. 6))  [ [ 0, 0, 0, 0, 0, 0 ]  , [ 0, 0, 0, 0, 0, 0 ]  ]>>> newMArray' @B @_ @Int (Sz2 2 6) >>= freezeS*** Exception: Uninitialized

Just like makeMArrayS, but also accepts computation strategy and runs in IO.

Just like makeMArrayLinearS, but also accepts computation strategy and runs in IO.

Create a mutable array using an index aware generating action.

Same as makeMArrayS, but index supplied to the action is row-major linear index.

Create a new array by supplying an action that will fill the new blank mutable array. Use createArray if you'd like to keep the result of the filling function.

Examples

>>> :set -XTypeApplications>>> import Data.Massiv.Array>>> createArray_ @P @_ @Int Seq (Sz1 2) (\ s marr -> scheduleWork s (writeM marr 0 10) >> scheduleWork s (writeM marr 1 11))Array P Seq (Sz1 2)  [ 10, 11 ]

Just like createArray_, but together with Array it returns results of scheduled filling actions.

Create a new array by supplying an action that will fill the new blank mutable array. Use createArrayS if you'd like to keep the result of the filling function.

Examples

>>> :set -XTypeApplications>>> import Data.Massiv.Array>>> createArrayS_ @P @_ @Int (Sz1 2) (\ marr -> write marr 0 10 >> write marr 1 12)Array P Seq (Sz1 2)  [ 10, 12 ]

Just like createArray_, but together with Array it returns the result of the filling action.

Just like createArrayS_, but restricted to ST.

Just like createArrayS, but restricted to ST.

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.

Same as withMArray_, but allows to keep artifacts of scheduled tasks.

Create a copy of a pure array, mutate it in place and return its frozen version. The big difference between withMArrayS is that it's not only gonna respect the computation strategy supplied to it while making a copy, but it will also pass extra argumens to the action that suppose to modify the mutable copy of the source array. These two extra arguments are:

• Number of capabilities derived from the Computation strategy of the array.

• An action that can be used to schedule arbitrary number of jobs that will be executed in parallel.

• And, of course, the mutable array itself.

Same as withMArray_, but the array supplied to this function can be any loadable array. For that reason it will be faster if supplied array is delayed.

Create a copy of a pure array, mutate it in place and return its frozen version. The important benefit over doing a manual thawS followed by a freezeS is that an array will only be copied once.

Same as withMArrayS, but will work with any loadable array.

Same as withMArrayS, except it discards the value produced by the supplied action

Same as withMArrayS_, but will work with any loadable array.

Same as withMArrayS but in ST. This is not only pure, but also the safest way to do mutation to the array.

Same as withMArrayST, but works with any loadable array.

Same as withMArrayS but in ST. This is not only pure, but also the safest way to do mutation to the array.

Same as withMArrayST_, but works with any loadable array.

Initialize mutable array to some default value.

Create new mutable array while initializing all elements to some default value.