massiv 0.6.1.0 → 1.0.0.0

raw patch · 50 files changed

+4373/−3276 lines, 50 filesdep +mwc-randomdep ~basedep ~primitivedep ~randomPVP ok

version bump matches the API change (PVP)

Dependencies added: mwc-random

Dependency ranges changed: base, primitive, random, scheduler

API changes (from Hackage documentation)

Files

• CHANGELOG.md +65/−1
• README.md +664/−4
• massiv.cabal +8/−4
• src/Data/Massiv/Array.hs +10/−9
• src/Data/Massiv/Array/Delayed.hs +2/−0
• src/Data/Massiv/Array/Delayed/Interleaved.hs +19/−18
• src/Data/Massiv/Array/Delayed/Pull.hs +99/−142
• src/Data/Massiv/Array/Delayed/Push.hs +63/−58
• src/Data/Massiv/Array/Delayed/Stream.hs +40/−44
• src/Data/Massiv/Array/Delayed/Windowed.hs +41/−120
• src/Data/Massiv/Array/Manifest.hs +11/−12
• src/Data/Massiv/Array/Manifest/Boxed.hs +119/−195
• src/Data/Massiv/Array/Manifest/Internal.hs +90/−250
• src/Data/Massiv/Array/Manifest/List.hs +51/−43
• src/Data/Massiv/Array/Manifest/Primitive.hs +40/−105
• src/Data/Massiv/Array/Manifest/Storable.hs +133/−123
• src/Data/Massiv/Array/Manifest/Unboxed.hs +45/−83
• src/Data/Massiv/Array/Manifest/Vector.hs +16/−19
• src/Data/Massiv/Array/Mutable.hs +306/−194
• src/Data/Massiv/Array/Mutable/Algorithms.hs +5/−5
• src/Data/Massiv/Array/Mutable/Atomic.hs +10/−10
• src/Data/Massiv/Array/Mutable/Internal.hs +9/−9
• src/Data/Massiv/Array/Numeric.hs +224/−70
• src/Data/Massiv/Array/Numeric/Integral.hs +19/−18
• src/Data/Massiv/Array/Ops/Construct.hs +103/−64
• src/Data/Massiv/Array/Ops/Fold.hs +61/−47
• src/Data/Massiv/Array/Ops/Fold/Internal.hs +83/−80
• src/Data/Massiv/Array/Ops/Map.hs +223/−99
• src/Data/Massiv/Array/Ops/Slice.hs +89/−56
• src/Data/Massiv/Array/Ops/Sort.hs +28/−38
• src/Data/Massiv/Array/Ops/Transform.hs +221/−117
• src/Data/Massiv/Array/Stencil.hs +2/−23
• src/Data/Massiv/Array/Stencil/Convolution.hs +2/−2
• src/Data/Massiv/Array/Stencil/Internal.hs +3/−0
• src/Data/Massiv/Array/Stencil/Unsafe.hs +0/−34
• src/Data/Massiv/Array/Unsafe.hs +21/−6
• src/Data/Massiv/Core.hs +13/−14
• src/Data/Massiv/Core/Common.hs +422/−313
• src/Data/Massiv/Core/Exception.hs +24/−18
• src/Data/Massiv/Core/Index.hs +72/−38
• src/Data/Massiv/Core/Index/Internal.hs +104/−39
• src/Data/Massiv/Core/Index/Ix.hs +58/−31
• src/Data/Massiv/Core/Index/Stride.hs +12/−0
• src/Data/Massiv/Core/Iterator.hs +15/−10
• src/Data/Massiv/Core/List.hs +176/−226
• src/Data/Massiv/Core/Operations.hs +9/−6
• src/Data/Massiv/Vector.hs +349/−359
• src/Data/Massiv/Vector/Stream.hs +179/−105
• src/Data/Massiv/Vector/Unsafe.hs +13/−13
• tests/doctests.hs +2/−2

@@ -1,3 +1,58 @@+# 1.0.0++* Addition of `sumArrays'`, `sumArraysM` and `productArrays'`, `productArraysM`.+* Remove `Num`/`Fractional`/`Floating` instances for `D` and `DI` arrays. This was done to+  prevent surprises as in: [#97](https://github.com/lehins/massiv/issues/97)+* Remove helper class `Nested` and type family `NestedStuct`+* Make `negate` in `Num` instance throw error for `Sz` in order to avoid surprising+  behavior reported in: [#114](https://github.com/lehins/massiv/issues/114)+* Add of `munsafeResize`+* Add `uniformArray` and `uniformRangeArray`+* Replace `isNonEmpty` with `isNotZeroSz` and added `isZeroSz`+* Consolidate `Construct` class into `Load`+* Introduce `Shape`, the parent of `Size`+* Move `size` from `Load` into new class `Size`+* Consolidate `Resize` into `Size`+* Removed `maxSize` and replaced it with `maxLinearSize`+* Remove specialized `DW` instances that used tuples as indices.+* Get rid of `M` representation+* Remove `R` type family and `Slice`, `InnerSlice` and `Extract` classes in favor of `D`.+* Consolidate `OuterSlice` into `Source`+* Add `Strategy` and move `setComp` (from `Construct`) and `getComp` (from `Load`) in there.+* Remove `ix` from `Mutable`, `Manifest`, `Source`+* Remove `liftArray2`. Instead add `liftArray2'` and `liftArray2M` that don't behave+  like a `map` for singleton argument.+* Expose `liftNumArray2M`+* Prevent `showsArrayPrec` from changing index type+* Change function argument to monadic action for `unstablePartitionM` and `unsafeUnstablePartitionM`+* Replace `snull` with a more generic `isNull`+* Switch `DL` loading function to run in `ST` monad, rather than in any `Monad m`.+* Rename `msize` -> `sizeOfMArray`+* Add `unsafeResizeMArray` and `unsafeLinearSliceMArray`+* Rename:+  * `loadArrayM` -> `iterArrayLinearM_`+  * `loadArrayWithSetM` -> `iterArrayLinearWithSetM_`.+  * `loadArrayWithStrideM` -> `iterArrayLinearWithStrideM_`.+* Add `iterArrayLinearST_` and `iterArrayLinearWithSetST_` to `Load` class instead+  of `loadArrayM` and `loadArrayWithSetM`.+* Add `iterArrayLinearWithStrideST_` to `LoadStride` class instead of `loadArrayWithStrideM`.+* Add new mutable functions:+  * `resizeMArrayM` and `flattenMArray`,+  * `outerSliceMArrayM` and `outerSlicesMArray`,+  * `for2PrimM_` and `ifor2PrimM_`,+  * `zipSwapM_`+* Switch effectful mapping functions to use the representation specific+  iteration. This means that they are now restricted to `Load` instead of+  `Source`. Functions affected:+  * `mapIO_`, `imapIO_`, `forIO_` and `iforIO_`+  * `mapIO`, `imapIO`, `forIO` and `iforIO`+* Add `Uniform`, `UniformRange` and `Random` instances for `Ix2`, `IxN`, `Dim`, `Sz` and `Stride`+* Consolidate `Mutable` into `Manifest` type class and move the `MArray` data+  family outside of the class.+* Make sure empty arrays are always equal, regardless of their size.+* Remove `LN` representation in favor of a standalone `List` newtype wrapper+  around lists.+ # 0.6.1  * Addition of `withLoadMArray_`, `withLoadMArrayS`, `withLoadMArrayS_`,@@ -6,6 +61,7 @@ * Addition of `quicksortBy`, `quicksortByM` and `quicksortByM_` * Fix performance regression for `quicksort` and `quicksortM_` introduced in previous release. + # 0.6.0  * Fix semantics of `Applicative`, `Num` and `Fractional` instance for `D` arrays:@@ -54,6 +110,14 @@  * Improve loading of push arrays by adding `loadArrayWithSetM` and deprecating `defaultElement`. +# 0.5.9++* Add `mallocCompute`, `mallocCopy` and `unsafeMallocMArray`++# 0.5.8++* Improve loading of push arrays by adding `loadArrayWithSetM` and deprecating `defaultElement`.+ # 0.5.7  * Improve performance of `><.` and `><!` while making their constraints a bit more relaxed.@@ -243,7 +307,7 @@   * `generateArrayS` * Redefined most of the numeric operators with `Numeric` and `NumericFloat`. Will be   required for SIMD operations.-* `Num`, `Fractional` and `Applicative` for `D` changed behavior: instead of treating+* `Num`, `Fractional` and `Applicative` for `D` and `DI` changed behavior: instead of treating   singleton as a special array of any size it is treated as singleton.  # 0.3.6

@@ -1,10 +1,670 @@ # massiv -Efficient Haskell Arrays featuring Parallel computation+`massiv` is a Haskell library for array manipulation. Performance is one of its main goals, thus it+is capable of seamless parallelization of most of the operations provided by the library -There is a decent introduction to the library with some examples in the main-[README](https://github.com/lehins/massiv/blob/master/README.md) on github.+The name for this library comes from the Russian word Massiv (Масси́в), which means an Array. -See [massiv-io](https://hackage.haskell.org/package/massiv-io) for ability to read/write images.+## Status +| Language | Github Actions | Coveralls |Gitter.im |+|:--------:|:--------------:|:---------:|:--------:|+| ![GitHub top language](https://img.shields.io/github/languages/top/lehins/massiv.svg) | [![Build Status](https://github.com/lehins/massiv/workflows/massiv-CI/badge.svg)](https://github.com/lehins/massiv/actions) | [![Coverage Status](https://coveralls.io/repos/github/lehins/massiv/badge.svg?branch=master)](https://coveralls.io/github/lehins/massiv?branch=master) | [![Join the chat at https://gitter.im/haskell-massiv/Lobby](https://badges.gitter.im/haskell-massiv/Lobby.svg)](https://gitter.im/haskell-massiv/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +|      Package       | Hackage | Nightly | LTS |+|:-------------------|:-------:|:-------:|:---:|+|  [`massiv`](https://github.com/lehins/massiv/tree/master/massiv)|                                       [![Hackage](https://img.shields.io/hackage/v/massiv.svg)](https://hackage.haskell.org/package/massiv)|                                                                                                        [![Nightly](https://www.stackage.org/package/massiv/badge/nightly)](https://www.stackage.org/nightly/package/massiv)|                                                                                         [![Nightly](https://www.stackage.org/package/massiv/badge/lts)](https://www.stackage.org/lts/package/massiv)|+|  [`massiv-io`](https://github.com/lehins/massiv-io)|                                [![Hackage](https://img.shields.io/hackage/v/massiv-io.svg)](https://hackage.haskell.org/package/massiv-io)|                                                                                                  [![Nightly](https://www.stackage.org/package/massiv-io/badge/nightly)](https://www.stackage.org/nightly/package/massiv-io)|                                                                                   [![Nightly](https://www.stackage.org/package/massiv-io/badge/lts)](https://www.stackage.org/lts/package/massiv-io)|+|  [`massiv-test`](https://github.com/lehins/massiv/tree/master/massiv-test)|                            [![Hackage](https://img.shields.io/hackage/v/massiv-test.svg)](https://hackage.haskell.org/package/massiv-test)|                                                                                              [![Nightly](https://www.stackage.org/package/massiv-test/badge/nightly)](https://www.stackage.org/nightly/package/massiv-test)|                                                                               [![Nightly](https://www.stackage.org/package/massiv-test/badge/lts)](https://www.stackage.org/lts/package/massiv-test)|+|  [`haskell-scheduler`](https://github.com/lehins/haskell-scheduler)|                                   [![Hackage](https://img.shields.io/hackage/v/scheduler.svg)](https://hackage.haskell.org/package/scheduler)|                                                                                          [![Nightly](https://www.stackage.org/package/scheduler/badge/nightly)](https://www.stackage.org/nightly/package/scheduler)|                                                                   [![Nightly](https://www.stackage.org/package/scheduler/badge/lts)](https://www.stackage.org/lts/package/scheduler)|++## Introduction++Everything in the library revolves around an `Array r ix e` - a data family for anything that can be+thought of as an array. The type variables, from the end, are:++* `e` - element of an array.+* `ix` - an index that will map to an actual element. The index must be an instance of the `Index`+  class with the default one being an `Ix n` type family and an optional being tuples of `Int`s.+* `r` - underlying representation. There are two main categories of representations described below.++### Manifest++These are your classical arrays that are located in memory and allow constant time lookup of+elements. Another main property they share is that they have a mutable interface. An `Array` with+manifest representation can be thawed into a mutable `MArray` and then frozen back into its+immutable counterpart after some destructive operation is applied to the mutable copy. The+differences among representations below is in the way that elements are being accessed in memory:++  * `P` - Array with elements that are an instance of `Prim` type class, i.e. common Haskell+    primitive types: `Int`, `Word`, `Char`, etc. It is backed by unpinned memory and based on+    [`ByteArray`](https://hackage.haskell.org/package/primitive/docs/Data-Primitive-ByteArray.html#t:ByteArray).+  * `U` - Unboxed arrays. The elements are instances of the+    [`Unbox`](https://hackage.haskell.org/package/vector/docs/Data-Vector-Unboxed.html#t:Vector)+    type class. Usually just as fast as `P`, but has a slightly wider range of data types that it+    can work with. Notable data types that can be stored as elements are `Bool`, tuples and `Ix n`.+  * `S` - Storable arrays. Backed by pinned memory and based on `ForeignPtr`, while elements are+    instances of the `Storable` type class.+  * `B` - Boxed arrays that don't have restrictions on their elements, since they are represented+    as pointers to elements, thus making them the slowest type of array, but also the most+    general. Arrays of this representation are element strict, in other words its elements are+    kept in Weak-Head Normal Form (WHNF).+  * `BN` - Also boxed arrays, but unlike the other representation `B`, its elements are in Normal+    Form, i.e. in a fully evaluated state and no thunks or memory leaks are possible. It does+    require an `NFData` instance for the elements though.+  * `BL` - Boxed lazy array. Just like `B` and `BN`, except values are evaluated on demand.++### Delayed++Main trait of delayed arrays is that they do not exist in memory and instead describe the contents+of an array as a function or a composition of functions. In fact all of the fusion capabilities in+`massiv` can be attributed to delayed arrays.++   * `D` - Delayed "pull" array is just a function from an index to an element: `(ix ->+     e)`. Therefore indexing into this type of array is not possible, instead elements are evaluated+     with the `evaluateM` function each time when applied to an index. It gives us a nice ability to+     compose functions together when applied to an array and possibly even fold over without ever+     allocating intermediate manifest arrays.+   * `DW` - Delayed windowed array is very similar to the version above, except it has two functions+     that describe it, one for the near border elements and one for the interior, aka. the+     window. This is used for [`Stencil`](stencil) computation and things that derive from it, such as+     convolution, for instance.+   * `DL` - Delayed "push" array contains a monadic action that describes how an array can be loaded+     into memory. This is most useful for composing arrays together.+   * `DS` - Delayed stream array is a sequence of elements, possibly even an infinite one. This is+     most useful for situations when we don't know the size of our resulting array ahead of time,+     which is common in operations such as `filter`, `mapMaybe`, `unfold` etc. Naturally, in the end+     we can only load such an array into a flat vector.+   * `DI` - Is just like `D`, except loading is interleaved and is useful for parallel loading+     arrays with unbalanced computation, such as Mandelbrot set or ray tracing, for example.++## Construct++Creating a delayed type of array allows us to fuse any future operations we decide to perform on+it. Let's look at this example:++```haskell+λ> import Data.Massiv.Array as A+λ> makeVectorR D Seq 10 id+Array D Seq (Sz1 10)+  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]+```++Here we created a delayed vector of size 10, which is in reality just an `id` function from its+index to an element (see the [Computation](#computation) section for the meaning of `Seq`). So let's+go ahead and square its elements++```haskell+λ> makeVectorR D Seq 10 id+λ> evaluateM vec 4+4+λ> vec2 = A.map (^ (2 :: Int)) vec+λ> evaluateM vec2 4+16+```++It's not that exciting, since every time we call `evaluateM` it will recompute the element, __every+time__, therefore this function should be avoided at all costs! Instead we can use all of the+functions that take `Source` like arrays and then fuse that computation together by calling+`compute`, or a handy `computeAs` function and only afterwards apply an `indexM` function or its+partial synonym: `(!)`. Any delayed array can also be reduced using one of the folding functions,+thus completely avoiding any memory allocation, or converted to a list, if that's what you need:++```haskell+λ> vec2U = computeAs U vec2+λ> vec2U+Array U Seq (Sz1 10)+  [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 ]+λ> vec2U ! 4+16+λ> toList vec2U+[0,1,4,9,16,25,36,49,64,81]+λ> A.sum vec2U+285+```++There is a whole multitude of ways to construct arrays:+ * by using one of many helper functions: `makeArray`, `range`, `rangeStepFrom`, `enumFromN`, etc.+ * through conversion: from lists, from `Vector`s in `vector` library, from `ByteString`s in+   `bytestring`;+ * with a mutable interface in `PrimMonad` (`IO`, `ST`, etc.), eg: `makeMArray`,+   `generateArray`, `unfoldrPrim`, etc.++It's worth noting that, in the next example, nested lists will be loaded into an unboxed manifest+array and the sum of its elements will be computed in parallel on all available cores.++```haskell+λ> A.sum (fromLists' Par [[0,0,0,0,0],[0,1,2,3,4],[0,2,4,6,8]] :: Array U Ix2 Double)+30.0+```++The above wouldn't run in parallel in ghci of course, as the program would have to be compiled with+`ghc` using `-threaded -with-rtsopts=-N` flags in order to use all available cores. Alternatively we+could compile with the `-threaded` flag and then pass the number of capabilities directly to the+runtime with `+RTS -N<n>`, where `<n>` is the number of cores you'd like to utilize.++## Index++The main `Ix n` closed type family can be somewhat confusing, but there is no need to fully+understand how it works in order to start using it. GHC might ask you for the `DataKinds` language+extension if `IxN n` is used in a type signature, but there are type and pattern synonyms for the+first five dimensions: `Ix1`, `Ix2`, `Ix3`, `Ix4` and `Ix5`.++There are three distinguishable constructors for the index:++* The first one is simply an int: `Ix1 = Ix 1 = Int`, therefore vectors can be indexed in a usual way+  without some extra wrapping data type, just as it was demonstrated in a previous section.+* The second one is `Ix2` for operating on 2-dimensional arrays and has a constructor `:.`++```haskell+λ> makeArrayR D Seq (Sz (3 :. 5)) (\ (i :. j) -> i * j)+Array D Seq (Sz (3 :. 5))+  [ [ 0, 0, 0, 0, 0 ]+  , [ 0, 1, 2, 3, 4 ]+  , [ 0, 2, 4, 6, 8 ]+  ]+```++* The third one is `IxN n` and is designed for working with N-dimensional arrays, and has a similar+  looking constructor `:>`, except that it can be chained indefinitely on top of `:.`++```haskell+λ> arr3 = makeArrayR P Seq (Sz (3 :> 2 :. 5)) (\ (i :> j :. k) -> i * j + k)+λ> :t arr3+arr3 :: Array P (IxN 3) Int+λ> arr3+Array P Seq (Sz (3 :> 2 :. 5))+  [ [ [ 0, 1, 2, 3, 4 ]+    , [ 0, 1, 2, 3, 4 ]+    ]+  , [ [ 0, 1, 2, 3, 4 ]+    , [ 1, 2, 3, 4, 5 ]+    ]+  , [ [ 0, 1, 2, 3, 4 ]+    , [ 2, 3, 4, 5, 6 ]+    ]+  ]+λ> arr3 ! (2 :> 1 :. 4)+6+λ> ix10 = 10 :> 9 :> 8 :> 7 :> 6 :> 5 :> 4 :> 3 :> 2 :. 1+λ> :t ix10+ix10 :: IxN 10+λ> ix10 -- 10-dimensional index+10 :> 9 :> 8 :> 7 :> 6 :> 5 :> 4 :> 3 :> 2 :. 1+```++Here is how we can construct a 4-dimensional array and sum its elements in constant memory:++```haskell+λ> arr = makeArrayR D Seq (Sz (10 :> 20 :> 30 :. 40)) $ \ (i :> j :> k :. l) -> (i * j + k) * k + l+λ> :t arr -- a 4-dimensional array+arr :: Array D (IxN 4) Int+λ> A.sum arr+221890000+```++There are quite a few helper functions that can operate on indices, but these are only needed when+writing functions that work for arrays of arbitrary dimension, as such they are scarcely used:++```haskell+λ> pullOutDim' ix10 5+(5,10 :> 9 :> 8 :> 7 :> 6 :> 4 :> 3 :> 2 :. 1)+λ> unconsDim ix10+(10,9 :> 8 :> 7 :> 6 :> 5 :> 4 :> 3 :> 2 :. 1)+λ> unsnocDim ix10+(10 :> 9 :> 8 :> 7 :> 6 :> 5 :> 4 :> 3 :. 2,1)+```++All of the `Ix n` indices are instances of `Num` so basic numeric operations are made easier:++```haskell+λ> (1 :> 2 :. 3) + (4 :> 5 :. 6)+5 :> 7 :. 9+λ> 5 :: Ix4+5 :> 5 :> 5 :. 5+```++It is important to note that the size type is distinct from the index by the newtype wrapper `Sz+ix`. There is a constructor `Sz`, which will make sure that none of the dimensions are negative:++```haskell+λ> Sz (2 :> 3 :. 4)+Sz (2 :> 3 :. 4)+λ> Sz (10 :> 2 :> -30 :. 4)+Sz (10 :> 2 :> 0 :. 4)+```++Same as with indices, there are helper pattern synonyms: `Sz1`, `Sz2`, `Sz3`, `Sz4` and `Sz5`.++```haskell+λ> Sz3 2 3 4+Sz (2 :> 3 :. 4)+λ> Sz4 10 2 (-30) 4+Sz (10 :> 2 :> 0 :. 4)+```++As well as the `Num` instance:++```haskell+λ> 4 :: Sz5+Sz (4 :> 4 :> 4 :> 4 :. 4)+λ> (Sz2 1 2) + 3+Sz (4 :. 5)+λ> (Sz2 1 2) - 3+Sz (0 :. 0)+```++Alternatively tuples of `Int`s can be used for working with arrays, up to and including 5-tuples+(type synonyms: `Ix2T` .. `Ix5T`), but since tuples are polymorphic it is necessary to restrict the+resulting array type. Not all operations in the library support tuples, so it is advised to avoid+them for indexing.++```haskell+λ> makeArray Seq (4, 20) (uncurry (*)) :: Array P Ix2T Int+(Array P Seq ((4,20))+  [ [ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ]+  , [ 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 ]+  , [ 0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38 ]+  , [ 0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57 ]+  ])+λ> :i Ix2T+type Ix2T = (Int, Int)+```++There are helper functions that can go back and forth between tuples and `Ix n` indices.++```haskell+λ> fromIx4 (3 :> 4 :> 5 :. 6)+(3,4,5,6)+λ> toIx5 (3, 4, 5, 6, 7)+3 :> 4 :> 5 :> 6 :. 7+```++## Slicing++In order to get a subsection of an array there is no need to recompute it, unless we want to free up+the no longer memory, of course. So, there are a few slicing, resizing and extraction operators that+can do it all in constant time, modulo the index manipulation:++```haskell+λ> arr = makeArrayR U Seq (Sz (4 :> 2 :. 6)) fromIx3+λ> arr !> 3 !> 1+Array M Seq (Sz1 6)+  [ (3,1,0), (3,1,1), (3,1,2), (3,1,3), (3,1,4), (3,1,5) ]+```++As you might suspect all of the slicing, indexing, extracting, resizing operations are partial, and+those are frowned upon in Haskell. So there are matching functions that can do the same operations+safely by using `MonadThrow` and thus returning `Nothing`, `Left SomeException` or throwing an+exception in case of `IO` on failure, for example:++```haskell+λ> arr !?> 3 ??> 1+Array M Seq (Sz1 6)+  [ (3,1,0), (3,1,1), (3,1,2), (3,1,3), (3,1,4), (3,1,5) ]+λ> arr !?> 3 ??> 1 ?? 0 :: Maybe (Int, Int, Int)+Just (3,1,0)+```++In above examples we first take a slice at the 4th page (index 3, since we start at 0), then another+one at the 2nd row (index 1). While in the last example we also take 1st element at+position 0. Pretty neat, huh?  Naturally, by doing a slice we always reduce dimension by one. We can+do slicing from the outside as well as from the inside:++```haskell+λ> Ix1 1 ... 9+Array D Seq (Sz1 10)+  [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]+λ> a <- resizeM (Sz (3 :> 2 :. 4)) $ Ix1 11 ... 34+λ> a+Array D Seq (Sz (3 :> 2 :. 4))+  [ [ [ 11, 12, 13, 14 ]+    , [ 15, 16, 17, 18 ]+    ]+  , [ [ 19, 20, 21, 22 ]+    , [ 23, 24, 25, 26 ]+    ]+  , [ [ 27, 28, 29, 30 ]+    , [ 31, 32, 33, 34 ]+    ]+  ]+λ> a !> 0+Array D Seq (Sz (2 :. 4))+  [ [ 11, 12, 13, 14 ]+  , [ 15, 16, 17, 18 ]+  ]+λ> a <! 0+Array D Seq (Sz (3 :. 2))+  [ [ 11, 15 ]+  , [ 19, 23 ]+  , [ 27, 31 ]+  ]+```++Or we can slice along any other available dimension:++```haskell+λ> a <!> (Dim 2, 0)+Array D Seq (Sz (3 :. 4))+  [ [ 11, 12, 13, 14 ]+  , [ 19, 20, 21, 22 ]+  , [ 27, 28, 29, 30 ]+  ]+```++In order to extract sub-array while preserving dimensionality we can use `extractM` or `extractFromToM`.++```haskell+λ> extractM (0 :> 1 :. 1) (Sz (3 :> 1 :. 2)) a+Array D Seq (Sz (3 :> 1 :. 2))+  [ [ [ 16, 17 ]+    ]+  , [ [ 24, 25 ]+    ]+  , [ [ 32, 33 ]+    ]+  ]+λ> extractFromToM (1 :> 0 :. 1) (3 :> 2 :. 4) a+Array D Seq (Sz (2 :> 2 :. 3))+  [ [ [ 20, 21, 22 ]+    , [ 24, 25, 26 ]+    ]+  , [ [ 28, 29, 30 ]+    , [ 32, 33, 34 ]+    ]+  ]+```++## Computation and parallelism++There is a data type `Comp` that controls how elements will be computed when calling the `compute`+function. It has a few constructors, although most of the time either `Seq` or `Par` will be+sufficient:++* `Seq` - computation will be done sequentially on one core (capability in ghc).+* `ParOn [Int]` - perform computation in parallel while pinning the workers to particular+  cores. Providing an empty list will result in the computation being distributed over all+  available cores, or better known in Haskell as capabilities.+* `ParN Word16` - similar to `ParOn`, except it simply specifies the number of cores to+  use, with `0` meaning all cores.+* `Par` - isn't really a constructor but a `pattern` for constructing `ParOn []`, which+  will result in Scheduler using all cores, thus should be used instead of `ParOn`.+* `Par'` - similar to `Par`, except it uses `ParN 0` underneath.++Just to make sure a simple novice mistake is prevented, which I have seen in the past, make sure+your source code is compiled with `ghc -O2 -threaded -with-rtsopts=-N`, otherwise no parallelization+and poor performance are waiting for you. Also a bit later you might notice the `{-# INLINE funcName+#-}` pragma being used, oftentimes it is a good idea to do that, but not always required. It is+worthwhile to benchmark and experiment.++## Stencil++Instead of manually iterating over a multi-dimensional array and applying a function to each element,+while reading its neighboring elements (as you would do in an imperative language) in a functional+language it is much more efficient to apply a stencil function and let the library take care of all+of bounds checking and iterating in a cache friendly manner.++What's a [stencil](https://en.wikipedia.org/wiki/Stencil_code)? It is a declarative way of+specifying a pattern for how elements of an array in a neighborhood will be used in order to update+each element of the newly created array. In massiv a `Stencil` is a function that can read the+neighboring elements of the stencil's _center_ (the zero index), and only those, and then outputs a+new value for the center element.++![stencil](massiv-examples/files/stencil.png)++Let's create a simple, but somewhat meaningful array and create an averaging stencil. There is+nothing special about the array itself, but the averaging filter is a stencil that sums the elements+in a [Moore neighborhood](https://en.wikipedia.org/wiki/Moore_neighborhood) and divides the result+by 9, i.e. finds the average of a 3 by 3 square.++```haskell+arrLightIx2 :: Comp -> Sz Ix2 -> Array D Ix2 Double+arrLightIx2 comp arrSz = makeArray comp arrSz $ \ (i :. j) -> sin (fromIntegral (i * i + j * j))+{-# INLINE arrLightIx2 #-}++average3x3Filter :: Fractional a => Stencil Ix2 a a+average3x3Filter = makeStencil (Sz (3 :. 3)) (1 :. 1) $ \ get ->+  (  get (-1 :. -1) + get (-1 :. 0) + get (-1 :. 1) ++     get ( 0 :. -1) + get ( 0 :. 0) + get ( 0 :. 1) ++     get ( 1 :. -1) + get ( 1 :. 0) + get ( 1 :. 1)   ) / 9+{-# INLINE average3x3Filter #-}+```++Here is what it would look like in GHCi. We create a delayed array with some funky periodic+function, and make sure it is computed prior to mapping an average stencil over it:++```haskell+λ> arr = computeAs U $ arrLightIx2 Par (Sz (600 :. 800))+λ> :t arr+arr :: Array U Ix2 Double+λ> :t mapStencil Edge average3x3Filter arr+mapStencil Edge average3x3Filter arr :: Array DW Ix2 Double+```++As you can see, that operation produced an array of the earlier mentioned representation Delayed+Windowed `DW`. In its essence `DW` is an array type that does no bounds checking in order to gain+performance, except when it's near the border, where it uses a border resolution technique supplied+by the user (`Edge` in the example above). Currently it is used only in stencils and not much else+can be done to an array of this type besides further computing it into a manifest representation.++This example will be continued in the next section, but before that I would like to mention that+some might notice that it looks very much like convolution, and in fact convolution can be+implemented with a stencil. There is a helper function `makeConvolutionStencil` that lets+you do just that. For the sake of example we'll do a sum of all neighbors by hand instead:++```haskell+sum3x3Filter :: Fractional a => Stencil Ix2 a a+sum3x3Filter = makeConvolutionStencil (Sz (3 :. 3)) (1 :. 1) $ \ get ->+  get (-1 :. -1) 1 . get (-1 :. 0) 1 . get (-1 :. 1) 1 .+  get ( 0 :. -1) 1 . get ( 0 :. 0) 1 . get ( 0 :. 1) 1 .+  get ( 1 :. -1) 1 . get ( 1 :. 0) 1 . get ( 1 :. 1) 1+{-# INLINE sum3x3Filter #-}+```++There is not a single plus or multiplication sign, that is because convolutions is actually+summation of elements multiplied by a kernel element, so instead we have composition of functions+applied to an offset index and a multiplier. After we map that stencil, we can further divide each+element of the array by 9 in order to get the average. Yeah, I lied a bit, `Array DW ix` is an+instance of `Functor` class, so we can map functions over it, which will be fused as with a regular+`D`elayed array:++```haskell+computeAs U $ fmap (/9) $ mapStencil Edge sum3x3Filter arr+```++If you are still confused of what a stencil is, but you are familiar with [Conway's Game of+Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life) this should hopefully clarify it a+bit more. The function `life` below is a single iteration of Game of Life:++```haskell+lifeRules :: Word8 -> Word8 -> Word8+lifeRules 0 3 = 1+lifeRules 1 2 = 1+lifeRules 1 3 = 1+lifeRules _ _ = 0++lifeStencil :: Stencil Ix2 Word8 Word8+lifeStencil = makeStencil (Sz (3 :. 3)) (1 :. 1) $ \ get ->+  lifeRules (get (0 :. 0)) $ get (-1 :. -1) + get (-1 :. 0) + get (-1 :. 1) ++                             get ( 0 :. -1)         +         get ( 0 :. 1) ++                             get ( 1 :. -1) + get ( 1 :. 0) + get ( 1 :. 1)++life :: Array S Ix2 Word8 -> Array S Ix2 Word8+life = compute . mapStencil Wrap lifeStencil+```++<!-- TODO: add a gif with a few iterations -->++The full working example that uses GLUT and OpenGL is located in+[GameOfLife](massiv-examples/GameOfLife/app/GameOfLife.hs). You can run it if you have the GLUT+dependencies installed:++```bash+$ cd massiv-examples && stack run GameOfLife+```++# massiv-io++In order to do anything useful with arrays we often need to be able to read some data from a+file. Considering that most common array-like files are images,+[massiv-io](https://github.com/lehins/massiv-io) provides an interface to read, write and display+images in common formats using Haskell native JuicyPixels and Netpbm packages.++[Color](https://github.com/lehins/Color) package provides a variety of color spaces and conversions+between them, which are used by `massiv-io` package as pixels during reading and writing images.++An earlier example wasn't particularly interesting, since we couldn't visualize what is actually+going on, so let's expand on it:++```haskell+import Data.Massiv.Array+import Data.Massiv.Array.IO++main :: IO ()+main = do+  let arr = computeAs S $ arrLightIx2 Par (600 :. 800)+      toImage ::+           (Functor (Array r Ix2), Load r Ix2 (Pixel (Y' SRGB) Word8))+        => Array r Ix2 Double+        -> Image S (Y' SRGB) Word8+      toImage = computeAs S . fmap (PixelY' . toWord8)+      lightPath = "files/light.png"+      lightImage = toImage $ delay arr+      lightAvgPath = "files/light_avg.png"+      lightAvgImage = toImage $ mapStencil Edge (avgStencil 3) arr+      lightSumPath = "files/light_sum.png"+      lightSumImage = toImage $ mapStencil Edge (sumStencil 3) arr+  writeImage lightPath lightImage+  putStrLn $ "written: " ++ lightPath+  writeImage lightAvgPath lightAvgImage+  putStrLn $ "written: " ++ lightAvgPath+  writeImage lightSumPath lightSumImage+  putStrLn $ "written: " ++ lightSumPath+  displayImageUsing defaultViewer True . computeAs S+    =<< concatM 1 [lightAvgImage, lightImage, lightSumImage]+```++`massiv-examples/vision/files/light.png`:++![Light](massiv-examples/vision/files/light.png)++`massiv-examples/vision/files/light_avg.png`:++![Light Average](massiv-examples/vision/files/light_avg.png)+++The full example is in the example [vision](massiv-examples/vision/app/AvgSum.hs) package and if you+have `stack` installed you can run it as:++```bash+$ cd massiv-examples && stack run avg-sum+```++# Other libraries++A natural question might come to mind: Why even bother with a new array library when we already have+a few really good ones in the Haskell world? The main reasons for me are performance and+usability. I personally felt like there was much room for improvement before I even started working on+this package, and it seems like it turned out to be true. For example, the most common goto library+for dealing with multidimensional arrays and parallel computation used to be+[Repa](https://hackage.haskell.org/package/repa), which I personally was a big fan of for quite some+time, to the point that I even wrote a [Haskell Image+Processing](https://hackage.haskell.org/package/hip) library based on top of it.++Here is a quick summary of how `massiv` is better than `Repa`:++* It is actively maintained.+* Much more sophisticated scheduler. It is resumable and is capable of handling nested parallel+  computation.+* Improved indexing data types.+* Safe stencils for arbitrary dimensions, not only 2D convolution. Stencils are composable+* Improved performance on almost all operations.+* Structural parallel folds (i.e. left/right - direction is preserved)+* Super easy slicing.+* Extensive mutable interface+* More fusion capabilities with delayed stream and push array representations.+* Delayed arrays aren't indexable, only Manifest are (saving user from common pitfall in Repa of+  trying to read elements of delayed array)++As far as usability of the library goes, it is very subjective, thus I'll let you be a judge of+that. When talking about performance it is the facts that do matter. Thus, let's not continue this+discussion in pure abstract words, below is a glimpse into benchmarks against Repa library running+with GHC 8.8.4 on Intel® Core™ i7-3740QM CPU @ 2.70GHz × 8++[Matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication_algorithm):++```+benchmarking Repa/MxM U Double - (500x800 X 800x500)/Par+time                 120.5 ms   (115.0 ms .. 127.2 ms)+                     0.998 R²   (0.996 R² .. 1.000 R²)+mean                 124.1 ms   (121.2 ms .. 127.3 ms)+std dev              5.212 ms   (2.422 ms .. 6.620 ms)+variance introduced by outliers: 11% (moderately inflated)++benchmarking Massiv/MxM U Double - (500x800 X 800x500)/Par+time                 41.46 ms   (40.67 ms .. 42.45 ms)+                     0.998 R²   (0.994 R² .. 0.999 R²)+mean                 38.45 ms   (37.22 ms .. 39.68 ms)+std dev              2.342 ms   (1.769 ms .. 3.010 ms)+variance introduced by outliers: 19% (moderately inflated)+```++[Sobel operator](https://en.wikipedia.org/wiki/Sobel_operator):+```+benchmarking Sobel/Par/Operator - Repa+time                 17.82 ms   (17.30 ms .. 18.32 ms)+                     0.997 R²   (0.994 R² .. 0.998 R²)+mean                 17.42 ms   (17.21 ms .. 17.69 ms)+std dev              593.0 μs   (478.1 μs .. 767.5 μs)+variance introduced by outliers: 12% (moderately inflated)++benchmarking Sobel/Par/Operator - Massiv+time                 7.421 ms   (7.230 ms .. 7.619 ms)+                     0.994 R²   (0.991 R² .. 0.997 R²)+mean                 7.537 ms   (7.422 ms .. 7.635 ms)+std dev              334.3 μs   (281.3 μs .. 389.9 μs)+variance introduced by outliers: 20% (moderately inflated)+```++Sum all elements of a 2D array:++```+benchmarking Sum/Seq/Repa+time                 539.7 ms   (523.2 ms .. 547.9 ms)+                     1.000 R²   (1.000 R² .. 1.000 R²)+mean                 540.1 ms   (535.7 ms .. 543.2 ms)+std dev              4.727 ms   (2.208 ms .. 6.609 ms)+variance introduced by outliers: 19% (moderately inflated)++benchmarking Sum/Seq/Vector+time                 16.95 ms   (16.78 ms .. 17.07 ms)+                     0.999 R²   (0.998 R² .. 1.000 R²)+mean                 17.23 ms   (17.13 ms .. 17.43 ms)+std dev              331.4 μs   (174.1 μs .. 490.0 μs)++benchmarking Sum/Seq/Massiv+time                 16.78 ms   (16.71 ms .. 16.85 ms)+                     1.000 R²   (1.000 R² .. 1.000 R²)+mean                 16.80 ms   (16.76 ms .. 16.88 ms)+std dev              127.8 μs   (89.95 μs .. 186.2 μs)++benchmarking Sum/Par/Repa+time                 81.76 ms   (78.52 ms .. 84.37 ms)+                     0.997 R²   (0.990 R² .. 1.000 R²)+mean                 79.20 ms   (78.03 ms .. 80.91 ms)+std dev              2.613 ms   (1.565 ms .. 3.736 ms)++benchmarking Sum/Par/Massiv+time                 8.102 ms   (7.971 ms .. 8.216 ms)+                     0.999 R²   (0.998 R² .. 1.000 R²)+mean                 7.967 ms   (7.852 ms .. 8.028 ms)+std dev              236.4 μs   (168.4 μs .. 343.2 μs)+variance introduced by outliers: 11% (moderately inflated)+```++Here is also a blog post that compares [Performance of Haskell Array libraries through Canny edge detection](https://alexey.kuleshevi.ch/blog/2020/07/10/canny-benchmarks/)++# Further resources on learning `massiv`:++* [2019 - Monadic Party - Haskell arrays with Massiv](https://github.com/lehins/talks#2019---monadic-party---haskell-arrays-with-massiv)+* [2018 - Monadic Warsaw #14 - Haskell arrays that are easy and fast](https://github.com/lehins/talks#2018---monadic-warsaw-14---haskell-arrays-that-are-easy-and-fast)

@@ -1,5 +1,5 @@ name:                massiv-version:             0.6.1.0+version:             1.0.0.0 synopsis:            Massiv (Массив) is an Array Library. description:         Multi-dimensional Arrays with fusion, stencils and parallel computation. homepage:            https://github.com/lehins/massiv@@ -20,6 +20,7 @@                     , GHC == 8.6.5                     , GHC == 8.8.4                     , GHC == 8.10.2+                    , GHC == 9.0.1  flag unsafe-checks   description: Enable all the bounds checks for unsafe functions at the cost of@@ -81,8 +82,9 @@                      , bytestring                      , deepseq                      , exceptions-                     , scheduler >= 1.5.0-                     , primitive+                     , scheduler >= 2.0.0 && < 3.0.0+                     , primitive >= 0.7.1.0+                     , random >= 1.2.0                      , unliftio-core                      , vector @@ -97,6 +99,7 @@                       -Wincomplete-record-updates                       -Wincomplete-uni-patterns                       -Wredundant-constraints+                      -Wno-simplifiable-class-constraints  test-suite doctests   type:             exitcode-stdio-1.0@@ -107,7 +110,8 @@                , QuickCheck                , massiv                , mersenne-random-pure64-               , random+               , random >= 1.2.0+               , mwc-random >= 0.15.0.1                , splitmix >= 0.0.1                , template-haskell   default-language:    Haskell2010

@@ -24,7 +24,8 @@ --         Form (NF). This property is very useful for parallel processing, i.e. when calling --         `compute` you do want all of your elements to be fully evaluated. ----- * `BL` - Similar to `B`, is also a boxed type, but lazy. It's elements are not evaluated.+-- * `BL` - Similar to `B`, is also a boxed type, but lazy. It's elements are not evaluated when+--         array is computed. -- -- * `S` - Is a type of array that is backed by pinned memory, therefore pointers to those arrays --         can be passed to FFI calls, because Garbage Collector (GC) is guaranteed not to move@@ -36,9 +37,6 @@ -- * `P` - Array that can hold Haskell primitives, such as `Int`, `Word`, `Double`, etc. Any element --        must be an instance of `Prim` class. ----- * `M` - General manifest array type, that any of the above representations can be converted to in---       constant time using `toManifest`.--- -- There are also array representations that only describe how values for its elements can be -- computed or loaded into memory, as such, they are represented by functions and do not impose the -- memory overhead, that is normally associated with arrays. They are needed for proper fusion and@@ -64,15 +62,15 @@ -- -- Other Array types: ----- * `L` and `LN` - those types aren't particularly useful on their own, but because of their unique---       ability to be converted to and from nested lists in constant time, provide a perfect---       intermediary for lists \<-> array conversion.+-- * `L` - this type isn't particularly useful on its own, but because it has unique ability to be+--       converted to and from nested lists in constant time, it provides a perfect intermediary for+--       conversion of nested lists into manifest arrays. -- -- Most of the `Manifest` arrays are capable of in-place mutation. Check out -- "Data.Massiv.Array.Mutable" module for available functionality. ----- Many of the function names exported by this package will clash with the ones--- from "Prelude", hence it can be more convenient to import like this:+-- Many of the function names exported by this package will clash with the ones from "Prelude",+-- hence it can be more convenient to import like this: -- -- @ -- import Prelude as P@@ -85,6 +83,7 @@   -- * Compute   , getComp   , setComp+  , appComp   , compute   , computeS   , computeP@@ -108,6 +107,8 @@   , elemsCount   , isEmpty   , isNotEmpty+  , isNull+  , isNotNull   -- * Indexing   , (!?)   , (!)

@@ -11,6 +11,8 @@   -- ** Delayed Pull Array     D(..)   , delay+  , liftArray2'+  , liftArray2M   -- ** Delayed Push Array   , DL(..)   , toLoadArray

@@ -15,6 +15,7 @@ -- module Data.Massiv.Array.Delayed.Interleaved   ( DI(..)+  , Array(..)   , toInterleaved   , fromInterleaved   ) where@@ -30,52 +31,52 @@  newtype instance Array DI ix e = DIArray   { diArray :: Array D ix e-  } deriving (Eq, Ord, Functor, Applicative, Foldable, Num, Floating, Fractional)+  } deriving (Eq, Ord, Functor, Applicative, Foldable)  instance (Ragged L ix e, Show e) => Show (Array DI ix e) where   showsPrec = showsArrayPrec diArray   showList = showArrayList -instance Index ix => Construct DI ix e where+instance Strategy DI where   setComp c arr = arr { diArray = (diArray arr) { dComp = c } }   {-# INLINE setComp #-}+  getComp = dComp . diArray+  {-# INLINE getComp #-} -  makeArray c sz = DIArray . makeArray c sz-  {-# INLINE makeArray #-}+instance Index ix => Shape DI ix where+  maxLinearSize = Just . SafeSz . elemsCount+  {-# INLINE maxLinearSize #-} -instance Index ix => Resize DI ix where++instance Size DI where+  size (DIArray arr) = size arr+  {-# INLINE size #-}   unsafeResize sz = DIArray . unsafeResize sz . diArray   {-# INLINE unsafeResize #-} -instance Index ix => Extract DI ix e where-  unsafeExtract sIx newSz = DIArray . unsafeExtract sIx newSz . diArray-  {-# INLINE unsafeExtract #-} - instance Index ix => Load DI ix e where-  size (DIArray arr) = size arr-  {-# INLINE size #-}-  getComp = dComp . diArray-  {-# INLINE getComp #-}-  loadArrayM scheduler (DIArray (DArray _ sz f)) uWrite =+  makeArray c sz = DIArray . makeArray c sz+  {-# INLINE makeArray #-}+  iterArrayLinearST_ scheduler (DIArray (DArray _ sz f)) uWrite =     loopM_ 0 (< numWorkers scheduler) (+ 1) $ \ !start ->       scheduleWork scheduler $       iterLinearM_ sz start (totalElem sz) (numWorkers scheduler) (<) $ \ !k -> uWrite k . f-  {-# INLINE loadArrayM #-}+  {-# INLINE iterArrayLinearST_ #-}  instance Index ix => StrideLoad DI ix e where-  loadArrayWithStrideM scheduler stride resultSize arr uWrite =+  iterArrayLinearWithStrideST_ scheduler stride resultSize arr uWrite =     let strideIx = unStride stride         DIArray (DArray _ _ f) = arr     in loopM_ 0 (< numWorkers scheduler) (+ 1) $ \ !start ->           scheduleWork scheduler $           iterLinearM_ resultSize start (totalElem resultSize) (numWorkers scheduler) (<) $             \ !i ix -> uWrite i (f (liftIndex2 (*) strideIx ix))-  {-# INLINE loadArrayWithStrideM #-}+  {-# INLINE iterArrayLinearWithStrideST_ #-}  -- | Convert a source array into an array that, when computed, will have its elemets evaluated out -- of order (interleaved amongst cores), hence making unbalanced computation better parallelizable.-toInterleaved :: Source r ix e => Array r ix e -> Array DI ix e+toInterleaved :: (Index ix, Source r e) => Array r ix e -> Array DI ix e toInterleaved = DIArray . delay {-# INLINE toInterleaved #-} 

@@ -21,24 +21,30 @@   , eqArrays   , compareArrays   , imap-  , liftArray2Matching+  , liftArray2'+  , liftArray2M+  , unsafeExtract+  , unsafeSlice+  , unsafeInnerSlice   ) where -import Control.Applicative+import           Control.Applicative import qualified Data.Foldable as F-import Data.Massiv.Array.Ops.Fold.Internal as A-import Data.Massiv.Vector.Stream as S (steps)-import Data.Massiv.Core.Common-import Data.Massiv.Core.Operations-import Data.Massiv.Core.List (L, showArrayList, showsArrayPrec)-import GHC.Base (build)-import Prelude hiding (zipWith)+import           Data.Massiv.Array.Ops.Fold.Internal as A+import           Data.Massiv.Core.Common as A+import           Data.Massiv.Core.List (L, showArrayList, showsArrayPrec)+import           Data.Massiv.Core.Operations+import           Data.Massiv.Vector.Stream as S (steps)+import           GHC.Base (build)+import           Prelude hiding (zipWith)  #include "massiv.h" + -- | Delayed representation. data D = D deriving Show + data instance Array D ix e = DArray { dComp :: !Comp                                     , dSize :: !(Sz ix)                                     , dIndex :: ix -> e }@@ -47,59 +53,59 @@   showsPrec = showsArrayPrec id   showList = showArrayList -instance Index ix => Resize D ix where+instance Index ix => Shape D ix where+  maxLinearSize = Just . SafeSz . elemsCount+  {-# INLINE maxLinearSize #-}++instance Size D where+  size = dSize+  {-# INLINE size #-}   unsafeResize !sz !arr =     DArray (dComp arr) sz $ \ !ix ->       unsafeIndex arr (fromLinearIndex (size arr) (toLinearIndex sz ix))   {-# INLINE unsafeResize #-} -instance Index ix => Extract D ix e where-  unsafeExtract !sIx !newSz !arr =-    DArray (dComp arr) newSz $ \ !ix ->-      unsafeIndex arr (liftIndex2 (+) ix sIx)-  {-# INLINE unsafeExtract #-}---instance Index ix => Construct D ix e where+instance Strategy D where   setComp c arr = arr { dComp = c }   {-# INLINE setComp #-}--  makeArray = DArray-  {-# INLINE makeArray #-}-+  getComp = dComp+  {-# INLINE getComp #-} -instance Index ix => Source D ix e where+instance Source D e where   unsafeIndex = INDEX_CHECK("(Source D ix e).unsafeIndex", size, dIndex)   {-# INLINE unsafeIndex #-}++  unsafeOuterSlice !arr !szL !i = DArray (dComp arr) szL (unsafeIndex arr . consDim i)+  {-# INLINE unsafeOuterSlice #-}+   unsafeLinearSlice !o !sz arr =     DArray (dComp arr) sz $ \ !i -> unsafeIndex arr (fromLinearIndex (size arr) (i + o))   {-# INLINE unsafeLinearSlice #-}  -instance ( Index ix-         , Index (Lower ix)-         , Elt D ix e ~ Array D (Lower ix) e-         ) =>-         Slice D ix e where-  unsafeSlice arr start cut@(SafeSz cutSz) dim = do-    newSz <- dropDimM cutSz dim-    return $ unsafeResize (SafeSz newSz) (unsafeExtract start cut arr)-  {-# INLINE unsafeSlice #-}+-- | /O(1)/ - Extract a portion of an array. Staring index and new size are+-- not validated.+unsafeExtract :: (Source r e, Index ix) => ix -> Sz ix -> Array r ix e -> Array D ix e+unsafeExtract !sIx !newSz !arr =+  DArray (getComp arr) newSz (unsafeIndex arr . liftIndex2 (+) sIx)+{-# INLINE unsafeExtract #-} +-- | /O(1)/ - Take a slice out of an array from within+unsafeSlice :: (Source r e, Index ix, Index (Lower ix), MonadThrow m) =>+  Array r ix e -> ix -> Sz ix -> Dim -> m (Array D (Lower ix) e)+unsafeSlice arr start cut@(SafeSz cutSz) dim = do+  newSz <- dropDimM cutSz dim+  return $ unsafeResize (SafeSz newSz) (unsafeExtract start cut arr)+{-# INLINE unsafeSlice #-} -instance (Elt D ix e ~ Array D (Lower ix) e, Index ix) => OuterSlice D ix e where+-- | /O(1)/ - Take a slice out of an array from the inside+unsafeInnerSlice ::+     (Source r e, Index ix) => Array r ix e -> Sz (Lower ix) -> Int -> Array D (Lower ix) e+unsafeInnerSlice !arr szL !i = DArray (getComp arr) szL (unsafeIndex arr . (`snocDim` i))+{-# INLINE unsafeInnerSlice #-} -  unsafeOuterSlice !arr !i =-    DArray (dComp arr) (snd (unconsSz (size arr))) (\ !ix -> unsafeIndex arr (consDim i ix))-  {-# INLINE unsafeOuterSlice #-} -instance (Elt D ix e ~ Array D (Lower ix) e, Index ix) => InnerSlice D ix e where -  unsafeInnerSlice !arr (szL, _) !i =-    DArray (dComp arr) szL (\ !ix -> unsafeIndex arr (snocDim ix i))-  {-# INLINE unsafeInnerSlice #-}-- instance (Eq e, Index ix) => Eq (Array D ix e) where   (==) = eqArrays (==)   {-# INLINE (==) #-}@@ -118,9 +124,12 @@ instance Index ix => Applicative (Array D ix) where   pure = singleton   {-# INLINE pure #-}-  liftA2 = liftArray2Matching+  (<*>) = liftArray2' id+  {-# INLINE (<*>) #-}+#if MIN_VERSION_base(4,10,0)+  liftA2 = liftArray2'   {-# INLINE liftA2 #-}-+#endif  -- | Row-major sequential folding over a Delayed array. instance Index ix => Foldable (Array D ix) where@@ -147,12 +156,11 @@   instance Index ix => Load D ix e where-  size = dSize-  {-# INLINE size #-}-  getComp = dComp-  {-# INLINE getComp #-}-  loadArrayM !scheduler !arr = splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)-  {-# INLINE loadArrayM #-}+  makeArray = DArray+  {-# INLINE makeArray #-}+  iterArrayLinearST_ !scheduler !arr =+    splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)+  {-# INLINE iterArrayLinearST_ #-}  instance Index ix => StrideLoad D ix e @@ -163,60 +171,13 @@   {-# INLINE toStreamIx #-}  -- | Map an index aware function over an array-imap :: Source r ix e' => (ix -> e' -> e) -> Array r ix e' -> Array D ix e+--+-- @since 0.1.0+imap :: forall r ix e a. (Index ix, Source r e) => (ix -> e -> a) -> Array r ix e -> Array D ix a imap f !arr = DArray (getComp arr) (size arr) (\ !ix -> f ix (unsafeIndex arr ix)) {-# INLINE imap #-} -instance (Index ix, Num e) => Num (Array D ix e) where-  (+)         = liftArray2Matching (+)-  {-# INLINE (+) #-}-  (-)         = liftArray2Matching (-)-  {-# INLINE (-) #-}-  (*)         = liftArray2Matching (*)-  {-# INLINE (*) #-}-  abs         = unsafeLiftArray abs-  {-# INLINE abs #-}-  signum      = unsafeLiftArray signum-  {-# INLINE signum #-}-  fromInteger = singleton . fromInteger-  {-# INLINE fromInteger #-} -instance (Index ix, Fractional e) => Fractional (Array D ix e) where-  (/)          = liftArray2Matching (/)-  {-# INLINE (/) #-}-  fromRational = singleton . fromRational-  {-# INLINE fromRational #-}---instance (Index ix, Floating e) => Floating (Array D ix e) where-  pi    = singleton pi-  {-# INLINE pi #-}-  exp   = unsafeLiftArray exp-  {-# INLINE exp #-}-  log   = unsafeLiftArray log-  {-# INLINE log #-}-  sin   = unsafeLiftArray sin-  {-# INLINE sin #-}-  cos   = unsafeLiftArray cos-  {-# INLINE cos #-}-  asin  = unsafeLiftArray asin-  {-# INLINE asin #-}-  atan  = unsafeLiftArray atan-  {-# INLINE atan #-}-  acos  = unsafeLiftArray acos-  {-# INLINE acos #-}-  sinh  = unsafeLiftArray sinh-  {-# INLINE sinh #-}-  cosh  = unsafeLiftArray cosh-  {-# INLINE cosh #-}-  asinh = unsafeLiftArray asinh-  {-# INLINE asinh #-}-  atanh = unsafeLiftArray atanh-  {-# INLINE atanh #-}-  acosh = unsafeLiftArray acosh-  {-# INLINE acosh #-}-- instance Num e => FoldNumeric D e where   unsafeDotProduct = defaultUnsafeDotProduct   {-# INLINE unsafeDotProduct #-}@@ -239,7 +200,7 @@   -- | /O(1)/ Conversion from a source array to `D` representation.-delay :: Source r ix e => Array r ix e -> Array D ix e+delay :: (Index ix, Source r e) => Array r ix e -> Array D ix e delay arr = DArray (getComp arr) (size arr) (unsafeIndex arr) {-# INLINE [1] delay #-} @@ -247,24 +208,30 @@ "delay" [~1] forall (arr :: Array D ix e) . delay arr = arr  #-} --- | /O(min (n1, n2))/ - Compute array equality by applying a comparing function to each element.+-- | Compute array equality by applying a comparing function to each+-- element. Empty arrays are always equal, regardless of their size. -- -- @since 0.5.7-eqArrays :: (Source r1 ix e1, Source r2 ix e2) =>-      (e1 -> e2 -> Bool) -> Array r1 ix e1 -> Array r2 ix e2 -> Bool+eqArrays :: (Index ix, Source r1 e1, Source r2 e2) =>+            (e1 -> e2 -> Bool) -> Array r1 ix e1 -> Array r2 ix e2 -> Bool eqArrays f arr1 arr2 =-  (size arr1 == size arr2) &&-  not (A.any not-       (DArray (getComp arr1 <> getComp arr2) (size arr1) $ \ix ->-           f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix)))+  let sz1 = size arr1+      sz2 = size arr2+   in (sz1 == sz2 &&+       not+         (A.any+            not+            (DArray (getComp arr1 <> getComp arr2) (size arr1) $ \ix ->+               f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix)))) ||+      (isZeroSz sz1 && isZeroSz sz2) {-# INLINE eqArrays #-} --- | /O(min (n1, n2))/ - Compute array ordering by applying a comparing function to each element.+-- | Compute array ordering by applying a comparing function to each element. -- The exact ordering is unspecified so this is only intended for use in maps and the like where -- you need an ordering but do not care about which one is used. -- -- @since 0.5.7-compareArrays :: (Source r1 ix e1, Source r2 ix e2) =>+compareArrays :: (Index ix, Source r1 e1, Source r2 e2) =>        (e1 -> e2 -> Ordering) -> Array r1 ix e1 -> Array r2 ix e2 -> Ordering compareArrays f arr1 arr2 =   compare (size arr1) (size arr2) <>@@ -273,45 +240,35 @@        f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix)) {-# INLINE compareArrays #-} --liftArray2Matching-  :: (Source r1 ix a, Source r2 ix b)+-- | Same as `liftArray2M`, but throws an imprecise exception on mismatched+-- sizes.+--+-- @since 1.0.0+liftArray2'+  :: (HasCallStack, Index ix, Source r1 a, Source r2 b)   => (a -> b -> e) -> Array r1 ix a -> Array r2 ix b -> Array D ix e-liftArray2Matching f !arr1 !arr2+liftArray2' f arr1 arr2 = throwEither $ liftArray2M f arr1 arr2+{-# INLINE liftArray2' #-}+++-- | Similar to `Data.Massiv.Array.zipWith`, except dimensions of both arrays+-- have to be the same, otherwise it throws `SizeMismatchException`.+--+-- @since 1.0.0+liftArray2M+  :: (Index ix, Source r1 a, Source r2 b, MonadThrow m)+  => (a -> b -> e) -> Array r1 ix a -> Array r2 ix b -> m (Array D ix e)+liftArray2M f !arr1 !arr2   | sz1 == sz2 =+    pure $     DArray       (getComp arr1 <> getComp arr2)       sz1       (\ !ix -> f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix))-  | otherwise = throw $ SizeMismatchException (size arr1) (size arr2)+  | isZeroSz sz1 && isZeroSz sz2 = pure A.empty+  | otherwise = throwM $ SizeMismatchException (size arr1) (size arr2)   where     sz1 = size arr1     sz2 = size arr2-{-# INLINE liftArray2Matching #-}----- -- | The usual map.--- liftArray :: Source r ix b => (b -> e) -> Array r ix b -> Array D ix e--- liftArray f !arr = DArray (getComp arr) (size arr) (f . unsafeIndex arr)--- {-# INLINE liftArray #-}---- -- | Similar to `Data.Massiv.Array.zipWith`, except dimensions of both arrays either have to be the--- -- same, or at least one of the two array must be a singleton array, in which case it will behave as--- -- a `Data.Massiv.Array.map`.--- ----- -- @since 0.1.4--- liftArray2---   :: (Source r1 ix a, Source r2 ix b)---   => (a -> b -> e) -> Array r1 ix a -> Array r2 ix b -> Array D ix e--- liftArray2 f !arr1 !arr2---   | sz1 == oneSz = liftArray (f (unsafeIndex arr1 zeroIndex)) arr2---   | sz2 == oneSz = liftArray (`f` unsafeIndex arr2 zeroIndex) arr1---   | sz1 == sz2 =---     DArray (getComp arr1 <> getComp arr2) sz1 (\ !ix -> f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix))---   | otherwise = throw $ SizeMismatchException (size arr1) (size arr2)---   where---     sz1 = size arr1---     sz2 = size arr2--- {-# INLINE liftArray2 #-}-+{-# INLINE liftArray2M #-} 

@@ -20,6 +20,7 @@ module Data.Massiv.Array.Delayed.Push   ( DL(..)   , Array(..)+  , Loader   , toLoadArray   , makeLoadArrayS   , makeLoadArray@@ -41,34 +42,36 @@ -- | Delayed load representation. Also known as Push array. data DL = DL deriving Show +type Loader e =+  forall s. Scheduler s () -- ^ Scheduler that will be used for loading+         -> Ix1 -- ^ Start loading at this linear index+         -> (Ix1 -> e -> ST s ()) -- ^ Linear element writing action+         -> (Ix1 -> Sz1 -> e -> ST s ()) -- ^ Linear region setting action+         -> ST s () + data instance Array DL ix e = DLArray   { dlComp    :: !Comp   , dlSize    :: !(Sz ix)-  , dlLoad    :: forall m . Monad m-              => Scheduler m ()-              -> Ix1 -- start loading at this linear index-              -> (Ix1 -> e -> m ()) -- linear element writing action-              -> (Ix1 -> Sz1 -> e -> m ()) -- linear region setting action-              -> m ()+  , dlLoad    :: Loader e   } -instance Index ix => Construct DL ix e where+instance Strategy DL where+  getComp = dlComp+  {-# INLINE getComp #-}   setComp c arr = arr {dlComp = c}   {-# INLINE setComp #-}-  makeArrayLinear comp sz f = DLArray comp sz load-    where-      load :: Monad m =>-        Scheduler m () -> Ix1 -> (Ix1 -> e -> m ()) -> (Ix1 -> Sz1 -> e -> m ()) -> m ()-      load scheduler startAt dlWrite _ =-        splitLinearlyWithStartAtM_ scheduler startAt (totalElem sz) (pure . f) dlWrite-      {-# INLINE load #-}-  {-# INLINE makeArrayLinear #-}-  replicate comp !sz !e = makeLoadArray comp sz e $ \_ _ -> pure ()-  {-# INLINE replicate #-} -instance Index ix => Resize DL ix where-  unsafeResize !sz arr = arr { dlSize = sz }++instance Index ix => Shape DL ix where+  maxLinearSize = Just . SafeSz . elemsCount+  {-# INLINE maxLinearSize #-}+++instance Size DL where+  size = dlSize+  {-# INLINE size #-}+  unsafeResize !sz !arr = arr { dlSize = sz }   {-# INLINE unsafeResize #-}  instance Semigroup (Array DL Ix1 e) where@@ -91,8 +94,8 @@   DLArray {dlComp = foldMap getComp arrs, dlSize = SafeSz k, dlLoad = load}   where     !k = F.foldl' (+) 0 (unSz . size <$> arrs)-    load :: Monad m =>-      Scheduler m () -> Ix1 -> (Ix1 -> e -> m ()) -> (Ix1 -> Sz1 -> e -> m ()) -> m ()+    load :: forall s .+      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()     load scheduler startAt dlWrite dlSet =       let loadArr !startAtCur DLArray {dlSize = SafeSz kCur, dlLoad} = do             let !endAtCur = startAtCur + kCur@@ -110,8 +113,8 @@   where     !k1 = unSz sz1     !k2 = unSz sz2-    load :: Monad n =>-      Scheduler n () -> Ix1 -> (Ix1 -> e -> n ()) -> (Ix1 -> Sz1 -> e -> n ()) -> n ()+    load :: forall s.+      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()     load scheduler !startAt dlWrite dlSet = do       scheduleWork_ scheduler $ load1 scheduler startAt dlWrite dlSet       scheduleWork_ scheduler $ load2 scheduler (startAt + k1) dlWrite dlSet@@ -132,9 +135,9 @@       (!i2, !szl2) = unconsSz sz2   unless (szl1 == szl2) $ throwM $ SizeMismatchException sz1 sz2   pure $-    DLArray {dlComp = c1 <> c2, dlSize = consSz (i1 + i2) szl1, dlLoad = load}+    DLArray {dlComp = c1 <> c2, dlSize = consSz (liftSz2 (+) i1 i2) szl1, dlLoad = load}   where-    load :: Monad n => Scheduler n () -> Ix1 -> (Ix1 -> e -> n ()) -> (Ix1 -> Sz1 -> e -> n ()) -> n ()+    load :: Loader e     load scheduler !startAt dlWrite dlSet = do       scheduleWork_ scheduler $ load1 scheduler startAt dlWrite dlSet       scheduleWork_ scheduler $ load2 scheduler (startAt + totalElem sz1) dlWrite dlSet@@ -171,8 +174,8 @@   -> Array DL ix e makeLoadArrayS sz defVal writer = DLArray Seq sz load   where-    load :: Monad m =>-      Scheduler m () -> Ix1 -> (Ix1 -> e -> m ()) -> (Ix1 -> Sz1 -> e -> m ()) -> m ()+    load :: forall s.+      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()     load _scheduler !startAt uWrite uSet = do       uSet startAt (toLinearSz sz) defVal       let safeWrite !ix !e@@ -197,15 +200,15 @@   -- ^ Size of the resulting array   -> e   -- ^ Default value to use for all cells that might have been ommitted by the writing function-  -> (forall m. Monad m => Scheduler m () -> (ix -> e -> m Bool) -> m ())+  -> (forall s. Scheduler s () -> (ix -> e -> ST s Bool) -> ST s ())   -- ^ Writing function that described which elements to write into the target array. It   -- accepts a scheduler, that can be used for parallelization, as well as a safe element   -- writing function.   -> Array DL ix e makeLoadArray comp sz defVal writer = DLArray comp sz load   where-    load :: Monad m =>-      Scheduler m () -> Ix1 -> (Ix1 -> e -> m ()) -> (Ix1 -> Sz1 -> e -> m ()) -> m ()+    load :: forall s.+      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()     load scheduler !startAt uWrite uSet = do       uSet startAt (toLinearSz sz) defVal       let safeWrite !ix !e@@ -232,7 +235,7 @@   -> 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 ())+  -> (forall s. Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> ST s ())   -- ^ This function accepts:   --   -- * A scheduler that can be used for parallelization of loading@@ -244,8 +247,7 @@   -> Array DL ix e unsafeMakeLoadArray comp sz mDefVal writer = DLArray comp sz load   where-    load :: Monad m =>-      Scheduler m () -> Ix1 -> (Ix1 -> e -> m ()) -> (Ix1 -> Sz1 -> e -> m ()) -> m ()+    load :: Loader e     load scheduler startAt uWrite uSet = do       S.traverse_ (uSet startAt (toLinearSz sz)) mDefVal       writer scheduler startAt uWrite@@ -261,12 +263,12 @@   => Comp   -> Sz ix   -> Maybe e-  -> (forall m. Monad m => Scheduler m () -> (Ix1 -> e -> m ()) -> m ())+  -> (forall s. Scheduler s () -> (Ix1 -> e -> ST s ()) -> ST s ())   -> Array DL ix e unsafeMakeLoadArrayAdjusted comp sz mDefVal writer = DLArray comp sz load   where-    load :: Monad m =>-      Scheduler m () -> Ix1 -> (Ix1 -> e -> m ()) -> (Ix1 -> Sz1 -> e -> m ()) -> m ()+    load :: forall s.+      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()     load scheduler !startAt uWrite dlSet = do       S.traverse_ (dlSet startAt (toLinearSz sz)) mDefVal       writer scheduler (\i -> uWrite (startAt + i))@@ -277,16 +279,16 @@ -- -- @since 0.3.0 toLoadArray ::-     forall r ix e. Load r ix e+     forall r ix e. (Size r, Load r ix e)   => Array r ix e   -> Array DL ix e toLoadArray arr = DLArray (getComp arr) sz load   where     !sz = size arr-    load :: Monad m =>-      Scheduler m () -> Ix1 -> (Ix1 -> e -> m ()) -> (Ix1 -> Sz1 -> e -> m ()) -> m ()+    load :: forall s.+      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()     load scheduler !startAt dlWrite dlSet =-      loadArrayWithSetM scheduler arr (dlWrite . (+ startAt)) (\offset -> dlSet (offset + startAt))+      iterArrayLinearWithSetST_ scheduler arr (dlWrite . (+ startAt)) (\offset -> dlSet (offset + startAt))     {-# INLINE load #-} {-# INLINE[1] toLoadArray #-} {-# RULES "toLoadArray/id" toLoadArray = id #-}@@ -295,28 +297,32 @@ -- -- @since 0.3.0 fromStrideLoad ::-     forall r ix e. StrideLoad r ix e+     forall r ix e. (StrideLoad r ix e)   => Stride ix   -> Array r ix e   -> Array DL ix e fromStrideLoad stride arr =   DLArray (getComp arr) newsz load   where-    !newsz = strideSize stride (size arr)-    load :: Monad m =>-      Scheduler m () -> Ix1 -> (Ix1 -> e -> m ()) -> (Ix1 -> Sz1 -> e -> m ()) -> m ()+    !newsz = strideSize stride (outerSize arr)+    load :: Loader e     load scheduler !startAt dlWrite _ =-      loadArrayWithStrideM scheduler stride newsz arr (\ !i -> dlWrite (i + startAt))+      iterArrayLinearWithStrideST_ scheduler stride newsz arr (\ !i -> dlWrite (i + startAt))     {-# INLINE load #-} {-# INLINE fromStrideLoad #-}  instance Index ix => Load DL ix e where-  size = dlSize-  {-# INLINE size #-}-  getComp = dlComp-  {-# INLINE getComp #-}-  loadArrayWithSetM scheduler DLArray {dlLoad} = dlLoad scheduler 0-  {-# INLINE loadArrayWithSetM #-}+  makeArrayLinear comp sz f = DLArray comp sz load+    where+      load :: Loader e+      load scheduler startAt dlWrite _ =+        splitLinearlyWithStartAtM_ scheduler startAt (totalElem sz) (pure . f) dlWrite+      {-# INLINE load #-}+  {-# INLINE makeArrayLinear #-}+  replicate comp !sz !e = makeLoadArray comp sz e $ \_ _ -> pure ()+  {-# INLINE replicate #-}+  iterArrayLinearWithSetST_ scheduler DLArray {dlLoad} = dlLoad scheduler 0+  {-# INLINE iterArrayLinearWithSetST_ #-}  instance Index ix => Functor (Array DL ix) where   fmap f arr = arr {dlLoad = loadFunctor arr f}@@ -327,21 +333,20 @@ overwriteFunctor :: forall ix a b. Index ix => a -> Array DL ix b -> Array DL ix a overwriteFunctor e arr = arr {dlLoad = load}   where-    load :: Scheduler m () -> Ix1 -> (Ix1 -> a -> m ()) -> (Ix1 -> Sz1 -> a -> m ()) -> m ()+    load :: Loader a     load _ !startAt _ dlSet = dlSet startAt (linearSize arr) e     {-# INLINE load #-} {-# INLINE overwriteFunctor #-}   loadFunctor ::-     Monad m-  => Array DL ix a+     Array DL ix a   -> (a -> b)-  -> Scheduler m ()+  -> Scheduler s ()   -> Ix1-  -> (Ix1 -> b -> m ())-  -> (Ix1 -> Sz1 -> b -> m ())-  -> m ()+  -> (Ix1 -> b -> ST s ())+  -> (Ix1 -> Sz1 -> b -> ST s ())+  -> ST s () loadFunctor arr f scheduler startAt uWrite uSet =   dlLoad arr scheduler startAt (\ !i e -> uWrite i (f e)) (\o sz e -> uSet o sz (f e)) {-# INLINE loadFunctor #-}

@@ -23,7 +23,7 @@   ) where  import Control.Applicative-import Control.Monad (void)+import Control.Monad.ST import Data.Coerce import Data.Foldable import Data.Massiv.Array.Delayed.Pull@@ -31,7 +31,6 @@ import Data.Massiv.Core.Common import GHC.Exts import Prelude hiding (take, drop)-import Data.Vector.Fusion.Bundle.Size (upperBound)  -- | Delayed stream array that represents a sequence of values that can be loaded -- sequentially. Important distinction from other arrays is that its size might no be@@ -45,25 +44,45 @@ -- | /O(1)/ - Convert delayed stream array into `Steps`. -- -- @since 0.4.1-toSteps :: Array DS Ix1 e -> Steps Id e+toSteps :: Vector DS e -> Steps Id e toSteps = coerce {-# INLINE toSteps #-}  -- | /O(1)/ - Convert `Steps` into delayed stream array -- -- @since 0.4.1-fromSteps :: Steps Id e -> Array DS Ix1 e+fromSteps :: Steps Id e -> Vector DS e fromSteps = coerce {-# INLINE fromSteps #-}  -- | /O(1)/ - Convert monadic `Steps` into delayed stream array -- -- @since 0.5.0-fromStepsM :: Monad m => Steps m e -> m (Array DS Ix1 e)+fromStepsM :: Monad m => Steps m e -> m (Vector DS e) fromStepsM = fmap DSArray . S.transSteps {-# INLINE fromStepsM #-}  +instance Shape DS Ix1 where+  linearSizeHint = stepsSize . dsArray+  {-# INLINE linearSizeHint #-}++  linearSize = SafeSz . unId . S.length . dsArray+  {-# INLINE linearSize #-}++  outerSize = linearSize+  {-# INLINE outerSize #-}++  isNull = S.unId . S.null . coerce+  {-# INLINE isNull #-}+++--TODO remove+instance Strategy DS where+  getComp _ = Seq+  setComp _ = id++ instance Functor (Array DS Ix1) where   fmap f = coerce . S.map f . dsArray   {-# INLINE fmap #-}@@ -114,8 +133,6 @@   minimum = S.unId . S.foldl1 min . toSteps   {-# INLINE minimum #-} -- instance Semigroup (Array DS Ix1 e) where   (<>) a1 a2 = fromSteps (coerce a1 `S.append` coerce a2)   {-# INLINE (<>) #-}@@ -129,9 +146,9 @@  instance IsList (Array DS Ix1 e) where   type Item (Array DS Ix1 e) = e-  fromList = fromSteps . S.fromList+  fromList = fromSteps . fromList   {-# INLINE fromList #-}-  fromListN n = fromSteps . S.fromListN n+  fromListN n = fromSteps . fromListN n   {-# INLINE fromListN #-}   toList = S.toList . coerce   {-# INLINE toList #-}@@ -147,7 +164,7 @@ -- | Flatten an array into a stream of values. -- -- @since 0.4.1-toStreamArray :: Source r ix e => Array r ix e -> Array DS Ix1 e+toStreamArray :: (Index ix, Source r e) => Array r ix e -> Vector DS e toStreamArray = DSArray . S.steps {-# INLINE[1] toStreamArray #-} {-# RULES "toStreamArray/id" toStreamArray = id #-}@@ -167,45 +184,24 @@ {-# INLINE toStreamIxM #-}  -instance Construct DS Ix1 e where-  setComp _ arr = arr-  {-# INLINE setComp #-}--  makeArrayLinear _ (Sz k) = fromSteps . S.generate k-  {-# INLINE makeArrayLinear #-}---instance Extract DS Ix1 e where-  unsafeExtract sIx newSz = fromSteps . S.slice sIx (unSz newSz) . dsArray-  {-# INLINE unsafeExtract #-}- -- | /O(n)/ - `size` implementation. instance Load DS Ix1 e where-  size = coerce . S.unId . S.length . coerce-  {-# INLINE size #-} -  maxSize = coerce . upperBound . stepsSize . dsArray-  {-# INLINE maxSize #-}--  isEmpty = S.unId . S.null . coerce-  {-# INLINE isEmpty #-}--  getComp _ = Seq-  {-# INLINE getComp #-}+  makeArrayLinear _ k = fromSteps . S.generate k+  {-# INLINE makeArrayLinear #-}+  replicate _ k = fromSteps . S.replicate k+  {-# INLINE replicate #-} -  loadArrayM _scheduler arr uWrite =-    case stepsSize (dsArray arr) of-      S.Exact _ ->-        void $ S.foldlM (\i e -> uWrite i e >> pure (i + 1)) 0 (S.transStepsId (coerce arr))-      _ -> error "Loading Stream array is not supported with loadArrayM"-  {-# INLINE loadArrayM #-}+  iterArrayLinearST_ _scheduler arr uWrite =+    S.mapM_ (uncurry uWrite) $ S.indexed $ S.transStepsId (coerce arr)+  {-# INLINE iterArrayLinearST_ #-} -  unsafeLoadIntoS marr (DSArray sts) =+  unsafeLoadIntoST marr (DSArray sts) =     S.unstreamIntoM marr (stepsSize sts) (stepsStream sts)-  {-# INLINE unsafeLoadIntoS #-}+  {-# INLINE unsafeLoadIntoST #-} -  unsafeLoadIntoM marr arr = liftIO $ unsafeLoadIntoS marr arr-  {-# INLINE unsafeLoadIntoM #-}+  unsafeLoadIntoIO marr arr = stToIO $ unsafeLoadIntoST marr arr+  {-# INLINE unsafeLoadIntoIO #-}   -- cons :: e -> Array DS Ix1 e -> Array DS Ix1 e@@ -223,13 +219,13 @@  -- TODO: skip the stride while loading -- instance StrideLoad DS Ix1 e where---   loadArrayWithStrideM scheduler stride resultSize arr uWrite =+--   iterArrayLinearWithStrideST_ scheduler stride resultSize arr uWrite = --     let strideIx = unStride stride --         DIArray (DArray _ _ f) = arr --     in loopM_ 0 (< numWorkers scheduler) (+ 1) $ \ !start -> --           scheduleWork scheduler $ --           iterLinearM_ resultSize start (totalElem resultSize) (numWorkers scheduler) (<) $ --             \ !i ix -> uWrite i (f (liftIndex2 (*) strideIx ix))---   {-# INLINE loadArrayWithStrideM #-}+--   {-# INLINE iterArrayLinearWithStrideST_ #-}  

@@ -62,15 +62,11 @@   showsPrec = showsArrayPrec (computeAs B)   showList = showArrayList --instance Index ix => Construct DW ix e where-+instance Strategy DW where   setComp c arr = arr { dwArray = (dwArray arr) { dComp = c } }   {-# INLINE setComp #-}--  makeArray c sz f = DWArray (makeArray c sz f) Nothing-  {-# INLINE makeArray #-}-+  getComp = dComp . dwArray+  {-# INLINE getComp #-}   instance Functor (Array DW ix) where@@ -122,7 +118,7 @@ -- -- @since 0.1.3 makeWindowedArray-  :: Source r ix e+  :: (Index ix, Source r e)   => Array r ix e -- ^ Source array that will have a window inserted into it   -> ix -- ^ Start index for the window   -> Sz ix -- ^ Size of the window@@ -138,7 +134,7 @@ -- -- @since 0.3.0 insertWindow-  :: Source D ix e+  :: Index ix   => Array D ix e -- ^ Source array that will have a window inserted into it   -> Window ix e -- ^ Window to place inside the delayed array   -> Array DW ix e@@ -209,13 +205,18 @@   return (\from to -> with $ iterM_ from to 1 (<) $ \ !i -> uWrite i (indexW i), it, wEnd) {-# INLINE loadWithIx1 #-} +instance Index ix => Shape DW ix where+  maxLinearSize = Just . linearSize+  {-# INLINE maxLinearSize #-}+  linearSize = SafeSz . totalElem . dSize . dwArray+  {-# INLINE linearSize #-}+  outerSize = dSize . dwArray+  {-# INLINE outerSize #-}  instance Load DW Ix1 e where-  size = dSize . dwArray-  {-# INLINE size #-}-  getComp = dComp . dwArray-  {-# INLINE getComp #-}-  loadArrayM scheduler arr uWrite = do+  makeArray c sz f = DWArray (makeArray c sz f) Nothing+  {-# INLINE makeArray #-}+  iterArrayLinearST_ scheduler arr uWrite = do     (loadWindow, wStart, wEnd) <- loadWithIx1 (scheduleWork scheduler) arr uWrite     let (chunkWidth, slackWidth) = (wEnd - wStart) `quotRem` numWorkers scheduler     loopM_ 0 (< numWorkers scheduler) (+ 1) $ \ !wid ->@@ -224,10 +225,10 @@     when (slackWidth > 0) $       let !itSlack = numWorkers scheduler * chunkWidth + wStart        in loadWindow itSlack (itSlack + slackWidth)-  {-# INLINE loadArrayM #-}+  {-# INLINE iterArrayLinearST_ #-}  instance StrideLoad DW Ix1 e where-  loadArrayWithStrideM scheduler stride sz arr uWrite = do+  iterArrayLinearWithStrideST_ scheduler stride sz arr uWrite = do       (loadWindow, (wStart, wEnd)) <- loadArrayWithIx1 (scheduleWork scheduler) arr stride sz uWrite       let (chunkWidth, slackWidth) = (wEnd - wStart) `quotRem` numWorkers scheduler       loopM_ 0 (< numWorkers scheduler) (+ 1) $ \ !wid ->@@ -236,7 +237,7 @@       when (slackWidth > 0) $         let !itSlack = numWorkers scheduler * chunkWidth + wStart          in loadWindow (itSlack, itSlack + slackWidth)-  {-# INLINE loadArrayWithStrideM #-}+  {-# INLINE iterArrayLinearWithStrideST_ #-}  loadArrayWithIx1 ::      (Monad m)@@ -276,7 +277,7 @@   let ib :. jb = (wm + it) :. (wn + jt)       !blockHeight = maybe 1 (min 7 . max 1) mUnrollHeight       stride = oneStride-      !sz = strideSize stride $ size arr+      !sz = strideSize stride $ outerSize arr       writeB !ix = uWrite (toLinearIndex sz ix) (indexB ix)       {-# INLINE writeB #-}       writeW !ix = uWrite (toLinearIndex sz ix) (indexW ix)@@ -335,42 +336,38 @@   instance Load DW Ix2 e where-  size = dSize . dwArray-  {-# INLINE size #-}-  getComp = dComp . dwArray-  {-# INLINE getComp #-}-  loadArrayM scheduler arr uWrite =+  makeArray c sz f = DWArray (makeArray c sz f) Nothing+  {-# INLINE makeArray #-}+  iterArrayLinearST_ scheduler arr uWrite =     loadWithIx2 (scheduleWork scheduler) arr uWrite >>=     uncurry (loadWindowIx2 (numWorkers scheduler))-  {-# INLINE loadArrayM #-}+  {-# INLINE iterArrayLinearST_ #-}  instance StrideLoad DW Ix2 e where-  loadArrayWithStrideM scheduler stride sz arr uWrite =+  iterArrayLinearWithStrideST_ scheduler stride sz arr uWrite =     loadArrayWithIx2 (scheduleWork scheduler) arr stride sz uWrite >>=     uncurry (loadWindowIx2 (numWorkers scheduler))-  {-# INLINE loadArrayWithStrideM #-}+  {-# INLINE iterArrayLinearWithStrideST_ #-}   instance (Index (IxN n), Load DW (Ix (n - 1)) e) => Load DW (IxN n) e where-  size = dSize . dwArray-  {-# INLINE size #-}-  getComp = dComp . dwArray-  {-# INLINE getComp #-}-  loadArrayM = loadWithIxN-  {-# INLINE loadArrayM #-}+  makeArray c sz f = DWArray (makeArray c sz f) Nothing+  {-# INLINE makeArray #-}+  iterArrayLinearST_ = loadWithIxN+  {-# INLINE iterArrayLinearST_ #-}  instance (Index (IxN n), StrideLoad DW (Ix (n - 1)) e) => StrideLoad DW (IxN n) e where-  loadArrayWithStrideM = loadArrayWithIxN-  {-# INLINE loadArrayWithStrideM #-}+  iterArrayLinearWithStrideST_ = loadArrayWithIxN+  {-# INLINE iterArrayLinearWithStrideST_ #-}  loadArrayWithIxN ::-     (Index ix, Monad m, StrideLoad DW (Lower ix) e)-  => Scheduler m ()+     (Index ix, StrideLoad DW (Lower ix) e)+  => Scheduler s ()   -> Stride ix   -> Sz ix   -> Array DW ix e-  -> (Int -> e -> m ())-  -> m ()+  -> (Int -> e -> ST s ())+  -> ST s () loadArrayWithIxN scheduler stride szResult arr uWrite = do   let DWArray darr window = arr       DArray {dSize = szSource, dIndex = indexBorder} = darr@@ -393,7 +390,7 @@         DWArray           {dwArray = DArray Seq lowerSourceSize (indexBorder . consDim i), dwWindow = ($ i) <$> mw}       loadLower mw !i =-        loadArrayWithStrideM+        iterArrayLinearWithStrideST_           scheduler           (Stride lowerStrideIx)           lowerSize@@ -412,11 +409,11 @@   loadWithIxN ::-     (Index ix, Monad m, Load DW (Lower ix) e)-  => Scheduler m ()+     (Index ix, Load DW (Lower ix) e)+  => Scheduler s ()   -> Array DW ix e-  -> (Int -> e -> m ())-  -> m ()+  -> (Int -> e -> ST s ())+  -> ST s () loadWithIxN scheduler arr uWrite = do   let DWArray darr window = arr       DArray {dSize = sz, dIndex = indexBorder} = darr@@ -436,7 +433,7 @@         DWArray {dwArray = DArray Seq szL (indexBorder . consDim i), dwWindow = ($ i) <$> mw}       loadLower mw !i =         scheduleWork_ scheduler $-        loadArrayM scheduler (mkLowerArray mw i) (\k -> uWrite (k + pageElements * i))+        iterArrayLinearST_ scheduler (mkLowerArray mw i) (\k -> uWrite (k + pageElements * i))       {-# NOINLINE loadLower #-}   loopM_ 0 (< headDim windowStart) (+ 1) (loadLower Nothing)   loopM_ t (< headDim windowEnd) (+ 1) (loadLower (Just mkLowerWindow))@@ -479,79 +476,3 @@   -- TODO: Implement Hilbert curve--toIx2Window :: Window Ix2T e -> Window Ix2 e-toIx2Window Window {..} =-  Window-    { windowStart = toIx2 windowStart-    , windowSize = SafeSz (toIx2 $ unSz windowSize)-    , windowIndex = windowIndex . fromIx2-    , windowUnrollIx2 = windowUnrollIx2-    }-{-# INLINE toIx2Window #-}--toIx2ArrayDW :: Array DW Ix2T e -> Array DW Ix2 e-toIx2ArrayDW DWArray {dwArray, dwWindow} =-  DWArray-    { dwArray =-        dwArray {dIndex = dIndex dwArray . fromIx2, dSize = SafeSz (toIx2 (unSz (dSize dwArray)))}-    , dwWindow = fmap toIx2Window dwWindow-    }-{-# INLINE toIx2ArrayDW #-}---instance Load DW Ix2T e where-  size = dSize . dwArray-  {-# INLINE size #-}-  getComp = dComp . dwArray-  {-# INLINE getComp #-}-  loadArrayM scheduler arr =-    loadArrayWithStrideM scheduler oneStride (size arr) arr-  {-# INLINE loadArrayM #-}--instance StrideLoad DW Ix2T e where-  loadArrayWithStrideM scheduler stride sz arr =-    loadArrayWithStrideM-      scheduler-      (Stride $ toIx2 $ unStride stride)-      (SafeSz (toIx2 (unSz sz)))-      (toIx2ArrayDW arr)-  {-# INLINE loadArrayWithStrideM #-}--instance Load DW Ix3T e where-  size = dSize . dwArray-  {-# INLINE size #-}-  getComp = dComp . dwArray-  {-# INLINE getComp #-}-  loadArrayM scheduler arr =-    loadArrayWithStrideM scheduler oneStride (size arr) arr-  {-# INLINE loadArrayM #-}--instance StrideLoad DW Ix3T e where-  loadArrayWithStrideM = loadArrayWithIxN-  {-# INLINE loadArrayWithStrideM #-}---instance Load DW Ix4T e where-  size = dSize . dwArray-  {-# INLINE size #-}-  getComp = dComp . dwArray-  {-# INLINE getComp #-}-  loadArrayM scheduler arr = loadArrayWithStrideM scheduler oneStride (size arr) arr-  {-# INLINE loadArrayM #-}--instance StrideLoad DW Ix4T e where-  loadArrayWithStrideM = loadArrayWithIxN-  {-# INLINE loadArrayWithStrideM #-}---instance Load DW Ix5T e where-  size = dSize . dwArray-  {-# INLINE size #-}-  getComp = dComp . dwArray-  {-# INLINE getComp #-}-  loadArrayM scheduler arr = loadArrayWithStrideM scheduler oneStride (size arr) arr-  {-# INLINE loadArrayM #-}-instance StrideLoad DW Ix5T e where-  loadArrayWithStrideM = loadArrayWithIxN-  {-# INLINE loadArrayWithStrideM #-}

@@ -17,8 +17,6 @@ module Data.Massiv.Array.Manifest   ( -- * Manifest     Manifest-  , toManifest-  , M   -- * Boxed   , B(..)   , BL(..)@@ -123,15 +121,16 @@ import Data.Massiv.Core.Common import Data.Word (Word8) --- | /O(1)/ - Convert a strict ByteString into a manifest array. Will return `Nothing` if length+-- | /O(n)/ - Convert a strict ByteString into a manifest array. Will return `Nothing` if length -- doesn't match the total number of elements of new array. -- -- @since 0.2.1 fromByteString ::-     Comp -- ^ Computation strategy+     Load r Ix1 Word8+  => Comp -- ^ Computation strategy   -> ByteString -- ^ Strict ByteString to use as a source.-  -> Array M Ix1 Word8-fromByteString comp bs = MArray comp (SafeSz (S.length bs)) (SU.unsafeIndex bs)+  -> Vector r Word8+fromByteString comp bs = makeArrayLinear comp (SafeSz (S.length bs)) (SU.unsafeIndex bs) {-# INLINE fromByteString #-}  -- | /O(n)/ - Convert any source array into a strict `ByteString`. In case when the source array is@@ -154,28 +153,28 @@ -- | /O(n)/ - Conversion of array monoidally into a ByteString `Builder`. -- -- @since 0.2.1-toBuilder :: Source r ix e => (e -> Builder) -> Array r ix e -> Builder+toBuilder :: (Index ix, Source r e) => (e -> Builder) -> Array r ix e -> Builder toBuilder = foldMono {-# INLINE toBuilder #-}  -- | /O(1)/ - Cast a storable array of `Word8` to ByteString `Builder`. -- -- @since 0.5.0-castToBuilder :: Array S ix Word8 -> Builder+castToBuilder :: Index ix => Array S ix Word8 -> Builder castToBuilder = byteString . castToByteString {-# INLINE castToBuilder #-}  -- | /O(1)/ - Cast a `S`torable array into a strict `ByteString` -- -- @since 0.3.0-castToByteString :: Array S ix Word8 -> ByteString+castToByteString :: Index ix => Array S ix Word8 -> ByteString castToByteString = (\(fp, len) -> PS fp 0 len) . unsafeArrayToForeignPtr {-# INLINE castToByteString #-}  -- | /O(1)/ - Cast a strict `ByteString` into a `S`torable array -- -- @since 0.3.0-castFromByteString :: Comp -> ByteString -> Array S Ix1 Word8+castFromByteString :: Comp -> ByteString -> Vector S Word8 castFromByteString comp (PS fp offset len) = unsafeArrayFromForeignPtr comp fp offset (Sz len) {-# INLINE castFromByteString #-} @@ -193,7 +192,7 @@ -- after it was applyied to all elements of the array. -- -- @since 0.5.5-findIndex :: Manifest r ix e => (e -> Bool) -> Array r ix e -> Maybe ix+findIndex :: (Index ix, Manifest r e) => (e -> Bool) -> Array r ix e -> Maybe ix findIndex f arr = go 0   where     !sz = size arr@@ -211,7 +210,7 @@ -- programs. -- -- @since 0.5.9-mallocCompute :: forall r ix e. (Source r ix e, Storable e) => Array r ix e -> IO (Array S ix e)+mallocCompute :: forall r ix e. (Size r, Load r ix e, Storable e) => Array r ix e -> IO (Array S ix e) mallocCompute arr = do   let sz = size arr   marr <- unsafeMallocMArray sz

@@ -24,6 +24,7 @@   , N   , pattern N   , Array(..)+  , MArray(..)   , wrapLazyArray   , unwrapLazyArray   , unwrapNormalForm@@ -61,7 +62,7 @@ import qualified Data.Foldable as F (Foldable(..)) import Data.Massiv.Array.Delayed.Push (DL) import Data.Massiv.Array.Delayed.Stream (DS)-import Data.Massiv.Array.Manifest.Internal (M, computeAs, toManifest)+import Data.Massiv.Array.Manifest.Internal (computeAs) import Data.Massiv.Array.Manifest.List as L import Data.Massiv.Array.Mutable import Data.Massiv.Array.Ops.Fold@@ -80,16 +81,6 @@  #include "massiv.h" -sizeofArray :: A.Array e -> Int-sizeofMutableArray :: A.MutableArray s e -> Int-#if MIN_VERSION_primitive(0,6,2)-sizeofArray = A.sizeofArray-sizeofMutableArray = A.sizeofMutableArray-#else-sizeofArray (A.Array a#) = I# (sizeofArray# a#)-sizeofMutableArray (A.MutableArray ma#) = I# (sizeofMutableArray# ma#)-#endif- ---------------- -- Boxed Lazy -- ----------------@@ -103,6 +94,8 @@                                       , blOffset :: {-# UNPACK #-} !Int                                       , blData   :: {-# UNPACK #-} !(A.Array e)                                       }+data instance MArray s BL ix e =+  MBLArray !(Sz ix) {-# UNPACK #-} !Int {-# UNPACK #-} !(A.MutableArray s e)  instance (Ragged L ix e, Show e) => Show (Array BL ix e) where   showsPrec = showsArrayPrec id@@ -129,71 +122,40 @@   compare = compareArrays compare   {-# INLINE compare #-} -instance Index ix => Construct BL ix e where+instance Strategy BL where   setComp c arr = arr { blComp = c }   {-# INLINE setComp #-}+  getComp = blComp+  {-# INLINE getComp #-} -  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)-  {-# INLINE makeArrayLinear #-} -  replicate comp sz e = runST (newMArray sz e >>= unsafeFreeze comp)-  {-# INLINE replicate #-}--instance Index ix => Source BL ix e where+instance Source BL e where   unsafeLinearIndex (BLArray _ _sz o a) i =     INDEX_CHECK("(Source BL ix e).unsafeLinearIndex",-                SafeSz . sizeofArray, A.indexArray) a (i + o)+                SafeSz . A.sizeofArray, A.indexArray) a (i + o)   {-# INLINE unsafeLinearIndex #-} -  unsafeLinearSlice i k (BLArray c _ o a) = BLArray c k (o + i) a-  {-# INLINE unsafeLinearSlice #-}---instance Index ix => Resize BL ix where-  unsafeResize !sz !arr = arr { blSize = sz }-  {-# INLINE unsafeResize #-}--instance Index ix => Extract BL ix e where-  unsafeExtract !sIx !newSz !arr = unsafeExtract sIx newSz (toManifest arr)-  {-# INLINE unsafeExtract #-}---instance ( Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt BL ix e ~ Array M (Lower ix) e-         ) =>-         OuterSlice BL ix e where-  unsafeOuterSlice arr = unsafeOuterSlice (toManifest arr)+  unsafeOuterSlice (BLArray c _ o a) szL i = BLArray c szL (i * totalElem szL + o) a   {-# INLINE unsafeOuterSlice #-} -instance ( Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt BL ix e ~ Array M (Lower ix) e-         ) =>-         InnerSlice BL ix e where-  unsafeInnerSlice arr = unsafeInnerSlice (toManifest arr)-  {-# INLINE unsafeInnerSlice #-}--instance {-# OVERLAPPING #-} Slice BL Ix1 e where-  unsafeSlice arr i _ _ = pure (unsafeLinearIndex arr i)-  {-# INLINE unsafeSlice #-}-+  unsafeLinearSlice i k (BLArray c _ o a) = BLArray c k (o + i) a+  {-# INLINE unsafeLinearSlice #-} -instance Index ix => Manifest BL ix e where+instance Manifest BL e where    unsafeLinearIndexM (BLArray _ _sz o a) i =     INDEX_CHECK("(Manifest BL ix e).unsafeLinearIndexM",-                SafeSz . sizeofArray, A.indexArray) a (i + o)+                SafeSz . A.sizeofArray, A.indexArray) a (i + o)   {-# INLINE unsafeLinearIndexM #-} +  sizeOfMArray (MBLArray sz _ _) = sz+  {-# INLINE sizeOfMArray #-} -instance Index ix => Mutable BL ix e where-  data MArray s BL ix e = MBLArray !(Sz ix) {-# UNPACK #-} !Int {-# UNPACK #-} !(A.MutableArray s e)+  unsafeResizeMArray sz (MBLArray _ off marr) = MBLArray sz off marr+  {-# INLINE unsafeResizeMArray #-} -  msize (MBLArray sz _ _) = sz-  {-# INLINE msize #-}+  unsafeLinearSliceMArray i k (MBLArray _ o a) = MBLArray k (i + o) a+  {-# INLINE unsafeLinearSliceMArray #-}    unsafeThaw (BLArray _ sz o a) = MBLArray sz o <$> A.unsafeThawArray a   {-# INLINE unsafeThaw #-}@@ -211,24 +173,37 @@   {-# INLINE newMArray #-}    unsafeLinearRead (MBLArray _ o ma) i =-    INDEX_CHECK("(Mutable BL ix e).unsafeLinearRead",-                SafeSz . sizeofMutableArray, A.readArray) ma (i + o)+    INDEX_CHECK("(Manifest BL ix e).unsafeLinearRead",+                SafeSz . A.sizeofMutableArray, A.readArray) ma (i + o)   {-# INLINE unsafeLinearRead #-}    unsafeLinearWrite (MBLArray _sz o ma) i e = e `seq`-    INDEX_CHECK("(Mutable BL ix e).unsafeLinearWrite",-                SafeSz . sizeofMutableArray, A.writeArray) ma (i + o) e+    INDEX_CHECK("(Manifest BL ix e).unsafeLinearWrite",+                SafeSz . A.sizeofMutableArray, A.writeArray) ma (i + o) e   {-# INLINE unsafeLinearWrite #-} -instance Index ix => Load BL ix e where-  type R BL = M+instance Size BL where   size = blSize   {-# INLINE size #-}-  getComp = blComp-  {-# INLINE getComp #-}-  loadArrayM !scheduler !arr = splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)-  {-# INLINE loadArrayM #-}+  unsafeResize !sz !arr = arr { blSize = sz }+  {-# INLINE unsafeResize #-} ++instance Index ix => Shape BL ix where+  maxLinearSize = Just . SafeSz . elemsCount+  {-# INLINE maxLinearSize #-}++instance Index ix => Load BL ix e where+  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)+  {-# INLINE makeArrayLinear #-}++  replicate comp sz e = runST (newMArray sz e >>= unsafeFreeze comp)+  {-# INLINE replicate #-}++  iterArrayLinearST_ !scheduler !arr =+    splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)+  {-# INLINE iterArrayLinearST_ #-}+ instance Index ix => StrideLoad BL ix e  instance Index ix => Stream BL ix e where@@ -270,12 +245,7 @@   traverse = traverseA   {-# INLINE traverse #-} -instance ( IsList (Array L ix e)-         , Nested LN ix e-         , Nested L ix e-         , Ragged L ix e-         ) =>-         IsList (Array BL ix e) where+instance (IsList (Array L ix e), Ragged L ix e) => IsList (Array BL ix e) where   type Item (Array BL ix e) = Item (Array L ix e)   fromList = L.fromLists' Seq   {-# INLINE fromList #-}@@ -308,6 +278,8 @@  newtype instance Array B ix e = BArray (Array BL ix e) +newtype instance MArray s B ix e = MBArray (MArray s BL ix e)+ instance (Ragged L ix e, Show e) => Show (Array B ix e) where   showsPrec = showsArrayPrec id   showList = showArrayList@@ -324,67 +296,48 @@   compare = compareArrays compare   {-# INLINE compare #-} -instance Index ix => Construct B ix e where-  setComp c = coerce (\arr -> arr { blComp = c })-  {-# INLINE setComp #-} -  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)-  {-# INLINE makeArrayLinear #-}--  replicate comp sz e = runST (newMArray sz e >>= unsafeFreeze comp)-  {-# INLINE replicate #-}--instance Index ix => Source B ix e where-  unsafeLinearIndex arr = unsafeLinearIndex (coerce arr :: Array BL ix e)+instance Source B e where+  unsafeLinearIndex arr = unsafeLinearIndex (toLazyArray arr)   {-# INLINE unsafeLinearIndex #-} -  unsafeLinearSlice i k arr = coerce (unsafeLinearSlice i k (coerce arr :: Array BL ix e))+  unsafeLinearSlice i k arr = coerce (unsafeLinearSlice i k (toLazyArray arr))   {-# INLINE unsafeLinearSlice #-} --instance Index ix => Resize B ix where-  unsafeResize sz = coerce (\arr -> arr { blSize = sz })-  {-# INLINE unsafeResize #-}+  unsafeOuterSlice arr i = coerce (unsafeOuterSlice (toLazyArray arr) i)+  {-# INLINE unsafeOuterSlice #-} -instance Index ix => Extract B ix e where-  unsafeExtract !sIx !newSz !arr = unsafeExtract sIx newSz (toManifest arr)-  {-# INLINE unsafeExtract #-}+instance Strategy B where+  getComp = blComp . coerce+  {-# INLINE getComp #-}+  setComp c arr = coerceBoxedArray (coerce arr) { blComp = c }+  {-# INLINE setComp #-}  -instance ( Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt B ix e ~ Array M (Lower ix) e-         ) =>-         OuterSlice B ix e where-  unsafeOuterSlice arr = unsafeOuterSlice (toManifest arr)-  {-# INLINE unsafeOuterSlice #-}--instance ( Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt B ix e ~ Array M (Lower ix) e-         ) =>-         InnerSlice B ix e where-  unsafeInnerSlice arr = unsafeInnerSlice (toManifest arr)-  {-# INLINE unsafeInnerSlice #-}+instance Index ix => Shape B ix where+  maxLinearSize = Just . SafeSz . elemsCount+  {-# INLINE maxLinearSize #-} -instance {-# OVERLAPPING #-} Slice B Ix1 e where-  unsafeSlice arr i _ _ = pure (unsafeLinearIndex arr i)-  {-# INLINE unsafeSlice #-}+instance Size B where+  size = blSize . coerce+  {-# INLINE size #-}+  unsafeResize sz = coerce (\arr -> arr { blSize = sz })+  {-# INLINE unsafeResize #-}  -instance Index ix => Manifest B ix e where+instance Manifest B e where    unsafeLinearIndexM = coerce unsafeLinearIndexM   {-# INLINE unsafeLinearIndexM #-} +  sizeOfMArray = sizeOfMArray . coerce+  {-# INLINE sizeOfMArray #-} -instance Index ix => Mutable B ix e where-  newtype MArray s B ix e = MBArray (MArray s BL ix e)+  unsafeResizeMArray sz = MBArray . unsafeResizeMArray sz . coerce+  {-# INLINE unsafeResizeMArray #-} -  msize = msize . coerce-  {-# INLINE msize #-}+  unsafeLinearSliceMArray i k = MBArray . unsafeLinearSliceMArray i k . coerce+  {-# INLINE unsafeLinearSliceMArray #-}    unsafeThaw arr = MBArray <$> unsafeThaw (coerce arr)   {-# INLINE unsafeThaw #-}@@ -408,14 +361,15 @@   {-# INLINE unsafeLinearWrite #-}  instance Index ix => Load B ix e where-  type R B = M-  size = blSize . coerce-  {-# INLINE size #-}-  getComp = blComp . coerce-  {-# INLINE getComp #-}-  loadArrayM scheduler = coerce (loadArrayM scheduler)-  {-# INLINE loadArrayM #-}+  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)+  {-# INLINE makeArrayLinear #-} +  replicate comp sz e = runST (newMArray sz e >>= unsafeFreeze comp)+  {-# INLINE replicate #-}++  iterArrayLinearST_ scheduler = coerce (iterArrayLinearST_ scheduler)+  {-# INLINE iterArrayLinearST_ #-}+ instance Index ix => StrideLoad B ix e  instance Index ix => Stream B ix e where@@ -457,12 +411,7 @@   traverse = traverseA   {-# INLINE traverse #-} -instance ( IsList (Array L ix e)-         , Nested LN ix e-         , Nested L ix e-         , Ragged L ix e-         ) =>-         IsList (Array B ix e) where+instance (IsList (Array L ix e), Ragged L ix e) => IsList (Array B ix e) where   type Item (Array B ix e) = Item (Array L ix e)   fromList = L.fromLists' Seq   {-# INLINE fromList #-}@@ -493,16 +442,20 @@ data BN = BN deriving Show  -- | Type and pattern `N` have been added for backwards compatibility and will be replaced--- in the future in favor of `BN`+-- in the future in favor of `BN`.+--+-- /Deprecated/ - since 1.0.0 type N = BN pattern N :: N pattern N = BN {-# COMPLETE N #-}+{-# DEPRECATED N "In favor of more consistently named `BN`" #-} -newtype instance Array N ix e = BNArray { bArray :: Array BL ix e }+newtype instance Array BN ix e = BNArray (Array BL ix e)+newtype instance MArray s BN ix e = MBNArray (MArray s BL ix e)  instance (Ragged L ix e, Show e, NFData e) => Show (Array BN ix e) where-  showsPrec = showsArrayPrec bArray+  showsPrec = showsArrayPrec coerce   showList = showArrayList  -- | /O(1)/ - `BN` is already in normal form@@ -518,67 +471,44 @@   compare = compareArrays compare   {-# INLINE compare #-} --instance (Index ix, NFData e) => Construct BN ix e where-  setComp c (BNArray arr) = BNArray (arr {blComp = c})+instance Strategy N where+  setComp c = coerce (setComp c)   {-# INLINE setComp #-}-  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)-  {-# INLINE makeArrayLinear #-}-  replicate comp sz e = runST (newMArray sz e >>= unsafeFreeze comp)-  {-# INLINE replicate #-}+  getComp = blComp . coerce+  {-# INLINE getComp #-} -instance (Index ix, NFData e) => Source BN ix e where+instance NFData e => Source BN e where   unsafeLinearIndex (BNArray arr) = unsafeLinearIndex arr   {-# INLINE unsafeLinearIndex #-}-  unsafeLinearSlice i k (BNArray a) = BNArray $ unsafeLinearSlice i k a+  unsafeLinearSlice i k (BNArray a) = coerce (unsafeLinearSlice i k a)   {-# INLINE unsafeLinearSlice #-}---instance Index ix => Resize BN ix where-  unsafeResize !sz = BNArray . unsafeResize sz . bArray-  {-# INLINE unsafeResize #-}--instance (Index ix, NFData e) => Extract BN ix e where-  unsafeExtract !sIx !newSz !arr = unsafeExtract sIx newSz (toManifest arr)-  {-# INLINE unsafeExtract #-}---instance ( NFData e-         , Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt BN ix e ~ Array M (Lower ix) e-         ) =>-         OuterSlice BN ix e where-  unsafeOuterSlice = unsafeOuterSlice . toManifest+  unsafeOuterSlice (BNArray a) i = coerce (unsafeOuterSlice a i)   {-# INLINE unsafeOuterSlice #-} -instance ( NFData e-         , Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt BN ix e ~ Array M (Lower ix) e-         ) =>-         InnerSlice BN ix e where-  unsafeInnerSlice = unsafeInnerSlice . toManifest-  {-# INLINE unsafeInnerSlice #-} -instance {-# OVERLAPPING #-} NFData e => Slice BN Ix1 e where-  unsafeSlice arr i _ _ = pure (unsafeLinearIndex arr i)-  {-# INLINE unsafeSlice #-}+instance Index ix => Shape BN ix where+  maxLinearSize = Just . SafeSz . elemsCount+  {-# INLINE maxLinearSize #-} +instance Size BN where+  size = blSize . coerce+  {-# INLINE size #-} -instance (Index ix, NFData e) => Manifest BN ix e where+  unsafeResize !sz = coerce . unsafeResize sz . coerce+  {-# INLINE unsafeResize #-} +instance NFData e => Manifest BN e where   unsafeLinearIndexM arr = unsafeLinearIndexM (coerce arr)   {-# INLINE unsafeLinearIndexM #-} +  sizeOfMArray = sizeOfMArray . coerce+  {-# INLINE sizeOfMArray #-} -instance (Index ix, NFData e) => Mutable BN ix e where-  newtype MArray s BN ix e = MBNArray (MArray s BL ix e)+  unsafeResizeMArray sz = coerce . unsafeResizeMArray sz . coerce+  {-# INLINE unsafeResizeMArray #-} -  msize = msize . coerce-  {-# INLINE msize #-}+  unsafeLinearSliceMArray i k = MBNArray . unsafeLinearSliceMArray i k . coerce+  {-# INLINE unsafeLinearSliceMArray #-}    unsafeThaw arr = MBNArray <$> unsafeThaw (coerce arr)   {-# INLINE unsafeThaw #-}@@ -602,13 +532,13 @@   {-# INLINE unsafeLinearWrite #-}  instance (Index ix, NFData e) => Load BN ix e where-  type R BN = M-  size = blSize . coerce-  {-# INLINE size #-}-  getComp = blComp . coerce-  {-# INLINE getComp #-}-  loadArrayM !scheduler !arr = splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)-  {-# INLINE loadArrayM #-}+  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)+  {-# INLINE makeArrayLinear #-}+  replicate comp sz e = runST (newMArray sz e >>= unsafeFreeze comp)+  {-# INLINE replicate #-}+  iterArrayLinearST_ !scheduler !arr =+    splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)+  {-# INLINE iterArrayLinearST_ #-}  instance (Index ix, NFData e) => StrideLoad BN ix e @@ -619,13 +549,7 @@   {-# INLINE toStreamIx #-}  -instance ( NFData e-         , IsList (Array L ix e)-         , Nested LN ix e-         , Nested L ix e-         , Ragged L ix e-         ) =>-         IsList (Array BN ix e) where+instance (NFData e, IsList (Array L ix e), Ragged L ix e) => IsList (Array BN ix e) where   type Item (Array BN ix e) = Item (Array L ix e)   fromList = L.fromLists' Seq   {-# INLINE fromList #-}@@ -688,7 +612,7 @@ -- -- @since 0.6.0 wrapLazyArray :: A.Array e -> Vector BL e-wrapLazyArray a = BLArray Seq (SafeSz (sizeofArray a)) 0 a+wrapLazyArray a = BLArray Seq (SafeSz (A.sizeofArray a)) 0 a {-# INLINE wrapLazyArray #-}  @@ -795,7 +719,7 @@   -> A.MutableArray (PrimState m) e   -> m (MArray (PrimState m) BL Ix1 e) fromMutableArraySeq with ma = do-  let !sz = sizeofMutableArray ma+  let !sz = A.sizeofMutableArray ma   loopM_ 0 (< sz) (+ 1) (A.readArray ma >=> (`with` return ()))   return $! MBLArray (SafeSz sz) 0 ma {-# INLINE fromMutableArraySeq #-}

@@ -1,8 +1,8 @@ {-# LANGUAGE BangPatterns #-}-{-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MagicHash #-}+{-# LANGUAGE MonoLocalBinds #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-}@@ -17,10 +17,9 @@ -- Portability : non-portable -- module Data.Massiv.Array.Manifest.Internal-  ( M-  , Manifest(..)+  ( Manifest(..)   , Array(..)-  , toManifest+  , flattenMArray   , compute   , computeS   , computeP@@ -38,190 +37,33 @@   , gcastArr   , fromRaggedArrayM   , fromRaggedArray'-  , sizeofArray-  , sizeofMutableArray+  , unsafeLoadIntoS+  , unsafeLoadIntoM   , iterateUntil   , iterateUntilM   ) where  import Control.Exception (try)+import Control.DeepSeq import Control.Monad.ST+import Control.Monad.Primitive import Control.Scheduler-import qualified Data.Foldable as F (Foldable(..)) import Data.Massiv.Array.Delayed.Pull import Data.Massiv.Array.Mutable-import Data.Massiv.Array.Ops.Fold.Internal as A import Data.Massiv.Array.Mutable.Internal (unsafeCreateArray_)-import Data.Massiv.Vector.Stream as S (steps, isteps) import Data.Massiv.Core.Common import Data.Massiv.Core.List-import Data.Massiv.Core.Operations import Data.Maybe (fromMaybe) import Data.Typeable-import GHC.Base hiding (ord) import System.IO.Unsafe (unsafePerformIO) -#if MIN_VERSION_primitive(0,6,2)-import Data.Primitive.Array (sizeofArray, sizeofMutableArray) -#else-import qualified Data.Primitive.Array as A (Array(..), MutableArray(..))-import GHC.Exts (sizeofArray#, sizeofMutableArray#)--sizeofArray :: A.Array a -> Int-sizeofArray (A.Array a) = I# (sizeofArray# a)-{-# INLINE sizeofArray #-}--sizeofMutableArray :: A.MutableArray s a -> Int-sizeofMutableArray (A.MutableArray ma) = I# (sizeofMutableArray# ma)-{-# INLINE sizeofMutableArray #-}-#endif----- | General Manifest representation-data M--data instance Array M ix e = MArray { mComp :: !Comp-                                    , mSize :: !(Sz ix)-                                    , mLinearIndex :: Int -> e }--instance (Ragged L ix e, Show e) => Show (Array M ix e) where-  showsPrec = showsArrayPrec id-  showList = showArrayList---instance (Eq e, Index ix) => Eq (Array M ix e) where-  (==) = eqArrays (==)-  {-# INLINE (==) #-}--instance (Ord e, Index ix) => Ord (Array M ix e) where-  compare = compareArrays compare-  {-# INLINE compare #-}----- | /O(1)/ - Conversion of `Manifest` arrays to `M` representation.-toManifest :: Manifest r ix e => Array r ix e -> Array M ix e-toManifest !arr = MArray (getComp arr) (size arr) (unsafeLinearIndexM arr)-{-# INLINE toManifest #-}----- | Row-major sequentia folding over a Manifest array.-instance Index ix => Foldable (Array M ix) where-  fold = fold-  {-# INLINE fold #-}-  foldMap = foldMono-  {-# INLINE foldMap #-}-  foldl = lazyFoldlS-  {-# INLINE foldl #-}-  foldl' = foldlS-  {-# INLINE foldl' #-}-  foldr = foldrFB-  {-# INLINE foldr #-}-  foldr' = foldrS-  {-# INLINE foldr' #-}-  null (MArray _ sz _) = totalElem sz == 0-  {-# INLINE null #-}-  length = totalElem . size-  {-# INLINE length #-}-  elem e = A.any (e ==)-  {-# INLINE elem #-}-  toList arr = build (\ c n -> foldrFB c n arr)-  {-# INLINE toList #-}---instance Index ix => Source M ix e where-  unsafeLinearIndex = mLinearIndex-  {-# INLINE unsafeLinearIndex #-}-  unsafeLinearSlice ix sz arr = unsafeExtract ix sz (unsafeResize sz arr)-  {-# INLINE unsafeLinearSlice #-}---instance Index ix => Manifest M ix e where--  unsafeLinearIndexM = mLinearIndex-  {-# INLINE unsafeLinearIndexM #-}---instance Index ix => Resize M ix where-  unsafeResize !sz !arr = arr { mSize = sz }-  {-# INLINE unsafeResize #-}--instance Index ix => Extract M ix e where-  unsafeExtract !sIx !newSz !arr =-    MArray (getComp arr) newSz $ \ i ->-      unsafeIndex arr (liftIndex2 (+) (fromLinearIndex newSz i) sIx)-  {-# INLINE unsafeExtract #-}----instance {-# OVERLAPPING #-} Slice M Ix1 e where-  unsafeSlice arr i _ _ = pure (unsafeLinearIndex arr i)-  {-# INLINE unsafeSlice #-}--instance ( Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         ) =>-         Slice M ix e where-  unsafeSlice arr start cutSz dim = do-    (_, newSz) <- pullOutSzM cutSz dim-    return $ unsafeResize newSz (unsafeExtract start cutSz arr)-  {-# INLINE unsafeSlice #-}--instance {-# OVERLAPPING #-} OuterSlice M Ix1 e where-  unsafeOuterSlice !arr = unsafeIndex arr-  {-# INLINE unsafeOuterSlice #-}--instance (Elt M ix e ~ Array M (Lower ix) e, Index ix, Index (Lower ix)) => OuterSlice M ix e where-  unsafeOuterSlice !arr !i =-    MArray (getComp arr) (snd (unconsSz (size arr))) (unsafeLinearIndex arr . (+ kStart))-    where-      !kStart = toLinearIndex (size arr) (consDim i (zeroIndex :: Lower ix))-  {-# INLINE unsafeOuterSlice #-}--instance {-# OVERLAPPING #-} InnerSlice M Ix1 e where-  unsafeInnerSlice !arr _ = unsafeIndex arr-  {-# INLINE unsafeInnerSlice #-}--instance (Elt M ix e ~ Array M (Lower ix) e, Index ix, Index (Lower ix)) => InnerSlice M ix e where-  unsafeInnerSlice !arr (szL, m) !i =-    MArray (getComp arr) szL (\k -> unsafeLinearIndex arr (k * unSz m + kStart))-    where-      !kStart = toLinearIndex (size arr) (snocDim (zeroIndex :: Lower ix) i)-  {-# INLINE unsafeInnerSlice #-}---instance Index ix => Load M ix e where-  size = mSize-  {-# INLINE size #-}-  getComp = mComp-  {-# INLINE getComp #-}-  loadArrayM scheduler (MArray _ sz f) = splitLinearlyWith_ scheduler (totalElem sz) f-  {-# INLINE loadArrayM #-}--instance Index ix => StrideLoad M ix e--instance Index ix => Stream M ix e where-  toStream = S.steps-  {-# INLINE toStream #-}-  toStreamIx = S.isteps-  {-# INLINE toStreamIx #-}---instance Num e => FoldNumeric M e where-  unsafeDotProduct = defaultUnsafeDotProduct-  {-# INLINE unsafeDotProduct #-}-  powerSumArray = defaultPowerSumArray-  {-# INLINE powerSumArray #-}-  foldArray = defaultFoldArray-  {-# INLINE foldArray #-}- -- | Ensure that Array is computed, i.e. represented with concrete elements in memory, hence is the -- `Mutable` type class restriction. Use `setComp` if you'd like to change computation strategy -- before calling @compute@ -- -- @since 0.1.0-compute :: forall r ix e r' . (Mutable r ix e, Load r' ix e) => Array r' ix e -> Array r ix e+compute :: forall r ix e r' . (Manifest r e, Load r' ix e) => Array r' ix e -> Array r ix e compute !arr = unsafePerformIO $ computeIO arr {-# INLINE compute #-} @@ -229,7 +71,7 @@ -- the same as `computePrimM`, but executed in `ST`, thus pure. -- -- @since 0.1.0-computeS :: forall r ix e r' . (Mutable r ix e, Load r' ix e) => Array r' ix e -> Array r ix e+computeS :: forall r ix e r' . (Manifest r e, Load r' ix e) => Array r' ix e -> Array r ix e computeS !arr = runST $ computePrimM arr {-# INLINE computeS #-} @@ -240,7 +82,7 @@ -- -- @since 0.5.4 computeP ::-     forall r ix e r'. (Mutable r ix e, Construct r' ix e, Load r' ix e)+     forall r ix e r'. (Manifest r e, Load r' ix e)   => Array r' ix e   -> Array r ix e computeP arr = setComp (getComp arr) $ compute (setComp Par arr)@@ -253,7 +95,7 @@ -- -- @since 0.4.5 computeIO ::-     forall r ix e r' m. (Mutable r ix e, Load r' ix e, MonadIO m)+     forall r ix e r' m. (Manifest r e, Load r' ix e, MonadIO m)   => Array r' ix e   -> m (Array r ix e) computeIO arr = liftIO (loadArray arr >>= unsafeFreeze (getComp arr))@@ -264,7 +106,7 @@ -- -- @since 0.4.5 computePrimM ::-     forall r ix e r' m. (Mutable r ix e, Load r' ix e, PrimMonad m)+     forall r ix e r' m. (Manifest r e, Load r' ix e, PrimMonad m)   => Array r' ix e   -> m (Array r ix e) computePrimM arr = loadArrayS arr >>= unsafeFreeze (getComp arr)@@ -280,7 +122,7 @@ -- Array P Seq (Sz1 10) --   [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ---computeAs :: (Mutable r ix e, Load r' ix e) => r -> Array r' ix e -> Array r ix e+computeAs :: (Manifest r e, Load r' ix e) => r -> Array r' ix e -> Array r ix e computeAs _ = compute {-# INLINE computeAs #-} @@ -300,7 +142,7 @@ --   [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 ] -- -- @since 0.1.1-computeProxy :: (Mutable r ix e, Load r' ix e) => proxy r -> Array r' ix e -> Array r ix e+computeProxy :: (Manifest r e, Load r' ix e) => proxy r -> Array r' ix e -> Array r ix e computeProxy _ = compute {-# INLINE computeProxy #-} @@ -309,16 +151,16 @@ -- resulting type is the same as the input. -- -- @since 0.1.0-computeSource :: forall r ix e r' . (Mutable r ix e, Source r' ix e)+computeSource :: forall r ix e r' . (Manifest r e, Source r' e, Index ix)               => Array r' ix e -> Array r ix e-computeSource arr = maybe (compute arr) (\Refl -> arr) (eqT :: Maybe (r' :~: r))+computeSource arr = maybe (compute $ delay arr) (\Refl -> arr) (eqT :: Maybe (r' :~: r)) {-# INLINE computeSource #-}   -- | /O(n)/ - Make an exact immutable copy of an Array. -- -- @since 0.1.0-clone :: Mutable r ix e => Array r ix e -> Array r ix e+clone :: (Manifest r e, Index ix) => Array r ix e -> Array r ix e clone arr = unsafePerformIO $ thaw arr >>= unsafeFreeze (getComp arr) {-# INLINE clone #-} @@ -333,7 +175,7 @@ -- result arrays are of the same representation, in which case it is an /O(1)/ operation. -- -- @since 0.1.0-convert :: forall r ix e r' . (Mutable r ix e, Load r' ix e)+convert :: forall r ix e r' . (Manifest r e, Load r' ix e)         => Array r' ix e -> Array r ix e convert arr = fromMaybe (compute arr) (gcastArr arr) {-# INLINE convert #-}@@ -341,7 +183,7 @@ -- | Same as `convert`, but let's you supply resulting representation type as an argument. -- -- @since 0.1.0-convertAs :: (Mutable r ix e, Load r' ix e)+convertAs :: (Manifest r e, Load r' ix e)           => r -> Array r' ix e -> Array r ix e convertAs _ = convert {-# INLINE convertAs #-}@@ -351,7 +193,7 @@ -- proxy argument. -- -- @since 0.1.1-convertProxy :: (Mutable r ix e, Load r' ix e)+convertProxy :: (Manifest r e, Load r' ix e)              => proxy r -> Array r' ix e -> Array r ix e convertProxy _ = convert {-# INLINE convertProxy #-}@@ -362,48 +204,48 @@ -- -- @since 0.4.0 fromRaggedArrayM ::-     forall r ix e r' m . (Mutable r ix e, Ragged r' ix e, Load r' ix e, MonadThrow m)+     forall r ix e r' m . (Manifest r e, Ragged r' ix e, MonadThrow m)   => Array r' ix e   -> m (Array r ix e) fromRaggedArrayM arr =-  let sz = edgeSize arr+  let sz = outerSize arr    in either (\(e :: ShapeException) -> throwM e) pure $       unsafePerformIO $ do         marr <- unsafeNew sz         traverse (\_ -> unsafeFreeze (getComp arr) marr) =<<           try (withMassivScheduler_ (getComp arr) $ \scheduler ->-                 loadRagged (scheduleWork scheduler) (unsafeLinearWrite marr) 0 (totalElem sz) sz arr)+                stToIO $ loadRaggedST scheduler arr (unsafeLinearWrite marr) 0 (totalElem sz) sz) {-# INLINE fromRaggedArrayM #-}  --- | Same as `fromRaggedArrayM`, but will throw a pure exception if its shape is not+-- | Same as `fromRaggedArrayM`, but will throw an impure exception if its shape is not -- rectangular. -- -- @since 0.1.1 fromRaggedArray' ::-     forall r ix e r'. (Mutable r ix e, Load r' ix e, Ragged r' ix e)+     forall r ix e r'. (HasCallStack, Manifest r e, Ragged r' ix e)   => Array r' ix e   -> Array r ix e-fromRaggedArray' arr = either throw id $ fromRaggedArrayM arr+fromRaggedArray' = throwEither . fromRaggedArrayM {-# INLINE fromRaggedArray' #-}   -- | Same as `compute`, but with `Stride`. ----- /O(n div k)/ - Where @n@ is numer of elements in the source array and @k@ is number of+-- /O(n div k)/ - Where @n@ is number of elements in the source array and @k@ is number of -- elements in the stride. -- -- @since 0.3.0 computeWithStride ::-     forall r ix e r'. (Mutable r ix e, StrideLoad r' ix e)+     forall r ix e r'. (Manifest r e, StrideLoad r' ix e)   => Stride ix   -> Array r' ix e   -> Array r ix e computeWithStride stride !arr =   unsafePerformIO $ do-    let !sz = strideSize stride (size arr)+    let !sz = strideSize stride (outerSize arr)     unsafeCreateArray_ (getComp arr) sz $ \scheduler marr ->-      loadArrayWithStrideM scheduler stride sz arr (unsafeLinearWrite marr)+      stToIO $ iterArrayLinearWithStrideST_ scheduler stride sz arr (unsafeLinearWrite marr) {-# INLINE computeWithStride #-}  @@ -411,12 +253,36 @@ -- -- @since 0.3.0 computeWithStrideAs ::-     (Mutable r ix e, StrideLoad r' ix e) => r -> Stride ix -> Array r' ix e -> Array r ix e+     (Manifest r e, StrideLoad r' ix e) => r -> Stride ix -> Array r' ix e -> Array r ix e computeWithStrideAs _ = computeWithStride {-# INLINE computeWithStrideAs #-}  +-- | 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.+--+-- @since 0.5.7+unsafeLoadIntoS ::+     forall r r' ix e m s. (Load r ix e, Manifest r' e, MonadPrim s m)+  => MVector s r' e+  -> Array r ix e+  -> m (MArray s r' ix e)+unsafeLoadIntoS marr arr = stToPrim $ unsafeLoadIntoS marr arr+{-# INLINE unsafeLoadIntoS #-} +-- | Same as `unsafeLoadIntoS`, but respecting computation strategy.+--+-- @since 0.5.7+unsafeLoadIntoM ::+     forall r r' ix e m. (Load r ix e, Manifest r' e, MonadIO m)+  => MVector RealWorld r' e+  -> Array r ix e+  -> m (MArray RealWorld r' ix e)+unsafeLoadIntoM marr arr = liftIO $ unsafeLoadIntoIO marr arr+{-# INLINE unsafeLoadIntoM #-}++ -- | Efficiently iterate a function until a convergence condition is satisfied. If the -- size of array doesn't change between iterations then no more than two new arrays will be -- allocated, regardless of the number of iterations. If the size does change from one@@ -426,8 +292,8 @@ -- ====__Example__ -- -- >>> import Data.Massiv.Array--- >>> a = computeAs P $ makeLoadArrayS (Sz2 8 8) (0 :: Int) $ \ w -> () <$ w (0 :. 0) 1--- >>> a+-- >>> let arr = computeAs P $ makeLoadArrayS (Sz2 8 8) (0 :: Int) $ \ w -> () <$ w (0 :. 0) 1+-- >>> arr -- Array P Seq (Sz (8 :. 8)) --   [ [ 1, 0, 0, 0, 0, 0, 0, 0 ] --   , [ 0, 0, 0, 0, 0, 0, 0, 0 ]@@ -438,9 +304,9 @@ --   , [ 0, 0, 0, 0, 0, 0, 0, 0 ] --   , [ 0, 0, 0, 0, 0, 0, 0, 0 ] --   ]--- >>> nextPascalRow cur above = if cur == 0 then above else cur--- >>> pascal = makeStencil (Sz2 2 2) 1 $ \ get -> nextPascalRow (get (0 :. 0)) (get (-1 :. -1) + get (-1 :. 0))--- >>> iterateUntil (\_ _ a -> (a ! (7 :. 7)) /= 0) (\ _ -> mapStencil (Fill 0) pascal) a+-- >>> let nextPascalRow cur above = if cur == 0 then above else cur+-- >>> let pascal = makeStencil (Sz2 2 2) 1 $ \ get -> nextPascalRow (get (0 :. 0)) (get (-1 :. -1) + get (-1 :. 0))+-- >>> iterateUntil (\_ _ a -> (a ! (7 :. 7)) /= 0) (\ _ -> mapStencil (Fill 0) pascal) arr -- Array P Seq (Sz (8 :. 8)) --   [ [ 1, 0, 0, 0, 0, 0, 0, 0 ] --   , [ 1, 1, 0, 0, 0, 0, 0, 0 ]@@ -454,7 +320,7 @@ -- -- @since 0.3.6 iterateUntil ::-     (Load r' ix e, Mutable r ix e)+     (Load r' ix e, Manifest r e, NFData (Array r ix e))   => (Int -> Array r ix e -> Array r ix e -> Bool)   -- ^ Convergence condition. Accepts current iteration counter, array at the previous   -- state and at the current state.@@ -463,85 +329,59 @@   -- differ if necessary   -> Array r ix e -- ^ Initial source array   -> Array r ix e-iterateUntil convergence iteration initArr0-  | convergence 0 initArr0 initArr1 = initArr1-  | otherwise =-    unsafePerformIO $ do-      let loadArr = iteration 1 initArr1-      marr <- unsafeNew (size loadArr)-      iterateLoop-        (\n a comp marr' -> convergence n a <$> unsafeFreeze comp marr')-        iteration-        1-        initArr1-        loadArr-        (asArr initArr0 marr)-  where-    !initArr1 = compute $ iteration 0 initArr0-    asArr :: Array r ix e -> MArray s r ix e -> MArray s r ix e-    asArr _ = id+iterateUntil convergence iteration initArr0 = unsafePerformIO $ do+  let loadArr0 = iteration 0 initArr0+  initMVec1 <- unsafeNew (fromMaybe zeroSz (maxLinearSize loadArr0))+  let conv n arr comp marr' = do+        arr' <- unsafeFreeze comp marr'+        arr' `deepseq` pure (convergence n arr arr', arr')+  iterateLoop conv (\n -> pure . iteration n) 0 initArr0 loadArr0 initMVec1 {-# INLINE iterateUntil #-} --- | Monadic version of `iterateUntil` where at each iteration mutable version of an array--- is available.+-- | Monadic version of `iterateUntil` where at each iteration mutable version+-- of an array is available. However it is less efficient then the pure+-- alternative, because an intermediate array must be copied at each+-- iteration. -- -- @since 0.3.6 iterateUntilM ::-     (Load r' ix e, Mutable r ix e, PrimMonad m, MonadIO m, PrimState m ~ RealWorld)-  => (Int -> Array r ix e -> MArray (PrimState m) r ix e -> m Bool)+     (Load r' ix e, Manifest r e, MonadIO m)+  => (Int -> Array r ix e -> MArray RealWorld r ix e -> m Bool)   -- ^ Convergence condition. Accepts current iteration counter, pure array at previous   -- state and a mutable at the current state, therefore after each iteration its contents   -- can be modifed if necessary.-  -> (Int -> Array r ix e -> Array r' ix e)+  -> (Int -> Array r ix e -> m (Array r' ix e))   -- ^ A modifying function to apply at each iteration.  The size of resulting array may   -- differ if necessary.   -> Array r ix e -- ^ Initial source array   -> m (Array r ix e) iterateUntilM convergence iteration initArr0 = do-  let loadArr0 = iteration 0 initArr0-  initMArr1 <- unsafeNew (size loadArr0)-  computeInto initMArr1 loadArr0-  shouldStop <- convergence 0 initArr0 initMArr1-  initArr1 <- unsafeFreeze (getComp loadArr0) initMArr1-  if shouldStop-    then pure initArr1-    else do-      let loadArr1 = iteration 1 initArr1-      marr <- unsafeNew (size loadArr1)-      iterateLoop (\n a _ -> convergence n a) iteration 1 initArr1 loadArr1 marr+  loadArr0 <- iteration 0 initArr0+  initMVec1 <- liftIO $ unsafeNew (fromMaybe zeroSz (maxLinearSize loadArr0))+  let conv n arr comp marr = (,) <$> convergence n arr marr <*> freeze comp marr+  iterateLoop conv iteration 0 initArr0 loadArr0 initMVec1 {-# INLINE iterateUntilM #-}   iterateLoop ::-     (Load r' ix e, Mutable r ix e, PrimMonad m, MonadIO m, PrimState m ~ RealWorld)-  => (Int -> Array r ix e -> Comp -> MArray (PrimState m) r ix e -> m Bool)-  -> (Int -> Array r ix e -> Array r' ix e)+     (Load r' ix e, Manifest r e, MonadIO m)+  => (Int -> Array r ix e -> Comp -> MArray RealWorld r ix e -> m (Bool, Array r ix e))+  -> (Int -> Array r ix e -> m (Array r' ix e))   -> Int   -> Array r ix e   -> Array r' ix e-  -> MArray (PrimState m) r ix e+  -> MVector RealWorld r e   -> m (Array r ix e) iterateLoop convergence iteration = go   where-    go !n !arr !loadArr !marr = do-      let !sz = size loadArr-          !k = totalElem sz-          !mk = totalElem (msize marr)-          !comp = getComp loadArr-      marr' <--        if k == mk-          then pure marr-          else if k < mk-                 then unsafeLinearShrink marr sz-                 else unsafeLinearGrow marr sz-      computeInto marr' loadArr-      shouldStop <- convergence n arr comp marr'-      arr' <- unsafeFreeze comp marr'+    go n !arr !loadArr !mvec = do+      let !comp = getComp loadArr+      marr' <- unsafeLoadIntoM mvec loadArr+      (shouldStop, arr') <- convergence n arr comp marr'       if shouldStop         then pure arr'         else do-          nextMArr <- unsafeThaw arr-          go (n + 1) arr' (iteration (n + 1) arr') nextMArr+          nextMArr <- liftIO $ unsafeThaw arr+          arr'' <- iteration (n + 1) arr'+          go (n + 1) arr' arr'' $ flattenMArray nextMArr {-# INLINE iterateLoop #-}--

@@ -13,8 +13,7 @@ -- Portability : non-portable -- module Data.Massiv.Array.Manifest.List-  (-  -- ** List+  ( -- ** List     fromList   , fromListsM   , fromLists'@@ -30,16 +29,16 @@ import Data.Massiv.Array.Ops.Fold.Internal (foldrFB) import Data.Massiv.Core.Common import Data.Massiv.Core.List-import GHC.Exts (build)+import qualified GHC.Exts as GHC (build, IsList(..))  -- | Convert a flat list into a vector -- -- @since 0.1.0 fromList ::-     forall r e. Mutable r Ix1 e+     forall r e. Manifest r e   => Comp -- ^ Computation startegy to use   -> [e] -- ^ Flat list-  -> Array r Ix1 e+  -> Vector r e fromList = fromLists' {-# INLINE fromList #-} @@ -75,27 +74,38 @@ --   , [ [4,5] ] --   ] -- )--- >>> fromListsM Seq [[[1,2,3]],[[4,5]]] :: Maybe (Array B Ix3 Int)+-- >>> fromListsM Seq [[[1,2,3]],[[4,5]]] :: Maybe (Array B Ix3 Integer) -- Nothing--- >>> fromListsM Seq [[[1,2,3]],[[4,5]]] :: IO (Array B Ix3 Int)--- *** Exception: DimTooShortException: expected (Sz1 3), got (Sz1 2)+-- >>> fromListsM Seq [[[1,2,3]],[[4,5,6],[7,8,9]]] :: IO (Array B Ix3 Integer)+-- *** Exception: DimTooLongException for (Dim 2): expected (Sz1 1), got (Sz1 2)+-- >>> fromListsM Seq [[1,2,3,4],[5,6,7]] :: IO (Matrix B Integer)+-- *** Exception: DimTooShortException for (Dim 1): expected (Sz1 4), got (Sz1 3) -- -- @since 0.3.0-fromListsM :: forall r ix e m . (Nested LN ix e, Ragged L ix e, Mutable r ix e, MonadThrow m)-           => Comp -> [ListItem ix e] -> m (Array r ix e)-fromListsM comp = fromRaggedArrayM . setComp comp . throughNested+fromListsM ::+     forall r ix e m. (Ragged L ix e, Manifest r e, MonadThrow m)+  => Comp+  -> [ListItem ix e]+  -> m (Array r ix e)+fromListsM comp = fromRaggedArrayM . setComp comp . fromListToListArray {-# INLINE fromListsM #-} --- TODO: Figure out QuickCheck properties. Best guess idea so far IMHO is to add it as dependency--- and move Arbitrary instances int the library------ prop> fromLists' Seq xs == fromList xs------ | Same as `fromListsM`, but will throw a pure error on irregular shaped lists.++fromListToListArray ::+     forall ix e. GHC.IsList (Array L ix e)+  => [ListItem ix e]+  -> Array L ix e+fromListToListArray = GHC.fromList+{-# INLINE fromListToListArray #-}+++-- | Same as `fromListsM`, but will throw an error on irregular shaped lists. -- -- __Note__: This function is the same as if you would turn on @{-\# LANGUAGE OverloadedLists #-}@ -- extension. For that reason you can also use `GHC.Exts.fromList`. --+-- prop> \xs -> fromLists' Seq xs == (fromList Seq xs :: Vector P Int)+-- -- ====__Examples__ -- -- Convert a list of lists into a 2D Array@@ -116,26 +126,17 @@ --   , [ 4, 5, 6 ] --   ] ----- Example of failure on conversion of an irregular nested list.------ >>> fromLists' Seq [[1],[3,4]] :: Array U Ix2 Int--- Array U *** Exception: DimTooLongException--- -- @since 0.1.0-fromLists' :: forall r ix e . (Nested LN ix e, Ragged L ix e, Mutable r ix e)-         => Comp -- ^ Computation startegy to use-         -> [ListItem ix e] -- ^ Nested list-         -> Array r ix e-fromLists' comp = fromRaggedArray' . setComp comp . throughNested+fromLists' ::+     forall r ix e. (HasCallStack, Ragged L ix e, Manifest r e)+  => Comp -- ^ Computation startegy to use+  -> [ListItem ix e] -- ^ Nested list+  -> Array r ix e+fromLists' comp = fromRaggedArray' . setComp comp . fromListToListArray {-# INLINE fromLists' #-}  -throughNested :: forall ix e . Nested LN ix e => [ListItem ix e] -> Array L ix e-throughNested xs = fromNested (fromNested xs :: Array LN ix e)-{-# INLINE throughNested #-} -- -- | Convert any array to a flat list. -- -- ==== __Examples__@@ -145,8 +146,8 @@ -- [(0,0),(0,1),(0,2),(1,0),(1,1),(1,2)] -- -- @since 0.1.0-toList :: Source r ix e => Array r ix e -> [e]-toList !arr = build (\ c n -> foldrFB c n arr)+toList :: (Index ix, Source r e) => Array r ix e -> [e]+toList !arr = GHC.build (\ c n -> foldrFB c n arr) {-# INLINE toList #-}  @@ -171,10 +172,11 @@ -- [[[0 :> 0 :. 0,0 :> 0 :. 1,0 :> 0 :. 2]],[[1 :> 0 :. 0,1 :> 0 :. 1,1 :> 0 :. 2]]] -- -- @since 0.1.0-toLists :: (Nested LN ix e, Construct L ix e, Source r ix e)-       => Array r ix e-       -> [ListItem ix e]-toLists = toNested . toNested . toListArray+toLists ::+     (Ragged L ix e, Shape r ix, Source r e)+  => Array r ix e -- ^ Array to be converted to nested lists+  -> [ListItem ix e]+toLists = GHC.toList . toListArray {-# INLINE toLists #-}  @@ -191,7 +193,7 @@ -- [[(0,0,0),(0,0,1),(0,0,2)],[(1,0,0),(1,0,1),(1,0,2)]] -- -- @since 0.1.0-toLists2 :: (Source r ix e, Index (Lower ix)) => Array r ix e -> [[e]]+toLists2 :: (Source r e, Index ix, Index (Lower ix)) => Array r ix e -> [[e]] toLists2 = toList . foldrInner (:) [] {-# INLINE toLists2 #-} @@ -200,7 +202,8 @@ -- get flattened. -- -- @since 0.1.0-toLists3 :: (Index (Lower (Lower ix)), Index (Lower ix), Source r ix e) => Array r ix e -> [[[e]]]+toLists3 ::+     (Source r e, Index ix, Index (Lower ix), Index (Lower (Lower ix))) => Array r ix e -> [[[e]]] toLists3 = toList . foldrInner (:) [] . foldrInner (:) [] {-# INLINE toLists3 #-} @@ -209,12 +212,17 @@ -- -- @since 0.1.0 toLists4 ::-     ( Index (Lower (Lower (Lower ix)))-     , Index (Lower (Lower ix))+     ( Source r e+     , Index ix      , Index (Lower ix)-     , Source r ix e+     , Index (Lower (Lower ix))+     , Index (Lower (Lower (Lower ix)))      )   => Array r ix e   -> [[[[e]]]] toLists4 = toList . foldrInner (:) [] . foldrInner (:) [] . foldrInner (:) [] {-# INLINE toLists4 #-}+++-- $setup+-- >>> import Data.Massiv.Array as A

@@ -20,6 +20,7 @@ module Data.Massiv.Array.Manifest.Primitive   ( P(..)   , Array(..)+  , MArray(..)   , Prim   , toPrimitiveVector   , toPrimitiveMVector@@ -83,6 +84,9 @@                                     , pData   :: {-# UNPACK #-} !ByteArray                                     } +data instance MArray s P ix e =+  MPArray !(Sz ix) {-# UNPACK #-} !Int {-# UNPACK #-} !(MutableByteArray s)+ instance (Ragged L ix e, Show e, Prim e) => Show (Array P ix e) where   showsPrec = showsArrayPrec id   showList = showArrayList@@ -103,92 +107,52 @@   compare = compareArrays compare   {-# INLINE compare #-} -instance (Prim e, Index ix) => Construct P ix e where+instance Strategy P where+  getComp = pComp+  {-# INLINE getComp #-}   setComp c arr = arr { pComp = c }   {-# INLINE setComp #-} -  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)-  {-# INLINE makeArrayLinear #-} -  replicate comp !sz !e = runST (newMArray sz e >>= unsafeFreeze comp)-  {-# INLINE replicate #-}+instance Index ix => Shape P ix where+  maxLinearSize = Just . SafeSz . elemsCount+  {-# INLINE maxLinearSize #-} -instance (Prim e, Index ix) => Source P ix e where+instance Size P where+  size = pSize+  {-# INLINE size #-}+  unsafeResize !sz !arr = arr { pSize = sz }+  {-# INLINE unsafeResize #-}++instance Prim e => Source P e where   unsafeLinearIndex _arr@(PArray _ _ o a) i =     INDEX_CHECK("(Source P ix e).unsafeLinearIndex",                 SafeSz . elemsBA _arr, indexByteArray) a (i + o)   {-# INLINE unsafeLinearIndex #-} -  unsafeLinearSlice i k (PArray c _ o a) = PArray c k (i + o) a-  {-# INLINE unsafeLinearSlice #-}---instance Index ix => Resize P ix where-  unsafeResize !sz !arr = arr { pSize = sz }-  {-# INLINE unsafeResize #-}--instance (Prim e, Index ix) => Extract P ix e where-  unsafeExtract !sIx !newSz !arr = unsafeExtract sIx newSz (toManifest arr)-  {-# INLINE unsafeExtract #-}---instance {-# OVERLAPPING #-} Prim e => Slice P Ix1 e where-  unsafeSlice arr i _ _ = pure (unsafeLinearIndex arr i)-  {-# INLINE unsafeSlice #-}---instance ( Prim e-         , Index ix-         , Index (Lower ix)-         , Elt P ix e ~ Elt M ix e-         , Elt M ix e ~ Array M (Lower ix) e-         ) =>-         Slice P ix e where-  unsafeSlice arr = unsafeSlice (toManifest arr)-  {-# INLINE unsafeSlice #-}--instance {-# OVERLAPPING #-} Prim e => OuterSlice P Ix1 e where-  unsafeOuterSlice = unsafeLinearIndex+  unsafeOuterSlice (PArray c _ o a) szL i =+    PArray c szL (i * totalElem szL + o) a   {-# INLINE unsafeOuterSlice #-} -instance ( Prim e-         , Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt P ix e ~ Array M (Lower ix) e-         ) =>-         OuterSlice P ix e where-  unsafeOuterSlice arr = unsafeOuterSlice (toManifest arr)-  {-# INLINE unsafeOuterSlice #-}+  unsafeLinearSlice i k (PArray c _ o a) = PArray c k (i + o) a+  {-# INLINE unsafeLinearSlice #-}  -instance {-# OVERLAPPING #-} Prim e => InnerSlice P Ix1 e where-  unsafeInnerSlice arr _ = unsafeLinearIndex arr-  {-# INLINE unsafeInnerSlice #-}--instance ( Prim e-         , Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt P ix e ~ Array M (Lower ix) e-         ) =>-         InnerSlice P ix e where-  unsafeInnerSlice arr = unsafeInnerSlice (toManifest arr)-  {-# INLINE unsafeInnerSlice #-}--instance (Index ix, Prim e) => Manifest P ix e where+instance Prim e => Manifest P e where    unsafeLinearIndexM _pa@(PArray _ _sz o a) i =     INDEX_CHECK("(Manifest P ix e).unsafeLinearIndexM",                 const (Sz (totalElem _sz)), indexByteArray) a (i + o)   {-# INLINE unsafeLinearIndexM #-} +  sizeOfMArray (MPArray sz _ _) = sz+  {-# INLINE sizeOfMArray #-} -instance (Index ix, Prim e) => Mutable P ix e where-  data MArray s P ix e = MPArray !(Sz ix) {-# UNPACK #-} !Int {-# UNPACK #-} !(MutableByteArray s)+  unsafeResizeMArray sz (MPArray _ off marr) = MPArray sz off marr+  {-# INLINE unsafeResizeMArray #-} -  msize (MPArray sz _ _) = sz-  {-# INLINE msize #-}+  unsafeLinearSliceMArray i k (MPArray _ o a) = MPArray k (i + o) a+  {-# INLINE unsafeLinearSliceMArray #-}    unsafeThaw (PArray _ sz o a) = MPArray sz o <$> unsafeThawByteArray a   {-# INLINE unsafeThaw #-}@@ -209,12 +173,12 @@   {-# INLINE initialize #-}    unsafeLinearRead _mpa@(MPArray _sz o ma) i =-    INDEX_CHECK("(Mutable P ix e).unsafeLinearRead",+    INDEX_CHECK("(Manifest P ix e).unsafeLinearRead",                 const (Sz (totalElem _sz)), readByteArray) ma (i + o)   {-# INLINE unsafeLinearRead #-}    unsafeLinearWrite _mpa@(MPArray _sz o ma) i =-    INDEX_CHECK("(Mutable P ix e).unsafeLinearWrite",+    INDEX_CHECK("(Manifest P ix e).unsafeLinearWrite",                 const (Sz (totalElem _sz)), writeByteArray) ma (i + o)   {-# INLINE unsafeLinearWrite #-} @@ -237,19 +201,20 @@   {-# INLINE unsafeLinearShrink #-}    unsafeLinearGrow (MPArray _ o ma) sz =-    MPArray sz o <$> resizeMutableByteArrayCompat ma ((o + totalElem sz) * sizeOf (undefined :: e))+    MPArray sz o <$> resizeMutableByteArray ma ((o + totalElem sz) * sizeOf (undefined :: e))   {-# INLINE unsafeLinearGrow #-}   instance (Prim e, Index ix) => Load P ix e where-  type R P = M-  size = pSize-  {-# INLINE size #-}-  getComp = pComp-  {-# INLINE getComp #-}-  loadArrayM !scheduler !arr =+  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)+  {-# INLINE makeArrayLinear #-}++  replicate comp !sz !e = runST (newMArray sz e >>= unsafeFreeze comp)+  {-# INLINE replicate #-}++  iterArrayLinearST_ !scheduler !arr =     splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)-  {-# INLINE loadArrayM #-}+  {-# INLINE iterArrayLinearST_ #-}  instance (Prim e, Index ix) => StrideLoad P ix e @@ -278,13 +243,7 @@ instance (Prim e, Floating e) => NumericFloat P e  -instance ( Prim e-         , IsList (Array L ix e)-         , Nested LN ix e-         , Nested L ix e-         , Ragged L ix e-         ) =>-         IsList (Array P ix e) where+instance (Prim e, IsList (Array L ix e), Ragged L ix e) => IsList (Array P ix e) where   type Item (Array P ix e) = Item (Array L ix e)   fromList = A.fromLists' Seq   {-# INLINE fromList #-}@@ -647,27 +606,3 @@   mba   (o + toLinearIndex sz ix) {-# INLINE unsafeAtomicXorIntArray #-}---#if !MIN_VERSION_primitive(0,7,1)-shrinkMutableByteArray :: forall m. (PrimMonad m)-  => MutableByteArray (PrimState m)-  -> Int -- ^ new size-  -> m ()-shrinkMutableByteArray (MutableByteArray arr#) (I# n#)-  = primitive_ (shrinkMutableByteArray# arr# n#)-{-# INLINE shrinkMutableByteArray #-}-#endif--resizeMutableByteArrayCompat ::-  PrimMonad m => MutableByteArray (PrimState m) -> Int -> m (MutableByteArray (PrimState m))-#if MIN_VERSION_primitive(0,6,4)-resizeMutableByteArrayCompat = resizeMutableByteArray-#else-resizeMutableByteArrayCompat (MutableByteArray arr#) (I# n#) =-  primitive-    (\s# ->-       case resizeMutableByteArray# arr# n# s# of-         (# s'#, arr'# #) -> (# s'#, MutableByteArray arr'# #))-#endif-{-# INLINE resizeMutableByteArrayCompat #-}

@@ -18,6 +18,7 @@ module Data.Massiv.Array.Manifest.Storable   ( S (..)   , Array(..)+  , MArray(..)   , Storable   , toStorableVector   , toStorableMVector@@ -36,51 +37,57 @@  import Control.DeepSeq (NFData(..), deepseq) import Control.Exception+import Control.Monad import Control.Monad.IO.Unlift-import Control.Monad.Primitive (unsafePrimToPrim)+import Control.Monad.Primitive import Data.Massiv.Array.Delayed.Pull (compareArrays, eqArrays) import Data.Massiv.Array.Manifest.Internal import Data.Massiv.Array.Manifest.List as A-import Data.Massiv.Array.Manifest.Primitive (shrinkMutableByteArray) import Data.Massiv.Array.Mutable import Data.Massiv.Core.Common import Data.Massiv.Core.List import Data.Massiv.Core.Operations import Data.Massiv.Vector.Stream as S (isteps, steps)-import Data.Primitive.ByteArray (MutableByteArray(..))-import qualified Data.Vector.Generic.Mutable as VGM-import qualified Data.Vector.Storable as VS-import qualified Data.Vector.Storable.Mutable as MVS-import Foreign.ForeignPtr (newForeignPtr, withForeignPtr)+import Data.Primitive.Ptr (setPtr)+import Data.Primitive.ByteArray+import Foreign.ForeignPtr import Foreign.Marshal.Alloc import Foreign.Marshal.Array (advancePtr, copyArray) import Foreign.Ptr import Foreign.Storable import GHC.Exts as GHC (IsList(..))-import GHC.ForeignPtr (ForeignPtr(..), ForeignPtrContents(..))+import GHC.ForeignPtr import Prelude hiding (mapM) import System.IO.Unsafe (unsafePerformIO)+import Data.Word+import Unsafe.Coerce +import qualified Data.Vector.Generic.Mutable as MVG+import qualified Data.Vector.Storable as VS+import qualified Data.Vector.Storable.Mutable as MVS+ #include "massiv.h"  -- | Representation for `Storable` elements data S = S deriving Show -data instance Array S ix e = SArray { sComp :: !Comp-                                    , sSize :: !(Sz ix)-                                    , sData :: !(VS.Vector e)+data instance Array S ix e = SArray { sComp   :: !Comp+                                    , sSize   :: !(Sz ix)+                                    , sData   :: {-# UNPACK #-} !(ForeignPtr e)                                     } +data instance MArray s S ix e = MSArray !(Sz ix) {-# UNPACK #-} !(ForeignPtr e)+ instance (Ragged L ix e, Show e, Storable e) => Show (Array S ix e) where   showsPrec = showsArrayPrec id   showList = showArrayList  instance NFData ix => NFData (Array S ix e) where-  rnf (SArray c sz v) = c `deepseq` sz `deepseq` v `deepseq` ()+  rnf (SArray c sz _v) = c `deepseq` sz `deepseq` ()   {-# INLINE rnf #-}  instance NFData ix => NFData (MArray s S ix e) where-  rnf (MSArray sz mv) = sz `deepseq` mv `deepseq` ()+  rnf (MSArray sz _mv) = sz `deepseq` ()   {-# INLINE rnf #-}  instance (Storable e, Eq e, Index ix) => Eq (Array S ix e) where@@ -91,98 +98,95 @@   compare = compareArrays compare   {-# INLINE compare #-} -instance (Storable e, Index ix) => Construct S ix e where+instance Strategy S where+  getComp = sComp+  {-# INLINE getComp #-}   setComp c arr = arr { sComp = c }   {-# INLINE setComp #-} -  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)-  {-# INLINE makeArrayLinear #-}--  replicate comp !sz !e = runST (newMArray sz e >>= unsafeFreeze comp)-  {-# INLINE replicate #-}+advanceForeignPtr :: forall e . Storable e => ForeignPtr e -> Int -> ForeignPtr e+advanceForeignPtr fp i = plusForeignPtr fp (i * sizeOf (undefined :: e))+{-# INLINE advanceForeignPtr #-} +indexForeignPtr :: Storable e => ForeignPtr e -> Int -> e+indexForeignPtr fp i = unsafeInlineIO $ unsafeWithForeignPtr fp $ \p -> peekElemOff p i+{-# INLINE indexForeignPtr #-} -instance (Storable e, Index ix) => Source S ix e where-  unsafeLinearIndex (SArray _ _ v) =-    INDEX_CHECK("(Source S ix e).unsafeLinearIndex", Sz . VS.length, VS.unsafeIndex) v+instance Storable e => Source S e where+  unsafeLinearIndex (SArray _ _sz fp) =+    INDEX_CHECK("(Source S ix e).unsafeLinearIndex", const (toLinearSz _sz), indexForeignPtr) fp   {-# INLINE unsafeLinearIndex #-}-  unsafeLinearSlice i k (SArray c _ v) = SArray c k $ VS.unsafeSlice i (unSz k) v-  {-# INLINE unsafeLinearSlice #-} -instance Index ix => Resize S ix where-  unsafeResize !sz !arr = arr { sSize = sz }-  {-# INLINE unsafeResize #-}--instance (Storable e, Index ix) => Extract S ix e where-  unsafeExtract !sIx !newSz !arr = unsafeExtract sIx newSz (toManifest arr)-  {-# INLINE unsafeExtract #-}----instance ( Storable e-         , Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt S ix e ~ Array M (Lower ix) e-         ) =>-         OuterSlice S ix e where-  unsafeOuterSlice arr = unsafeOuterSlice (toManifest arr)+  unsafeOuterSlice (SArray c _ fp) szL i =+    let k = totalElem szL+    in SArray c szL $ advanceForeignPtr fp (i * k)   {-# INLINE unsafeOuterSlice #-} -instance ( Storable e-         , Index ix-         , Index (Lower ix)-         , Elt M ix e ~ Array M (Lower ix) e-         , Elt S ix e ~ Array M (Lower ix) e-         ) =>-         InnerSlice S ix e where-  unsafeInnerSlice arr = unsafeInnerSlice (toManifest arr)-  {-# INLINE unsafeInnerSlice #-}+  unsafeLinearSlice i k (SArray c _ fp) =+    SArray c k $ advanceForeignPtr fp i+  {-# INLINE unsafeLinearSlice #-} -instance {-# OVERLAPPING #-} Storable e => Slice S Ix1 e where-  unsafeSlice arr i _ _ = pure (unsafeLinearIndex arr i)-  {-# INLINE unsafeSlice #-}+instance Index ix => Shape S ix where+  maxLinearSize = Just . SafeSz . elemsCount+  {-# INLINE maxLinearSize #-} +instance Size S where+  size = sSize+  {-# INLINE size #-}+  unsafeResize !sz !arr = arr { sSize = sz }+  {-# INLINE unsafeResize #-} -instance (Index ix, Storable e) => Manifest S ix e where -  unsafeLinearIndexM (SArray _ _ v) =-    INDEX_CHECK("(Manifest S ix e).unsafeLinearIndexM", Sz . VS.length, VS.unsafeIndex) v+instance Storable e => Manifest S e where++  unsafeLinearIndexM (SArray _ _sz fp) =+    INDEX_CHECK("(Source S ix e).unsafeLinearIndex", const (toLinearSz _sz), indexForeignPtr) fp   {-# INLINE unsafeLinearIndexM #-} +  sizeOfMArray (MSArray sz _) = sz+  {-# INLINE sizeOfMArray #-} -instance (Index ix, Storable e) => Mutable S ix e where-  data MArray s S ix e = MSArray !(Sz ix) !(VS.MVector s e)+  unsafeResizeMArray sz (MSArray _ fp) = MSArray sz fp+  {-# INLINE unsafeResizeMArray #-} -  msize (MSArray sz _) = sz-  {-# INLINE msize #-}+  unsafeLinearSliceMArray i k (MSArray _ fp) = MSArray k $ advanceForeignPtr fp i+  {-# INLINE unsafeLinearSliceMArray #-} -  unsafeThaw (SArray _ sz v) = MSArray sz <$> VS.unsafeThaw v+  unsafeThaw (SArray _ sz fp) = pure $ MSArray sz fp   {-# INLINE unsafeThaw #-} -  unsafeFreeze comp (MSArray sz v) = SArray comp sz <$> VS.unsafeFreeze v+  unsafeFreeze comp (MSArray sz v) = pure $ SArray comp sz v   {-# INLINE unsafeFreeze #-} -  unsafeNew sz = MSArray sz <$> MVS.unsafeNew (totalElem sz)+  unsafeNew sz = do+    let !n = totalElem sz+        dummy = undefined :: e+        !eSize = sizeOf dummy+    when (n > (maxBound :: Int) `div` eSize) $ error $ "Array size is too big: " ++ show sz+    unsafeIOToPrim $ do+      fp <- mallocPlainForeignPtrAlignedBytes (n * sizeOf dummy) (alignment dummy)+      pure $ MSArray sz fp   {-# INLINE unsafeNew #-} -  initialize (MSArray _ marr) = VGM.basicInitialize marr+  initialize (MSArray sz fp) =+    unsafeIOToPrim $+      unsafeWithForeignPtr fp $ \p ->+        setPtr (castPtr p) (totalElem sz * sizeOf (undefined :: e)) (0 :: Word8)   {-# INLINE initialize #-} -  unsafeLinearRead (MSArray _ mv) =-    INDEX_CHECK("(Mutable S ix e).unsafeLinearRead", Sz . MVS.length, MVS.unsafeRead) mv+  unsafeLinearRead (MSArray _sz fp) o = unsafeIOToPrim $+    INDEX_CHECK("(Manifest S ix e).unsafeLinearRead", const (toLinearSz _sz), (\_ _ -> unsafeWithForeignPtr fp (`peekElemOff` o))) fp o   {-# INLINE unsafeLinearRead #-} -  unsafeLinearWrite (MSArray _ mv) =-    INDEX_CHECK("(Mutable S ix e).unsafeLinearWrite", Sz . MVS.length, MVS.unsafeWrite) mv+  unsafeLinearWrite (MSArray _sz fp) o e = unsafeIOToPrim $+    INDEX_CHECK("(Manifest S ix e).unsafeLinearWrite", const (toLinearSz _sz), (\_ _ -> unsafeWithForeignPtr fp (\p -> pokeElemOff p o e))) fp o   {-# INLINE unsafeLinearWrite #-} -  unsafeLinearSet (MSArray _ mv) i k = VGM.basicSet (MVS.unsafeSlice i (unSz k) mv)+  unsafeLinearSet (MSArray _ fp) i k =+    MVG.basicSet (MVS.unsafeFromForeignPtr0 (advanceForeignPtr fp i) (unSz k))   {-# INLINE unsafeLinearSet #-} -  unsafeLinearCopy marrFrom iFrom marrTo iTo (Sz k) = do-    let MSArray _ (MVS.MVector _ fpFrom) = marrFrom-        MSArray _ (MVS.MVector _ fpTo) = marrTo+  unsafeLinearCopy (MSArray _ fpFrom) iFrom (MSArray _ fpTo) iTo (Sz k) = do     unsafePrimToPrim $       withForeignPtr fpFrom $ \ ptrFrom ->         withForeignPtr fpTo $ \ ptrTo -> do@@ -196,33 +200,30 @@     unsafeLinearCopy marrFrom iFrom marrTo iTo sz   {-# INLINE unsafeArrayLinearCopy #-} -  unsafeLinearShrink marr@(MSArray _ mv@(MVS.MVector _ (ForeignPtr _ fpc))) sz = do+  unsafeLinearShrink marr@(MSArray _ fp@(ForeignPtr _ fpc)) sz = do     let shrinkMBA :: MutableByteArray RealWorld -> IO ()         shrinkMBA mba = shrinkMutableByteArray mba (totalElem sz * sizeOf (undefined :: e))         {-# INLINE shrinkMBA #-}     case fpc of       MallocPtr mba# _ -> do         unsafePrimToPrim $ shrinkMBA (MutableByteArray mba#)-        pure $ MSArray sz mv+        pure $ MSArray sz fp       PlainPtr mba# -> do         unsafePrimToPrim $ shrinkMBA (MutableByteArray mba#)-        pure $ MSArray sz mv+        pure $ MSArray sz fp       _ -> unsafeDefaultLinearShrink marr sz   {-# INLINE unsafeLinearShrink #-} -  unsafeLinearGrow (MSArray oldSz mv) sz =-    MSArray sz <$> MVS.unsafeGrow mv (totalElem sz - totalElem oldSz)-  {-# INLINE unsafeLinearGrow #-}+instance (Index ix, Storable e) => Load S ix e where+  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)+  {-# INLINE makeArrayLinear #-} +  replicate comp !sz !e = runST (newMArray sz e >>= unsafeFreeze comp)+  {-# INLINE replicate #-} -instance (Index ix, Storable e) => Load S ix e where-  type R S = M-  size = sSize-  {-# INLINE size #-}-  getComp = sComp-  {-# INLINE getComp #-}-  loadArrayM !scheduler !arr = splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)-  {-# INLINE loadArrayM #-}+  iterArrayLinearST_ !scheduler !arr =+    splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)+  {-# INLINE iterArrayLinearST_ #-}  instance (Index ix, Storable e) => StrideLoad S ix e @@ -250,13 +251,7 @@ instance (Storable e, Floating e) => NumericFloat S e  -instance ( Storable e-         , IsList (Array L ix e)-         , Nested LN ix e-         , Nested L ix e-         , Ragged L ix e-         ) =>-         IsList (Array S ix e) where+instance (Storable e, IsList (Array L ix e), Ragged L ix e) => IsList (Array S ix e) where   type Item (Array S ix e) = Item (Array L ix e)   fromList = A.fromLists' Seq   {-# INLINE fromList #-}@@ -267,69 +262,75 @@ -- referential transparency. -- -- @since 0.1.3-unsafeWithPtr :: (MonadUnliftIO m, Storable a) => Array S ix a -> (Ptr a -> m b) -> m b-unsafeWithPtr arr f = withRunInIO $ \run -> VS.unsafeWith (sData arr) (run . f)+unsafeWithPtr :: MonadUnliftIO m => Array S ix e -> (Ptr e -> m b) -> m b+unsafeWithPtr arr f = withRunInIO $ \run -> unsafeWithForeignPtr (sData arr) (run . f) {-# INLINE unsafeWithPtr #-}   -- | A pointer to the beginning of the mutable array. -- -- @since 0.1.3-withPtr :: (MonadUnliftIO m, Storable a) => MArray RealWorld S ix a -> (Ptr a -> m b) -> m b-withPtr (MSArray _ mv) f = withRunInIO $ \run -> MVS.unsafeWith mv (run . f)+withPtr :: MonadUnliftIO m => MArray RealWorld S ix e -> (Ptr e -> m b) -> m b+withPtr (MSArray _ fp) f = withRunInIO $ \run -> unsafeWithForeignPtr fp (run . f) {-# INLINE withPtr #-}   -- | /O(1)/ - Unwrap storable array and pull out the underlying storable vector. -- -- @since 0.2.1-toStorableVector :: Array S ix e -> VS.Vector e-toStorableVector = sData+toStorableVector :: Index ix => Array S ix e -> VS.Vector e+toStorableVector arr =+  unsafeCoerce $ -- this hack is needed to workaround the redundant Storable constraint+                 -- see haskell/vector#394+  VS.unsafeFromForeignPtr0 (castForeignPtr (sData arr) :: ForeignPtr Word) (totalElem (sSize arr)) {-# INLINE toStorableVector #-}   -- | /O(1)/ - Unwrap storable mutable array and pull out the underlying storable mutable vector. -- -- @since 0.2.1-toStorableMVector :: MArray s S ix e -> VS.MVector s e-toStorableMVector (MSArray _ mv) = mv+toStorableMVector :: Index ix => MArray s S ix e -> VS.MVector s e+toStorableMVector (MSArray sz fp) = MVS.MVector (totalElem sz) fp {-# INLINE toStorableMVector #-}  -- | /O(1)/ - Cast a storable vector to a storable array. -- -- @since 0.5.0-fromStorableVector :: Storable e => Comp -> VS.Vector e -> Array S Ix1 e-fromStorableVector comp v = SArray {sComp = comp, sSize = SafeSz (VS.length v), sData = v}+fromStorableVector :: Comp -> VS.Vector e -> Vector S e+fromStorableVector comp v =+  -- unasfeCoerce hack below is needed to workaround the redundant Storable+  -- constraint see haskell/vector#394+  case VS.unsafeToForeignPtr0 (unsafeCoerce v :: VS.Vector Word) of+    (fp, k) -> SArray {sComp = comp, sSize = SafeSz k, sData = castForeignPtr fp} {-# INLINE fromStorableVector #-}  -- | /O(1)/ - Cast a mutable storable vector to a mutable storable array. -- -- @since 0.5.0-fromStorableMVector :: MVS.MVector s e -> MArray s S Ix1 e-fromStorableMVector mv@(MVS.MVector len _) = MSArray (SafeSz len) mv+fromStorableMVector :: MVS.MVector s e -> MVector s S e+fromStorableMVector (MVS.MVector n fp) = MSArray (SafeSz n) fp {-# INLINE fromStorableMVector #-}   -- | /O(1)/ - Yield the underlying `ForeignPtr` together with its length. -- -- @since 0.3.0-unsafeArrayToForeignPtr :: Storable e => Array S ix e -> (ForeignPtr e, Int)-unsafeArrayToForeignPtr = VS.unsafeToForeignPtr0 . toStorableVector+unsafeArrayToForeignPtr :: Index ix => Array S ix e -> (ForeignPtr e, Int)+unsafeArrayToForeignPtr (SArray _ sz fp) = (fp, totalElem sz) {-# INLINE unsafeArrayToForeignPtr #-}  -- | /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)-unsafeMArrayToForeignPtr = MVS.unsafeToForeignPtr0 . toStorableMVector+unsafeMArrayToForeignPtr :: Index ix => MArray s S ix e -> (ForeignPtr e, Int)+unsafeMArrayToForeignPtr (MSArray sz fp) = (fp, totalElem sz) {-# INLINE unsafeMArrayToForeignPtr #-}  -- | /O(1)/ - Wrap a `ForeignPtr` and it's size into a pure storable array. -- -- @since 0.3.0-unsafeArrayFromForeignPtr0 :: Storable e => Comp -> ForeignPtr e -> Sz1 -> Array S Ix1 e-unsafeArrayFromForeignPtr0 comp ptr sz =-  SArray {sComp = comp, sSize = sz, sData = VS.unsafeFromForeignPtr0 ptr (unSz sz)}+unsafeArrayFromForeignPtr0 :: Comp -> ForeignPtr e -> Sz1 -> Vector S e+unsafeArrayFromForeignPtr0 comp fp sz = SArray {sComp = comp, sSize = sz, sData = fp} {-# INLINE unsafeArrayFromForeignPtr0 #-}  -- | /O(1)/ - Wrap a `ForeignPtr`, an offset and it's size into a pure storable array.@@ -337,7 +338,7 @@ -- @since 0.3.0 unsafeArrayFromForeignPtr :: Storable e => Comp -> ForeignPtr e -> Int -> Sz1 -> Array S Ix1 e unsafeArrayFromForeignPtr comp ptr offset sz =-  SArray {sComp = comp, sSize = sz, sData = VS.unsafeFromForeignPtr ptr offset (unSz sz)}+  SArray {sComp = comp, sSize = sz, sData = advanceForeignPtr ptr offset} {-# INLINE unsafeArrayFromForeignPtr #-}  @@ -345,9 +346,8 @@ -- 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-unsafeMArrayFromForeignPtr0 fp sz =-  MSArray sz (MVS.unsafeFromForeignPtr0 fp (unSz sz))+unsafeMArrayFromForeignPtr0 :: ForeignPtr e -> Sz1 -> MArray s S Ix1 e+unsafeMArrayFromForeignPtr0 fp sz = MSArray sz fp {-# INLINE unsafeMArrayFromForeignPtr0 #-}  @@ -356,8 +356,7 @@ -- -- @since 0.3.0 unsafeMArrayFromForeignPtr :: Storable e => ForeignPtr e -> Int -> Sz1 -> MArray s S Ix1 e-unsafeMArrayFromForeignPtr fp offset sz =-  MSArray sz (MVS.unsafeFromForeignPtr fp offset (unSz sz))+unsafeMArrayFromForeignPtr fp offset sz = MSArray sz (advanceForeignPtr fp offset) {-# INLINE unsafeMArrayFromForeignPtr #-}  @@ -366,13 +365,24 @@ -- -- @since 0.5.9 unsafeMallocMArray ::-     forall ix e m. (Index ix, Storable e, MonadIO m)+     forall ix e m. (Index ix, Storable e, PrimMonad m)   => Sz ix-  -> m (MArray RealWorld S ix e)-unsafeMallocMArray sz = liftIO $ do+  -> m (MArray (PrimState m) S ix e)+unsafeMallocMArray sz = unsafePrimToPrim $ do   let n = totalElem sz   foreignPtr <- mask_ $ do     ptr <- mallocBytes (sizeOf (undefined :: e) * n)     newForeignPtr finalizerFree ptr-  pure $ MSArray sz (MVS.unsafeFromForeignPtr0 foreignPtr n)+  pure $ MSArray sz foreignPtr {-# INLINE unsafeMallocMArray #-}+++#if !MIN_VERSION_base(4,15,0)+-- | A compatibility wrapper for 'GHC.ForeignPtr.unsafeWithForeignPtr' provided+-- by GHC 9.0.1 and later.+--+-- Only to be used when the continuation is known not to+-- unconditionally diverge lest unsoundness can result.+unsafeWithForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b+unsafeWithForeignPtr = withForeignPtr+#endif

@@ -16,8 +16,9 @@ -- module Data.Massiv.Array.Manifest.Unboxed   ( U (..)-  , VU.Unbox+  , Unbox   , Array(..)+  , MArray(..)   , toUnboxedVector   , toUnboxedMVector   , fromUnboxedVector@@ -26,13 +27,13 @@  import Control.DeepSeq (NFData(..), deepseq) import Data.Massiv.Array.Delayed.Pull (eqArrays, compareArrays)-import Data.Massiv.Array.Manifest.Internal (M, toManifest) import Data.Massiv.Array.Manifest.List as A import Data.Massiv.Vector.Stream as S (steps, isteps) import Data.Massiv.Array.Mutable import Data.Massiv.Core.Common import Data.Massiv.Core.List import Data.Massiv.Core.Operations+import Data.Vector.Unboxed (Unbox) import qualified Data.Vector.Generic.Mutable as VGM import qualified Data.Vector.Unboxed as VU import qualified Data.Vector.Unboxed.Mutable as MVU@@ -49,8 +50,9 @@                                     , uSize :: !(Sz ix)                                     , uData :: !(VU.Vector e)                                     }+data instance MArray s U ix e = MUArray !(Sz ix) !(VU.MVector s e) -instance (Ragged L ix e, Show e, VU.Unbox e) => Show (Array U ix e) where+instance (Ragged L ix e, Show e, Unbox e) => Show (Array U ix e) where   showsPrec = showsArrayPrec id   showList = showArrayList @@ -62,110 +64,76 @@   rnf (MUArray sz mv) = sz `deepseq` mv `deepseq` ()   {-# INLINE rnf #-} -instance (VU.Unbox e, Index ix) => Construct U ix e where+instance Strategy U where+  getComp = uComp+  {-# INLINE getComp #-}   setComp c arr = arr { uComp = c }   {-# INLINE setComp #-} -  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)-  {-# INLINE makeArrayLinear #-} -  replicate comp !sz !e = runST (newMArray sz e >>= unsafeFreeze comp)-  {-# INLINE replicate #-}---instance (VU.Unbox e, Eq e, Index ix) => Eq (Array U ix e) where+instance (Unbox e, Eq e, Index ix) => Eq (Array U ix e) where   (==) = eqArrays (==)   {-# INLINE (==) #-} -instance (VU.Unbox e, Ord e, Index ix) => Ord (Array U ix e) where+instance (Unbox e, Ord e, Index ix) => Ord (Array U ix e) where   compare = compareArrays compare   {-# INLINE compare #-}  -instance (VU.Unbox e, Index ix) => Source U ix e where+instance Unbox e => Source U e where   unsafeLinearIndex (UArray _ _ v) =     INDEX_CHECK("(Source U ix e).unsafeLinearIndex", Sz . VU.length, VU.unsafeIndex) v   {-# INLINE unsafeLinearIndex #-}++  unsafeOuterSlice (UArray c _ v) szL i =+    let k = totalElem szL+    in UArray c szL $ VU.unsafeSlice (i * k) k v+  {-# INLINE unsafeOuterSlice #-}+   unsafeLinearSlice i k (UArray c _ v) = UArray c k $ VU.unsafeSlice i (unSz k) v   {-# INLINE unsafeLinearSlice #-} +instance Index ix => Shape U ix where+  maxLinearSize = Just . SafeSz . elemsCount+  {-# INLINE maxLinearSize #-} -instance Index ix => Resize U ix where+instance Size U where+  size = uSize+  {-# INLINE size #-}   unsafeResize !sz !arr = arr { uSize = sz }   {-# INLINE unsafeResize #-} -instance (VU.Unbox e, Index ix) => Extract U ix e where-  unsafeExtract !sIx !newSz !arr = unsafeExtract sIx newSz (toManifest arr)-  {-# INLINE unsafeExtract #-}+instance (Unbox e, Index ix) => Load U ix e where+  makeArrayLinear !comp !sz f = unsafePerformIO $ generateArrayLinear comp sz (pure . f)+  {-# INLINE makeArrayLinear #-} -instance (VU.Unbox e, Index ix) => Load U ix e where-  type R U = M-  size = uSize-  {-# INLINE size #-}-  getComp = uComp-  {-# INLINE getComp #-}-  loadArrayM !scheduler !arr = splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)-  {-# INLINE loadArrayM #-}+  replicate comp !sz !e = runST (newMArray sz e >>= unsafeFreeze comp)+  {-# INLINE replicate #-} -instance (VU.Unbox e, Index ix) => StrideLoad U ix e+  iterArrayLinearST_ !scheduler !arr =+    splitLinearlyWith_ scheduler (elemsCount arr) (unsafeLinearIndex arr)+  {-# INLINE iterArrayLinearST_ #-} +instance (Unbox e, Index ix) => StrideLoad U ix e -instance {-# OVERLAPPING #-} VU.Unbox e => Slice U Ix1 e where-  unsafeSlice arr i _ _ = pure (unsafeLinearIndex arr i)-  {-# INLINE unsafeSlice #-}  -instance ( VU.Unbox e-         , Index ix-         , Index (Lower ix)-         , Elt U ix e ~ Elt M ix e-         , Elt M ix e ~ Array M (Lower ix) e-         ) =>-         Slice U ix e where-  unsafeSlice arr = unsafeSlice (toManifest arr)-  {-# INLINE unsafeSlice #-}  -instance {-# OVERLAPPING #-} VU.Unbox e => OuterSlice U Ix1 e where-  unsafeOuterSlice = unsafeLinearIndex-  {-# INLINE unsafeOuterSlice #-}--instance ( VU.Unbox e-         , Index ix-         , Index (Lower ix)-         , Elt U ix e ~ Elt M ix e-         , Elt M ix e ~ Array M (Lower ix) e-         ) =>-         OuterSlice U ix e where-  unsafeOuterSlice arr = unsafeOuterSlice (toManifest arr)-  {-# INLINE unsafeOuterSlice #-}--instance {-# OVERLAPPING #-} VU.Unbox e => InnerSlice U Ix1 e where-  unsafeInnerSlice arr _ = unsafeLinearIndex arr-  {-# INLINE unsafeInnerSlice #-}--instance ( VU.Unbox e-         , Index ix-         , Index (Lower ix)-         , Elt U ix e ~ Elt M ix e-         , Elt M ix e ~ Array M (Lower ix) e-         ) =>-         InnerSlice U ix e where-  unsafeInnerSlice arr = unsafeInnerSlice (toManifest arr)-  {-# INLINE unsafeInnerSlice #-}--instance (VU.Unbox e, Index ix) => Manifest U ix e where+instance Unbox e => Manifest U e where    unsafeLinearIndexM (UArray _ _ v) =     INDEX_CHECK("(Manifest U ix e).unsafeLinearIndexM", Sz . VU.length, VU.unsafeIndex) v   {-# INLINE unsafeLinearIndexM #-} +  sizeOfMArray (MUArray sz _) = sz+  {-# INLINE sizeOfMArray #-} -instance (VU.Unbox e, Index ix) => Mutable U ix e where-  data MArray s U ix e = MUArray !(Sz ix) !(VU.MVector s e)+  unsafeResizeMArray sz (MUArray _ mv) = MUArray sz mv+  {-# INLINE unsafeResizeMArray #-} -  msize (MUArray sz _) = sz-  {-# INLINE msize #-}+  unsafeLinearSliceMArray i k (MUArray _ mv) = MUArray k $ MVU.unsafeSlice i (unSz k) mv+  {-# INLINE unsafeLinearSliceMArray #-}    unsafeThaw (UArray _ sz v) = MUArray sz <$> VU.unsafeThaw v   {-# INLINE unsafeThaw #-}@@ -184,31 +152,25 @@   {-# INLINE unsafeLinearCopy #-}    unsafeLinearRead (MUArray _ mv) =-    INDEX_CHECK("(Mutable U ix e).unsafeLinearRead", Sz . MVU.length, MVU.unsafeRead) mv+    INDEX_CHECK("(Manifest U ix e).unsafeLinearRead", Sz . MVU.length, MVU.unsafeRead) mv   {-# INLINE unsafeLinearRead #-}    unsafeLinearWrite (MUArray _ mv) =-    INDEX_CHECK("(Mutable U ix e).unsafeLinearWrite", Sz . MVU.length, MVU.unsafeWrite) mv+    INDEX_CHECK("(Manifest U ix e).unsafeLinearWrite", Sz . MVU.length, MVU.unsafeWrite) mv   {-# INLINE unsafeLinearWrite #-}    unsafeLinearGrow (MUArray _ mv) sz = MUArray sz <$> MVU.unsafeGrow mv (totalElem sz)   {-# INLINE unsafeLinearGrow #-}  -instance (Index ix, VU.Unbox e) => Stream U ix e where+instance (Index ix, Unbox e) => Stream U ix e where   toStream = S.steps   {-# INLINE toStream #-}   toStreamIx = S.isteps   {-# INLINE toStreamIx #-}  -instance ( VU.Unbox e-         , IsList (Array L ix e)-         , Nested LN ix e-         , Nested L ix e-         , Ragged L ix e-         ) =>-         IsList (Array U ix e) where+instance (Unbox e, IsList (Array L ix e), Ragged L ix e) => IsList (Array U ix e) where   type Item (Array U ix e) = Item (Array L ix e)   fromList = A.fromLists' Seq   {-# INLINE fromList #-}@@ -251,7 +213,7 @@ -- | /O(1)/ - Wrap an unboxed vector and produce an unboxed flat array. -- -- @since 0.6.0-fromUnboxedVector :: VU.Unbox e => Comp -> VU.Vector e -> Array U Ix1 e+fromUnboxedVector :: VU.Unbox e => Comp -> VU.Vector e -> Vector U e fromUnboxedVector comp v = UArray comp (SafeSz (VU.length v)) v {-# INLINE fromUnboxedVector #-} @@ -259,6 +221,6 @@ -- | /O(1)/ - Wrap an unboxed mutable vector and produce a mutable unboxed flat array. -- -- @since 0.5.0-fromUnboxedMVector :: VU.Unbox e => VU.MVector s e -> MArray s U Ix1 e+fromUnboxedMVector :: Unbox e => VU.MVector s e -> MVector s U e fromUnboxedMVector mv = MUArray (SafeSz (MVU.length mv)) mv {-# INLINE fromUnboxedMVector #-}

@@ -23,12 +23,12 @@   ) where  import Control.Monad (guard, join, msum)+import Data.Kind import Data.Massiv.Array.Manifest.Boxed import Data.Massiv.Array.Manifest.Internal import Data.Massiv.Array.Manifest.Primitive import Data.Massiv.Array.Manifest.Storable import Data.Massiv.Array.Manifest.Unboxed-import Data.Massiv.Array.Mutable import Data.Massiv.Core.Common import Data.Maybe (fromMaybe) import Data.Typeable@@ -39,19 +39,19 @@ import qualified Data.Vector.Unboxed as VU  -- | Match vector type to array representation-type family ARepr (v :: * -> *) :: * where+type family ARepr (v :: Type -> Type) :: Type where   ARepr VU.Vector = U   ARepr VS.Vector = S   ARepr VP.Vector = P   ARepr VB.Vector = BL  -- | Match array representation to a vector type-type family VRepr r :: * -> * where+type family VRepr r :: Type -> Type where   VRepr U = VU.Vector   VRepr S = VS.Vector   VRepr P = VP.Vector   VRepr B = VB.Vector-  VRepr N = VB.Vector+  VRepr BN = VB.Vector   VRepr BL = VB.Vector  @@ -59,7 +59,7 @@ -- return `Nothing` if there is a size mismatch or if some non-standard vector type is -- supplied. Is suppplied is the boxed `Data.Vector.Vector` then it's all elements will be -- evaluated toWHNF, therefore complexity will be /O(n)/-castFromVector :: forall v r ix e. (VG.Vector v e, Typeable v, Mutable r ix e, ARepr v ~ r)+castFromVector :: forall v r ix e. (VG.Vector v e, Typeable v, Index ix, ARepr v ~ r)                => Comp                -> Sz ix -- ^ Size of the result Array                -> v e -- ^ Source Vector@@ -72,7 +72,7 @@          return $ UArray {uComp = comp, uSize = sz, uData = uVector}     , do Refl <- eqT :: Maybe (v :~: VS.Vector)          sVector <- join $ gcast1 (Just vector)-         return $ SArray {sComp = comp, sSize = sz, sData = sVector}+         return $ unsafeResize sz $ fromStorableVector comp sVector     , do Refl <- eqT :: Maybe (v :~: VP.Vector)          VP.Vector o _ ba <- join $ gcast1 (Just vector)          return $ PArray {pComp = comp, pSize = sz, pOffset = o, pData = ba}@@ -90,12 +90,7 @@ -- -- @since 0.3.0 fromVectorM ::-     ( MonadThrow m-     , Typeable v-     , VG.Vector v a-     , Mutable (ARepr v) ix a-     , Mutable r ix a-     )+     (MonadThrow m, Typeable v, VG.Vector v a, Manifest r a, Load (ARepr v) ix a, Load r ix a)   => Comp   -> Sz ix -- ^ Resulting size of the array   -> v a -- ^ Source Vector@@ -113,19 +108,19 @@ -- -- @since 0.3.0 fromVector' ::-     (Typeable v, VG.Vector v a, Mutable (ARepr v) ix a, Mutable r ix a)+     (HasCallStack, Typeable v, VG.Vector v a, Load (ARepr v) ix a, Load r ix a, Manifest r a)   => Comp   -> Sz ix -- ^ Resulting size of the array   -> v a -- ^ Source Vector   -> Array r ix a-fromVector' comp sz = either throw id . fromVectorM comp sz+fromVector' comp sz = throwEither . fromVectorM comp sz {-# INLINE fromVector' #-}  -- | /O(1)/ - conversion from `Mutable` array to a corresponding vector. Will -- return `Nothing` only if source array representation was not one of `B`, `N`, -- `P`, `S` or `U`. castToVector ::-     forall v r ix e. (Mutable r ix e, VRepr r ~ v)+     forall v r ix e. (Manifest r e, Index ix, VRepr r ~ v)   => Array r ix e   -> Maybe (v e) castToVector arr =@@ -135,14 +130,14 @@          return $ uData uArr     , do Refl <- eqT :: Maybe (r :~: S)          sArr <- gcastArr arr-         return $ sData sArr+         return $ toStorableVector sArr     , do Refl <- eqT :: Maybe (r :~: P)          pArr <- gcastArr arr          return $ VP.Vector (pOffset pArr) (totalElem (size arr)) $ pData pArr     , do Refl <- eqT :: Maybe (r :~: B)          bArr <- gcastArr arr          return $ toBoxedVector $ toLazyArray bArr-    , do Refl <- eqT :: Maybe (r :~: N)+    , do Refl <- eqT :: Maybe (r :~: BN)          bArr <- gcastArr arr          return $ toBoxedVector $ toLazyArray $ unwrapNormalForm bArr     , do Refl <- eqT :: Maybe (r :~: BL)@@ -161,6 +156,7 @@ -- `VS.Vector` in costant time: -- -- >>> import Data.Massiv.Array as A+-- >>> import Data.Massiv.Array.Manifest.Vector (toVector) -- >>> import qualified Data.Vector.Storable as VS -- >>> toVector (makeArrayR S Par (Sz2 5 6) (\(i :. j) -> i + j)) :: VS.Vector Int -- [0,1,2,3,4,5,1,2,3,4,5,6,2,3,4,5,6,7,3,4,5,6,7,8,4,5,6,7,8,9]@@ -175,8 +171,9 @@ -- toVector ::      forall r ix e v.-     ( Manifest r ix e-     , Mutable (ARepr v) ix e+     ( Manifest r e+     , Load r ix e+     , Manifest (ARepr v) e      , VG.Vector v e      , VRepr (ARepr v) ~ v      )

@@ -1,6 +1,7 @@ {-# LANGUAGE BangPatterns #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE LambdaCase #-}+{-# LANGUAGE MonoLocalBinds #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-}@@ -14,25 +15,27 @@ -- module Data.Massiv.Array.Mutable   ( -- ** Size-    msize+    sizeOfMArray+  , msize+  , resizeMArrayM+  , flattenMArray+  , outerSliceMArrayM+  , outerSlicesMArray     -- ** Element-wise mutation   , read   , readM-  , read'   , write   , write_   , writeM-  , write'   , modify   , modify_   , modifyM   , modifyM_-  , modify'   , swap   , swap_   , swapM   , swapM_-  , swap'+  , zipSwapM_   -- ** Operations on @MArray@   -- *** Immutable conversion   , thaw@@ -40,7 +43,6 @@   , freeze   , freezeS   -- *** Create mutable-  , new   , newMArray   , newMArray'   , makeMArray@@ -78,6 +80,8 @@   , iforPrimM_   , iforLinearPrimM   , iforLinearPrimM_+  , for2PrimM_+  , ifor2PrimM_   -- *** Modify   , withMArray   , withMArray_@@ -94,7 +98,7 @@   , initialize   , initializeNew   -- ** Computation-  , Mutable+  , Manifest   , MArray   , RealWorld   , computeInto@@ -107,28 +111,123 @@ import Data.Maybe (fromMaybe) import Control.Monad (void, when, unless, (>=>)) import Control.Monad.ST+import Control.Monad.Primitive import Control.Scheduler import Data.Massiv.Core.Common import Data.Massiv.Array.Mutable.Internal+import Data.Massiv.Array.Delayed.Pull (D) import Prelude hiding (mapM, read) --- | /O(n)/ - Initialize a new mutable array. All elements will be set to some default value. For--- boxed arrays in will be a thunk with `Uninitialized` exception, while for others it will be--- simply zeros.+-- | /O(1)/ - Change the size of a mutable array. Throws+-- `SizeElementsMismatchException` if total number of elements does not match+-- the supplied array. ----- @since 0.1.0-new ::-     forall r ix e m. (Mutable r ix e, PrimMonad m)-  => Sz ix-  -> m (MArray (PrimState m) r ix e)-new = initializeNew Nothing-{-# INLINE new #-}-{-# DEPRECATED new "In favor of a more robust and safer `newMArray` or a more consistently named `newMArray'`" #-}+-- @since 1.0.0+resizeMArrayM ::+     (Manifest r e, Index ix', Index ix, MonadThrow m)+  => Sz ix'+  -> MArray s r ix e+  -> m (MArray s r ix' e)+resizeMArrayM sz marr =+  unsafeResizeMArray sz marr <$ guardNumberOfElements (sizeOfMArray marr) sz+{-# INLINE resizeMArrayM #-}  +-- | /O(1)/ - Change a mutable array to a mutable vector.+--+-- @since 1.0.0+flattenMArray :: (Manifest r e, Index ix) => MArray s r ix e -> MVector s r e+flattenMArray marr = unsafeResizeMArray (toLinearSz (sizeOfMArray marr)) marr+{-# INLINE flattenMArray #-}+++-- | /O(1)/ - Slice a mutable array from the outside, while reducing its+-- dimensionality by one. Same as `Data.Massiv.Array.!?>` operator, but for+-- mutable arrays.+--+-- @since 1.0.0+outerSliceMArrayM ::+     forall r ix e m s. (MonadThrow m, Index (Lower ix), Index ix, Manifest r e)+  => MArray s r ix e+  -> Ix1+  -> m (MArray s r (Lower ix) e)+outerSliceMArrayM !marr !i = do+  let (k, szL) = unconsSz (sizeOfMArray marr)+  unless (isSafeIndex k i) $ throwM $ IndexOutOfBoundsException k i+  pure $ unsafeResizeMArray szL $ unsafeLinearSliceMArray (i * totalElem szL) (toLinearSz szL) marr+{-# INLINE outerSliceMArrayM #-}++-- | /O(1)/ - Take all outer slices of a mutable array and construct a delayed+-- vector out of them. In other words it applies `outerSliceMArrayM` to each+-- outer index. Same as `Data.Massiv.Array.outerSlices` function, but for+-- mutable arrays.+--+-- ====__Examples__+--+-- >>> import Data.Massiv.Array as A+-- >>> arr <- resizeM (Sz2 4 7) $ makeArrayR P Seq (Sz1 28) (+10)+-- >>> arr+-- Array P Seq (Sz (4 :. 7))+--   [ [ 10, 11, 12, 13, 14, 15, 16 ]+--   , [ 17, 18, 19, 20, 21, 22, 23 ]+--   , [ 24, 25, 26, 27, 28, 29, 30 ]+--   , [ 31, 32, 33, 34, 35, 36, 37 ]+--   ]+--+-- Here we can see we can get individual rows from a mutable matrix+--+-- >>> marr <- thawS arr+-- >>> import Control.Monad ((<=<))+-- >>> mapIO_ (print <=< freezeS)  $ outerSlicesMArray Seq marr+-- Array P Seq (Sz1 7)+--   [ 10, 11, 12, 13, 14, 15, 16 ]+-- Array P Seq (Sz1 7)+--   [ 17, 18, 19, 20, 21, 22, 23 ]+-- Array P Seq (Sz1 7)+--   [ 24, 25, 26, 27, 28, 29, 30 ]+-- Array P Seq (Sz1 7)+--   [ 31, 32, 33, 34, 35, 36, 37 ]+--+-- For the sake of example what if our goal was to mutate array in such a way+-- that rows from the top half were swapped with the bottom half:+--+-- >>> (top, bottom) <- splitAtM 1 2 $ outerSlicesMArray Seq marr+-- >>> mapIO_ (print <=< freezeS) top+-- Array P Seq (Sz1 7)+--   [ 10, 11, 12, 13, 14, 15, 16 ]+-- Array P Seq (Sz1 7)+--   [ 17, 18, 19, 20, 21, 22, 23 ]+-- >>> mapIO_ (print <=< freezeS) bottom+-- Array P Seq (Sz1 7)+--   [ 24, 25, 26, 27, 28, 29, 30 ]+-- Array P Seq (Sz1 7)+--   [ 31, 32, 33, 34, 35, 36, 37 ]+-- >>> szipWithM_ (zipSwapM_ 0) top bottom+-- >>> freezeS marr+-- Array P Seq (Sz (4 :. 7))+--   [ [ 24, 25, 26, 27, 28, 29, 30 ]+--   , [ 31, 32, 33, 34, 35, 36, 37 ]+--   , [ 10, 11, 12, 13, 14, 15, 16 ]+--   , [ 17, 18, 19, 20, 21, 22, 23 ]+--   ]+--+-- @since 1.0.0+outerSlicesMArray ::+     forall r ix e s. (Index (Lower ix), Index ix, Manifest r e)+  => Comp+  -> MArray s r ix e+  -> Vector D (MArray s r (Lower ix) e)+outerSlicesMArray comp marr =+  makeArray comp k (\i -> unsafeResizeMArray szL $ unsafeLinearSliceMArray (i * unSz kL) kL marr)+  where+    kL = toLinearSz szL+    (k, szL) = unconsSz $ sizeOfMArray marr+{-# INLINE outerSlicesMArray #-}++ -- | /O(n)/ - Initialize a new mutable array. All elements will be set to some default value. For--- boxed arrays in will be a thunk with `Uninitialized` exception, while for others it will be--- simply zeros. This is a partial function.+-- boxed arrays it will be a thunk with `Uninitialized` exception, while for others it will be+-- simply zeros. -- -- ==== __Examples__ --@@ -148,12 +247,12 @@ --   [ [ 0, 0, 0, 0, 0, 0 ] --   , [ 0, 0, 0, 0, 0, 0 ] --   ]--- >>> newMArray' @B @_ @Int (Sz2 2 6) >>= (`readM` 1)+-- >>> newMArray' @B @_ @Int (Sz2 2 6) >>= freezeS -- *** Exception: Uninitialized -- -- @since 0.6.0 newMArray' ::-     forall r ix e m. (Mutable r ix e, PrimMonad m)+     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix   -> m (MArray (PrimState m) r ix e) newMArray' sz = unsafeNew sz >>= \ma -> ma <$ initialize ma@@ -178,7 +277,7 @@ --   ] -- -- @since 0.1.0-thaw :: forall r ix e m. (Mutable r ix e, MonadIO m) => Array r ix e -> m (MArray RealWorld r ix e)+thaw :: forall r ix e m. (Manifest r e, Index ix, MonadIO m) => Array r ix e -> m (MArray RealWorld r ix e) thaw arr =   liftIO $ do     let sz = size arr@@ -210,7 +309,7 @@ -- -- @since 0.3.0 thawS ::-     forall r ix e m. (Mutable r ix e, PrimMonad m)+     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)   => Array r ix e   -> m (MArray (PrimState m) r ix e) thawS arr = do@@ -226,7 +325,7 @@ -- ==== __Example__ -- -- >>> import Data.Massiv.Array--- >>> marr <- newMArray @P @_ @Int (Sz2 2 6) 0+-- >>> marr <- newMArray @P (Sz2 2 6) (0 :: Int) -- >>> forM_ (range Seq 0 (Ix2 1 4)) $ \ix -> write marr ix 9 -- >>> freeze Seq marr -- Array P Seq (Sz (2 :. 6))@@ -236,13 +335,13 @@ -- -- @since 0.1.0 freeze ::-     forall r ix e m. (Mutable r ix e, MonadIO m)+     forall r ix e m. (Manifest r e, Index ix, MonadIO m)   => Comp   -> MArray RealWorld r ix e   -> m (Array r ix e) freeze comp smarr =   liftIO $ do-    let sz = msize smarr+    let sz = sizeOfMArray smarr         totalLength = totalElem sz     tmarr <- unsafeNew sz     withMassivScheduler_ comp $ \scheduler ->@@ -262,33 +361,31 @@ -- -- @since 0.3.0 freezeS ::-     forall r ix e m. (Mutable r ix e, PrimMonad m)+     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)   => MArray (PrimState m) r ix e   -> m (Array r ix e) freezeS smarr = do-  let sz = msize smarr+  let sz = sizeOfMArray smarr   tmarr <- unsafeNew sz   unsafeLinearCopy smarr 0 tmarr 0 (SafeSz (totalElem sz))   unsafeFreeze Seq tmarr {-# INLINE freezeS #-} --unsafeNewUninitialized ::-     (Load r' ix e, Mutable r ix e, PrimMonad m) => Array r' ix e -> m (MArray (PrimState m) r ix e)-unsafeNewUninitialized !arr = unsafeNew (fromMaybe zeroSz (maxSize arr))-{-# INLINE unsafeNewUninitialized #-}-+unsafeNewUpper ::+     (Load r' ix e, Manifest r e, PrimMonad m) => Array r' ix e -> m (MArray (PrimState m) r Ix1 e)+unsafeNewUpper !arr = unsafeNew (fromMaybe zeroSz (maxLinearSize arr))+{-# INLINE unsafeNewUpper #-}  -- | Load sequentially a pure array into the newly created mutable array. -- -- @since 0.3.0 loadArrayS ::-     forall r ix e r' m. (Load r' ix e, Mutable r ix e, PrimMonad m)+     forall r ix e r' m. (Load r' ix e, Manifest r e, PrimMonad m)   => Array r' ix e   -> m (MArray (PrimState m) r ix e) loadArrayS arr = do-  marr <- unsafeNewUninitialized arr-  unsafeLoadIntoS marr arr+  marr <- unsafeNewUpper arr+  stToPrim $ unsafeLoadIntoST marr arr {-# INLINE loadArrayS #-}  @@ -296,13 +393,13 @@ -- -- @since 0.3.0 loadArray ::-     forall r ix e r' m. (Load r' ix e, Mutable r ix e, MonadIO m)+     forall r ix e r' m. (Load r' ix e, Manifest r e, MonadIO m)   => Array r' ix e   -> m (MArray RealWorld r ix e) loadArray arr =   liftIO $ do-    marr <- unsafeNewUninitialized arr-    unsafeLoadIntoM marr arr+    marr <- unsafeNewUpper arr+    unsafeLoadIntoIO marr arr {-# INLINE loadArray #-}  @@ -312,16 +409,16 @@ -- -- @since 0.1.3 computeInto ::-     (Load r' ix' e, Mutable r ix e, MonadIO m)+     (Size r', Load r' ix' e, Manifest r e, Index ix, MonadIO m)   => MArray RealWorld r ix e -- ^ Target Array   -> Array r' ix' e -- ^ Array to load   -> m () computeInto !mArr !arr =   liftIO $ do-    unless (totalElem (msize mArr) == totalElem (size arr)) $-      throwM $ SizeElementsMismatchException (msize mArr) (size arr)+    unless (totalElem (sizeOfMArray mArr) == totalElem (size arr)) $+      throwM $ SizeElementsMismatchException (sizeOfMArray mArr) (size arr)     withMassivScheduler_ (getComp arr) $ \scheduler ->-      loadArrayM scheduler arr (unsafeLinearWrite mArr)+      stToPrim $ iterArrayLinearST_ scheduler arr (unsafeLinearWrite mArr) {-# INLINE computeInto #-}  @@ -329,7 +426,7 @@ -- -- @since 0.3.0 makeMArrayS ::-     forall r ix e m. (Mutable r ix e, PrimMonad m)+     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Size of the create array   -> (ix -> m e) -- ^ Element generating action   -> m (MArray (PrimState m) r ix e)@@ -341,13 +438,13 @@ -- -- @since 0.3.0 makeMArrayLinearS ::-     forall r ix e m. (Mutable r ix e, PrimMonad m)+     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix   -> (Int -> m e)   -> m (MArray (PrimState m) r ix e) makeMArrayLinearS sz f = do   marr <- unsafeNew sz-  loopM_ 0 (< totalElem (msize marr)) (+ 1) (\ !i -> f i >>= unsafeLinearWrite marr i)+  loopM_ 0 (< totalElem (sizeOfMArray marr)) (+ 1) (\ !i -> f i >>= unsafeLinearWrite marr i)   return marr {-# INLINE makeMArrayLinearS #-} @@ -355,11 +452,11 @@ -- -- @since 0.3.0 makeMArray ::-     forall r ix e m. (PrimMonad m, MonadUnliftIO m, Mutable r ix e)+     forall r ix e m. (MonadUnliftIO m, Manifest r e, Index ix)   => Comp   -> Sz ix   -> (ix -> m e)-  -> m (MArray (PrimState m) r ix e)+  -> m (MArray RealWorld r ix e) makeMArray comp sz f = makeMArrayLinear comp sz (f . fromLinearIndex sz) {-# INLINE makeMArray #-} @@ -368,15 +465,16 @@ -- -- @since 0.3.0 makeMArrayLinear ::-     forall r ix e m. (PrimMonad m, MonadUnliftIO m, Mutable r ix e)+     forall r ix e m. (MonadUnliftIO m, Manifest r e, Index ix)   => Comp   -> Sz ix   -> (Int -> m e)-  -> m (MArray (PrimState m) r ix e)+  -> m (MArray RealWorld r ix e) makeMArrayLinear comp sz f = do-  marr <- unsafeNew sz+  marr <- liftIO $ unsafeNew sz   withScheduler_ comp $ \scheduler ->-    splitLinearlyWithM_ scheduler (totalElem sz) f (unsafeLinearWrite marr)+    withRunInIO $ \run ->+    splitLinearlyWithM_ scheduler (totalElem sz) (run . f) (unsafeLinearWrite marr)   return marr {-# INLINE makeMArrayLinear #-} @@ -397,16 +495,16 @@ -- @since 0.3.0 -- createArray_ ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m, MonadUnliftIO m)+     forall r ix e a m. (Manifest r e, Index ix, MonadUnliftIO m)   => Comp -- ^ Computation strategy to use after `MArray` gets frozen and onward.   -> Sz ix -- ^ Size of the newly created array-  -> (Scheduler m () -> MArray (PrimState m) r ix e -> m a)+  -> (Scheduler RealWorld () -> MArray RealWorld r ix e -> m a)   -- ^ An action that should fill all elements of the brand new mutable array   -> m (Array r ix e) createArray_ comp sz action = do-  marr <- new sz+  marr <- liftIO $ newMArray' sz   withScheduler_ comp (`action` marr)-  unsafeFreeze comp marr+  liftIO $ unsafeFreeze comp marr {-# INLINE createArray_ #-}  -- | Just like `createArray_`, but together with `Array` it returns results of scheduled filling@@ -415,16 +513,16 @@ -- @since 0.3.0 -- createArray ::-     forall r ix e a m b. (Mutable r ix e, PrimMonad m, MonadUnliftIO m)+     forall r ix e a m b. (Manifest r e, Index ix, 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)+  -> (Scheduler RealWorld a -> MArray RealWorld r ix e -> m b)   -- ^ An action that should fill all elements of the brand new mutable array   -> m ([a], Array r ix e) createArray comp sz action = do-  marr <- new sz+  marr <- liftIO $ newMArray' sz   a <- withScheduler comp (`action` marr)-  arr <- unsafeFreeze comp marr+  arr <- liftIO $ unsafeFreeze comp marr   return (a, arr) {-# INLINE createArray #-} @@ -442,7 +540,7 @@ -- -- @since 0.3.0 createArrayS_ ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, 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@@ -454,13 +552,13 @@ -- -- @since 0.3.0 createArrayS ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, 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) createArrayS sz action = do-  marr <- new sz+  marr <- newMArray' sz   a <- action marr   arr <- unsafeFreeze Seq marr   return (a, arr)@@ -470,7 +568,7 @@ -- -- @since 0.3.0 createArrayST_ ::-     forall r ix e a. Mutable r ix e+     forall r ix e a. (Manifest r e, Index ix)   => Sz ix   -> (forall s. MArray s r ix e -> ST s a)   -> Array r ix e@@ -482,7 +580,7 @@ -- -- @since 0.2.6 createArrayST ::-     forall r ix e a. Mutable r ix e+     forall r ix e a. (Manifest r e, Index ix)   => Sz ix   -> (forall s. MArray s r ix e -> ST s a)   -> (a, Array r ix e)@@ -491,7 +589,7 @@   -- | Sequentially generate a pure array. Much like `makeArray` creates a pure array this--- function will use `Mutable` interface to generate a pure `Array` in the end, except that+-- 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.@@ -515,7 +613,7 @@ -- -- @since 0.2.6 generateArrayS ::-     forall r ix e m. (Mutable r ix e, PrimMonad m)+     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Resulting size of the array   -> (ix -> m e) -- ^ Element producing generator   -> m (Array r ix e)@@ -526,13 +624,13 @@ -- -- @since 0.3.0 generateArrayLinearS ::-     forall r ix e m. (Mutable r ix e, PrimMonad m)+     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Resulting size of the array   -> (Int -> m e) -- ^ Element producing generator   -> m (Array r ix e) generateArrayLinearS sz gen = do   marr <- unsafeNew sz-  loopM_ 0 (< totalElem (msize marr)) (+ 1) $ \i -> gen i >>= unsafeLinearWrite marr i+  loopM_ 0 (< totalElem (sizeOfMArray marr)) (+ 1) $ \i -> gen i >>= unsafeLinearWrite marr i   unsafeFreeze Seq marr {-# INLINE generateArrayLinearS #-} @@ -542,7 +640,7 @@ -- -- @since 0.2.6 generateArray ::-     forall r ix e m. (MonadUnliftIO m, PrimMonad m, Mutable r ix e)+     forall r ix e m. (MonadUnliftIO m, Manifest r e, Index ix)   => Comp   -> Sz ix   -> (ix -> m e)@@ -555,12 +653,12 @@ -- -- @since 0.3.0 generateArrayLinear ::-     forall r ix e m. (MonadUnliftIO m, PrimMonad m, Mutable r ix e)+     forall r ix e m. (MonadUnliftIO m, Manifest r e, Index ix)   => Comp   -> Sz ix   -> (Int -> m e)   -> m (Array r ix e)-generateArrayLinear comp sz f = makeMArrayLinear comp sz f >>= unsafeFreeze comp+generateArrayLinear comp sz f = makeMArrayLinear comp sz f >>= liftIO . unsafeFreeze comp {-# INLINE generateArrayLinear #-}  @@ -568,7 +666,7 @@ -- -- @since 0.3.4 generateArrayLinearWS ::-     forall r ix e s m. (Mutable r ix e, MonadUnliftIO m, PrimMonad m)+     forall r ix e s m. (Manifest r e, Index ix, MonadUnliftIO m, PrimMonad m)   => WorkerStates s   -> Sz ix   -> (Int -> s -> m e)@@ -589,7 +687,7 @@ -- -- @since 0.3.4 generateArrayWS ::-     forall r ix e s m. (Mutable r ix e, MonadUnliftIO m, PrimMonad m)+     forall r ix e s m. (Manifest r e, Index ix, MonadUnliftIO m, PrimMonad m)   => WorkerStates s   -> Sz ix   -> (ix -> s -> m e)@@ -622,7 +720,7 @@ -- -- @since 0.3.0 unfoldrPrimM_ ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Size of the desired array   -> (a -> m (e, a)) -- ^ Unfolding action   -> a -- ^ Initial accumulator@@ -634,7 +732,7 @@ -- -- @since 0.3.0 iunfoldrPrimM_ ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Size of the desired array   -> (a -> ix -> m (e, a)) -- ^ Unfolding action   -> a -- ^ Initial accumulator@@ -647,14 +745,14 @@ -- -- @since 0.3.0 iunfoldrPrimM ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Size of the desired array   -> (a -> ix -> m (e, a)) -- ^ Unfolding action   -> a -- ^ Initial accumulator   -> m (a, Array r ix e) iunfoldrPrimM sz gen acc0 =   unsafeCreateArrayS sz $ \marr ->-    let sz' = msize marr+    let sz' = sizeOfMArray marr      in iterLinearM sz' 0 (totalElem sz') 1 (<) acc0 $ \ !i ix !acc -> do           (e, acc') <- gen acc ix           unsafeLinearWrite marr i e@@ -665,14 +763,14 @@ -- -- @since 0.3.0 unfoldrPrimM ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Size of the desired array   -> (a -> m (e, a)) -- ^ Unfolding action   -> a -- ^ Initial accumulator   -> m (a, Array r ix e) unfoldrPrimM sz gen acc0 =   unsafeCreateArrayS sz $ \marr ->-    let sz' = msize marr+    let sz' = sizeOfMArray marr      in loopM 0 (< totalElem sz') (+ 1) acc0 $ \ !i !acc -> do           (e, acc') <- gen acc           unsafeLinearWrite marr i e@@ -703,7 +801,7 @@ -- -- @since 0.3.0 unfoldlPrimM_ ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Size of the desired array   -> (a -> m (a, e)) -- ^ Unfolding action   -> a -- ^ Initial accumulator@@ -715,7 +813,7 @@ -- -- @since 0.3.0 iunfoldlPrimM_ ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Size of the desired array   -> (a -> ix -> m (a, e)) -- ^ Unfolding action   -> a -- ^ Initial accumulator@@ -728,14 +826,14 @@ -- -- @since 0.3.0 iunfoldlPrimM ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Size of the desired array   -> (a -> ix -> m (a, e)) -- ^ Unfolding action   -> a -- ^ Initial accumulator   -> m (a, Array r ix e) iunfoldlPrimM sz gen acc0 =   unsafeCreateArrayS sz $ \marr ->-    let sz' = msize marr+    let sz' = sizeOfMArray marr      in iterLinearM sz' (totalElem sz' - 1) 0 (negate 1) (>=) acc0 $ \ !i ix !acc -> do           (acc', e) <- gen acc ix           unsafeLinearWrite marr i e@@ -746,14 +844,14 @@ -- -- @since 0.3.0 unfoldlPrimM ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)   => Sz ix -- ^ Size of the desired array   -> (a -> m (a, e)) -- ^ Unfolding action   -> a -- ^ Initial accumulator   -> m (a, Array r ix e) unfoldlPrimM sz gen acc0 =   unsafeCreateArrayS sz $ \marr ->-    let sz' = msize marr+    let sz' = sizeOfMArray marr      in loopDeepM 0 (< totalElem sz') (+1) acc0 $ \ !i !acc -> do           (acc', e) <- gen acc           unsafeLinearWrite marr i e@@ -764,17 +862,17 @@ -- action to it. There is no mutation to the array, unless the action itself modifies it. -- -- @since 0.4.0-forPrimM_ :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m ()) -> m ()+forPrimM_ :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m ()) -> m () forPrimM_ marr f =-  loopM_ 0 (< totalElem (msize marr)) (+1) (unsafeLinearRead marr >=> f)+  loopM_ 0 (< totalElem (sizeOfMArray marr)) (+1) (unsafeLinearRead marr >=> f) {-# INLINE forPrimM_ #-}  -- | Sequentially loop over a mutable array while modifying each element with an action. -- -- @since 0.4.0-forPrimM :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m e) -> m ()+forPrimM :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m e) -> m () forPrimM marr f =-  loopM_ 0 (< totalElem (msize marr)) (+1) (unsafeLinearModify marr f)+  loopM_ 0 (< totalElem (sizeOfMArray marr)) (+1) (unsafeLinearModify marr f) {-# INLINE forPrimM #-}  @@ -784,16 +882,16 @@ -- -- @since 0.4.0 iforPrimM_ ::-     (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (ix -> e -> m ()) -> m ()-iforPrimM_ marr f = iforLinearPrimM_ marr (f . fromLinearIndex (msize marr))+     (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (ix -> e -> m ()) -> m ()+iforPrimM_ marr f = iforLinearPrimM_ marr (f . fromLinearIndex (sizeOfMArray marr)) {-# INLINE iforPrimM_ #-}  -- | Sequentially loop over a mutable array while modifying each element with an index aware action. -- -- @since 0.4.0 iforPrimM ::-     (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (ix -> e -> m e) -> m ()-iforPrimM marr f = iforLinearPrimM marr (f . fromLinearIndex (msize marr))+     (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (ix -> e -> m e) -> m ()+iforPrimM marr f = iforLinearPrimM marr (f . fromLinearIndex (sizeOfMArray marr)) {-# INLINE iforPrimM #-}  @@ -803,27 +901,61 @@ -- -- @since 0.4.0 iforLinearPrimM_ ::-     (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (Int -> e -> m ()) -> m ()+     (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (Int -> e -> m ()) -> m () iforLinearPrimM_ marr f =-  loopM_ 0 (< totalElem (msize marr)) (+ 1) (\i -> unsafeLinearRead marr i >>= f i)+  loopM_ 0 (< totalElem (sizeOfMArray marr)) (+ 1) (\i -> unsafeLinearRead marr i >>= f i) {-# INLINE iforLinearPrimM_ #-}  -- | Sequentially loop over a mutable array while modifying each element with an index aware action. -- -- @since 0.4.0 iforLinearPrimM ::-     (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> (Int -> e -> m e) -> m ()+     (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (Int -> e -> m e) -> m () iforLinearPrimM marr f =-  loopM_ 0 (< totalElem (msize marr)) (+ 1) (\i -> unsafeLinearModify marr (f i) i)+  loopM_ 0 (< totalElem (sizeOfMArray marr)) (+ 1) (\i -> unsafeLinearModify marr (f i) i) {-# INLINE iforLinearPrimM #-} +++-- | 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.+--+-- @since 1.0.0+for2PrimM_ ::+     forall r1 r2 e1 e2 ix m. (PrimMonad m, Index ix, Manifest r1 e1, Manifest r2 e2)+  => MArray (PrimState m) r1 ix e1+  -> MArray (PrimState m) r2 ix e2+  -> (e1 -> e2 -> m ())+  -> m ()+for2PrimM_ m1 m2 f = ifor2PrimM_ m1 m2 (const f)+{-# INLINE for2PrimM_ #-}++-- | Same as `for2PrimM_`, but with index aware action.+--+-- @since 1.0.0+ifor2PrimM_ ::+     forall r1 r2 e1 e2 ix m. (PrimMonad m, Index ix, Manifest r1 e1, Manifest r2 e2)+  => MArray (PrimState m) r1 ix e1+  -> MArray (PrimState m) r2 ix e2+  -> (ix -> e1 -> e2 -> m ())+  -> m ()+ifor2PrimM_ m1 m2 f = do+  let sz = liftIndex2 min (unSz (sizeOfMArray m1)) (unSz (sizeOfMArray m2))+  iterM_ zeroIndex sz oneIndex (<) $ \ix -> do+    e1 <- unsafeRead m1 ix+    e2 <- unsafeRead m2 ix+    f ix e1 e2+{-# INLINE ifor2PrimM_ #-}++ -- | Same as `withMArray_`, but allows to keep artifacts of scheduled tasks. -- -- @since 0.5.0 withMArray ::-     (Mutable r ix e, MonadUnliftIO m)+     (Manifest r e, Index ix, MonadUnliftIO m)   => Array r ix e-  -> (Scheduler m a -> MArray RealWorld r ix e -> m b)+  -> (Scheduler RealWorld a -> MArray RealWorld r ix e -> m b)   -> m ([a], Array r ix e) withMArray arr action = do   marr <- thaw arr@@ -845,9 +977,9 @@ -- -- @since 0.5.0 withMArray_ ::-     (Mutable r ix e, MonadUnliftIO m)+     (Manifest r e, Index ix, MonadUnliftIO m)   => Array r ix e-  -> (Scheduler m () -> MArray RealWorld r ix e -> m a)+  -> (Scheduler RealWorld () -> MArray RealWorld r ix e -> m a)   -> m (Array r ix e) withMArray_ arr action = do   marr <- thaw arr@@ -861,15 +993,13 @@ -- -- @since 0.6.1 withLoadMArray_ ::-     forall r ix e r' m b. (Load r' ix e, Mutable r ix e, MonadUnliftIO m)+     forall r ix e r' m b. (Load r' ix e, Manifest r e, MonadUnliftIO m)   => Array r' ix e-  -> (Scheduler m () -> MArray RealWorld r ix e -> m b)+  -> (Scheduler RealWorld () -> MArray RealWorld r ix e -> m b)   -> m (Array r ix e) withLoadMArray_ arr action = do-  marr <- liftIO $ unsafeNew (size arr)-  withScheduler_ (getComp arr) $ \scheduler -> do-    runBatch_ scheduler $ \_ -> loadArrayM scheduler arr (\i -> liftIO . unsafeLinearWrite marr i)-    action scheduler marr+  marr <- loadArray arr+  withScheduler_ (getComp arr) (`action` marr)   liftIO $ unsafeFreeze (getComp arr) marr {-# INLINE[2] withLoadMArray_ #-} {-# RULES@@ -884,7 +1014,7 @@ -- -- @since 0.5.0 withMArrayS ::-     (Mutable r ix e, PrimMonad m)+     (Manifest r e, Index ix, PrimMonad m)   => Array r ix e   -> (MArray (PrimState m) r ix e -> m a)   -> m (a, Array r ix e)@@ -899,7 +1029,7 @@ -- -- @since 0.5.0 withMArrayS_ ::-     (Mutable r ix e, PrimMonad m)+     (Manifest r e, Index ix, PrimMonad m)   => Array r ix e   -> (MArray (PrimState m) r ix e -> m a)   -> m (Array r ix e)@@ -911,13 +1041,12 @@ -- -- @since 0.6.1 withLoadMArrayS ::-     forall r ix e r' m a. (Load r' ix e, Mutable r ix e, PrimMonad m)+     forall r ix e r' m a. (Load r' ix e, Manifest r e, PrimMonad m)   => Array r' ix e   -> (MArray (PrimState m) r ix e -> m a)   -> m (a, Array r ix e) withLoadMArrayS arr action = do-  marr <- unsafeNew (size arr)-  loadArrayM trivialScheduler_ arr (unsafeLinearWrite marr)+  marr <- loadArrayS arr   a <- action marr   (,) a <$> unsafeFreeze (getComp arr) marr {-# INLINE[2] withLoadMArrayS #-}@@ -926,7 +1055,7 @@ -- -- @since 0.6.1 withLoadMArrayS_ ::-     forall r ix e r' m a. (Load r' ix e, Mutable r ix e, PrimMonad m)+     forall r ix e r' m a. (Load r' ix e, Manifest r e, PrimMonad m)   => Array r' ix e   -> (MArray (PrimState m) r ix e -> m a)   -> m (Array r ix e)@@ -939,7 +1068,7 @@ -- -- @since 0.5.0 withMArrayST ::-     Mutable r ix e+     (Manifest r e, Index ix)   => Array r ix e   -> (forall s . MArray s r ix e -> ST s a)   -> (a, Array r ix e)@@ -951,7 +1080,7 @@ -- -- @since 0.5.0 withMArrayST_ ::-     Mutable r ix e => Array r ix e -> (forall s. MArray s r ix e -> ST s a) -> Array r ix e+     (Manifest r e, Index ix) => Array r ix e -> (forall s. MArray s r ix e -> ST s a) -> Array r ix e withMArrayST_ arr f = runST $ withMArrayS_ arr f {-# INLINE withMArrayST_ #-} @@ -960,7 +1089,7 @@ -- -- @since 0.6.1 withLoadMArrayST ::-     forall r ix e r' a. (Load r' ix e, Mutable r ix e)+     forall r ix e r' a. (Load r' ix e, Manifest r e)   => Array r' ix e   -> (forall s. MArray s r ix e -> ST s a)   -> (a, Array r ix e)@@ -971,7 +1100,7 @@ -- -- @since 0.6.1 withLoadMArrayST_ ::-     forall r ix e r' a. (Load r' ix e, Mutable r ix e)+     forall r ix e r' a. (Load r' ix e, Manifest r e)   => Array r' ix e   -> (forall s. MArray s r ix e -> ST s a)   -> Array r ix e@@ -982,10 +1111,10 @@ -- | /O(1)/ - Lookup an element in the mutable array. Returns `Nothing` when index is out of bounds. -- -- @since 0.1.0-read :: (Mutable r ix e, PrimMonad m) =>+read :: (Manifest r e, Index ix, PrimMonad m) =>         MArray (PrimState m) r ix e -> ix -> m (Maybe e) read marr ix =-  if isSafeIndex (msize marr) ix+  if isSafeIndex (sizeOfMArray marr) ix     then Just <$> unsafeRead marr ix     else return Nothing {-# INLINE read #-}@@ -994,34 +1123,22 @@ -- | /O(1)/ - Same as `read`, but throws `IndexOutOfBoundsException` on an invalid index. -- -- @since 0.4.0-readM :: (Mutable r ix e, PrimMonad m, MonadThrow m) =>+readM :: (Manifest r e, Index ix, PrimMonad m, MonadThrow m) =>         MArray (PrimState m) r ix e -> ix -> m e readM marr ix =   read marr ix >>= \case     Just e -> pure e-    Nothing -> throwM $ IndexOutOfBoundsException (msize marr) ix+    Nothing -> throwM $ IndexOutOfBoundsException (sizeOfMArray marr) ix {-# INLINE readM #-}  --- | /O(1)/ - Same as `read`, but throws `IndexOutOfBoundsException` on an invalid index.------ @since 0.1.0-read' :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> m e-read' marr ix =-  read marr ix >>= \case-    Just e -> pure e-    Nothing -> throw $ IndexOutOfBoundsException (msize marr) ix-{-# INLINE read' #-}-{-# DEPRECATED read' "In favor of more general `readM`" #-}-- -- | /O(1)/ - Write an element into the cell of a mutable array. Returns `False` when index is out -- of bounds. -- -- @since 0.1.0-write :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> e -> m Bool+write :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> e -> m Bool write marr ix e =-  if isSafeIndex (msize marr) ix+  if isSafeIndex (sizeOfMArray marr) ix   then unsafeWrite marr ix e >> pure True   else pure False {-# INLINE write #-}@@ -1032,42 +1149,32 @@ -- words, just like `writeM`, but doesn't throw an exception. -- -- @since 0.4.4-write_ :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> e -> m ()-write_ marr ix = when (isSafeIndex (msize marr) ix) . unsafeWrite marr ix+write_ :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> e -> m ()+write_ marr ix = when (isSafeIndex (sizeOfMArray marr) ix) . unsafeWrite marr ix {-# INLINE write_ #-}  -- | /O(1)/ - Same as `write`, but throws `IndexOutOfBoundsException` on an invalid index. -- -- @since 0.4.0 writeM ::-     (Mutable r ix e, PrimMonad m, MonadThrow m) => MArray (PrimState m) r ix e -> ix -> e -> m ()+     (Manifest r e, Index ix, PrimMonad m, MonadThrow m) => MArray (PrimState m) r ix e -> ix -> e -> m () writeM marr ix e =-  write marr ix e >>= (`unless` throwM (IndexOutOfBoundsException (msize marr) ix))+  write marr ix e >>= (`unless` throwM (IndexOutOfBoundsException (sizeOfMArray marr) ix)) {-# INLINE writeM #-}  --- | /O(1)/ - Same as `write`, but lives in IO and throws `IndexOutOfBoundsException` on invalid--- index.------ @since 0.1.0-write' ::-     (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> e -> m ()-write' marr ix e = write marr ix e >>= (`unless` throw (IndexOutOfBoundsException (msize marr) ix))-{-# INLINE write' #-}-{-# DEPRECATED write' "In favor of more general `writeM`" #-}- -- | /O(1)/ - Modify an element in the cell of a mutable array with a supplied -- action. Returns the previous value, if index was not out of bounds. -- -- @since 0.1.0 modify ::-     (Mutable r ix e, PrimMonad m)+     (Manifest r e, Index ix, PrimMonad m)   => MArray (PrimState m) r ix e -- ^ Array to mutate.   -> (e -> m e) -- ^ Monadic action that modifies the element   -> ix -- ^ Index at which to perform modification.   -> m (Maybe e) modify marr f ix =-  if isSafeIndex (msize marr) ix+  if isSafeIndex (sizeOfMArray marr) ix     then Just <$> unsafeModify marr f ix     else return Nothing {-# INLINE modify #-}@@ -1078,12 +1185,12 @@ -- -- @since 0.4.4 modify_ ::-     (Mutable r ix e, PrimMonad m)+     (Manifest r e, Index ix, PrimMonad m)   => MArray (PrimState m) r ix e -- ^ Array to mutate.   -> (e -> m e) -- ^ Monadic action that modifies the element   -> ix -- ^ Index at which to perform modification.   -> m ()-modify_ marr f ix = when (isSafeIndex (msize marr) ix) $ void $ unsafeModify marr f ix+modify_ marr f ix = when (isSafeIndex (sizeOfMArray marr) ix) $ void $ unsafeModify marr f ix {-# INLINE modify_ #-}  -- | /O(1)/ - Modify an element in the cell of a mutable array with a supplied@@ -1092,14 +1199,14 @@ -- -- @since 0.4.0 modifyM ::-     (Mutable r ix e, PrimMonad m, MonadThrow m)+     (Manifest r e, Index ix, PrimMonad m, MonadThrow m)   => MArray (PrimState m) r ix e -- ^ Array to mutate.   -> (e -> m e) -- ^ Monadic action that modifies the element   -> ix -- ^ Index at which to perform modification.   -> m e modifyM marr f ix-  | isSafeIndex (msize marr) ix = unsafeModify marr f ix-  | otherwise = throwM (IndexOutOfBoundsException (msize marr) ix)+  | isSafeIndex (sizeOfMArray marr) ix = unsafeModify marr f ix+  | otherwise = throwM (IndexOutOfBoundsException (sizeOfMArray marr) ix) {-# INLINE modifyM #-}  -- | /O(1)/ - Same as `modifyM`, but discard the returned element@@ -1115,7 +1222,7 @@ -- -- @since 0.4.0 modifyM_ ::-     (Mutable r ix e, PrimMonad m, MonadThrow m)+     (Manifest r e, Index ix, PrimMonad m, MonadThrow m)   => MArray (PrimState m) r ix e -- ^ Array to mutate.   -> (e -> m e) -- ^ Monadic action that modifies the element   -> ix -- ^ Index at which to perform modification.@@ -1124,27 +1231,14 @@ {-# INLINE modifyM_ #-}  --- | /O(1)/ - Same as `modify`, but throws an error if index is out of bounds.------ @since 0.1.0-modify' :: (Mutable r ix e, PrimMonad m) =>-        MArray (PrimState m) r ix e -> (e -> e) -> ix -> m ()-modify' marr f ix =-  modify marr (pure . f) ix >>= \case-    Just _ -> pure ()-    Nothing -> throw (IndexOutOfBoundsException (msize marr) ix)-{-# INLINE modify' #-}-{-# DEPRECATED modify' "In favor of more general `modifyM`" #-}-- -- | /O(1)/ - Same as `swapM`, but instead of throwing an exception returns `Nothing` when -- either one of the indices is out of bounds and `Just` elements under those indices -- otherwise. -- -- @since 0.1.0-swap :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m (Maybe (e, e))+swap :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m (Maybe (e, e)) swap marr ix1 ix2 =-  let !sz = msize marr+  let !sz = sizeOfMArray marr    in if isSafeIndex sz ix1 && isSafeIndex sz ix2         then Just <$> unsafeSwap marr ix1 ix2         else pure Nothing@@ -1155,9 +1249,9 @@ -- words, it is similar to `swapM_`, but does not throw any exceptions. -- -- @since 0.4.4-swap_ :: (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m ()+swap_ :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m () swap_ marr ix1 ix2 =-  let !sz = msize marr+  let !sz = sizeOfMArray marr    in when (isSafeIndex sz ix1 && isSafeIndex sz ix2) $ void $ unsafeSwap marr ix1 ix2 {-# INLINE swap_ #-} @@ -1167,7 +1261,7 @@ -- -- @since 0.4.0 swapM ::-     (Mutable r ix e, PrimMonad m, MonadThrow m)+     (Manifest r e, Index ix, PrimMonad m, MonadThrow m)   => MArray (PrimState m) r ix e   -> ix -- ^ Index for the first element, which will be returned as the first element in the         -- tuple.@@ -1175,11 +1269,11 @@         -- the tuple.   -> m (e, e) swapM marr ix1 ix2-  | not (isSafeIndex sz ix1) = throwM $ IndexOutOfBoundsException (msize marr) ix1-  | not (isSafeIndex sz ix2) = throwM $ IndexOutOfBoundsException (msize marr) ix2+  | not (isSafeIndex sz ix1) = throwM $ IndexOutOfBoundsException (sizeOfMArray marr) ix1+  | not (isSafeIndex sz ix2) = throwM $ IndexOutOfBoundsException (sizeOfMArray marr) ix2   | otherwise = unsafeSwap marr ix1 ix2   where-    !sz = msize marr+    !sz = sizeOfMArray marr {-# INLINE swapM #-}  @@ -1187,22 +1281,40 @@ -- -- @since 0.4.0 swapM_ ::-     (Mutable r ix e, PrimMonad m, MonadThrow m) => MArray (PrimState m) r ix e -> ix -> ix -> m ()+     (Manifest r e, Index ix, PrimMonad m, MonadThrow m)+  => MArray (PrimState m) r ix e+  -> ix+  -> ix+  -> m () swapM_ marr ix1 ix2 = void $ swapM marr ix1 ix2 {-# INLINE swapM_ #-} +-- | Swap elements in the intersection of two mutable arrays starting at the+-- initial index.+--+-- @since 1.0.0+zipSwapM_ ::+     forall r1 r2 ix e m s. (MonadPrim s m, Manifest r2 e, Manifest r1 e, Index ix)+  => ix+  -> MArray s r1 ix e+  -> MArray s r2 ix e+  -> m ()+zipSwapM_ startIx m1 m2 = do+  let sz1 = sizeOfMArray m1+      sz2 = sizeOfMArray m2+      sz = liftIndex2 min (unSz sz1) (unSz sz2)+  iterM_ startIx sz oneIndex (<) $ \ix -> do+    let i1 = toLinearIndex sz1 ix+        i2 = toLinearIndex sz2 ix+    e1 <- unsafeLinearRead m1 i1+    e2 <- unsafeLinearRead m2 i2+    unsafeLinearWrite m2 i2 e1+    unsafeLinearWrite m1 i1 e2+{-# INLINE zipSwapM_ #-} --- | /O(1)/ - Same as `swap`, but throws an `IndexOutOfBoundsException` on invalid indices.+-- | Get the size of a mutable array. -- -- @since 0.1.0-swap' ::-     (Mutable r ix e, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m ()-swap' marr ix1 ix2 =-  swap marr ix1 ix2 >>= \case-    Just _ -> pure ()-    Nothing ->-      if isSafeIndex (msize marr) ix1-        then throw $ IndexOutOfBoundsException (msize marr) ix2-        else throw $ IndexOutOfBoundsException (msize marr) ix1-{-# INLINE swap' #-}-{-# DEPRECATED swap' "In favor of more general `swapM`" #-}+msize :: (Manifest r e, Index ix) => MArray s r ix e -> Sz ix+msize = sizeOfMArray+{-# DEPRECATED msize "In favor of `sizeOfMArray`" #-}

@@ -28,16 +28,16 @@ -- >>> import Data.Massiv.Array.Mutable.Algorithms -- >>> :set -XOverloadedLists -- >>> m <- thaw ([2,1,50,10,20,8] :: Array P Ix1 Int)--- >>> unstablePartitionM m (<= 10)+-- >>> unstablePartitionM m (pure . (<= 10)) -- 4 -- >>> freeze Seq m -- Array P Seq (Sz1 6) --   [ 2, 1, 8, 10, 20, 50 ] ----- @since 0.3.2+-- @since 1.0.0 unstablePartitionM ::-     forall r e m. (Mutable r Ix1 e, PrimMonad m)+     forall r e m. (Manifest r e, PrimMonad m)   => MVector (PrimState m) r e-  -> (e -> Bool) -- ^ Predicate+  -> (e -> m Bool) -- ^ Predicate   -> m Ix1-unstablePartitionM marr f = unsafeUnstablePartitionRegionM marr f 0 (unSz (msize marr) - 1)+unstablePartitionM marr f = unsafeUnstablePartitionRegionM marr f 0 (unSz (sizeOfMArray marr) - 1)

@@ -37,7 +37,7 @@ atomicReadIntArray ::      (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> m (Maybe Int) atomicReadIntArray marr ix-  | isSafeIndex (msize marr) ix = Just <$> unsafeAtomicReadIntArray marr ix+  | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicReadIntArray marr ix   | otherwise = pure Nothing {-# INLINE atomicReadIntArray #-} @@ -49,7 +49,7 @@ atomicWriteIntArray ::      (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Bool atomicWriteIntArray marr ix f-  | isSafeIndex (msize marr) ix = unsafeAtomicWriteIntArray marr ix f >> pure True+  | isSafeIndex (sizeOfMArray marr) ix = unsafeAtomicWriteIntArray marr ix f >> pure True   | otherwise = pure False {-# INLINE atomicWriteIntArray #-} @@ -65,7 +65,7 @@   -> Int -- ^ New value   -> m (Maybe Int) casIntArray marr ix e n-  | isSafeIndex (msize marr) ix = Just <$> unsafeCasIntArray marr ix e n+  | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeCasIntArray marr ix e n   | otherwise = pure Nothing {-# INLINE casIntArray #-} @@ -77,7 +77,7 @@ atomicModifyIntArray ::      (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> (Int -> Int) -> m (Maybe Int) atomicModifyIntArray marr ix f-  | isSafeIndex (msize marr) ix = Just <$> unsafeAtomicModifyIntArray marr ix f+  | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicModifyIntArray marr ix f   | otherwise = pure Nothing {-# INLINE atomicModifyIntArray #-} @@ -88,7 +88,7 @@ atomicAddIntArray ::      (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicAddIntArray marr ix e-  | isSafeIndex (msize marr) ix = Just <$> unsafeAtomicAddIntArray marr ix e+  | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicAddIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicAddIntArray #-} @@ -99,7 +99,7 @@ atomicSubIntArray ::      (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicSubIntArray marr ix e-  | isSafeIndex (msize marr) ix = Just <$> unsafeAtomicSubIntArray marr ix e+  | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicSubIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicSubIntArray #-} @@ -110,7 +110,7 @@ atomicAndIntArray ::      (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicAndIntArray marr ix e-  | isSafeIndex (msize marr) ix = Just <$> unsafeAtomicAndIntArray marr ix e+  | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicAndIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicAndIntArray #-} @@ -121,7 +121,7 @@ atomicNandIntArray ::      (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicNandIntArray marr ix e-  | isSafeIndex (msize marr) ix = Just <$> unsafeAtomicNandIntArray marr ix e+  | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicNandIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicNandIntArray #-} @@ -132,7 +132,7 @@ atomicOrIntArray ::      (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicOrIntArray marr ix e-  | isSafeIndex (msize marr) ix = Just <$> unsafeAtomicOrIntArray marr ix e+  | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicOrIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicOrIntArray #-} @@ -143,6 +143,6 @@ atomicXorIntArray ::      (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicXorIntArray marr ix e-  | isSafeIndex (msize marr) ix = Just <$> unsafeAtomicXorIntArray marr ix e+  | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicXorIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicXorIntArray #-}

@@ -21,7 +21,7 @@ -- -- @since 0.5.0 unsafeCreateArrayS ::-     forall r ix e a m. (Mutable r ix e, PrimMonad m)+     forall r ix e a m. (Manifest r e, Index ix, 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@@ -38,16 +38,16 @@ -- -- @since 0.5.0 unsafeCreateArray ::-     forall r ix e a m b. (Mutable r ix e, PrimMonad m, MonadUnliftIO m)+     forall r ix e a m b. (Manifest r e, Index ix, 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)+  -> (Scheduler RealWorld a -> MArray RealWorld r ix e -> m b)   -- ^ An action that should fill all elements of the brand new mutable array   -> m ([a], Array r ix e) unsafeCreateArray comp sz action = do-  marr <- unsafeNew sz+  marr <- liftIO $ unsafeNew sz   a <- withScheduler comp (`action` marr)-  arr <- unsafeFreeze comp marr+  arr <- liftIO $ unsafeFreeze comp marr   return (a, arr) {-# INLINE unsafeCreateArray #-} @@ -56,15 +56,15 @@ -- -- @since 0.5.0 unsafeCreateArray_ ::-     forall r ix e a m b. (Mutable r ix e, PrimMonad m, MonadUnliftIO m)+     forall r ix e a m b. (Manifest r e, Index ix, 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)+  -> (Scheduler RealWorld a -> MArray RealWorld r ix e -> m b)   -- ^ An action that should fill all elements of the brand new mutable array   -> m (Array r ix e) unsafeCreateArray_ comp sz action = do-  marr <- unsafeNew sz+  marr <- liftIO $ unsafeNew sz   withScheduler_ comp (`action` marr)-  arr <- unsafeFreeze comp marr+  arr <- liftIO $ unsafeFreeze comp marr   return arr {-# INLINE unsafeCreateArray_ #-}

@@ -15,11 +15,14 @@   ( -- * Numeric     Numeric   , NumericFloat+  , liftNumArray2M     -- ** Pointwise addition   , (.+)   , (+.)   , (.+.)   , (!+!)+  , sumArraysM+  , sumArrays'   -- ** Pointwise subtraction   , (.-)   , (-.)@@ -31,6 +34,8 @@   , (.*.)   , (!*!)   , (.^)+  , productArraysM+  , productArrays'   -- ** Dot product   , (!.!)   , dotM@@ -96,14 +101,13 @@   ) where  import Data.Massiv.Array.Mutable-import Data.Massiv.Array.Manifest import Data.Massiv.Array.Delayed.Pull import Data.Massiv.Array.Delayed.Push import Data.Massiv.Array.Manifest.Internal import Data.Massiv.Array.Ops.Map as A import Data.Massiv.Array.Ops.Construct import Data.Massiv.Core-import Data.Massiv.Core.Common+import Data.Massiv.Core.Common as A import Data.Massiv.Core.Operations import Prelude as P import System.IO.Unsafe@@ -116,28 +120,40 @@ infixl 7  !*!, .*., .*, *., !/!, ./., ./, /., `quotA`, `remA`, `divA`, `modA` infixl 6  !+!, .+., .+, +., !-!, .-., .-, -. -liftArray2M ::-     (Load r ix e, Numeric r e, MonadThrow m)+-- | Similar to `liftArray2M`, except it can be applied only to representations+-- with `Numeric` instance and result representation stays the same.+--+-- @since 1.0.0+liftNumArray2M ::+     (Index ix, Numeric r e, MonadThrow m)   => (e -> e -> e)   -> Array r ix e   -> Array r ix e   -> m (Array r ix e)-liftArray2M f a1 a2+liftNumArray2M f a1 a2   | size a1 == size a2 = pure $ unsafeLiftArray2 f a1 a2-  | otherwise = throwM $ SizeMismatchException (size a1) (size a2)-{-# INLINE liftArray2M #-}+  | isZeroSz sz1 && isZeroSz sz2 = pure $ unsafeResize zeroSz a1+  | otherwise = throwM $ SizeMismatchException sz1 sz2+  where+    !sz1 = size a1+    !sz2 = size a2+{-# INLINE liftNumArray2M #-}  -liftNumericArray2M ::-     (Load r ix e, MonadThrow m)+applyExactSize2M ::+     (Index ix, Size r, MonadThrow m)   => (Array r ix e -> Array r ix e -> Array r ix e)   -> Array r ix e   -> Array r ix e   -> m (Array r ix e)-liftNumericArray2M f a1 a2+applyExactSize2M f a1 a2   | size a1 == size a2 = pure $ f a1 a2-  | otherwise = throwM $ SizeMismatchException (size a1) (size a2)-{-# INLINE liftNumericArray2M #-}+  | isZeroSz sz1 && isZeroSz sz2 = pure $ unsafeResize zeroSz a1+  | otherwise = throwM $ SizeMismatchException sz1 sz2+  where+    !sz1 = size a1+    !sz2 = size a2+{-# INLINE applyExactSize2M #-}   -- | Add two arrays together pointwise. Same as `!+!` but produces monadic computation@@ -146,9 +162,8 @@ -- /__Throws Exception__/: `SizeMismatchException` when array sizes do not match. -- -- @since 0.4.0-(.+.) ::-     (Load r ix e, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e)-(.+.) = liftNumericArray2M additionPointwise+(.+.) :: (Index ix, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e)+(.+.) = applyExactSize2M additionPointwise {-# INLINE (.+.) #-}  -- | Add two arrays together pointwise. Prefer to use monadic version of this function@@ -165,7 +180,7 @@ --   [ 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40 ] -- -- @since 0.5.6-(!+!) :: (Load r ix e, Numeric r e) => Array r ix e -> Array r ix e -> Array r ix e+(!+!) :: (Index ix, Numeric r e) => Array r ix e -> Array r ix e -> Array r ix e (!+!) a1 a2 = throwEither (a1 .+. a2) {-# INLINE (!+!) #-} @@ -190,8 +205,8 @@ -- -- @since 0.4.0 (.-.) ::-     (Load r ix e, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e)-(.-.) = liftNumericArray2M subtractionPointwise+     (Index ix, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e)+(.-.) = applyExactSize2M subtractionPointwise {-# INLINE (.-.) #-}  @@ -209,7 +224,7 @@ --   [ -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, -20 ] -- -- @since 0.5.6-(!-!) :: (Load r ix e, Numeric r e) => Array r ix e -> Array r ix e -> Array r ix e+(!-!) :: (Index ix, Numeric r e) => Array r ix e -> Array r ix e -> Array r ix e (!-!) a1 a2 = throwEither (a1 .-. a2) {-# INLINE (!-!) #-} @@ -235,8 +250,8 @@ -- -- @since 0.4.0 (.*.) ::-     (Load r ix e, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e)-(.*.) = liftNumericArray2M multiplicationPointwise+     (Index ix, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e)+(.*.) = applyExactSize2M multiplicationPointwise {-# INLINE (.*.) #-}  @@ -256,7 +271,7 @@ --   [ 0, 21, 44, 69, 96, 125, 156, 189, 224, 261, 300 ] -- -- @since 0.5.6-(!*!) :: (Load r ix e, Numeric r e) => Array r ix e -> Array r ix e -> Array r ix e+(!*!) :: (Index ix, Numeric r e) => Array r ix e -> Array r ix e -> Array r ix e (!*!) a1 a2 = throwEither (a1 .*. a2) {-# INLINE (!*!) #-} @@ -320,7 +335,7 @@ -- [Partial] Throws an impure exception when lengths of vectors do not match -- -- @since 0.5.6-(!.!) :: (Numeric r e, Source r Ix1 e) => Vector r e -> Vector r e -> e+(!.!) :: (Numeric r e, Source r e) => Vector r e -> Vector r e -> e (!.!) v1 v2 = throwEither $ dotM v1 v2 {-# INLINE (!.!) #-} @@ -329,7 +344,7 @@ -- /__Throws Exception__/: `SizeMismatchException` when lengths of vectors do not match -- -- @since 0.5.6-dotM :: (FoldNumeric r e, Source r Ix1 e, MonadThrow m) => Vector r e -> Vector r e -> m e+dotM :: (FoldNumeric r e, Source r e, MonadThrow m) => Vector r e -> Vector r e -> m e dotM v1 v2   | size v1 /= size v2 = throwM $ SizeMismatchException (size v1) (size v2)   | comp == Seq = pure $! unsafeDotProduct v1 v2@@ -340,14 +355,14 @@   unsafeDotProductIO ::-     (MonadUnliftIO m, FoldNumeric r b, Source r ix b)+     (MonadUnliftIO m, Index ix, FoldNumeric r b, Source r b)   => Array r ix b   -> Array r ix b   -> m b unsafeDotProductIO v1 v2 = do   results <-     withScheduler comp $ \scheduler ->-      splitLinearly (numWorkers scheduler) totalLength $ \chunkLength slackStart -> do+      splitLinearly (numWorkers scheduler) totalLength $ \chunkLength slackStart -> liftIO $ do         let n = SafeSz chunkLength         loopM_ 0 (< slackStart) (+ chunkLength) $ \ !start ->           scheduleWork scheduler $@@ -367,21 +382,21 @@ -- | Compute L2 norm of an array. -- -- @since 0.5.6-normL2 :: (Floating e, FoldNumeric r e, Source r ix e) => Array r ix e -> e+normL2 :: (FoldNumeric r e, Source r e, Index ix, Floating e) => Array r ix e -> e normL2 v   | getComp v == Seq = sqrt $! powerSumArray v 2   | otherwise = sqrt $! unsafePerformIO $ powerSumArrayIO v 2 {-# INLINE normL2 #-}  powerSumArrayIO ::-     (MonadUnliftIO m, FoldNumeric r b, Source r ix b)+     (MonadUnliftIO m, Index ix, FoldNumeric r b, Source r b)   => Array r ix b   -> Int   -> m b powerSumArrayIO v p = do   results <-     withScheduler (getComp v) $ \scheduler ->-      splitLinearly (numWorkers scheduler) totalLength $ \chunkLength slackStart -> do+      splitLinearly (numWorkers scheduler) totalLength $ \chunkLength slackStart -> liftIO $ do         let n = SafeSz chunkLength         loopM_ 0 (< slackStart) (+ chunkLength) $ \ !start ->           scheduleWork scheduler $ pure $! powerSumArray (unsafeLinearSlice start n v) p@@ -401,7 +416,7 @@ -- -- @since 0.5.6 (.><) ::-     (MonadThrow m, FoldNumeric r e, Source r Ix1 e, Source r Ix2 e)+     (MonadThrow m, FoldNumeric r e, Source r e)   => Matrix r e -- ^ Matrix   -> Vector r e -- ^ Column vector (Used many times, so make sure it is computed)   -> m (Vector D e)@@ -422,7 +437,7 @@ -- -- @since 0.5.7 multiplyMatrixByVector ::-     (MonadThrow m, Numeric r e, Mutable r Ix1 e, Mutable r Ix2 e)+     (MonadThrow m, Numeric r e, Manifest r e)   => Matrix r e -- ^ Matrix   -> Vector r e -- ^ Column vector (Used many times, so make sure it is computed)   -> m (Vector r e)@@ -436,7 +451,7 @@ -- -- @since 0.5.6 (!><) ::-     (Numeric r e, Source r Ix1 e, Source r Ix2 e)+     (Numeric r e, Source r e)   => Matrix r e -- ^ Matrix   -> Vector r e -- ^ Column vector (Used many times, so make sure it is computed)   -> Vector D e@@ -450,7 +465,7 @@ -- /__Throws Exception__/: `SizeMismatchException` when inner dimensions of arrays do not match. -- -- @since 0.5.6-(><.) :: (MonadThrow m, Numeric r e, Mutable r Ix1 e, Mutable r Ix2 e) =>+(><.) :: (MonadThrow m, Numeric r e, Manifest r e) =>          Vector r e -- ^ Row vector       -> Matrix r e -- ^ Matrix       -> m (Vector r e)@@ -464,13 +479,13 @@ -- -- @since 0.5.7 multiplyVectorByMatrix ::-     (MonadThrow m, Numeric r e, Mutable r Ix1 e, Mutable r Ix2 e)+     (MonadThrow m, Numeric r e, Manifest r e)   => Vector r e -- ^ Row vector   -> Matrix r e -- ^ Matrix   -> m (Vector r e) multiplyVectorByMatrix v mm   | mRows /= n = throwM $ SizeMismatchException (Sz2 1 n) (size mm)-  | mRows == 0 || mCols == 0 = pure $ setComp comp empty+  | mRows == 0 || mCols == 0 = pure $ runST (unsafeFreeze comp =<< unsafeNew zeroSz)   | otherwise =     pure $!     unsafePerformIO $ do@@ -501,7 +516,7 @@ -- -- @since 0.5.6 (><!) ::-     (Numeric r e, Mutable r Ix1 e, Mutable r Ix2 e)+     (Numeric r e, Manifest r e)   => Vector r e -- ^ Row vector (Used many times, so make sure it is computed)   -> Matrix r e -- ^ Matrix   -> Vector r e@@ -516,6 +531,7 @@ -- -- ====__Examples__ --+-- >>> import Data.Massiv.Array -- >>> a1 = makeArrayR P Seq (Sz2 5 6) $ \(i :. j) -> i + j -- >>> a2 = makeArrayR P Seq (Sz2 6 5) $ \(i :. j) -> i - j -- >>> a1 !><! a2@@ -528,7 +544,7 @@ --   ] -- -- @since 0.5.6-(!><!) :: (Numeric r e, Mutable r Ix2 e) => Matrix r e -> Matrix r e -> Matrix r e+(!><!) :: (Numeric r e, Manifest r e) => Matrix r e -> Matrix r e -> Matrix r e (!><!) a1 a2 = throwEither (a1 `multiplyMatrices` a2) {-# INLINE (!><!) #-} @@ -538,7 +554,7 @@ -- /__Throws Exception__/: `SizeMismatchException` when inner dimensions of arrays do not match. -- -- @since 0.5.6-(.><.) :: (Numeric r e, Mutable r Ix2 e, MonadThrow m) => Matrix r e -> Matrix r e -> m (Matrix r e)+(.><.) :: (Numeric r e, Manifest r e, MonadThrow m) => Matrix r e -> Matrix r e -> m (Matrix r e) (.><.) = multiplyMatrices {-# INLINE (.><.) #-} @@ -547,12 +563,12 @@ -- -- @since 0.5.6 multiplyMatrices ::-     (Numeric r e, Mutable r Ix2 e, MonadThrow m) => Matrix r e -> Matrix r e -> m (Matrix r e)+     (Numeric r e, Manifest r e, MonadThrow m) => Matrix r e -> Matrix r e -> m (Matrix r e) multiplyMatrices arrA arrB    -- mA == 1 = -- TODO: call multiplyVectorByMatrix    -- nA == 1 = -- TODO: call multiplyMatrixByVector   | nA /= mB = throwM $ SizeMismatchException (size arrA) (size arrB)-  | isEmpty arrA || isEmpty arrB = pure $ setComp comp empty+  | isEmpty arrA || isEmpty arrB = pure $ runST (unsafeFreeze comp =<< unsafeNew zeroSz)   | otherwise = pure $! unsafePerformIO $ do     marrC <- newMArray (SafeSz (mA :. nB)) 0     withScheduler_ comp $ \scheduler -> do@@ -693,7 +709,7 @@ -- -- @since 0.5.6 multiplyMatricesTransposed ::-     (Numeric r e, Manifest r Ix2 e, MonadThrow m)+     (Numeric r e, Manifest r e, MonadThrow m)   => Matrix r e   -> Matrix r e   -> m (Matrix D e)@@ -711,8 +727,6 @@     SafeSz (n2 :. m2) = size arr2 {-# INLINE multiplyMatricesTransposed #-} -- -- | Create an indentity matrix. -- -- ==== __Example__@@ -813,11 +827,11 @@ -- -- @since 0.4.0 (./.) ::-     (Load r ix e, NumericFloat r e, MonadThrow m)+     (Index ix, NumericFloat r e, MonadThrow m)   => Array r ix e   -> Array r ix e   -> m (Array r ix e)-(./.) = liftNumericArray2M divisionPointwise+(./.) = applyExactSize2M divisionPointwise {-# INLINE (./.) #-}  @@ -835,7 +849,7 @@ --   [ 0.2, 0.20792079, 0.21568628, 0.22330096, 0.23076923 ] -- -- @since 0.5.6-(!/!) :: (Load r ix e, NumericFloat r e) => Array r ix e -> Array r ix e -> Array r ix e+(!/!) :: (Index ix, NumericFloat r e) => Array r ix e -> Array r ix e -> Array r ix e (!/!) a1 a2 = throwEither (a1 ./. a2) {-# INLINE (!/!) #-} @@ -928,9 +942,9 @@ -- -- @since 0.4.0 logBaseA-  :: (Source r1 ix e, Source r2 ix e, Floating e)+  :: (Index ix, Source r1 e, Source r2 e, Floating e)   => Array r1 ix e -> Array r2 ix e -> Array D ix e-logBaseA = liftArray2Matching logBase+logBaseA = liftArray2' logBase {-# INLINE logBaseA #-} -- TODO: siwtch to -- (breaking) logBaseA :: Array r ix e -> e -> Array D ix e@@ -948,9 +962,9 @@ -- -- @since 0.4.0 (.**)-  :: (Source r1 ix e, Source r2 ix e, Floating e)+  :: (Index ix, Source r1 e, Source r2 e, Floating e)   => Array r1 ix e -> Array r2 ix e -> Array D ix e-(.**) = liftArray2Matching (**)+(.**) = liftArray2' (**) {-# INLINE (.**) #-} -- TODO: -- !**! :: Array r1 ix e -> Array r2 ix e -> Array D ix e@@ -1077,9 +1091,9 @@ -- -- @since 0.1.0 quotA-  :: (Source r1 ix e, Source r2 ix e, Integral e)+  :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)   => Array r1 ix e -> Array r2 ix e -> Array D ix e-quotA = liftArray2Matching quot+quotA = liftArray2' quot {-# INLINE quotA #-}  @@ -1091,9 +1105,9 @@ -- -- @since 0.1.0 remA-  :: (Source r1 ix e, Source r2 ix e, Integral e)+  :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)   => Array r1 ix e -> Array r2 ix e -> Array D ix e-remA = liftArray2Matching rem+remA = liftArray2' rem {-# INLINE remA #-}  -- | Perform a pointwise integer division where first array contains numerators and the@@ -1105,9 +1119,9 @@ -- -- @since 0.1.0 divA-  :: (Source r1 ix e, Source r2 ix e, Integral e)+  :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)   => Array r1 ix e -> Array r2 ix e -> Array D ix e-divA = liftArray2Matching div+divA = liftArray2' div {-# INLINE divA #-} -- TODO: --  * Array r ix e -> Array r ix e -> m (Array r ix e)@@ -1122,9 +1136,9 @@ -- -- @since 0.1.0 modA-  :: (Source r1 ix e, Source r2 ix e, Integral e)+  :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)   => Array r1 ix e -> Array r2 ix e -> Array D ix e-modA = liftArray2Matching mod+modA = liftArray2' mod {-# INLINE modA #-}  @@ -1138,9 +1152,9 @@ -- -- @since 0.1.0 quotRemA-  :: (Source r1 ix e, Source r2 ix e, Integral e)+  :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)   => Array r1 ix e -> Array r2 ix e -> (Array D ix e, Array D ix e)-quotRemA arr1 = A.unzip . liftArray2Matching quotRem arr1+quotRemA arr1 = A.unzip . liftArray2' quotRem arr1 {-# INLINE quotRemA #-}  @@ -1153,9 +1167,9 @@ -- -- @since 0.1.0 divModA-  :: (Source r1 ix e, Source r2 ix e, Integral e)+  :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)   => Array r1 ix e -> Array r2 ix e -> (Array D ix e, Array D ix e)-divModA arr1 = A.unzip . liftArray2Matching divMod arr1+divModA arr1 = A.unzip . liftArray2' divMod arr1 {-# INLINE divModA #-}  @@ -1165,9 +1179,7 @@ -- > truncateA arr == map truncate arr -- -- @since 0.1.0-truncateA-  :: (Source r ix a, RealFrac a, Integral e)-  => Array r ix a -> Array D ix e+truncateA :: (Index ix, Source r a, RealFrac a, Integral e) => Array r ix a -> Array D ix e truncateA = A.map truncate {-# INLINE truncateA #-} @@ -1177,7 +1189,7 @@ -- > truncateA arr == map truncate arr -- -- @since 0.1.0-roundA :: (Source r ix a, RealFrac a, Integral e) => Array r ix a -> Array D ix e+roundA :: (Index ix, Source r a, RealFrac a, Integral e) => Array r ix a -> Array D ix e roundA = A.map round {-# INLINE roundA #-} @@ -1187,7 +1199,7 @@ -- > truncateA arr == map truncate arr -- -- @since 0.1.0-ceilingA :: (Source r ix a, RealFrac a, Integral e) => Array r ix a -> Array D ix e+ceilingA :: (Index ix, Source r a, RealFrac a, Integral e) => Array r ix a -> Array D ix e ceilingA = A.map ceiling {-# INLINE ceilingA #-} @@ -1197,7 +1209,7 @@ -- > truncateA arr == map truncate arr -- -- @since 0.1.0-floorA :: (Source r ix a, RealFrac a, Integral e) => Array r ix a -> Array D ix e+floorA :: (Index ix, Source r a, RealFrac a, Integral e) => Array r ix a -> Array D ix e floorA = A.map floor {-# INLINE floorA #-} @@ -1209,9 +1221,151 @@ -- -- @since 0.1.0 atan2A ::-     (Load r ix e, Numeric r e, RealFloat e, MonadThrow m)+     (Index ix, Numeric r e, RealFloat e, MonadThrow m)   => Array r ix e   -> Array r ix e   -> m (Array r ix e)-atan2A = liftArray2M atan2+atan2A = liftNumArray2M atan2 {-# INLINE atan2A #-}++-- | Same as `sumArraysM`, compute sum of arrays pointwise. All arrays must have the same+-- size, otherwise it will result in an error.+--+-- @since 1.0.0+sumArrays' :: (HasCallStack, Foldable t, Load r ix e, Numeric r e) => t (Array r ix e) -> Array r ix e+sumArrays' = throwEither . sumArraysM+{-# INLINE sumArrays' #-}++-- | Compute sum of arrays pointwise. All arrays must have the same size.+--+-- ====__Examples__+--+-- >>> import Data.Massiv.Array as A+-- >>> sumArraysM [] :: IO (Array P Ix3 Int)+-- Array P Seq (Sz (0 :> 0 :. 0))+--   [  ]+-- >>> arr = A.makeArrayR P Seq (Sz3 4 5 6) $ \(i :> j :. k) -> i + j * k+-- >>> arr+-- Array P Seq (Sz (4 :> 5 :. 6))+--   [ [ [ 0, 0, 0, 0, 0, 0 ]+--     , [ 0, 1, 2, 3, 4, 5 ]+--     , [ 0, 2, 4, 6, 8, 10 ]+--     , [ 0, 3, 6, 9, 12, 15 ]+--     , [ 0, 4, 8, 12, 16, 20 ]+--     ]+--   , [ [ 1, 1, 1, 1, 1, 1 ]+--     , [ 1, 2, 3, 4, 5, 6 ]+--     , [ 1, 3, 5, 7, 9, 11 ]+--     , [ 1, 4, 7, 10, 13, 16 ]+--     , [ 1, 5, 9, 13, 17, 21 ]+--     ]+--   , [ [ 2, 2, 2, 2, 2, 2 ]+--     , [ 2, 3, 4, 5, 6, 7 ]+--     , [ 2, 4, 6, 8, 10, 12 ]+--     , [ 2, 5, 8, 11, 14, 17 ]+--     , [ 2, 6, 10, 14, 18, 22 ]+--     ]+--   , [ [ 3, 3, 3, 3, 3, 3 ]+--     , [ 3, 4, 5, 6, 7, 8 ]+--     , [ 3, 5, 7, 9, 11, 13 ]+--     , [ 3, 6, 9, 12, 15, 18 ]+--     , [ 3, 7, 11, 15, 19, 23 ]+--     ]+--   ]+-- >>> sumArraysM $ outerSlices arr+-- Array P Seq (Sz (5 :. 6))+--   [ [ 6, 6, 6, 6, 6, 6 ]+--   , [ 6, 10, 14, 18, 22, 26 ]+--   , [ 6, 14, 22, 30, 38, 46 ]+--   , [ 6, 18, 30, 42, 54, 66 ]+--   , [ 6, 22, 38, 54, 70, 86 ]+--   ]+-- >>> sumArraysM $ innerSlices arr+-- Array D Seq (Sz (4 :. 5))+--   [ [ 0, 15, 30, 45, 60 ]+--   , [ 6, 21, 36, 51, 66 ]+--   , [ 12, 27, 42, 57, 72 ]+--   , [ 18, 33, 48, 63, 78 ]+--   ]+--+-- @since 1.0.0+sumArraysM ::+     (Foldable t, Load r ix e, Numeric r e, MonadThrow m) => t (Array r ix e) -> m (Array r ix e)+sumArraysM as =+  case F.toList as of+    [] -> pure empty+    (x:xs) -> F.foldlM (.+.) x xs+{-# INLINE sumArraysM #-}+-- OPTIMIZE: Allocate a single result array and write sums into it incrementally.++-- | Same as `productArraysM`. Compute product of arrays pointwise. All arrays must have+-- the same size, otherwise it+-- will result in an error.+--+-- @since 1.0.0+productArrays' ::+     (HasCallStack, Foldable t, Load r ix e, Numeric r e) => t (Array r ix e) -> Array r ix e+productArrays' = throwEither . productArraysM+{-# INLINE productArrays' #-}+++-- | Compute product of arrays pointwise. All arrays must have the same size.+--+-- ====__Examples__+--+-- >>> import Data.Massiv.Array as A+-- >>> productArraysM [] :: IO (Array P Ix3 Int)+-- Array P Seq (Sz (0 :> 0 :. 0))+--   [  ]+-- >>> arr = A.makeArrayR P Seq (Sz3 4 5 6) $ \(i :> j :. k) -> i + j * k+-- >>> arr+-- Array P Seq (Sz (4 :> 5 :. 6))+--   [ [ [ 0, 0, 0, 0, 0, 0 ]+--     , [ 0, 1, 2, 3, 4, 5 ]+--     , [ 0, 2, 4, 6, 8, 10 ]+--     , [ 0, 3, 6, 9, 12, 15 ]+--     , [ 0, 4, 8, 12, 16, 20 ]+--     ]+--   , [ [ 1, 1, 1, 1, 1, 1 ]+--     , [ 1, 2, 3, 4, 5, 6 ]+--     , [ 1, 3, 5, 7, 9, 11 ]+--     , [ 1, 4, 7, 10, 13, 16 ]+--     , [ 1, 5, 9, 13, 17, 21 ]+--     ]+--   , [ [ 2, 2, 2, 2, 2, 2 ]+--     , [ 2, 3, 4, 5, 6, 7 ]+--     , [ 2, 4, 6, 8, 10, 12 ]+--     , [ 2, 5, 8, 11, 14, 17 ]+--     , [ 2, 6, 10, 14, 18, 22 ]+--     ]+--   , [ [ 3, 3, 3, 3, 3, 3 ]+--     , [ 3, 4, 5, 6, 7, 8 ]+--     , [ 3, 5, 7, 9, 11, 13 ]+--     , [ 3, 6, 9, 12, 15, 18 ]+--     , [ 3, 7, 11, 15, 19, 23 ]+--     ]+--   ]+-- >>> productArraysM $ outerSlices arr+-- Array P Seq (Sz (5 :. 6))+--   [ [ 0, 0, 0, 0, 0, 0 ]+--   , [ 0, 24, 120, 360, 840, 1680 ]+--   , [ 0, 120, 840, 3024, 7920, 17160 ]+--   , [ 0, 360, 3024, 11880, 32760, 73440 ]+--   , [ 0, 840, 7920, 32760, 93024, 212520 ]+--   ]+-- >>> productArraysM $ innerSlices arr+-- Array D Seq (Sz (4 :. 5))+--   [ [ 0, 0, 0, 0, 0 ]+--   , [ 1, 720, 10395, 58240, 208845 ]+--   , [ 64, 5040, 46080, 209440, 665280 ]+--   , [ 729, 20160, 135135, 524880, 1514205 ]+--   ]+--+-- @since 1.0.0+productArraysM ::+     (Foldable t, Load r ix e, Numeric r e, MonadThrow m) => t (Array r ix e) -> m (Array r ix e)+productArraysM as =+  case F.toList as of+    [] -> pure empty+    (x:xs) -> F.foldlM (.*.) x xs+{-# INLINE productArraysM #-}