massiv 1.0.2.0 → 1.0.3.0

raw patch · 52 files changed

+8243/−7411 lines, 52 filesdep +vector-streamPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: vector-stream

API changes (from Hackage documentation)

Files

• CHANGELOG.md +6/−0
• README.md +4/−4
• include/massiv.h +2/−2
• massiv.cabal +4/−2
• src/Data/Massiv/Array.hs +95/−67
• src/Data/Massiv/Array/Delayed.hs +30/−26
• src/Data/Massiv/Array/Delayed/Interleaved.hs +10/−13
• src/Data/Massiv/Array/Delayed/Pull.hs +61/−56
• src/Data/Massiv/Array/Delayed/Stream.hs +15/−26
• src/Data/Massiv/Array/Delayed/Windowed.hs +119/−117
• src/Data/Massiv/Array/Manifest.hs +1/−1
• src/Data/Massiv/Array/Manifest/Boxed.hs +5/−9
• src/Data/Massiv/Array/Manifest/Internal.hs +99/−89
• src/Data/Massiv/Array/Manifest/List.hs +43/−44
• src/Data/Massiv/Array/Manifest/Primitive.hs +196/−206
• src/Data/Massiv/Array/Manifest/Storable.hs +62/−61
• src/Data/Massiv/Array/Manifest/Unboxed.hs +27/−44
• src/Data/Massiv/Array/Manifest/Vector.hs +77/−64
• src/Data/Massiv/Array/Mutable.hs +420/−344
• src/Data/Massiv/Array/Mutable/Algorithms.hs +13/−12
• src/Data/Massiv/Array/Mutable/Atomic.hs +42/−47
• src/Data/Massiv/Array/Mutable/Internal.hs +25/−17
• src/Data/Massiv/Array/Numeric.hs +338/−324
• src/Data/Massiv/Array/Numeric/Integral.hs +142/−102
• src/Data/Massiv/Array/Ops/Construct.hs +239/−188
• src/Data/Massiv/Array/Ops/Fold.hs +212/−177
• src/Data/Massiv/Array/Ops/Fold/Internal.hs +202/−187
• src/Data/Massiv/Array/Ops/Map.hs +307/−266
• src/Data/Massiv/Array/Ops/Slice.hs +61/−59
• src/Data/Massiv/Array/Ops/Sort.hs +53/−58
• src/Data/Massiv/Array/Ops/Transform.hs +258/−195
• src/Data/Massiv/Array/Stencil.hs +63/−54
• src/Data/Massiv/Array/Stencil/Convolution.hs +26/−24
• src/Data/Massiv/Array/Stencil/Internal.hs +12/−14
• src/Data/Massiv/Array/Stencil/Unsafe.hs +21/−21
• src/Data/Massiv/Array/Unsafe.hs +124/−99
• src/Data/Massiv/Core.hs +48/−47
• src/Data/Massiv/Core/Common.hs +293/−210
• src/Data/Massiv/Core/Exception.hs +17/−20
• src/Data/Massiv/Core/Index.hs +256/−187
• src/Data/Massiv/Core/Index/Internal.hs +374/−266
• src/Data/Massiv/Core/Index/Iterator.hs +255/−172
• src/Data/Massiv/Core/Index/Ix.hs +56/−67
• src/Data/Massiv/Core/Index/Stride.hs +23/−25
• src/Data/Massiv/Core/Index/Tuple.hs +96/−92
• src/Data/Massiv/Core/List.hs +102/−101
• src/Data/Massiv/Core/Loop.hs +134/−119
• src/Data/Massiv/Core/Operations.hs +24/−35
• src/Data/Massiv/Vector.hs +2836/−2749
• src/Data/Massiv/Vector/Stream.hs +289/−273
• src/Data/Massiv/Vector/Unsafe.hs +25/−29
• tests/doctests.hs +1/−0

@@ -1,3 +1,9 @@+# 1.0.3++* Deprecated `indexWith` in favor of `indexAssert`+* Addition of scans: `sscanl`, `sscanl1`, `sprescanl`, `spostscanl` and `spostscanlAcc`+* Expose `unsafePrefIndex`+ # 1.0.2  * Addition of `Iterator` type class and related fucntions:

@@ -13,9 +13,9 @@  |      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)| ](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)|+|  [`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)| [![LTS](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)|                                                                               [![LTS](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)|                                                                   [![LTS](https://www.stackage.org/package/scheduler/badge/lts)](https://www.stackage.org/lts/package/scheduler)|  ## Introduction @@ -94,7 +94,7 @@ go ahead and square its elements  ```haskell-λ> makeVectorR D Seq 10 id+λ> vec = makeVectorR D Seq 10 id λ> evaluateM vec 4 4 λ> vec2 = A.map (^ (2 :: Int)) vec

@@ -3,9 +3,9 @@ #define MASSIV_INCLUDE  #if MASSIV_UNSAFE_CHECKS-#define INDEX_CHECK(name, s, f) (indexWith __FILE__ __LINE__ (name) (s) (f))+#define HAS_CALL_STACK (HasCallStack) #else-#define INDEX_CHECK(name, s, f) ((f))+#define HAS_CALL_STACK () #endif  #endif

@@ -1,5 +1,5 @@ name:                massiv-version:             1.0.2.0+version:             1.0.3.0 synopsis:            Massiv (Массив) is an Array Library. description:         Multi-dimensional Arrays with fusion, stencils and parallel computation. homepage:            https://github.com/lehins/massiv@@ -20,7 +20,8 @@                     , GHC == 8.8.4                     , GHC == 8.10.7                     , GHC == 9.0.2-                    , GHC == 9.2.4+                    , GHC == 9.2.5+                    , GHC == 9.4.3  flag unsafe-checks   description: Enable all the bounds checks for unsafe functions at the cost of@@ -88,6 +89,7 @@                      , random >= 1.2.0                      , unliftio-core                      , vector >= 0.12+                     , vector-stream    include-dirs: include   install-includes: massiv.h

@@ -1,4 +1,5 @@ {-# OPTIONS_GHC -fno-warn-duplicate-exports #-}+ -- | -- Module      : Data.Massiv.Array -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -76,85 +77,98 @@ -- import Prelude as P -- import Data.Massiv.Array as A -- @----module Data.Massiv.Array-  ( -- * Construct-    module Data.Massiv.Array.Ops.Construct+module Data.Massiv.Array (+  -- * Construct+  module Data.Massiv.Array.Ops.Construct,+   -- * Compute-  , getComp-  , setComp-  , appComp-  , compute-  , computeS-  , computeP-  , computeIO-  , computePrimM-  , computeAs-  , computeProxy-  , computeSource-  , computeWithStride-  , computeWithStrideAs-  , clone-  , convert-  , convertAs-  , convertProxy-  , fromRaggedArrayM-  , fromRaggedArray'+  getComp,+  setComp,+  appComp,+  compute,+  computeS,+  computeP,+  computeIO,+  computePrimM,+  computeAs,+  computeProxy,+  computeSource,+  computeWithStride,+  computeWithStrideAs,+  clone,+  convert,+  convertAs,+  convertProxy,+  fromRaggedArrayM,+  fromRaggedArray',+   -- * Vector-  , module Data.Massiv.Vector+  module Data.Massiv.Vector,+   -- * Size-  , size-  , elemsCount-  , isEmpty-  , isNotEmpty-  , isNull-  , isNotNull+  size,+  elemsCount,+  isEmpty,+  isNotEmpty,+  isNull,+  isNotNull,+   -- * Indexing-  , (!?)-  , (!)-  , (??)-  , indexM-  , index-  , index'-  , defaultIndex-  , borderIndex-  , evaluateM-  , evaluate'+  (!?),+  (!),+  (??),+  indexM,+  index,+  index',+  defaultIndex,+  borderIndex,+  evaluateM,+  evaluate',+   -- * Mapping-  , module Data.Massiv.Array.Ops.Map-  -- * Folding+  module Data.Massiv.Array.Ops.Map, +  -- * Folding   -- $folding+  module Data.Massiv.Array.Ops.Fold, -  , module Data.Massiv.Array.Ops.Fold   -- * Transforming-  , module Data.Massiv.Array.Ops.Transform+  module Data.Massiv.Array.Ops.Transform,+   -- * Slicing-  , module Data.Massiv.Array.Ops.Slice+  module Data.Massiv.Array.Ops.Slice,+   -- * Algorithms+   -- ** Sorting-  , quicksort-  , quicksortBy-  , quicksortByM-  , tally+  quicksort,+  quicksortBy,+  quicksortByM,+  tally,+   -- ** Iterations-  , iterateUntil+  iterateUntil,+   -- * Conversion-  , module Data.Massiv.Array.Manifest.List+  module Data.Massiv.Array.Manifest.List,+   -- * Mutable-  , module Data.Massiv.Array.Mutable+  module Data.Massiv.Array.Mutable,+   -- * Core-  , module Data.Massiv.Core+  module Data.Massiv.Core,+   -- * Representations-  , module Data.Massiv.Array.Delayed-  , module Data.Massiv.Array.Manifest+  module Data.Massiv.Array.Delayed,+  module Data.Massiv.Array.Manifest,+   -- * Stencil-  , module Data.Massiv.Array.Stencil+  module Data.Massiv.Array.Stencil,+   -- * Numeric Operations-  , module Data.Massiv.Array.Numeric-  ) where+  module Data.Massiv.Array.Numeric,+) where -import Data.Massiv.Vector import Data.Massiv.Array.Delayed import Data.Massiv.Array.Manifest import Data.Massiv.Array.Manifest.Internal@@ -170,12 +184,26 @@ import Data.Massiv.Array.Stencil import Data.Massiv.Core import Data.Massiv.Core.Common-import Prelude as P hiding (all, and, any, enumFromTo, foldl, foldr, mapM,-                            mapM_, maximum, minimum, or, product, replicate, splitAt,-                            sum, zip)--{- $folding--All folding is done in a row-major order.+import Data.Massiv.Vector+import Prelude as P hiding (+  all,+  and,+  any,+  enumFromTo,+  foldl,+  foldr,+  mapM,+  mapM_,+  maximum,+  minimum,+  or,+  product,+  replicate,+  splitAt,+  sum,+  zip,+ ) --}+-- $folding+--+-- All folding is done in a row-major order.

@@ -5,37 +5,41 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Delayed-  ( -- * Delayed+module Data.Massiv.Array.Delayed (+  -- * Delayed+   -- ** Delayed Pull Array-    D(..)-  , delay-  , liftArray2'-  , liftArray2M+  D (..),+  delay,+  liftArray2',+  liftArray2M,+   -- ** Delayed Push Array-  , DL(..)-  , toLoadArray-  , makeLoadArrayS-  , makeLoadArray-  , fromStrideLoad+  DL (..),+  toLoadArray,+  makeLoadArrayS,+  makeLoadArray,+  fromStrideLoad,+   -- ** Delayed Stream Array-  , DS(..)-  , toStreamArray-  , toSteps-  , fromSteps+  DS (..),+  toStreamArray,+  toSteps,+  fromSteps,+   -- ** Delayed Interleaved Array-  , DI(..)-  , toInterleaved-  , fromInterleaved+  DI (..),+  toInterleaved,+  fromInterleaved,+   -- ** Delayed Windowed Array-  , DW(..)-  , Window(..)-  , insertWindow-  , getWindow-  , dropWindow-  , makeWindowedArray-  ) where+  DW (..),+  Window (..),+  insertWindow,+  getWindow,+  dropWindow,+  makeWindowedArray,+) where  import Data.Massiv.Array.Delayed.Interleaved import Data.Massiv.Array.Delayed.Pull

@@ -5,6 +5,7 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}+ -- | -- Module      : Data.Massiv.Array.Delayed.Interleaved -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -12,19 +13,17 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Delayed.Interleaved-  ( DI(..)-  , Array(..)-  , toInterleaved-  , fromInterleaved-  ) where+module Data.Massiv.Array.Delayed.Interleaved (+  DI (..),+  Array (..),+  toInterleaved,+  fromInterleaved,+) where  import Data.Massiv.Array.Delayed.Pull import Data.Massiv.Core.Common import Data.Massiv.Core.List (L, showArrayList, showsArrayPrec) - -- | Delayed array that will be loaded in an interleaved fashion during parallel -- computation. --@@ -33,14 +32,15 @@  newtype instance Array DI ix e = DIArray   { diArray :: Array D ix e-  } deriving (Eq, Ord, Functor, Applicative, Foldable)+  }+  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 Strategy DI where-  setComp c arr = arr { diArray = (diArray arr) { dComp = c } }+  setComp c arr = arr{diArray = (diArray arr){dComp = c}}   {-# INLINE setComp #-}   getComp = dComp . diArray   {-# INLINE getComp #-}@@ -50,14 +50,12 @@   maxLinearSize = Just . SafeSz . elemsCount   {-# INLINE maxLinearSize #-} - instance Size DI where   size (DIArray arr) = size arr   {-# INLINE size #-}   unsafeResize sz = DIArray . unsafeResize sz . diArray   {-# INLINE unsafeResize #-} - instance Index ix => Load DI ix e where   makeArray c sz = DIArray . makeArray c sz   {-# INLINE makeArray #-}@@ -78,7 +76,6 @@  -- | 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 :: (Index ix, Source r e) => Array r ix e -> Array DI ix e toInterleaved = DIArray . delay {-# INLINE toInterleaved #-}

@@ -17,20 +17,20 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable-module Data.Massiv.Array.Delayed.Pull-  ( D(..)-  , Array(..)-  , delay-  , eqArrays-  , compareArrays-  , imap-  , liftArray2'-  , liftArray2M-  , unsafeExtract-  , unsafeSlice-  , unsafeInnerSlice-  , zipWithInternal-  ) where+module Data.Massiv.Array.Delayed.Pull (+  D (..),+  Array (..),+  delay,+  eqArrays,+  compareArrays,+  imap,+  liftArray2',+  liftArray2M,+  unsafeExtract,+  unsafeSlice,+  unsafeInnerSlice,+  zipWithInternal,+) where  import Control.Applicative import qualified Data.Foldable as F@@ -45,16 +45,15 @@ #include "massiv.h"  -- | Delayed representation.-data D =-  D+data D+  = D   deriving (Show) --data instance  Array D ix e =-  DArray { dComp :: !Comp-         , dSize :: !(Sz ix)-         , dPrefIndex :: !(PrefIndex ix e)-         }+data instance Array D ix e = DArray+  { dComp :: !Comp+  , dSize :: !(Sz ix)+  , dPrefIndex :: !(PrefIndex ix e)+  }  instance (Ragged L ix e, Show e) => Show (Array D ix e) where   showsPrec = showsArrayPrec id@@ -72,7 +71,7 @@   {-# INLINE unsafeResize #-}  instance Strategy D where-  setComp c arr = arr {dComp = c}+  setComp c arr = arr{dComp = c}   {-# INLINE setComp #-}   getComp = dComp   {-# INLINE getComp #-}@@ -106,8 +105,8 @@ {-# INLINE unsafeExtract #-}  -- | /O(1)/ - Take a slice out of an array from within-unsafeSlice ::-     (Source r e, Index ix, Index (Lower ix), MonadThrow m)+unsafeSlice+  :: (Source r e, Index ix, Index (Lower ix), MonadThrow m)   => Array r ix e   -> ix   -> Sz ix@@ -119,8 +118,8 @@ {-# INLINE unsafeSlice #-}  -- | /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+  :: (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 $ PrefIndex (unsafeIndex arr . (`snocDim` i)) {-# INLINE unsafeInnerSlice #-}@@ -177,7 +176,7 @@   {-# INLINE makeArray #-}   makeArrayLinear comp sz = DArray comp sz . PrefIndexLinear   {-# INLINE makeArrayLinear #-}-  iterArrayLinearST_ !scheduler DArray {..} uWrite =+  iterArrayLinearST_ !scheduler DArray{..} uWrite =     case dPrefIndex of       PrefIndex f ->         iterTargetFullST_ defRowMajor scheduler 0 dSize $ \ !i -> uWrite i . f@@ -186,7 +185,7 @@   {-# INLINE iterArrayLinearST_ #-}  instance Index ix => StrideLoad D ix e where-  iterArrayLinearWithStrideST_ !scheduler !stride sz DArray {..} uWrite =+  iterArrayLinearWithStrideST_ !scheduler !stride sz DArray{..} uWrite =     case dPrefIndex of       PrefIndex f ->         iterTargetFullWithStrideST_ defRowMajor scheduler 0 sz stride $ \i ->@@ -205,8 +204,9 @@ -- | Map an index aware function over an array -- -- @since 0.1.0-imap ::-     forall r ix e a. (Index ix, Source r e)+imap+  :: forall r ix e a+   . (Index ix, Source r e)   => (ix -> e -> a)   -> Array r ix e   -> Array D ix a@@ -228,7 +228,7 @@   {-# INLINE foldArray #-}  instance Num e => Numeric D e where-  unsafeLiftArray f arr = arr {dPrefIndex = f <$> dPrefIndex arr}+  unsafeLiftArray f arr = arr{dPrefIndex = f <$> dPrefIndex arr}   {-# INLINE unsafeLiftArray #-}   unsafeLiftArray2 f a1 a2 = zipWithInternal (size a1) f a1 a2   {-# INLINE unsafeLiftArray2 #-}@@ -242,16 +242,17 @@     PrefIndex gix -> makeArray (getComp arr) (size arr) gix     PrefIndexLinear gi -> makeArrayLinear (getComp arr) (size arr) gi {-# INLINE [1] delay #-}+ {-# RULES-"delay" [~1] forall (arr :: Array D ix e) . delay arr = arr- #-}+"delay" [~1] forall (arr :: Array D ix e). delay arr = arr+  #-}  -- | 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 ::-     (Index ix, Source r1 e1, Source r2 e2)+eqArrays+  :: (Index ix, Source r1 e1, Source r2 e2)   => (e1 -> e2 -> Bool)   -> Array r1 ix e1   -> Array r2 ix e2@@ -259,13 +260,16 @@ eqArrays f arr1 arr2 =   let sz1 = size arr1       sz2 = size arr2-   in (sz1 == sz2 &&-       not-         (A.any-            not-            (makeArray @D (getComp arr1 <> getComp arr2) (size arr1) $ \ix ->-               f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix)))) ||-      (isZeroSz sz1 && isZeroSz sz2)+   in ( sz1 == sz2+          && not+            ( A.any+                not+                ( makeArray @D (getComp arr1 <> getComp arr2) (size arr1) $ \ix ->+                    f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix)+                )+            )+      )+        || (isZeroSz sz1 && isZeroSz sz2) {-# INLINE eqArrays #-}  -- | Compute array ordering by applying a comparing function to each element.@@ -273,25 +277,26 @@ -- you need an ordering but do not care about which one is used. -- -- @since 0.5.7-compareArrays ::-     (Index ix, Source r1 e1, Source r2 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) <>-  A.fold-    (makeArray @D (getComp arr1 <> getComp arr2) (size arr1) $ \ix ->-       f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix))+  compare (size arr1) (size arr2)+    <> A.fold+      ( makeArray @D (getComp arr1 <> getComp arr2) (size arr1) $ \ix ->+          f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix)+      ) {-# INLINE compareArrays #-}  -- | 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)+liftArray2'+  :: (HasCallStack, Index ix, Source r1 a, Source r2 b)   => (a -> b -> e)   -> Array r1 ix a   -> Array r2 ix b@@ -303,8 +308,8 @@ -- have to be the same, otherwise it throws `SizeMismatchException`. -- -- @since 1.0.0-liftArray2M ::-     (Index ix, Source r1 a, Source r2 b, MonadThrow m)+liftArray2M+  :: (Index ix, Source r1 a, Source r2 b, MonadThrow m)   => (a -> b -> e)   -> Array r1 ix a   -> Array r2 ix b@@ -318,8 +323,8 @@     sz2 = size arr2 {-# INLINE liftArray2M #-} -zipWithInternal ::-     (Index ix, Source r1 e1, Source r2 e2)+zipWithInternal+  :: (Index ix, Source r1 e1, Source r2 e2)   => Sz ix   -> (e1 -> e2 -> e3)   -> Array r1 ix e1@@ -329,7 +334,7 @@   case unsafePrefIndex arr1 of     PrefIndexLinear gi1       | PrefIndexLinear gi2 <- unsafePrefIndex arr2 ->-        makeArrayLinear comp sz (\ !i -> f (gi1 i) (gi2 i))+          makeArrayLinear comp sz (\ !i -> f (gi1 i) (gi2 i))     _ -> makeArray comp sz (\ !ix -> f (unsafeIndex arr1 ix) (unsafeIndex arr2 ix))   where     comp = getComp arr1 <> getComp arr2

@@ -3,6 +3,7 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TypeFamilies #-}+ -- | -- Module      : Data.Massiv.Array.Delayed.Stream -- Copyright   : (c) Alexey Kuleshevich 2019-2022@@ -10,27 +11,26 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Delayed.Stream-  ( DS(..)-  , Array (..)-  , toStreamArray-  , toStreamM-  , toStreamIxM-  , toSteps-  , fromSteps-  , fromStepsM-  ) where+module Data.Massiv.Array.Delayed.Stream (+  DS (..),+  Array (..),+  toStreamArray,+  toStreamM,+  toStreamIxM,+  toSteps,+  fromSteps,+  fromStepsM,+) where  import Control.Applicative import Control.Monad.ST import Data.Coerce import Data.Foldable import Data.Massiv.Array.Delayed.Pull-import qualified Data.Massiv.Vector.Stream as S import Data.Massiv.Core.Common+import qualified Data.Massiv.Vector.Stream as S import GHC.Exts-import Prelude hiding (take, drop)+import Prelude hiding (drop, take)  -- | 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@@ -62,7 +62,6 @@ fromStepsM = fmap DSArray . S.transSteps {-# INLINE fromStepsM #-} - instance Shape DS Ix1 where   linearSizeHint = stepsSize . dsArray   {-# INLINE linearSizeHint #-}@@ -82,7 +81,6 @@   setComp _ = id   repr = DS - instance Functor (Array DS Ix1) where   fmap f = coerce . S.map f . dsArray   {-# INLINE fmap #-}@@ -104,7 +102,6 @@   (>>=) arr f = coerce (S.concatMap (coerce . f) (dsArray arr))   {-# INLINE (>>=) #-} - instance Foldable (Array DS Ix1) where   foldr f acc = S.unId . S.foldrLazy f acc . toSteps   {-# INLINE foldr #-}@@ -135,7 +132,6 @@   (<>) a1 a2 = fromSteps (coerce a1 `S.append` coerce a2)   {-# INLINE (<>) #-} - instance Monoid (Array DS Ix1 e) where   mempty = DSArray S.empty   {-# INLINE mempty #-}@@ -153,20 +149,19 @@   toList = S.toList . coerce   {-# INLINE toList #-} - instance S.Stream DS Ix1 e where   toStream = coerce   {-# INLINE toStream #-}   toStreamIx = S.indexed . coerce   {-# INLINE toStreamIx #-} - -- | Flatten an array into a stream of values. -- -- @since 0.4.1 toStreamArray :: (Index ix, Source r e) => Array r ix e -> Vector DS e toStreamArray = DSArray . S.steps-{-# INLINE[1] toStreamArray #-}+{-# INLINE [1] toStreamArray #-}+ {-# RULES "toStreamArray/id" toStreamArray = id #-}  -- | /O(1)/ - Convert an array into monadic `Steps`@@ -183,10 +178,8 @@ toStreamIxM = S.transStepsId . toStreamIx {-# INLINE toStreamIxM #-} - -- | /O(n)/ - `size` implementation. instance Load DS Ix1 e where-   makeArrayLinear _ k = fromSteps . S.generate k   {-# INLINE makeArrayLinear #-}   replicate _ k = fromSteps . S.replicate k@@ -203,7 +196,6 @@   unsafeLoadIntoIO marr arr = stToIO $ unsafeLoadIntoST marr arr   {-# INLINE unsafeLoadIntoIO #-} - -- cons :: e -> Array DS Ix1 e -> Array DS Ix1 e -- cons e = coerce . S.cons e . dsArray -- {-# INLINE cons #-}@@ -216,7 +208,6 @@ -- snoc (DSArray sts) e = DSArray (S.snoc sts e) -- {-# INLINE snoc #-} - -- TODO: skip the stride while loading -- instance StrideLoad DS Ix1 e where --   iterArrayLinearWithStrideST_ scheduler stride resultSize arr uWrite =@@ -227,5 +218,3 @@ --           iterLinearM_ resultSize start (totalElem resultSize) (numWorkers scheduler) (<) $ --             \ !i ix -> uWrite i (f (liftIndex2 (*) strideIx ix)) --   {-# INLINE iterArrayLinearWithStrideST_ #-}--

@@ -8,6 +8,7 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}+ -- | -- Module      : Data.Massiv.Array.Delayed.Windowed -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -15,16 +16,15 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Delayed.Windowed-  ( DW(..)-  , Array(..)-  , Window(..)-  , insertWindow-  , getWindow-  , dropWindow-  , makeWindowedArray-  ) where+module Data.Massiv.Array.Delayed.Windowed (+  DW (..),+  Array (..),+  Window (..),+  insertWindow,+  getWindow,+  dropWindow,+  makeWindowedArray,+) where  import Control.Monad (when) import Data.Massiv.Array.Delayed.Pull@@ -39,46 +39,46 @@ -- | Delayed Windowed Array representation. data DW = DW -data Window ix e = Window { windowStart     :: !ix-                          -- ^ Index of where window will start at.-                          , windowSize      :: !(Sz ix)-                          -- ^ Size of the window-                          , windowIndex     :: ix -> e-                          -- ^ Indexing function for the window-                          , windowUnrollIx2 :: !(Maybe Int)-                          -- ^ Setting this value during stencil application improves cache-                          -- utilization by unrolling the loop for Ix2 and higher dimensions.-                          -- Has no affect on arrays with one dimension.-                          }+data Window ix e = Window+  { windowStart :: !ix+  -- ^ Index of where window will start at.+  , windowSize :: !(Sz ix)+  -- ^ Size of the window+  , windowIndex :: ix -> e+  -- ^ Indexing function for the window+  , windowUnrollIx2 :: !(Maybe Int)+  -- ^ Setting this value during stencil application improves cache+  -- utilization by unrolling the loop for Ix2 and higher dimensions.+  -- Has no affect on arrays with one dimension.+  }  instance Functor (Window ix) where-  fmap f arr@Window{windowIndex} = arr { windowIndex = f . windowIndex }+  fmap f arr@Window{windowIndex} = arr{windowIndex = f . windowIndex} -data instance Array DW ix e = DWArray { dwArray :: !(Array D ix e)-                                      , dwWindow :: !(Maybe (Window ix e))-                                      }+data instance Array DW ix e = DWArray+  { dwArray :: !(Array D ix e)+  , dwWindow :: !(Maybe (Window ix e))+  }  instance (Ragged L ix e, Load DW ix e, Show e) => Show (Array DW ix e) where   showsPrec = showsArrayPrec (computeAs B)   showList = showArrayList  instance Strategy DW where-  setComp c arr = arr { dwArray = (dwArray arr) { dComp = c } }+  setComp c arr = arr{dwArray = (dwArray arr){dComp = c}}   {-# INLINE setComp #-}   getComp = dComp . dwArray   {-# INLINE getComp #-}   repr = DW - instance Functor (Array DW ix) where   fmap f arr@DWArray{dwArray, dwWindow} =     arr-    { dwArray = fmap f dwArray-    , dwWindow = fmap f <$> dwWindow-    }+      { dwArray = fmap f dwArray+      , dwWindow = fmap f <$> dwWindow+      }   {-# INLINE fmap #-} - -- -- -- @since 0.3.0@@ -120,14 +120,18 @@ -- @since 0.1.3 makeWindowedArray   :: (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-  -> (ix -> e) -- ^ Indexing function foto use inside window+  => 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+  -> (ix -> e)+  -- ^ Indexing function foto use inside window   -> Array DW ix e makeWindowedArray !arr wStart wSize wIndex =   insertWindow (delay arr) $-  Window {windowStart = wStart, windowSize = wSize, windowIndex = wIndex, windowUnrollIx2 = Nothing}+    Window{windowStart = wStart, windowSize = wSize, windowIndex = wIndex, windowUnrollIx2 = Nothing} {-# INLINE makeWindowedArray #-}  -- | Inserts a `Window` into a delayed array while scaling the window down if it doesn't fit inside@@ -136,32 +140,34 @@ -- @since 0.3.0 insertWindow   :: 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 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 insertWindow !arr !window =   DWArray     { dwArray = delay arr     , dwWindow =         Just $!-        Window-          { windowStart = wStart'-          , windowSize = Sz (liftIndex2 min wSize (liftIndex2 (-) sz wStart'))-          , windowIndex = wIndex-          , windowUnrollIx2 = wUnrollIx2-          }+          Window+            { windowStart = wStart'+            , windowSize = Sz (liftIndex2 min wSize (liftIndex2 (-) sz wStart'))+            , windowIndex = wIndex+            , windowUnrollIx2 = wUnrollIx2+            }     }   where     wStart' = unSz (Sz (liftIndex2 min wStart (liftIndex (subtract 1) sz)))     Sz sz = size arr-    Window { windowStart = wStart-           , windowSize = Sz wSize-           , windowIndex = wIndex-           , windowUnrollIx2 = wUnrollIx2-           } = window+    Window+      { windowStart = wStart+      , windowSize = Sz wSize+      , windowIndex = wIndex+      , windowUnrollIx2 = wUnrollIx2+      } = window {-# INLINE insertWindow #-} - -- | Get the `Window` from a windowed array. -- -- @since 0.2.1@@ -176,7 +182,6 @@ dropWindow = dwArray {-# INLINE dropWindow #-} - zeroWindow :: Index ix => Window ix e zeroWindow = Window zeroIndex zeroSz windowError Nothing {-# INLINE zeroWindow #-}@@ -184,16 +189,14 @@ data EmptyWindowException = EmptyWindowException deriving (Eq, Show)  instance Exception EmptyWindowException where-   displayException _ = "Index of zero size Window"  windowError :: a windowError = throwImpossible EmptyWindowException {-# NOINLINE windowError #-} --loadWithIx1 ::-     (Monad m)+loadWithIx1+  :: (Monad m)   => (m () -> m ())   -> Array DW Ix1 e   -> (Ix1 -> e -> m a)@@ -230,18 +233,18 @@  instance StrideLoad DW Ix1 e where   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-      loopA_ 0 (< numWorkers scheduler) (+ 1) $ \ !wid ->-        let !it' = wid * chunkWidth + wStart-         in loadWindow (it', it' + chunkWidth)-      when (slackWidth > 0) $-        let !itSlack = numWorkers scheduler * chunkWidth + wStart-         in loadWindow (itSlack, itSlack + slackWidth)+    (loadWindow, (wStart, wEnd)) <- loadArrayWithIx1 (scheduleWork scheduler) arr stride sz uWrite+    let (chunkWidth, slackWidth) = (wEnd - wStart) `quotRem` numWorkers scheduler+    loopA_ 0 (< numWorkers scheduler) (+ 1) $ \ !wid ->+      let !it' = wid * chunkWidth + wStart+       in loadWindow (it', it' + chunkWidth)+    when (slackWidth > 0) $+      let !itSlack = numWorkers scheduler * chunkWidth + wStart+       in loadWindow (itSlack, itSlack + slackWidth)   {-# INLINE iterArrayLinearWithStrideST_ #-} -loadArrayWithIx1 ::-     (Monad m)+loadArrayWithIx1+  :: (Monad m)   => (m () -> m ())   -> Array DW Ix1 e   -> Stride Ix1@@ -259,15 +262,14 @@   return     ( \(from, to) ->         with $-        iterA_ (strideStart stride from) to strideIx (<) $ \ !i ->-          uWrite (i `div` strideIx) (indexW i)-    , (it, wEnd))+          iterA_ (strideStart stride from) to strideIx (<) $ \ !i ->+            uWrite (i `div` strideIx) (indexW i)+    , (it, wEnd)+    ) {-# INLINE loadArrayWithIx1 #-} ---loadWithIx2 ::-     Monad m+loadWithIx2+  :: Monad m   => (m () -> m ())   -> Array DW Ix2 t1   -> (Int -> t1 -> m ())@@ -293,8 +295,8 @@   return (f, it :. ib) {-# INLINE loadWithIx2 #-} -loadArrayWithIx2 ::-     Monad m+loadArrayWithIx2+  :: Monad m   => (m () -> m ())   -> Array DW Ix2 e   -> Stride Ix2@@ -317,15 +319,15 @@   with $ iterA_ (strideStart stride (it :. 0)) (ib :. jt) strideIx (<) writeB   with $ iterA_ (strideStart stride (it :. jb)) (ib :. n) strideIx (<) writeB   let f (it' :. ib')-        | is > 1 || blockHeight <= 1 -- Turn off unrolling for vertical strides-         = iterA_ (strideStart stride (it' :. jt)) (ib' :. jb) strideIx (<) writeW+        | is > 1 || blockHeight <= 1 =+            -- Turn off unrolling for vertical strides+            iterA_ (strideStart stride (it' :. jt)) (ib' :. jb) strideIx (<) writeW         | otherwise =-          unrollAndJam blockHeight (strideStart stride (it' :. jt)) (ib' :. jb) js writeW+            unrollAndJam blockHeight (strideStart stride (it' :. jt)) (ib' :. jb) js writeW       {-# INLINE f #-}   return (with . f, it :. ib) {-# INLINE loadArrayWithIx2 #-} - loadWindowIx2 :: Monad m => Int -> (Ix2 -> m ()) -> Ix2 -> m () loadWindowIx2 nWorkers loadWindow (it :. ib) = do   let !(chunkHeight, slackHeight) = (ib - it) `quotRem` nWorkers@@ -337,22 +339,20 @@      in loadWindow (itSlack :. (itSlack + slackHeight)) {-# INLINE loadWindowIx2 #-} - instance Load DW Ix2 e where   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))+    loadWithIx2 (scheduleWork scheduler) arr uWrite+      >>= uncurry (loadWindowIx2 (numWorkers scheduler))   {-# INLINE iterArrayLinearST_ #-}  instance StrideLoad DW Ix2 e where   iterArrayLinearWithStrideST_ scheduler stride sz arr uWrite =-    loadArrayWithIx2 (scheduleWork scheduler) arr stride sz uWrite >>=-    uncurry (loadWindowIx2 (numWorkers scheduler))+    loadArrayWithIx2 (scheduleWork scheduler) arr stride sz uWrite+      >>= uncurry (loadWindowIx2 (numWorkers scheduler))   {-# INLINE iterArrayLinearWithStrideST_ #-} - instance (Index (IxN n), Load DW (Ix (n - 1)) e) => Load DW (IxN n) e where   makeArray c sz f = DWArray (makeArray c sz f) Nothing   {-# INLINE makeArray #-}@@ -363,8 +363,8 @@   iterArrayLinearWithStrideST_ = loadArrayWithIxN   {-# INLINE iterArrayLinearWithStrideST_ #-} -loadArrayWithIxN ::-     (Index ix, StrideLoad DW (Lower ix) e)+loadArrayWithIxN+  :: (Index ix, StrideLoad DW (Lower ix) e)   => Scheduler s ()   -> Stride ix   -> Sz ix@@ -373,7 +373,7 @@   -> ST s () loadArrayWithIxN scheduler stride szResult arr uWrite = do   let DWArray darr window = arr-      Window {windowStart, windowSize, windowIndex, windowUnrollIx2} = fromMaybe zeroWindow window+      Window{windowStart, windowSize, windowIndex, windowUnrollIx2} = fromMaybe zeroWindow window       !(headSourceSize, lowerSourceSize) = unconsSz (dSize darr)       !lowerSize = snd $ unconsSz szResult       !(s, lowerStrideIx) = unconsDim $ unStride stride@@ -390,10 +390,12 @@           }       mkLowerArray mw i =         DWArray-          { dwArray = darr { dComp = Seq-                           , dSize = lowerSourceSize-                           , dPrefIndex = PrefIndex (unsafeIndex darr . consDim i)-                           }+          { dwArray =+              darr+                { dComp = Seq+                , dSize = lowerSourceSize+                , dPrefIndex = PrefIndex (unsafeIndex darr . consDim i)+                }           , dwWindow = ($ i) <$> mw           }       loadLower mw !i =@@ -413,17 +415,15 @@   loopA_ (strideStart (Stride s) curWindowEnd) (< unSz headSourceSize) (+ s) (loadLower Nothing) {-# INLINE loadArrayWithIxN #-} ---loadWithIxN ::-     (Index ix, Load DW (Lower ix) e)+loadWithIxN+  :: (Index ix, Load DW (Lower ix) e)   => Scheduler s ()   -> Array DW ix e   -> (Int -> e -> ST s ())   -> ST s () loadWithIxN scheduler arr uWrite = do   let DWArray darr window = arr-      Window {windowStart, windowSize, windowIndex, windowUnrollIx2} = fromMaybe zeroWindow window+      Window{windowStart, windowSize, windowIndex, windowUnrollIx2} = fromMaybe zeroWindow window       !(si, szL) = unconsSz (dSize darr)       !windowEnd = liftIndex2 (+) windowStart (unSz windowSize)       !(t, windowStartL) = unconsDim windowStart@@ -438,42 +438,46 @@       mkLowerArray mw i =         DWArray           { dwArray =-              darr {dComp = Seq, dSize = szL, dPrefIndex = PrefIndex (unsafeIndex darr . consDim i)}+              darr{dComp = Seq, dSize = szL, dPrefIndex = PrefIndex (unsafeIndex darr . consDim i)}           , dwWindow = ($ i) <$> mw           }       loadLower mw !i =         scheduleWork_ scheduler $-        iterArrayLinearST_ scheduler (mkLowerArray mw i) (\k -> uWrite (k + pageElements * i))+          iterArrayLinearST_ scheduler (mkLowerArray mw i) (\k -> uWrite (k + pageElements * i))       {-# NOINLINE loadLower #-}   loopA_ 0 (< headDim windowStart) (+ 1) (loadLower Nothing)   loopA_ t (< headDim windowEnd) (+ 1) (loadLower (Just mkLowerWindow))   loopA_ (headDim windowEnd) (< unSz si) (+ 1) (loadLower Nothing) {-# INLINE loadWithIxN #-} ---unrollAndJam :: Monad m =>-                 Int -- ^ Block height-              -> Ix2 -- ^ Top corner-              -> Ix2 -- ^ Bottom corner-              -> Int -- ^ Column Stride-              -> (Ix2 -> m ()) -- ^ Writing function-              -> m ()+unrollAndJam+  :: Monad m+  => Int+  -- ^ Block height+  -> Ix2+  -- ^ Top corner+  -> Ix2+  -- ^ Bottom corner+  -> Int+  -- ^ Column Stride+  -> (Ix2 -> m ())+  -- ^ Writing function+  -> m () unrollAndJam !bH (it :. jt) (ib :. jb) js f = do-  let f2 (i :. j) = f (i :. j) >> f  ((i + 1) :. j)+  let f2 (i :. j) = f (i :. j) >> f ((i + 1) :. j)   let f3 (i :. j) = f (i :. j) >> f2 ((i + 1) :. j)   let f4 (i :. j) = f (i :. j) >> f3 ((i + 1) :. j)   let f5 (i :. j) = f (i :. j) >> f4 ((i + 1) :. j)   let f6 (i :. j) = f (i :. j) >> f5 ((i + 1) :. j)   let f7 (i :. j) = f (i :. j) >> f6 ((i + 1) :. j)   let f' = case bH of-             1 -> f-             2 -> f2-             3 -> f3-             4 -> f4-             5 -> f5-             6 -> f6-             _ -> f7+        1 -> f+        2 -> f2+        3 -> f3+        4 -> f4+        5 -> f5+        6 -> f6+        _ -> f7   let !ibS = ib - ((ib - it) `mod` bH)   loopA_ it (< ibS) (+ bH) $ \ !i ->     loopA_ jt (< jb) (+ js) $ \ !j ->@@ -482,7 +486,5 @@     loopA_ jt (< jb) (+ js) $ \ !j ->       f (i :. j) {-# INLINE unrollAndJam #-}--  -- TODO: Implement Hilbert curve

@@ -171,7 +171,7 @@ toByteString = castToByteString . #if __GLASGOW_HASKELL__ >= 820   convert-  {- For ghc-8.0 `covert` results in "internal error: ARR_WORDS object entered!" -}+  {- For ghc-8.0 `convert` results in "internal error: ARR_WORDS object entered!" -} #else   compute #endif

@@ -158,8 +158,7 @@  instance Source BL e where   unsafeLinearIndex (BLArray _ _sz o a) i =-    INDEX_CHECK("(Source BL ix e).unsafeLinearIndex",-                SafeSz . A.sizeofArray, A.indexArray) a (i + o)+    indexAssert "BL.unsafeLinearIndex" (SafeSz . A.sizeofArray) A.indexArray a (i + o)   {-# INLINE unsafeLinearIndex #-}    unsafeOuterSlice (BLArray c _ o a) szL i = BLArray c szL (i * totalElem szL + o) a@@ -171,8 +170,7 @@ instance Manifest BL e where    unsafeLinearIndexM (BLArray _ _sz o a) i =-    INDEX_CHECK("(Manifest BL ix e).unsafeLinearIndexM",-                SafeSz . A.sizeofArray, A.indexArray) a (i + o)+    indexAssert "BL.unsafeLinearIndexM" (SafeSz . A.sizeofArray) A.indexArray a (i + o)   {-# INLINE unsafeLinearIndexM #-}    sizeOfMArray (MBLArray sz _ _) = sz@@ -200,13 +198,11 @@   {-# INLINE newMArray #-}    unsafeLinearRead (MBLArray _ o ma) i =-    INDEX_CHECK("(Manifest BL ix e).unsafeLinearRead",-                SafeSz . A.sizeofMutableArray, A.readArray) ma (i + o)+    indexAssert "B.unsafeLinearRead" (SafeSz . A.sizeofMutableArray) A.readArray ma (i + o)   {-# INLINE unsafeLinearRead #-} -  unsafeLinearWrite (MBLArray _sz o ma) i e =-    INDEX_CHECK("(Manifest BL ix e).unsafeLinearWrite",-                SafeSz . A.sizeofMutableArray, A.writeArray) ma (i + o) e+  unsafeLinearWrite (MBLArray _sz o ma) i =+    indexAssert "B.unsafeLinearWrite" (SafeSz . A.sizeofMutableArray) A.writeArray ma (i + o)   {-# INLINE unsafeLinearWrite #-}  instance Size BL where

@@ -8,6 +8,7 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}+ -- | -- Module      : Data.Massiv.Array.Manifest.Internal -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -15,38 +16,37 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Manifest.Internal-  ( Manifest(..)-  , Array(..)-  , flattenMArray-  , compute-  , computeS-  , computeP-  , computeIO-  , computePrimM-  , computeAs-  , computeProxy-  , computeSource-  , computeWithStride-  , computeWithStrideAs-  , clone-  , convert-  , convertAs-  , convertProxy-  , gcastArr-  , fromRaggedArrayM-  , fromRaggedArray'-  , unsafeLoadIntoS-  , unsafeLoadIntoM-  , iterateUntil-  , iterateUntilM-  ) where+module Data.Massiv.Array.Manifest.Internal (+  Manifest (..),+  Array (..),+  flattenMArray,+  compute,+  computeS,+  computeP,+  computeIO,+  computePrimM,+  computeAs,+  computeProxy,+  computeSource,+  computeWithStride,+  computeWithStrideAs,+  clone,+  convert,+  convertAs,+  convertProxy,+  gcastArr,+  fromRaggedArrayM,+  fromRaggedArray',+  unsafeLoadIntoS,+  unsafeLoadIntoM,+  iterateUntil,+  iterateUntilM,+) where -import Control.Exception (try) import Control.DeepSeq-import Control.Monad.ST+import Control.Exception (try) import Control.Monad.Primitive+import Control.Monad.ST import Control.Scheduler import Data.Massiv.Array.Delayed.Pull import Data.Massiv.Array.Mutable@@ -57,13 +57,12 @@ import Data.Typeable import System.IO.Unsafe (unsafePerformIO) - -- | 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' . (Manifest r 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 #-} @@ -71,18 +70,18 @@ -- the same as `computePrimM`, but executed in `ST`, thus pure. -- -- @since 0.1.0-computeS :: forall r ix e r' . (Manifest r 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 #-} - -- | Compute array in parallel using all cores disregarding predefined computation -- strategy. Computation stategy of the resulting array will match the source, despite -- that it is diregarded. -- -- @since 0.5.4-computeP ::-     forall r ix e r'. (Manifest r e, Load r' ix e)+computeP+  :: 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)@@ -94,8 +93,9 @@ -- computing an array during benchmarking. -- -- @since 0.4.5-computeIO ::-     forall r ix e r' m. (Manifest r e, Load r' ix e, MonadIO m)+computeIO+  :: 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))@@ -105,14 +105,14 @@ -- strategy. -- -- @since 0.4.5-computePrimM ::-     forall r ix e r' m. (Manifest r e, Load r' ix e, PrimMonad m)+computePrimM+  :: 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) {-# INLINE computePrimM #-} - -- | Just as `compute`, but let's you supply resulting representation type as an argument. -- -- ====__Examples__@@ -121,12 +121,10 @@ -- >>> computeAs P $ range Seq (Ix1 0) 10 -- Array P Seq (Sz1 10) --   [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]--- computeAs :: (Manifest r e, Load r' ix e) => r -> Array r' ix e -> Array r ix e computeAs _ = compute {-# INLINE computeAs #-} - -- | Same as `compute` and `computeAs`, but let's you supply resulting representation type as a proxy -- argument. --@@ -146,17 +144,18 @@ computeProxy _ = compute {-# INLINE computeProxy #-} - -- | This is just like `convert`, but restricted to `Source` arrays. Will be a noop if -- resulting type is the same as the input. -- -- @since 0.1.0-computeSource :: forall r ix e r' . (Manifest r e, Source r' e, Index ix)-              => Array r' ix e -> Array 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 $ delay arr) (\Refl -> arr) (eqT :: Maybe (r' :~: r)) {-# INLINE computeSource #-} - -- | /O(n)/ - Make an exact immutable copy of an Array. -- -- @since 0.1.0@@ -164,80 +163,91 @@ clone arr = unsafePerformIO $ thaw arr >>= unsafeFreeze (getComp arr) {-# INLINE clone #-} - -- | /O(1)/ - Cast over Array representation-gcastArr :: forall r ix e r' . (Typeable r, Typeable r')-       => Array r' ix e -> Maybe (Array r ix e)+gcastArr+  :: forall r ix e r'+   . (Typeable r, Typeable r')+  => Array r' ix e+  -> Maybe (Array r ix e) gcastArr arr = fmap (\Refl -> arr) (eqT :: Maybe (r :~: r')) - -- | /O(n)/ - conversion between array types. A full copy will occur, unless when the source and -- 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' . (Manifest r e, Load r' ix e)-        => Array r' ix e -> Array 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 #-}  -- | Same as `convert`, but let's you supply resulting representation type as an argument. -- -- @since 0.1.0-convertAs :: (Manifest r e, Load r' ix e)-          => r -> Array r' ix e -> Array r ix e+convertAs+  :: (Manifest r e, Load r' ix e)+  => r+  -> Array r' ix e+  -> Array r ix e convertAs _ = convert {-# INLINE convertAs #-} - -- | Same as `convert` and `convertAs`, but let's you supply resulting representation type as a -- proxy argument. -- -- @since 0.1.1-convertProxy :: (Manifest r e, Load r' ix e)-             => proxy r -> Array r' ix e -> Array 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 #-} - -- | Convert a ragged array into a common array with rectangular shape. Throws `ShapeException` -- whenever supplied ragged array does not have a rectangular shape. -- -- @since 0.4.0-fromRaggedArrayM ::-     forall r ix e r' m . (Manifest r e, Ragged r' ix e, MonadThrow m)+fromRaggedArrayM+  :: 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 = outerSize arr    in either (\(e :: ShapeException) -> throwM e) pure $-      unsafePerformIO $ do-        marr <- unsafeNew sz-        traverse (\_ -> unsafeFreeze (getComp arr) marr) =<<-          try (withMassivScheduler_ (getComp arr) $ \scheduler ->-                stToIO $ loadRaggedST scheduler arr (unsafeLinearWrite marr) 0 (totalElem sz) sz)+        unsafePerformIO $ do+          marr <- unsafeNew sz+          traverse (\_ -> unsafeFreeze (getComp arr) marr)+            =<< try+              ( withMassivScheduler_ (getComp arr) $ \scheduler ->+                  stToIO $ loadRaggedST scheduler arr (unsafeLinearWrite marr) 0 (totalElem sz) sz+              ) {-# INLINE fromRaggedArrayM #-} - -- | 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'. (HasCallStack, Manifest r e, Ragged r' ix e)+fromRaggedArray'+  :: forall r ix e r'+   . (HasCallStack, Manifest r e, Ragged r' ix e)   => Array r' ix e   -> Array r ix e fromRaggedArray' = throwEither . fromRaggedArrayM {-# INLINE fromRaggedArray' #-} - -- | Same as `compute`, but with `Stride`. -- -- /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'. (Manifest r e, StrideLoad r' ix e)+computeWithStride+  :: forall r ix e r'+   . (Manifest r e, StrideLoad r' ix e)   => Stride ix   -> Array r' ix e   -> Array r ix e@@ -248,23 +258,22 @@       stToIO $ iterArrayLinearWithStrideST_ scheduler stride sz arr (unsafeLinearWrite marr) {-# INLINE computeWithStride #-} - -- | Same as `computeWithStride`, but with ability to specify resulting array representation. -- -- @since 0.3.0-computeWithStrideAs ::-     (Manifest r e, StrideLoad r' ix e) => r -> Stride ix -> Array r' ix e -> Array r ix e+computeWithStrideAs+  :: (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)+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)@@ -274,15 +283,15 @@ -- | 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)+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@@ -319,16 +328,17 @@ --   ] -- -- @since 0.3.6-iterateUntil ::-     (Load r' ix e, Manifest r e, NFData (Array r ix e))+iterateUntil+  :: (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.   -> (Int -> Array r ix e -> 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   -> Array r ix e+  -- ^ Initial source array+  -> Array r ix e iterateUntil convergence iteration initArr0 = unsafePerformIO $ do   let loadArr0 = iteration 0 initArr0   initMVec1 <- unsafeNew (fromMaybe zeroSz (maxLinearSize loadArr0))@@ -344,8 +354,8 @@ -- iteration. -- -- @since 0.3.6-iterateUntilM ::-     (Load r' ix e, Manifest r e, MonadIO m)+iterateUntilM+  :: (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@@ -353,7 +363,8 @@   -> (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+  -> Array r ix e+  -- ^ Initial source array   -> m (Array r ix e) iterateUntilM convergence iteration initArr0 = do   loadArr0 <- iteration 0 initArr0@@ -362,9 +373,8 @@   iterateLoop conv iteration 0 initArr0 loadArr0 initMVec1 {-# INLINE iterateUntilM #-} --iterateLoop ::-     (Load r' ix e, Manifest r e, MonadIO m)+iterateLoop+  :: (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

@@ -4,6 +4,7 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-}+ -- | -- Module      : Data.Massiv.Array.Manifest.List -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -11,38 +12,39 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Manifest.List-  ( -- ** List-    fromList-  , fromListsM-  , fromLists'-  , toList-  , toLists-  , toLists2-  , toLists3-  , toLists4-  ) where+module Data.Massiv.Array.Manifest.List (+  -- ** List+  fromList,+  fromListsM,+  fromLists',+  toList,+  toLists,+  toLists2,+  toLists3,+  toLists4,+) where  import Data.Massiv.Array.Manifest.Internal import Data.Massiv.Array.Ops.Fold (foldrInner) import Data.Massiv.Array.Ops.Fold.Internal (foldrFB) import Data.Massiv.Core.Common import Data.Massiv.Core.List-import qualified GHC.Exts as GHC (build, IsList(..))+import qualified GHC.Exts as GHC (IsList (..), build)  -- | Convert a flat list into a vector -- -- @since 0.1.0-fromList ::-     forall r e. Manifest r e-  => Comp -- ^ Computation startegy to use-  -> [e] -- ^ Flat list+fromList+  :: forall r e+   . Manifest r e+  => Comp+  -- ^ Computation startegy to use+  -> [e]+  -- ^ Flat list   -> Vector r e fromList = fromLists' {-# INLINE fromList #-} - -- | /O(n)/ - Convert a nested list into an array. Nested list must be of a rectangular shape, -- otherwise a runtime error will occur. Also, nestedness must match the rank of resulting array, -- which should be specified through an explicit type signature.@@ -82,26 +84,26 @@ -- *** Exception: DimTooShortException for (Dim 1): expected (Sz1 4), got (Sz1 3) -- -- @since 0.3.0-fromListsM ::-     forall r ix e m. (Ragged L ix e, Manifest r e, MonadThrow m)+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 #-} --fromListToListArray ::-     forall ix e. GHC.IsList (Array L ix e)+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 #-}@+-- __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)@@ -127,16 +129,17 @@ --   ] -- -- @since 0.1.0-fromLists' ::-     forall r ix e. (HasCallStack, Ragged L ix e, Manifest r e)-  => Comp -- ^ Computation startegy to use-  -> [ListItem ix e] -- ^ Nested list+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' #-} -- -- | Convert any array to a flat list. -- -- ==== __Examples__@@ -147,10 +150,9 @@ -- -- @since 0.1.0 toList :: (Index ix, Source r e) => Array r ix e -> [e]-toList !arr = GHC.build (\ c n -> foldrFB c n arr)+toList !arr = GHC.build (\c n -> foldrFB c n arr) {-# INLINE toList #-} - -- | /O(n)/ - Convert an array into a nested list. Number of array dimensions and list nestedness -- will always match, but you can use `toList`, `toLists2`, etc. if flattening of inner dimensions -- is desired.@@ -172,15 +174,14 @@ -- [[[0 :> 0 :. 0,0 :> 0 :. 1,0 :> 0 :. 2]],[[1 :> 0 :. 0,1 :> 0 :. 1,1 :> 0 :. 2]]] -- -- @since 0.1.0-toLists ::-     (Ragged L ix e, Shape r ix, Source r e)-  => Array r ix e -- ^ Array to be converted to nested lists+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 #-} -- -- | Convert an array with at least 2 dimensions into a list of lists. Inner dimensions will get -- flattened. --@@ -197,13 +198,12 @@ toLists2 = toList . foldrInner (:) [] {-# INLINE toLists2 #-} - -- | Convert an array with at least 3 dimensions into a 3 deep nested list. Inner dimensions will -- get flattened. -- -- @since 0.1.0-toLists3 ::-     (Source r e, Index ix, Index (Lower ix), Index (Lower (Lower ix))) => 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 #-} @@ -211,8 +211,8 @@ -- get flattened. -- -- @since 0.1.0-toLists4 ::-     ( Source r e+toLists4+  :: ( Source r e      , Index ix      , Index (Lower ix)      , Index (Lower (Lower ix))@@ -222,7 +222,6 @@   -> [[[[e]]]] toLists4 = toList . foldrInner (:) [] . foldrInner (:) [] . foldrInner (:) [] {-# INLINE toLists4 #-}-  -- $setup -- >>> import Data.Massiv.Array as A

@@ -1,5 +1,4 @@ {-# LANGUAGE BangPatterns #-}-{-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MagicHash #-}@@ -9,6 +8,7 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UnboxedTuples #-} {-# LANGUAGE UndecidableInstances #-}+ -- | -- Module      : Data.Massiv.Array.Manifest.Primitive -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -16,76 +16,74 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Manifest.Primitive-  ( P(..)-  , Array(..)-  , MArray(..)-  , Prim-  , toPrimitiveVector-  , toPrimitiveMVector-  , fromPrimitiveVector-  , fromPrimitiveMVector-  , toByteArray-  , toByteArrayM-  , unwrapByteArray-  , unwrapByteArrayOffset-  , unwrapMutableByteArray-  , unwrapMutableByteArrayOffset-  , fromByteArray-  , fromByteArrayM-  , fromByteArrayOffsetM-  , toMutableByteArray-  , toMutableByteArrayM-  , fromMutableByteArrayM-  , fromMutableByteArrayOffsetM-  , fromMutableByteArray-  , shrinkMutableByteArray-  , unsafeAtomicReadIntArray-  , unsafeAtomicWriteIntArray-  , unsafeCasIntArray-  , unsafeAtomicModifyIntArray-  , unsafeAtomicAddIntArray-  , unsafeAtomicSubIntArray-  , unsafeAtomicAndIntArray-  , unsafeAtomicNandIntArray-  , unsafeAtomicOrIntArray-  , unsafeAtomicXorIntArray-  ) where+module Data.Massiv.Array.Manifest.Primitive (+  P (..),+  Array (..),+  MArray (..),+  Prim,+  toPrimitiveVector,+  toPrimitiveMVector,+  fromPrimitiveVector,+  fromPrimitiveMVector,+  toByteArray,+  toByteArrayM,+  unwrapByteArray,+  unwrapByteArrayOffset,+  unwrapMutableByteArray,+  unwrapMutableByteArrayOffset,+  fromByteArray,+  fromByteArrayM,+  fromByteArrayOffsetM,+  toMutableByteArray,+  toMutableByteArrayM,+  fromMutableByteArrayM,+  fromMutableByteArrayOffsetM,+  fromMutableByteArray,+  shrinkMutableByteArray,+  unsafeAtomicReadIntArray,+  unsafeAtomicWriteIntArray,+  unsafeCasIntArray,+  unsafeAtomicModifyIntArray,+  unsafeAtomicAddIntArray,+  unsafeAtomicSubIntArray,+  unsafeAtomicAndIntArray,+  unsafeAtomicNandIntArray,+  unsafeAtomicOrIntArray,+  unsafeAtomicXorIntArray,+) where +import Control.DeepSeq (NFData (..), deepseq) import Control.Monad-import Control.DeepSeq (NFData(..), deepseq)-import Control.Monad.Primitive (PrimMonad(..), primitive_)+import Control.Monad.Primitive (PrimMonad (..), primitive_) import Data.Massiv.Array.Delayed.Pull -- (eq, ord) import Data.Massiv.Array.Manifest.Internal import Data.Massiv.Array.Manifest.List as A import Data.Massiv.Array.Mutable import Data.Massiv.Core.Common-import Data.Massiv.Core.Operations import Data.Massiv.Core.List-import Data.Massiv.Vector.Stream as S (steps, isteps)+import Data.Massiv.Core.Operations+import Data.Massiv.Vector.Stream as S (isteps, steps) import Data.Maybe (fromMaybe)-import Data.Primitive (sizeOf, Prim)+import Data.Primitive (Prim, sizeOf) import Data.Primitive.ByteArray import qualified Data.Vector.Primitive as VP import qualified Data.Vector.Primitive.Mutable as MVP import GHC.Exts as GHC-import Prelude hiding (mapM) import System.IO.Unsafe (unsafePerformIO)--#include "massiv.h"+import Prelude hiding (mapM)  -- | Representation for `Prim`itive elements-data P = P deriving Show+data P = P deriving (Show) -data instance Array P ix e = PArray { pComp   :: !Comp-                                    , pSize   :: !(Sz ix)-                                    , pOffset :: {-# UNPACK #-} !Int-                                    , pData   :: {-# UNPACK #-} !ByteArray-                                    }+data instance Array P ix e = PArray+  { pComp :: !Comp+  , pSize :: !(Sz ix)+  , pOffset :: {-# UNPACK #-} !Int+  , pData :: {-# UNPACK #-} !ByteArray+  } -data instance MArray s P ix e =-  MPArray !(Sz ix) {-# UNPACK #-} !Int {-# UNPACK #-} !(MutableByteArray s)+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@@ -110,11 +108,10 @@ instance Strategy P where   getComp = pComp   {-# INLINE getComp #-}-  setComp c arr = arr { pComp = c }+  setComp c arr = arr{pComp = c}   {-# INLINE setComp #-}   repr = P - instance Index ix => Shape P ix where   maxLinearSize = Just . SafeSz . elemsCount   {-# INLINE maxLinearSize #-}@@ -122,13 +119,12 @@ instance Size P where   size = pSize   {-# INLINE size #-}-  unsafeResize !sz !arr = arr { pSize = sz }+  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)+    indexAssert "P.unsafeLinearIndex" (SafeSz . elemsBA _arr) indexByteArray a (i + o)   {-# INLINE unsafeLinearIndex #-}    unsafeOuterSlice (PArray c _ o a) szL i =@@ -138,12 +134,9 @@   unsafeLinearSlice i k (PArray c _ o a) = PArray c k (i + o) a   {-# INLINE unsafeLinearSlice #-} - 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)+    indexAssert "P.unsafeLinearIndexM" (const (Sz (totalElem _sz))) indexByteArray a (i + o)   {-# INLINE unsafeLinearIndexM #-}    sizeOfMArray (MPArray sz _ _) = sz@@ -164,23 +157,22 @@   unsafeNew sz     | n <= (maxBound :: Int) `div` eSize = MPArray sz 0 <$> newByteArray (n * eSize)     | otherwise = error $ "Array size is too big: " ++ show sz-    where !n = totalElem sz-          !eSize = sizeOf (undefined :: e)+    where+      !n = totalElem sz+      !eSize = sizeOf (undefined :: e)   {-# INLINE unsafeNew #-}    initialize (MPArray sz o mba) =     let k = totalElem sz * sizeOf (undefined :: e)-    in when (k > 0) $ fillByteArray mba o k 0+     in when (k > 0) $ fillByteArray mba o k 0   {-# INLINE initialize #-}    unsafeLinearRead _mpa@(MPArray _sz o ma) i =-    INDEX_CHECK("(Manifest P ix e).unsafeLinearRead",-                const (Sz (totalElem _sz)), readByteArray) ma (i + o)+    indexAssert "P.unsafeLinearRead" (const (Sz (totalElem _sz))) readByteArray ma (i + o)   {-# INLINE unsafeLinearRead #-}    unsafeLinearWrite _mpa@(MPArray _sz o ma) i =-    INDEX_CHECK("(Manifest P ix e).unsafeLinearWrite",-                const (Sz (totalElem _sz)), writeByteArray) ma (i + o)+    indexAssert "P.unsafeLinearWrite" (const (Sz (totalElem _sz))) writeByteArray ma (i + o)   {-# INLINE unsafeLinearWrite #-}    unsafeLinearSet (MPArray _ o ma) offset (SafeSz sz) = setByteArray ma (offset + o) sz@@ -188,12 +180,14 @@    unsafeLinearCopy (MPArray _ oFrom maFrom) iFrom (MPArray _ oTo maTo) iTo (Sz k) =     copyMutableByteArray maTo ((oTo + iTo) * esz) maFrom ((oFrom + iFrom) * esz) (k * esz)-    where esz = sizeOf (undefined :: e)+    where+      esz = sizeOf (undefined :: e)   {-# INLINE unsafeLinearCopy #-}    unsafeArrayLinearCopy (PArray _ _ oFrom aFrom) iFrom (MPArray _ oTo maTo) iTo (Sz k) =     copyByteArray maTo ((oTo + iTo) * esz) aFrom ((oFrom + iFrom) * esz) (k * esz)-    where esz = sizeOf (undefined :: e)+    where+      esz = sizeOf (undefined :: e)   {-# INLINE unsafeArrayLinearCopy #-}    unsafeLinearShrink (MPArray _ o ma) sz = do@@ -205,7 +199,6 @@     MPArray sz o <$> resizeMutableByteArray ma ((o + totalElem sz) * sizeOf (undefined :: e))   {-# INLINE unsafeLinearGrow #-} - instance (Prim e, Index ix) => Load P ix e where   makeArray comp sz f = compute (makeArray comp sz f :: Array D ix e)   {-# INLINE makeArray #-}@@ -227,7 +220,6 @@   toStreamIx = S.isteps   {-# INLINE toStreamIx #-} - instance (Prim e, Num e) => FoldNumeric P e where   unsafeDotProduct = defaultUnsafeDotProduct   {-# INLINE unsafeDotProduct #-}@@ -242,10 +234,8 @@   unsafeLiftArray2 = defaultUnsafeLiftArray2   {-# INLINE unsafeLiftArray2 #-} - instance (Prim e, Floating e) => NumericFloat P e - 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@@ -253,17 +243,14 @@   toList = GHC.toList . toListArray   {-# INLINE toList #-} --elemsBA :: forall proxy e . Prim e => proxy e -> ByteArray -> Int+elemsBA :: forall proxy e. Prim e => proxy e -> ByteArray -> Int elemsBA _ a = sizeofByteArray a `div` sizeOf (undefined :: e) {-# INLINE elemsBA #-} --elemsMBA :: forall proxy e s . Prim e => proxy e -> MutableByteArray s -> Int+elemsMBA :: forall proxy e s. Prim e => proxy e -> MutableByteArray s -> Int elemsMBA _ a = sizeofMutableByteArray a `div` sizeOf (undefined :: e) {-# INLINE elemsMBA #-} - -- | /O(n)/ - Ensure that the size matches the internal `ByteArray`. If not make a copy of -- the slice and return it as `ByteArray` --@@ -281,7 +268,6 @@ unwrapByteArray = pData {-# INLINE unwrapByteArray #-} - -- | /O(1)/ - Extract potential linear offset into the underlying `ByteArray`, which can -- also be extracted with `unwrapByteArray`. --@@ -290,16 +276,14 @@ unwrapByteArrayOffset = pOffset {-# INLINE unwrapByteArrayOffset #-} - -- | /O(1)/ - Unwrap Ensure that the size matches the internal `ByteArray`. -- -- @since 0.5.0 toByteArrayM :: (Prim e, Index ix, MonadThrow m) => Array P ix e -> m ByteArray-toByteArrayM arr@PArray {pSize, pData} = do+toByteArrayM arr@PArray{pSize, pData} = do   pData <$ guardNumberOfElements pSize (Sz (elemsBA arr pData)) {-# INLINE toByteArrayM #-} - -- | /O(1)/ - Construct a primitive array from the `ByteArray`. Will return `Nothing` if -- number of elements doesn't match. --@@ -312,8 +296,8 @@ -- number of elements doesn't match. -- -- @since 0.5.9-fromByteArrayOffsetM ::-     (MonadThrow m, Index ix, Prim e) => Comp -> Sz ix -> Int -> ByteArray -> m (Array P ix e)+fromByteArrayOffsetM+  :: (MonadThrow m, Index ix, Prim e) => Comp -> Sz ix -> Int -> ByteArray -> m (Array P ix e) fromByteArrayOffsetM comp sz off ba =   arr <$ guardNumberOfElements sz (SafeSz (elemsBA arr ba - off))   where@@ -323,11 +307,10 @@ -- | /O(1)/ - Construct a flat Array from `ByteArray` -- -- @since 0.4.0-fromByteArray :: forall e . Prim e => Comp -> ByteArray -> Array P Ix1 e+fromByteArray :: forall e. Prim e => Comp -> ByteArray -> Array P Ix1 e fromByteArray comp ba = PArray comp (SafeSz (elemsBA (Proxy :: Proxy e) ba)) 0 ba {-# INLINE fromByteArray #-} - -- | /O(1)/ - Extract the internal `MutableByteArray`. This will discard any possible -- slicing that has been applied to the array. --@@ -349,8 +332,9 @@ -- that the source at the resulting array are still pointing to the same location in memory. -- -- @since 0.5.0-toMutableByteArray ::-     forall ix e m. (Prim e, Index ix, PrimMonad m)+toMutableByteArray+  :: forall ix e m+   . (Prim e, Index ix, PrimMonad m)   => MArray (PrimState m) P ix e   -> m (Bool, MutableByteArray (PrimState m)) toMutableByteArray marr@(MPArray sz offset mbas) =@@ -364,7 +348,6 @@       pure (False, mbad) {-# INLINE toMutableByteArray #-} - -- | /O(1)/ - Extract the internal `MutableByteArray`. -- -- @since 0.2.1@@ -373,13 +356,12 @@   mba <$ guardNumberOfElements sz (Sz (elemsMBA marr mba)) {-# INLINE toMutableByteArrayM #-} - -- | /O(1)/ - Construct a primitive mutable array from the `MutableByteArray`. Will throw -- `SizeElementsMismatchException` if number of elements doesn't match. -- -- @since 0.3.0-fromMutableByteArrayM ::-     (MonadThrow m, Index ix, Prim e) => Sz ix -> MutableByteArray s -> m (MArray s P ix e)+fromMutableByteArrayM+  :: (MonadThrow m, Index ix, Prim e) => Sz ix -> MutableByteArray s -> m (MArray s P ix e) fromMutableByteArrayM sz = fromMutableByteArrayOffsetM sz 0 {-# INLINE fromMutableByteArrayM #-} @@ -387,33 +369,28 @@ -- `SizeElementsMismatchException` if number of elements doesn't match. -- -- @since 0.5.9-fromMutableByteArrayOffsetM ::-     (MonadThrow m, Index ix, Prim e) => Sz ix -> Ix1 -> MutableByteArray s -> m (MArray s P ix e)+fromMutableByteArrayOffsetM+  :: (MonadThrow m, Index ix, Prim e) => Sz ix -> Ix1 -> MutableByteArray s -> m (MArray s P ix e) fromMutableByteArrayOffsetM sz off mba =   marr <$ guardNumberOfElements sz (SafeSz (elemsMBA marr mba - off))   where     marr = MPArray sz off mba {-# INLINE fromMutableByteArrayOffsetM #-} - -- | /O(1)/ - Construct a flat Array from `MutableByteArray` -- -- @since 0.4.0-fromMutableByteArray :: forall e s . Prim e => MutableByteArray s -> MArray s P Ix1 e+fromMutableByteArray :: forall e s. Prim e => MutableByteArray s -> MArray s P Ix1 e fromMutableByteArray mba = MPArray (SafeSz (elemsMBA (Proxy :: Proxy e) mba)) 0 mba {-# INLINE fromMutableByteArray #-} --- -- | /O(1)/ - Cast a primitive array to a primitive vector. -- -- @since 0.5.0 toPrimitiveVector :: Index ix => Array P ix e -> VP.Vector e-toPrimitiveVector PArray {pSize, pOffset, pData} = VP.Vector pOffset (totalElem pSize) pData+toPrimitiveVector PArray{pSize, pOffset, pData} = VP.Vector pOffset (totalElem pSize) pData {-# INLINE toPrimitiveVector #-} - -- | /O(1)/ - Cast a mutable primitive array to a mutable primitive vector. -- -- @since 0.5.0@@ -421,13 +398,12 @@ toPrimitiveMVector (MPArray sz offset mba) = MVP.MVector offset (totalElem sz) mba {-# INLINE toPrimitiveMVector #-} - -- | /O(1)/ - Cast a primitive vector to a primitive array. -- -- @since 0.5.0 fromPrimitiveVector :: VP.Vector e -> Array P Ix1 e fromPrimitiveVector (VP.Vector offset len ba) =-  PArray {pComp = Seq, pSize = SafeSz len, pOffset = offset, pData = ba}+  PArray{pComp = Seq, pSize = SafeSz len, pOffset = offset, pData = ba} {-# INLINE fromPrimitiveVector #-}  -- | /O(1)/ - Cast a mutable primitive vector to a mutable primitive array.@@ -440,59 +416,67 @@ -- | Atomically read an `Int` element from the array -- -- @since 0.3.0-unsafeAtomicReadIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> m Int+unsafeAtomicReadIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> m Int unsafeAtomicReadIntArray _mpa@(MPArray sz o mba) ix =-  INDEX_CHECK( "unsafeAtomicReadIntArray"-             , SafeSz . elemsMBA _mpa-             , \(MutableByteArray mba#) (I# i#) ->-                 primitive $ \s# ->-                 case atomicReadIntArray# mba# i# s# of-                   (# s'#, e# #) -> (# s'#, I# e# #))-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeAtomicReadIntArray"+    (SafeSz . elemsMBA _mpa)+    ( \(MutableByteArray mba#) (I# i#) ->+        primitive $ \s# ->+          case atomicReadIntArray# mba# i# s# of+            (# s'#, e# #) -> (# s'#, I# e# #)+    )+    mba+    (o + toLinearIndex sz ix) {-# INLINE unsafeAtomicReadIntArray #-}  -- | Atomically write an `Int` element int the array -- -- @since 0.3.0-unsafeAtomicWriteIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m ()+unsafeAtomicWriteIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m () unsafeAtomicWriteIntArray _mpa@(MPArray sz o mba) ix (I# e#) =-  INDEX_CHECK( "unsafeAtomicWriteIntArray"-             , SafeSz . elemsMBA _mpa-             , \(MutableByteArray mba#) (I# i#) ->-                 primitive_ (atomicWriteIntArray# mba# i# e#))-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeAtomicWriteIntArray"+    (SafeSz . elemsMBA _mpa)+    ( \(MutableByteArray mba#) (I# i#) ->+        primitive_ (atomicWriteIntArray# mba# i# e#)+    )+    mba+    (o + toLinearIndex sz ix) {-# INLINE unsafeAtomicWriteIntArray #-}  -- | Atomically CAS an `Int` in the array. Returns the old value. -- -- @since 0.3.0-unsafeCasIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> Int -> m Int+unsafeCasIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> Int -> m Int unsafeCasIntArray _mpa@(MPArray sz o mba) ix (I# e#) (I# n#) =-  INDEX_CHECK( "unsafeCasIntArray"-             , SafeSz . elemsMBA _mpa-             , \(MutableByteArray mba#) (I# i#) ->-                 primitive $ \s# ->-                 case casIntArray# mba# i# e# n# s# of-                   (# s'#, o# #) -> (# s'#, I# o# #))-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeCasIntArray"+    (SafeSz . elemsMBA _mpa)+    ( \(MutableByteArray mba#) (I# i#) ->+        primitive $ \s# ->+          case casIntArray# mba# i# e# n# s# of+            (# s'#, o# #) -> (# s'#, I# o# #)+    )+    mba+    (o + toLinearIndex sz ix) {-# INLINE unsafeCasIntArray #-} - -- | Atomically modify an `Int` element of the array. Returns the old value. -- -- @since 0.3.0-unsafeAtomicModifyIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> (Int -> Int) -> m Int+unsafeAtomicModifyIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> (Int -> Int) -> m Int unsafeAtomicModifyIntArray _mpa@(MPArray sz o mba) ix f =-  INDEX_CHECK("unsafeAtomicModifyIntArray", SafeSz . elemsMBA _mpa, atomicModify)-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeAtomicModifyIntArray"+    (SafeSz . elemsMBA _mpa)+    atomicModify+    mba+    (o + toLinearIndex sz ix)   where     atomicModify (MutableByteArray mba#) (I# i#) =       let go s# o# =@@ -501,111 +485,117 @@                   (# s'#, o'# #) ->                     case o# ==# o'# of                       0# -> go s# o'#-                      _  -> (# s'#, I# o# #)+                      _ -> (# s'#, I# o# #)        in primitive $ \s# ->             case atomicReadIntArray# mba# i# s# of               (# s'#, o# #) -> go s'# o#     {-# INLINE atomicModify #-} {-# INLINE unsafeAtomicModifyIntArray #-} - -- | Atomically add to an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-unsafeAtomicAddIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int+unsafeAtomicAddIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int unsafeAtomicAddIntArray _mpa@(MPArray sz o mba) ix (I# e#) =-  INDEX_CHECK( "unsafeAtomicAddIntArray"-             , SafeSz . elemsMBA _mpa-             , \(MutableByteArray mba#) (I# i#) ->-                 primitive $ \s# ->-                 case fetchAddIntArray# mba# i# e# s# of-                   (# s'#, p# #) -> (# s'#, I# p# #))-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeAtomicAddIntArray"+    (SafeSz . elemsMBA _mpa)+    ( \(MutableByteArray mba#) (I# i#) ->+        primitive $ \s# ->+          case fetchAddIntArray# mba# i# e# s# of+            (# s'#, p# #) -> (# s'#, I# p# #)+    )+    mba+    (o + toLinearIndex sz ix) {-# INLINE unsafeAtomicAddIntArray #-} - -- | Atomically subtract from an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-unsafeAtomicSubIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int+unsafeAtomicSubIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int unsafeAtomicSubIntArray _mpa@(MPArray sz o mba) ix (I# e#) =-  INDEX_CHECK( "unsafeAtomicSubIntArray"-             , SafeSz . elemsMBA _mpa-             , \(MutableByteArray mba#) (I# i#) ->-                 primitive $ \s# ->-                 case fetchSubIntArray# mba# i# e# s# of-                   (# s'#, p# #) -> (# s'#, I# p# #))-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeAtomicSubIntArray"+    (SafeSz . elemsMBA _mpa)+    ( \(MutableByteArray mba#) (I# i#) ->+        primitive $ \s# ->+          case fetchSubIntArray# mba# i# e# s# of+            (# s'#, p# #) -> (# s'#, I# p# #)+    )+    mba+    (o + toLinearIndex sz ix) {-# INLINE unsafeAtomicSubIntArray #-} - -- | Atomically AND an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-unsafeAtomicAndIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int+unsafeAtomicAndIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int unsafeAtomicAndIntArray _mpa@(MPArray sz o mba) ix (I# e#) =-  INDEX_CHECK( "unsafeAtomicAndIntArray"-             , SafeSz . elemsMBA _mpa-             , \(MutableByteArray mba#) (I# i#) ->-                 primitive $ \s# ->-                 case fetchAndIntArray# mba# i# e# s# of-                   (# s'#, p# #) -> (# s'#, I# p# #))-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeAtomicAndIntArray"+    (SafeSz . elemsMBA _mpa)+    ( \(MutableByteArray mba#) (I# i#) ->+        primitive $ \s# ->+          case fetchAndIntArray# mba# i# e# s# of+            (# s'#, p# #) -> (# s'#, I# p# #)+    )+    mba+    (o + toLinearIndex sz ix) {-# INLINE unsafeAtomicAndIntArray #-} - -- | Atomically NAND an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-unsafeAtomicNandIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int+unsafeAtomicNandIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int unsafeAtomicNandIntArray _mpa@(MPArray sz o mba) ix (I# e#) =-  INDEX_CHECK( "unsafeAtomicNandIntArray"-             , SafeSz . elemsMBA _mpa-             , \(MutableByteArray mba#) (I# i#) ->-                 primitive $ \s# ->-                 case fetchNandIntArray# mba# i# e# s# of-                   (# s'#, p# #) -> (# s'#, I# p# #))-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeAtomicNandIntArray"+    (SafeSz . elemsMBA _mpa)+    ( \(MutableByteArray mba#) (I# i#) ->+        primitive $ \s# ->+          case fetchNandIntArray# mba# i# e# s# of+            (# s'#, p# #) -> (# s'#, I# p# #)+    )+    mba+    (o + toLinearIndex sz ix) {-# INLINE unsafeAtomicNandIntArray #-} - -- | Atomically OR an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-unsafeAtomicOrIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int+unsafeAtomicOrIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int unsafeAtomicOrIntArray _mpa@(MPArray sz o mba) ix (I# e#) =-  INDEX_CHECK( "unsafeAtomicOrIntArray"-             , SafeSz . elemsMBA _mpa-             , \(MutableByteArray mba#) (I# i#) ->-                 primitive $ \s# ->-                 case fetchOrIntArray# mba# i# e# s# of-                   (# s'#, p# #) -> (# s'#, I# p# #))-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeAtomicOrIntArray"+    (SafeSz . elemsMBA _mpa)+    ( \(MutableByteArray mba#) (I# i#) ->+        primitive $ \s# ->+          case fetchOrIntArray# mba# i# e# s# of+            (# s'#, p# #) -> (# s'#, I# p# #)+    )+    mba+    (o + toLinearIndex sz ix) {-# INLINE unsafeAtomicOrIntArray #-} - -- | Atomically XOR an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-unsafeAtomicXorIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int+unsafeAtomicXorIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Int unsafeAtomicXorIntArray _mpa@(MPArray sz o mba) ix (I# e#) =-  INDEX_CHECK( "unsafeAtomicXorIntArray"-             , SafeSz . elemsMBA _mpa-             , \(MutableByteArray mba#) (I# i#) ->-                 primitive $ \s# ->-                 case fetchXorIntArray# mba# i# e# s# of-                   (# s'#, p# #) -> (# s'#, I# p# #))-  mba-  (o + toLinearIndex sz ix)+  indexAssert+    "P.unsafeAtomicXorIntArray"+    (SafeSz . elemsMBA _mpa)+    ( \(MutableByteArray mba#) (I# i#) ->+        primitive $ \s# ->+          case fetchXorIntArray# mba# i# e# s# of+            (# s'#, p# #) -> (# s'#, I# p# #)+    )+    mba+    (o + toLinearIndex sz ix) {-# INLINE unsafeAtomicXorIntArray #-}

@@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}+ -- | -- Module      : Data.Massiv.Array.Manifest.Storable -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -14,28 +15,27 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Manifest.Storable-  ( S (..)-  , Array(..)-  , MArray(..)-  , Storable-  , toStorableVector-  , toStorableMVector-  , fromStorableVector-  , fromStorableMVector-  , withPtr-  , unsafeWithPtr-  , unsafeMallocMArray-  , unsafeArrayToForeignPtr-  , unsafeMArrayToForeignPtr-  , unsafeArrayFromForeignPtr-  , unsafeArrayFromForeignPtr0-  , unsafeMArrayFromForeignPtr-  , unsafeMArrayFromForeignPtr0-  ) where+module Data.Massiv.Array.Manifest.Storable (+  S (..),+  Array (..),+  MArray (..),+  Storable,+  toStorableVector,+  toStorableMVector,+  fromStorableVector,+  fromStorableMVector,+  withPtr,+  unsafeWithPtr,+  unsafeMallocMArray,+  unsafeArrayToForeignPtr,+  unsafeMArrayToForeignPtr,+  unsafeArrayFromForeignPtr,+  unsafeArrayFromForeignPtr0,+  unsafeMArrayFromForeignPtr,+  unsafeMArrayFromForeignPtr0,+) where -import Control.DeepSeq (NFData(..), deepseq)+import Control.DeepSeq (NFData (..), deepseq) import Control.Exception import Control.Monad import Control.Monad.IO.Unlift@@ -58,23 +58,22 @@ import Foreign.Storable import GHC.Exts as GHC import GHC.ForeignPtr-import Prelude hiding (mapM) import System.IO.Unsafe (unsafePerformIO) import Unsafe.Coerce+import Prelude hiding (mapM)  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 S = S deriving (Show) -data instance Array S ix e = SArray { sComp   :: !Comp-                                    , sSize   :: !(Sz ix)-                                    , sData   :: {-# UNPACK #-} !(ForeignPtr 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) @@ -101,14 +100,14 @@ instance Strategy S where   getComp = sComp   {-# INLINE getComp #-}-  setComp c arr = arr { sComp = c }+  setComp c arr = arr{sComp = c}   {-# INLINE setComp #-}   repr = S  plusFp :: ForeignPtr a -> Int -> ForeignPtr b plusFp (ForeignPtr addr c) (I# d) = ForeignPtr (plusAddr# addr d) c -advanceForeignPtr :: forall e . Storable e => ForeignPtr e -> Int -> ForeignPtr e+advanceForeignPtr :: forall e. Storable e => ForeignPtr e -> Int -> ForeignPtr e advanceForeignPtr fp i = plusFp fp (i * sizeOf (undefined :: e)) {-# INLINE advanceForeignPtr #-} @@ -118,12 +117,12 @@  instance Storable e => Source S e where   unsafeLinearIndex (SArray _ _sz fp) =-    INDEX_CHECK("(Source S ix e).unsafeLinearIndex", const (toLinearSz _sz), indexForeignPtr) fp+    indexAssert "S.unsafeLinearIndex" (const (toLinearSz _sz)) indexForeignPtr fp   {-# INLINE unsafeLinearIndex #-}    unsafeOuterSlice (SArray c _ fp) szL i =     let k = totalElem szL-    in SArray c szL $ advanceForeignPtr fp (i * k)+     in SArray c szL $ advanceForeignPtr fp (i * k)   {-# INLINE unsafeOuterSlice #-}    unsafeLinearSlice i k (SArray c _ fp) =@@ -137,14 +136,12 @@ instance Size S where   size = sSize   {-# INLINE size #-}-  unsafeResize !sz !arr = arr { sSize = sz }+  unsafeResize !sz !arr = arr{sSize = sz}   {-# INLINE unsafeResize #-} - instance Storable e => Manifest S e where-   unsafeLinearIndexM (SArray _ _sz fp) =-    INDEX_CHECK("(Source S ix e).unsafeLinearIndex", const (toLinearSz _sz), indexForeignPtr) fp+    indexAssert "S.unsafeLinearIndex" (const (toLinearSz _sz)) indexForeignPtr fp   {-# INLINE unsafeLinearIndexM #-}    sizeOfMArray (MSArray sz _) = sz@@ -178,12 +175,24 @@         setPtr (castPtr p) (totalElem sz * sizeOf (undefined :: e)) (0 :: Word8)   {-# INLINE initialize #-} -  unsafeLinearRead (MSArray _sz fp) o = unsafeIOToPrim $-    INDEX_CHECK("(Manifest S ix e).unsafeLinearRead", const (toLinearSz _sz), (\_ _ -> unsafeWithForeignPtr fp (`peekElemOff` o))) fp o+  unsafeLinearRead (MSArray _sz fp) o =+    unsafeIOToPrim $+      indexAssert+        "S.unsafeLinearRead"+        (const (toLinearSz _sz))+        (\_ _ -> unsafeWithForeignPtr fp (`peekElemOff` o))+        fp+        o   {-# INLINE unsafeLinearRead #-} -  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+  unsafeLinearWrite (MSArray _sz fp) o e =+    unsafeIOToPrim $+      indexAssert+        "S.unsafeLinearWrite"+        (const (toLinearSz _sz))+        (\_ _ -> unsafeWithForeignPtr fp (\p -> pokeElemOff p o e))+        fp+        o   {-# INLINE unsafeLinearWrite #-}    unsafeLinearSet (MSArray _ fp) i k e =@@ -192,8 +201,8 @@    unsafeLinearCopy (MSArray _ fpFrom) iFrom (MSArray _ fpTo) iTo (Sz k) = do     unsafePrimToPrim $-      withForeignPtr fpFrom $ \ ptrFrom ->-        withForeignPtr fpTo $ \ ptrTo -> do+      withForeignPtr fpFrom $ \ptrFrom ->+        withForeignPtr fpTo $ \ptrTo -> do           let ptrFrom' = advancePtr ptrFrom iFrom               ptrTo' = advancePtr ptrTo iTo           copyArray ptrTo' ptrFrom' k@@ -240,7 +249,6 @@   toStreamIx = S.isteps   {-# INLINE toStreamIx #-} - instance (Storable e, Num e) => FoldNumeric S e where   unsafeDotProduct = defaultUnsafeDotProduct   {-# INLINE unsafeDotProduct #-}@@ -257,7 +265,6 @@  instance (Storable e, Floating e) => NumericFloat S e - 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@@ -273,7 +280,6 @@ 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@@ -281,18 +287,17 @@ 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 :: 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))+  -- this hack is needed to workaround the redundant Storable constraint+  -- see haskell/vector#394+  unsafeCoerce $+    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@@ -308,7 +313,7 @@   -- 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}+    (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.@@ -318,7 +323,6 @@ 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@@ -337,7 +341,7 @@ -- -- @since 0.3.0 unsafeArrayFromForeignPtr0 :: Comp -> ForeignPtr e -> Sz1 -> Vector S e-unsafeArrayFromForeignPtr0 comp fp sz = SArray {sComp = comp, sSize = sz, sData = fp}+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.@@ -345,10 +349,9 @@ -- @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 = advanceForeignPtr ptr offset}+  SArray{sComp = comp, sSize = sz, sData = advanceForeignPtr ptr offset} {-# INLINE unsafeArrayFromForeignPtr #-} - -- | /O(1)/ - Wrap a `ForeignPtr` and it's size into a mutable storable array. It is still safe to -- modify the pointer, unless the array gets frozen prior to modification. --@@ -357,7 +360,6 @@ unsafeMArrayFromForeignPtr0 fp sz = MSArray sz fp {-# INLINE unsafeMArrayFromForeignPtr0 #-} - -- | /O(1)/ - Wrap a `ForeignPtr`, an offset and it's size into a mutable storable array. It is -- still safe to modify the pointer, unless the array gets frozen prior to modification. --@@ -366,13 +368,13 @@ unsafeMArrayFromForeignPtr fp offset sz = MSArray sz (advanceForeignPtr fp offset) {-# INLINE unsafeMArrayFromForeignPtr #-} - -- | Allocate memory using @malloc@ on C heap, instead of on Haskell heap. Memory is left -- uninitialized -- -- @since 0.5.9-unsafeMallocMArray ::-     forall ix e m. (Index ix, Storable e, PrimMonad m)+unsafeMallocMArray+  :: forall ix e m+   . (Index ix, Storable e, PrimMonad m)   => Sz ix   -> m (MArray (PrimState m) S ix e) unsafeMallocMArray sz = unsafePrimToPrim $ do@@ -382,7 +384,6 @@     newForeignPtr finalizerFree ptr   pure $ MSArray sz foreignPtr {-# INLINE unsafeMallocMArray #-}-  #if !MIN_VERSION_base(4,15,0) -- | A compatibility wrapper for 'GHC.ForeignPtr.unsafeWithForeignPtr' provided

@@ -1,11 +1,11 @@ {-# LANGUAGE BangPatterns #-}-{-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}+ -- | -- Module      : Data.Massiv.Array.Manifest.Unboxed -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -13,19 +13,18 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Manifest.Unboxed-  ( U (..)-  , Unbox-  , Array(..)-  , MArray(..)-  , toUnboxedVector-  , toUnboxedMVector-  , fromUnboxedVector-  , fromUnboxedMVector-  ) where+module Data.Massiv.Array.Manifest.Unboxed (+  U (..),+  Unbox,+  Array (..),+  MArray (..),+  toUnboxedVector,+  toUnboxedMVector,+  fromUnboxedVector,+  fromUnboxedMVector,+) where -import Control.DeepSeq (NFData(..), deepseq)+import Control.DeepSeq (NFData (..), deepseq) import Control.Monad.Primitive (stToPrim) import Data.Massiv.Array.Delayed.Pull (D, compareArrays, eqArrays) import Data.Massiv.Array.Manifest.Internal@@ -39,19 +38,18 @@ import Data.Vector.Unboxed (Unbox) import qualified Data.Vector.Unboxed as VU import qualified Data.Vector.Unboxed.Mutable as MVU-import GHC.Exts as GHC (IsList(..))-import Prelude hiding (mapM)+import GHC.Exts as GHC (IsList (..)) import System.IO.Unsafe (unsafePerformIO)--#include "massiv.h"+import Prelude hiding (mapM)  -- | Representation for `Unbox`ed elements-data U = U deriving Show+data U = U deriving (Show) -data instance Array U ix e = UArray { uComp :: !Comp-                                    , uSize :: !(Sz ix)-                                    , uData :: !(VU.Vector e)-                                    }+data instance Array U ix e = UArray+  { uComp :: !Comp+  , 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, Unbox e) => Show (Array U ix e) where@@ -69,11 +67,10 @@ instance Strategy U where   getComp = uComp   {-# INLINE getComp #-}-  setComp c arr = arr { uComp = c }+  setComp c arr = arr{uComp = c}   {-# INLINE setComp #-}   repr = U - instance (Unbox e, Eq e, Index ix) => Eq (Array U ix e) where   (==) = eqArrays (==)   {-# INLINE (==) #-}@@ -82,15 +79,14 @@   compare = compareArrays compare   {-# INLINE compare #-} - instance Unbox e => Source U e where   unsafeLinearIndex (UArray _ _ v) =-    INDEX_CHECK("(Source U ix e).unsafeLinearIndex", Sz . VU.length, VU.unsafeIndex) v+    indexAssert "U.unsafeLinearIndex" (SafeSz . 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+     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@@ -103,7 +99,7 @@ instance Size U where   size = uSize   {-# INLINE size #-}-  unsafeResize !sz !arr = arr { uSize = sz }+  unsafeResize !sz !arr = arr{uSize = sz}   {-# INLINE unsafeResize #-}  instance (Unbox e, Index ix) => Load U ix e where@@ -122,14 +118,9 @@  instance (Unbox e, Index ix) => StrideLoad U ix e ---- instance Unbox e => Manifest U e where-   unsafeLinearIndexM (UArray _ _ v) =-    INDEX_CHECK("(Manifest U ix e).unsafeLinearIndexM", Sz . VU.length, VU.unsafeIndex) v+    indexAssert "S.unsafeLinearIndexM" (SafeSz . VU.length) VU.unsafeIndex v   {-# INLINE unsafeLinearIndexM #-}    sizeOfMArray (MUArray sz _) = sz@@ -158,24 +149,22 @@   {-# INLINE unsafeLinearCopy #-}    unsafeLinearRead (MUArray _ mv) =-    INDEX_CHECK("(Manifest U ix e).unsafeLinearRead", Sz . MVU.length, MVU.unsafeRead) mv+    indexAssert "U.unsafeLinearRead" (Sz . MVU.length) MVU.unsafeRead mv   {-# INLINE unsafeLinearRead #-}    unsafeLinearWrite (MUArray _ mv) =-    INDEX_CHECK("(Manifest U ix e).unsafeLinearWrite", Sz . MVU.length, MVU.unsafeWrite) mv+    indexAssert "U.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, Unbox e) => Stream U ix e where   toStream = S.steps   {-# INLINE toStream #-}   toStreamIx = S.isteps   {-# INLINE toStreamIx #-} - 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@@ -183,7 +172,6 @@   toList = GHC.toList . toListArray   {-# INLINE toList #-} - instance (VU.Unbox e, Num e) => FoldNumeric U e where   unsafeDotProduct = defaultUnsafeDotProduct   {-# INLINE unsafeDotProduct #-}@@ -198,7 +186,6 @@   unsafeLiftArray2 = defaultUnsafeLiftArray2   {-# INLINE unsafeLiftArray2 #-} - -- | /O(1)/ - Unwrap unboxed array and pull out the underlying unboxed vector. -- -- @since 0.2.1@@ -206,7 +193,6 @@ toUnboxedVector = uData {-# INLINE toUnboxedVector #-} - -- | /O(1)/ - Unwrap unboxed mutable array and pull out the underlying unboxed mutable vector. -- -- @since 0.2.1@@ -214,15 +200,12 @@ toUnboxedMVector (MUArray _ mv) = mv {-# INLINE toUnboxedMVector #-} -- -- | /O(1)/ - Wrap an unboxed vector and produce an unboxed flat array. -- -- @since 0.6.0 fromUnboxedVector :: VU.Unbox e => Comp -> VU.Vector e -> Vector U e fromUnboxedVector comp v = UArray comp (SafeSz (VU.length v)) v {-# INLINE fromUnboxedVector #-}-  -- | /O(1)/ - Wrap an unboxed mutable vector and produce a mutable unboxed flat array. --

@@ -4,6 +4,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-}+ -- | -- Module      : Data.Massiv.Array.Manifest.Vector -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -11,16 +12,15 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Manifest.Vector-  ( fromVectorM-  , fromVector'-  , castFromVector-  , toVector-  , castToVector-  , ARepr-  , VRepr-  ) where+module Data.Massiv.Array.Manifest.Vector (+  fromVectorM,+  fromVector',+  castFromVector,+  toVector,+  castToVector,+  ARepr,+  VRepr,+) where  import Control.Monad (guard, join, msum) import Data.Kind@@ -54,46 +54,54 @@   VRepr BN = VB.Vector   VRepr BL = VB.Vector - -- | /O(1)/ - conversion from vector to an array with a corresponding representation. Will -- 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, Index ix, ARepr v ~ r)-               => Comp-               -> Sz ix -- ^ Size of the result Array-               -> v e -- ^ Source Vector-               -> Maybe (Array r ix e)+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+  -> Maybe (Array r ix e) castFromVector comp sz vector = do   guard (totalElem sz == VG.length vector)   msum-    [ do Refl <- eqT :: Maybe (v :~: VU.Vector)-         uVector <- join $ gcast1 (Just vector)-         return $ UArray {uComp = comp, uSize = sz, uData = uVector}-    , do Refl <- eqT :: Maybe (v :~: VS.Vector)-         sVector <- join $ gcast1 (Just vector)-         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}-    , do Refl <- eqT :: Maybe (v :~: VB.Vector)-         bVector <- join $ gcast1 (Just vector)-         pure $ unsafeResize sz $ setComp comp $ fromBoxedVector bVector+    [ do+        Refl <- eqT :: Maybe (v :~: VU.Vector)+        uVector <- join $ gcast1 (Just vector)+        return $ UArray{uComp = comp, uSize = sz, uData = uVector}+    , do+        Refl <- eqT :: Maybe (v :~: VS.Vector)+        sVector <- join $ gcast1 (Just vector)+        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}+    , do+        Refl <- eqT :: Maybe (v :~: VB.Vector)+        bVector <- join $ gcast1 (Just vector)+        pure $ unsafeResize sz $ setComp comp $ fromBoxedVector bVector     ] {-# NOINLINE castFromVector #-} - -- | In case when resulting array representation matches the one of vector's it -- will do a /O(1)/ - conversion using `castFromVector`, otherwise Vector elements -- will be copied into a new array. Will throw an error if length of resulting -- array doesn't match the source vector length. -- -- @since 0.3.0-fromVectorM ::-     (MonadThrow m, Typeable v, VG.Vector v a, Manifest r a, Load (ARepr v) ix a, Load r ix a)+fromVectorM+  :: (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+  -> Sz ix+  -- ^ Resulting size of the array+  -> v a+  -- ^ Source Vector   -> m (Array r ix a) fromVectorM comp sz v =   case castFromVector comp sz v of@@ -103,15 +111,16 @@       pure (makeArrayLinear comp sz (VG.unsafeIndex v)) {-# NOINLINE fromVectorM #-} - -- | Just like `fromVectorM`, but will throw an exception on a mismatched size. -- -- @since 0.3.0-fromVector' ::-     (HasCallStack, Typeable v, VG.Vector v a, Load (ARepr v) ix a, Load r ix a, Manifest r a)+fromVector'+  :: (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+  -> Sz ix+  -- ^ Resulting size of the array+  -> v a+  -- ^ Source Vector   -> Array r ix a fromVector' comp sz = throwEither . fromVectorM comp sz {-# INLINE fromVector' #-}@@ -119,34 +128,40 @@ -- | /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. (Manifest r e, Index ix, VRepr r ~ v)+castToVector+  :: forall v r ix e+   . (Manifest r e, Index ix, VRepr r ~ v)   => Array r ix e   -> Maybe (v e) castToVector arr =   msum-    [ do Refl <- eqT :: Maybe (r :~: U)-         uArr <- gcastArr arr-         return $ uData uArr-    , do Refl <- eqT :: Maybe (r :~: S)-         sArr <- gcastArr arr-         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 :~: BN)-         bArr <- gcastArr arr-         return $ toBoxedVector $ toLazyArray $ unwrapNormalForm bArr-    , do Refl <- eqT :: Maybe (r :~: BL)-         bArr <- gcastArr arr-         return $ toBoxedVector bArr+    [ do+        Refl <- eqT :: Maybe (r :~: U)+        uArr <- gcastArr arr+        return $ uData uArr+    , do+        Refl <- eqT :: Maybe (r :~: S)+        sArr <- gcastArr arr+        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 :~: BN)+        bArr <- gcastArr arr+        return $ toBoxedVector $ toLazyArray $ unwrapNormalForm bArr+    , do+        Refl <- eqT :: Maybe (r :~: BL)+        bArr <- gcastArr arr+        return $ toBoxedVector bArr     ] {-# NOINLINE castToVector #-} - -- | Convert an array into a vector. Will perform a cast if resulting vector is -- of compatible representation, otherwise memory copy will occur. --@@ -168,10 +183,9 @@ -- >>> import qualified Data.Vector.Unboxed as VU -- >>> toVector (makeArrayR S Par (Sz2 5 6) (\(i :. j) -> i + j)) :: VU.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]----toVector ::-     forall r ix e v.-     ( Manifest r e+toVector+  :: forall r ix e v+   . ( Manifest r e      , Load r ix e      , Manifest (ARepr v) e      , VG.Vector v e@@ -184,4 +198,3 @@     (VG.generate (totalElem (size arr)) (unsafeLinearIndex arr))     (castToVector (convert arr :: Array (ARepr v) ix e)) {-# NOINLINE toVector #-}-

@@ -5,6 +5,7 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-}+ -- | -- Module      : Data.Massiv.Array.Mutable -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -12,100 +13,111 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Mutable-  ( -- ** Size-    sizeOfMArray-  , msize-  , resizeMArrayM-  , flattenMArray-  , outerSliceMArrayM-  , outerSlicesMArray-    -- ** Element-wise mutation-  , read-  , readM-  , write-  , write_-  , writeM-  , modify-  , modify_-  , modifyM-  , modifyM_-  , swap-  , swap_-  , swapM-  , swapM_-  , zipSwapM_+module Data.Massiv.Array.Mutable (+  -- ** Size+  sizeOfMArray,+  msize,+  resizeMArrayM,+  flattenMArray,+  outerSliceMArrayM,+  outerSlicesMArray,++  -- ** Element-wise mutation+  read,+  readM,+  write,+  write_,+  writeM,+  modify,+  modify_,+  modifyM,+  modifyM_,+  swap,+  swap_,+  swapM,+  swapM_,+  zipSwapM_,+   -- ** Operations on @MArray@+   -- *** Immutable conversion-  , thaw-  , thawS-  , freeze-  , freezeS+  thaw,+  thawS,+  freeze,+  freezeS,+   -- *** Create mutable-  , newMArray-  , newMArray'-  , makeMArray-  , makeMArrayLinear-  , makeMArrayS-  , makeMArrayLinearS+  newMArray,+  newMArray',+  makeMArray,+  makeMArrayLinear,+  makeMArrayS,+  makeMArrayLinearS,+   -- *** Create pure-  , createArray_-  , createArray-  , createArrayS_-  , createArrayS-  , createArrayST_-  , createArrayST+  createArray_,+  createArray,+  createArrayS_,+  createArrayS,+  createArrayST_,+  createArrayST,+   -- *** Generate-  , generateArray-  , generateArrayLinear-  , generateArrayS-  , generateArrayLinearS-  , generateSplitSeedArray+  generateArray,+  generateArrayLinear,+  generateArrayS,+  generateArrayLinearS,+  generateSplitSeedArray,+   -- *** Stateful worker threads-  , generateArrayWS-  , generateArrayLinearWS+  generateArrayWS,+  generateArrayLinearWS,+   -- *** Unfold-  , unfoldrPrimM_-  , iunfoldrPrimM_-  , unfoldrPrimM-  , iunfoldrPrimM-  , unfoldlPrimM_-  , iunfoldlPrimM_-  , unfoldlPrimM-  , iunfoldlPrimM+  unfoldrPrimM_,+  iunfoldrPrimM_,+  unfoldrPrimM,+  iunfoldrPrimM,+  unfoldlPrimM_,+  iunfoldlPrimM_,+  unfoldlPrimM,+  iunfoldlPrimM,+   -- *** Mapping-  , forPrimM-  , forPrimM_-  , iforPrimM-  , iforPrimM_-  , iforLinearPrimM-  , iforLinearPrimM_-  , for2PrimM_-  , ifor2PrimM_+  forPrimM,+  forPrimM_,+  iforPrimM,+  iforPrimM_,+  iforLinearPrimM,+  iforLinearPrimM_,+  for2PrimM_,+  ifor2PrimM_,+   -- *** Modify-  , withMArray-  , withMArray_-  , withLoadMArray_-  , withMArrayS-  , withLoadMArrayS-  , withMArrayS_-  , withLoadMArrayS_-  , withMArrayST-  , withLoadMArrayST-  , withMArrayST_-  , withLoadMArrayST_+  withMArray,+  withMArray_,+  withLoadMArray_,+  withMArrayS,+  withLoadMArrayS,+  withMArrayS_,+  withLoadMArrayS_,+  withMArrayST,+  withLoadMArrayST,+  withMArrayST_,+  withLoadMArrayST_,+   -- *** Initialize-  , initialize-  , initializeNew+  initialize,+  initializeNew,+   -- ** Computation-  , Manifest-  , MArray-  , RealWorld-  , computeInto-  , loadArray-  , loadArrayS-  ) where+  Manifest,+  MArray,+  RealWorld,+  computeInto,+  loadArray,+  loadArrayS,+) where  -- TODO: add fromListM, et al. @@ -118,16 +130,16 @@ import Data.Massiv.Array.Mutable.Internal import Data.Massiv.Core.Common import Data.Maybe (fromMaybe)-import Prelude hiding (mapM, read) import System.IO.Unsafe (unsafePerformIO)+import Prelude hiding (mapM, read)  -- | /O(1)/ - Change the size of a mutable array. Throws -- `SizeElementsMismatchException` if total number of elements does not match -- the supplied array. -- -- @since 1.0.0-resizeMArrayM ::-     (Manifest r e, Index ix', Index ix, MonadThrow m)+resizeMArrayM+  :: (Manifest r e, Index ix', Index ix, MonadThrow m)   => Sz ix'   -> MArray s r ix e   -> m (MArray s r ix' e)@@ -135,7 +147,6 @@   unsafeResizeMArray sz marr <$ guardNumberOfElements (sizeOfMArray marr) sz {-# INLINE resizeMArrayM #-} - -- | /O(1)/ - Change a mutable array to a mutable vector. -- -- @since 1.0.0@@ -143,14 +154,14 @@ 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)+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)@@ -215,8 +226,9 @@ --   ] -- -- @since 1.0.0-outerSlicesMArray ::-     forall r ix e s. (Index (Lower ix), Index ix, Manifest r e)+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)@@ -227,7 +239,6 @@     (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 it will be a thunk with `Uninitialized` exception, while for others it will be -- simply zeros.@@ -254,14 +265,14 @@ -- *** Exception: Uninitialized -- -- @since 0.6.0-newMArray' ::-     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)+newMArray'+  :: 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 {-# INLINE newMArray' #-} - -- | /O(n)/ - Make a mutable copy of a pure array. Keep in mind that both `freeze` and `thaw` trigger a -- copy of the full array. --@@ -293,7 +304,7 @@         let slackLength = totalLength - slackStart         when (slackLength > 0) $           scheduleWork_ scheduler $-          unsafeArrayLinearCopy arr slackStart marr slackStart (SafeSz slackLength)+            unsafeArrayLinearCopy arr slackStart marr slackStart (SafeSz slackLength)     pure marr {-# INLINE thaw #-} @@ -311,8 +322,9 @@ --   [ 1.0, 2.0, 3.0, 4.0, 5.0, 100.0, 7.0, 8.0, 9.0, 10.0 ] -- -- @since 0.3.0-thawS ::-     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)+thawS+  :: 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@@ -321,7 +333,6 @@   pure tmarr {-# INLINE thawS #-} - -- | /O(n)/ - Yield an immutable copy of the mutable array. Note that mutable representations -- have to be the same. --@@ -337,8 +348,9 @@ --   ] -- -- @since 0.1.0-freeze ::-     forall r ix e m. (Manifest r e, Index ix, MonadIO m)+freeze+  :: forall r ix e m+   . (Manifest r e, Index ix, MonadIO m)   => Comp   -> MArray RealWorld r ix e   -> m (Array r ix e)@@ -354,17 +366,17 @@         let slackLength = totalLength - slackStart         when (slackLength > 0) $           scheduleWork_ scheduler $-          unsafeLinearCopy smarr slackStart tmarr slackStart (SafeSz slackLength)+            unsafeLinearCopy smarr slackStart tmarr slackStart (SafeSz slackLength)     unsafeFreeze comp tmarr {-# INLINE freeze #-} - -- | Same as `freeze`, but do the copy of supplied muable array sequentially. Also, unlike `freeze` -- that has to be done in `IO`, `freezeS` can be used with `ST`. -- -- @since 0.3.0-freezeS ::-     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)+freezeS+  :: 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@@ -374,16 +386,17 @@   unsafeFreeze Seq tmarr {-# INLINE freezeS #-} -unsafeNewUpper ::-     (Load r' ix e, Manifest r e, PrimMonad m) => Array r' ix e -> m (MArray (PrimState m) r Ix1 e)+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, Manifest r e, PrimMonad m)+loadArrayS+  :: 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@@ -391,12 +404,12 @@   stToPrim $ unsafeLoadIntoST marr arr {-# INLINE loadArrayS #-} - -- | Load a pure array into the newly created mutable array, while respecting computation startegy. -- -- @since 0.3.0-loadArray ::-     forall r ix e r' m. (Load r' ix e, Manifest r e, MonadIO m)+loadArray+  :: 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 =@@ -405,44 +418,47 @@     unsafeLoadIntoIO marr arr {-# INLINE loadArray #-} -- -- | Compute an Array while loading the results into the supplied mutable target array. Number of -- elements for arrays must agree, otherwise `SizeElementsMismatchException` exception is thrown. -- -- @since 0.1.3-computeInto ::-     (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+computeInto+  :: (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     let sz = outerSize arr     unless (totalElem (sizeOfMArray mArr) == totalElem sz) $-      throwM $ SizeElementsMismatchException (sizeOfMArray mArr) sz+      throwM $+        SizeElementsMismatchException (sizeOfMArray mArr) sz     withMassivScheduler_ (getComp arr) $ \scheduler ->       stToPrim $ iterArrayLinearST_ scheduler arr (unsafeLinearWrite mArr) {-# INLINE computeInto #-} - -- | Create a mutable array using an index aware generating action. -- -- @since 0.3.0-makeMArrayS ::-     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+makeMArrayS+  :: 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) makeMArrayS sz f = makeMArrayLinearS sz (f . fromLinearIndex sz) {-# INLINE makeMArrayS #-} - -- | Same as `makeMArrayS`, but index supplied to the action is row-major linear index. -- -- @since 0.3.0-makeMArrayLinearS ::-     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)+makeMArrayLinearS+  :: forall r ix e m+   . (Manifest r e, Index ix, PrimMonad m)   => Sz ix   -> (Int -> m e)   -> m (MArray (PrimState m) r ix e)@@ -455,8 +471,9 @@ -- | Just like `makeMArrayS`, but also accepts computation strategy and runs in `IO`. -- -- @since 0.3.0-makeMArray ::-     forall r ix e m. (MonadUnliftIO m, Manifest r e, Index ix)+makeMArray+  :: forall r ix e m+   . (MonadUnliftIO m, Manifest r e, Index ix)   => Comp   -> Sz ix   -> (ix -> m e)@@ -464,12 +481,12 @@ makeMArray comp sz f = makeMArrayLinear comp sz (f . fromLinearIndex sz) {-# INLINE makeMArray #-} - -- | Just like `makeMArrayLinearS`, but also accepts computation strategy and runs in `IO`. -- -- @since 0.3.0-makeMArrayLinear ::-     forall r ix e m. (MonadUnliftIO m, Manifest r e, Index ix)+makeMArrayLinear+  :: forall r ix e m+   . (MonadUnliftIO m, Manifest r e, Index ix)   => Comp   -> Sz ix   -> (Int -> m e)@@ -478,13 +495,10 @@   marr <- liftIO $ unsafeNew sz   withScheduler_ comp $ \scheduler ->     withRunInIO $ \run ->-    splitLinearlyWithM_ scheduler (totalElem sz) (run . f) (unsafeLinearWrite marr)+      splitLinearlyWithM_ scheduler (totalElem sz) (run . f) (unsafeLinearWrite marr)   return marr {-# INLINE makeMArrayLinear #-} --- -- | Create a new array by supplying an action that will fill the new blank mutable array. Use -- `createArray` if you'd like to keep the result of the filling function. --@@ -497,11 +511,13 @@ --   [ 10, 11 ] -- -- @since 0.3.0----createArray_ ::-     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+createArray_+  :: 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 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)@@ -515,11 +531,13 @@ -- actions. -- -- @since 0.3.0----createArray ::-     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+createArray+  :: 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 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)@@ -530,7 +548,6 @@   return (a, arr) {-# INLINE createArray #-} - -- | Create a new array by supplying an action that will fill the new blank mutable array. Use -- `createArrayS` if you'd like to keep the result of the filling function. --@@ -543,9 +560,11 @@ --   [ 10, 12 ] -- -- @since 0.3.0-createArrayS_ ::-     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)-  => Sz ix -- ^ Size of the newly created array+createArrayS_+  :: 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 (Array r ix e)@@ -555,9 +574,11 @@ -- | Just like `createArray_`, but together with `Array` it returns the result of the filling action. -- -- @since 0.3.0-createArrayS ::-     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)-  => Sz ix -- ^ Size of the newly created array+createArrayS+  :: 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)@@ -571,27 +592,27 @@ -- | Just like `createArrayS_`, but restricted to `ST`. -- -- @since 0.3.0-createArrayST_ ::-     forall r ix e a. (Manifest r e, Index ix)+createArrayST_+  :: 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 createArrayST_ sz action = runST $ createArrayS_ sz action {-# INLINE createArrayST_ #-} - -- | Just like `createArrayS`, but restricted to `ST`. -- -- @since 0.2.6-createArrayST ::-     forall r ix e a. (Manifest r e, Index ix)+createArrayST+  :: 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) createArrayST sz action = runST $ createArrayS sz action {-# INLINE createArrayST #-} - -- | Sequentially generate a pure array. Much like `makeArray` creates a pure array this -- function will use `Manifest` interface to generate a pure `Array` in the end, except that -- computation strategy is set to `Seq`. Element producing function no longer has to be pure@@ -616,10 +637,13 @@ -- 15 -- -- @since 0.2.6-generateArrayS ::-     forall r ix e m. (Manifest r e, Index ix, PrimMonad m)-  => Sz ix -- ^ Size of the array-  -> (ix -> m e) -- ^ Element producing action+generateArrayS+  :: forall r ix e m+   . (Manifest r e, Index ix, PrimMonad m)+  => Sz ix+  -- ^ Size of the array+  -> (ix -> m e)+  -- ^ Element producing action   -> m (Array r ix e) generateArrayS sz gen = generateArrayLinearS sz (gen . fromLinearIndex sz) {-# INLINE generateArrayS #-}@@ -627,10 +651,13 @@ -- | Same as `generateArray` but with action that accepts row-major linear index. -- -- @since 0.3.0-generateArrayLinearS ::-     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+generateArrayLinearS+  :: 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@@ -638,13 +665,13 @@   unsafeFreeze Seq marr {-# INLINE generateArrayLinearS #-} - -- | Just like `generateArrayS`, except this generator __will__ respect the supplied computation -- strategy, and for that reason it is restricted to `IO`. -- -- @since 0.2.6-generateArray ::-     forall r ix e m. (MonadUnliftIO m, Manifest r e, Index ix)+generateArray+  :: forall r ix e m+   . (MonadUnliftIO m, Manifest r e, Index ix)   => Comp   -> Sz ix   -> (ix -> m e)@@ -656,8 +683,9 @@ -- index. -- -- @since 0.3.0-generateArrayLinear ::-     forall r ix e m. (MonadUnliftIO m, Manifest r e, Index ix)+generateArrayLinear+  :: forall r ix e m+   . (MonadUnliftIO m, Manifest r e, Index ix)   => Comp   -> Sz ix   -> (Ix1 -> m e)@@ -665,29 +693,33 @@ generateArrayLinear comp sz f = makeMArrayLinear comp sz f >>= liftIO . unsafeFreeze comp {-# INLINE generateArrayLinear #-} - -- | Similar to `Data.Massiv.Array.makeSplitSeedArray`, except it will produce a -- Manifest array and will return back the last unused seed together with all -- final seeds produced by each scheduled job. This function can be thought of -- as an unfolding done in parallel while iterating in a customizable manner. -- -- @since 1.0.2-generateSplitSeedArray ::-     forall r ix e g it. (Iterator it, Manifest r e, Index ix)-  => it -- ^ Iterator-  -> g -- ^ Initial seed+generateSplitSeedArray+  :: forall r ix e g it+   . (Iterator it, Manifest r e, Index ix)+  => it+  -- ^ Iterator+  -> g+  -- ^ Initial seed   -> (forall s. g -> ST s (g, g))-     -- ^ An ST action that can split a seed into two independent seeds. It will-     -- be called the same number of times as the number of jobs that will get-     -- scheduled during parallelization. Eg. only once for the sequential case.-  -> Comp -- ^ Computation strategy.-  -> Sz ix -- ^ Resulting size of the array.+  -- ^ An ST action that can split a seed into two independent seeds. It will+  -- be called the same number of times as the number of jobs that will get+  -- scheduled during parallelization. Eg. only once for the sequential case.+  -> Comp+  -- ^ Computation strategy.+  -> Sz ix+  -- ^ Resulting size of the array.   -> (forall s. Ix1 -> ix -> g -> ST s (e, g))-     -- ^ An ST action that produces a value and the next seed. It takes both-     -- versions of the index, in linear and in multi-dimensional forms, as well-     -- as the current seeding value. Returns the element for the array cell-     -- together with the new seed that will be used for the next element-     -- generation+  -- ^ An ST action that produces a value and the next seed. It takes both+  -- versions of the index, in linear and in multi-dimensional forms, as well+  -- as the current seeding value. Returns the element for the array cell+  -- together with the new seed that will be used for the next element+  -- generation   -> (g, [g], Array r ix e)   -- ^ Returned values are:   --@@ -700,30 +732,32 @@   unsafePerformIO $ do     marr <- unsafeNew sz     ref <- newIORef Nothing-    res <- withSchedulerR comp $ \ scheduler -> do+    res <- withSchedulerR comp $ \scheduler -> do       fin <- stToIO $         iterTargetFullAccST it scheduler 0 sz seed splitSeed $ \ !i ix !g ->-          genFunc i ix g >>= \ (x, g') -> g' <$ unsafeLinearWrite marr i x+          genFunc i ix g >>= \(x, g') -> g' <$ unsafeLinearWrite marr i x       writeIORef ref $ Just fin     mFin <- readIORef ref     case res of-      Finished gs |-        Just fin <- mFin -> do-          arr <- unsafeFreeze comp marr-          pure (fin, gs, arr)+      Finished gs+        | Just fin <- mFin -> do+            arr <- unsafeFreeze comp marr+            pure (fin, gs, arr)       -- This case does not make much sence for array filling and can only       -- happen with a custom 'Iterator' defined outside massiv, therefore it is       -- ok to not support it.-      _ -> error $ "Parallelized array filling finished prematurely. " ++-           "This feature is not supported by the 'generateSplitSeedArray' function."+      _ ->+        error $+          "Parallelized array filling finished prematurely. "+            ++ "This feature is not supported by the 'generateSplitSeedArray' function." {-# INLINE generateSplitSeedArray #-} - -- | Same as `generateArrayWS`, but use linear indexing instead. -- -- @since 0.3.4-generateArrayLinearWS ::-     forall r ix e s m. (Manifest r e, Index ix, MonadUnliftIO m, PrimMonad m)+generateArrayLinearWS+  :: forall r ix e s m+   . (Manifest r e, Index ix, MonadUnliftIO m, PrimMonad m)   => WorkerStates s   -> Sz ix   -> (Int -> s -> m e)@@ -743,8 +777,9 @@ -- things that are not thread safe. -- -- @since 0.3.4-generateArrayWS ::-     forall r ix e s m. (Manifest r e, Index ix, MonadUnliftIO m, PrimMonad m)+generateArrayWS+  :: forall r ix e s m+   . (Manifest r e, Index ix, MonadUnliftIO m, PrimMonad m)   => WorkerStates s   -> Sz ix   -> (ix -> s -> m e)@@ -752,7 +787,6 @@ generateArrayWS states sz make = generateArrayLinearWS states sz (make . fromLinearIndex sz) {-# INLINE generateArrayWS #-} - -- | Sequentially unfold an array from the left. -- -- ====__Examples__@@ -775,11 +809,15 @@ --   [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ] -- -- @since 0.3.0-unfoldrPrimM_ ::-     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+unfoldrPrimM_+  :: 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 (Array r ix e) unfoldrPrimM_ sz gen acc0 = snd <$> unfoldrPrimM sz gen acc0 {-# INLINE unfoldrPrimM_ #-}@@ -787,24 +825,31 @@ -- | Same as `unfoldrPrimM_` but do the unfolding with index aware function. -- -- @since 0.3.0-iunfoldrPrimM_ ::-     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+iunfoldrPrimM_+  :: 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 (Array r ix e) iunfoldrPrimM_ sz gen acc0 = snd <$> iunfoldrPrimM sz gen acc0 {-# INLINE iunfoldrPrimM_ #-} - -- | Just like `iunfoldrPrimM_`, but also returns the final value of the accumulator. -- -- @since 0.3.0-iunfoldrPrimM ::-     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+iunfoldrPrimM+  :: 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 ->@@ -818,11 +863,15 @@ -- | Just like `iunfoldrPrimM`, but do the unfolding with index aware function. -- -- @since 0.3.0-unfoldrPrimM ::-     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+unfoldrPrimM+  :: 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 ->@@ -856,11 +905,15 @@ --   [ 34, 21, 13, 8, 5, 3, 2, 1, 1, 0 ] -- -- @since 0.3.0-unfoldlPrimM_ ::-     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+unfoldlPrimM_+  :: 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 (Array r ix e) unfoldlPrimM_ sz gen acc0 = snd <$> unfoldlPrimM sz gen acc0 {-# INLINE unfoldlPrimM_ #-}@@ -868,24 +921,31 @@ -- | Same as `unfoldlPrimM_` but do the unfolding with index aware function. -- -- @since 0.3.0-iunfoldlPrimM_ ::-     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+iunfoldlPrimM_+  :: 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 (Array r ix e) iunfoldlPrimM_ sz gen acc0 = snd <$> iunfoldlPrimM sz gen acc0 {-# INLINE iunfoldlPrimM_ #-} - -- | Just like `iunfoldlPrimM_`, but also returns the final value of the accumulator. -- -- @since 0.3.0-iunfoldlPrimM ::-     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+iunfoldlPrimM+  :: 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 ->@@ -899,16 +959,20 @@ -- | Just like `iunfoldlPrimM`, but do the unfolding with index aware function. -- -- @since 0.3.0-unfoldlPrimM ::-     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+unfoldlPrimM+  :: 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' = sizeOfMArray marr-     in loopDeepM 0 (< totalElem sz') (+1) acc0 $ \ !i !acc -> do+     in loopDeepM 0 (< totalElem sz') (+ 1) acc0 $ \ !i !acc -> do           (acc', e) <- gen acc           unsafeLinearWrite marr i e           pure acc'@@ -920,7 +984,7 @@ -- @since 0.4.0 forPrimM_ :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m ()) -> m () forPrimM_ marr f =-  loopA_ 0 (< totalElem (sizeOfMArray marr)) (+1) (unsafeLinearRead marr >=> f)+  loopA_ 0 (< totalElem (sizeOfMArray marr)) (+ 1) (unsafeLinearRead marr >=> f) {-# INLINE forPrimM_ #-}  -- | Sequentially loop over a mutable array while modifying each element with an action.@@ -928,36 +992,34 @@ -- @since 0.4.0 forPrimM :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m e) -> m () forPrimM marr f =-  loopA_ 0 (< totalElem (sizeOfMArray marr)) (+1) (unsafeLinearModify marr f)+  loopA_ 0 (< totalElem (sizeOfMArray marr)) (+ 1) (unsafeLinearModify marr f) {-# INLINE forPrimM #-} - -- | Sequentially loop over a mutable array while reading each element and applying an -- index aware action to it. There is no mutation to the array, unless the -- action itself modifies it. -- -- @since 0.4.0-iforPrimM_ ::-     (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (ix -> e -> m ()) -> m ()+iforPrimM_+  :: (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 ::-     (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (ix -> e -> m e) -> m ()+iforPrimM+  :: (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 #-} - -- | Sequentially loop over a mutable array while reading each element and applying a -- linear index aware action to it. There is no mutation to the array, unless the action -- itself modifies it. -- -- @since 0.4.0-iforLinearPrimM_ ::-     (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (Int -> e -> m ()) -> m ()+iforLinearPrimM_+  :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (Int -> e -> m ()) -> m () iforLinearPrimM_ marr f =   loopA_ 0 (< totalElem (sizeOfMArray marr)) (+ 1) (\i -> unsafeLinearRead marr i >>= f i) {-# INLINE iforLinearPrimM_ #-}@@ -965,21 +1027,20 @@ -- | Sequentially loop over a mutable array while modifying each element with an index aware action. -- -- @since 0.4.0-iforLinearPrimM ::-     (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (Int -> e -> m e) -> m ()+iforLinearPrimM+  :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (Int -> e -> m e) -> m () iforLinearPrimM marr f =   loopA_ 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)+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 ())@@ -990,8 +1051,9 @@ -- | 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)+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 ())@@ -1004,12 +1066,11 @@     f ix e1 e2 {-# INLINE ifor2PrimM_ #-} - -- | Same as `withMArray_`, but allows to keep artifacts of scheduled tasks. -- -- @since 0.5.0-withMArray ::-     (Manifest r e, Index ix, MonadUnliftIO m)+withMArray+  :: (Manifest r e, Index ix, MonadUnliftIO m)   => Array r ix e   -> (Scheduler RealWorld a -> MArray RealWorld r ix e -> m b)   -> m ([a], Array r ix e)@@ -1032,8 +1093,8 @@ -- * And, of course, the mutable array itself. -- -- @since 0.5.0-withMArray_ ::-     (Manifest r e, Index ix, MonadUnliftIO m)+withMArray_+  :: (Manifest r e, Index ix, MonadUnliftIO m)   => Array r ix e   -> (Scheduler RealWorld () -> MArray RealWorld r ix e -> m a)   -> m (Array r ix e)@@ -1043,13 +1104,13 @@   liftIO $ unsafeFreeze (getComp arr) marr {-# INLINE withMArray_ #-} - -- | Same as `withMArray_`, but the array supplied to this function can be any loadable -- array. For that reason it will be faster if supplied array is delayed. -- -- @since 0.6.1-withLoadMArray_ ::-     forall r ix e r' m b. (Load r' ix e, Manifest r e, MonadUnliftIO m)+withLoadMArray_+  :: forall r ix e r' m b+   . (Load r' ix e, Manifest r e, MonadUnliftIO m)   => Array r' ix e   -> (Scheduler RealWorld () -> MArray RealWorld r ix e -> m b)   -> m (Array r ix e)@@ -1057,20 +1118,21 @@   marr <- loadArray arr   withScheduler_ (getComp arr) (`action` marr)   liftIO $ unsafeFreeze (getComp arr) marr-{-# INLINE[2] withLoadMArray_ #-}+{-# INLINE [2] withLoadMArray_ #-}+ {-# RULES "withLoadMArray_/withMArray_" [~2] withLoadMArray_ = withMArray_ "withLoadMArrayS/withMArrayS" [~2] withLoadMArrayS = withMArrayS "withLoadMArrayS_/withMArrayS_" [~2] withLoadMArrayS_ = withMArrayS_-#-}+  #-}  -- | Create a copy of a pure array, mutate it in place and return its frozen version. The important -- benefit over doing a manual `thawS` followed by a `freezeS` is that an array will only be copied -- once. -- -- @since 0.5.0-withMArrayS ::-     (Manifest r e, Index ix, PrimMonad m)+withMArrayS+  :: (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)@@ -1080,24 +1142,23 @@   (,) a <$> unsafeFreeze (getComp arr) marr {-# INLINE withMArrayS #-} - -- | Same as `withMArrayS`, except it discards the value produced by the supplied action -- -- @since 0.5.0-withMArrayS_ ::-     (Manifest r e, Index ix, PrimMonad m)+withMArrayS_+  :: (Manifest r e, Index ix, PrimMonad m)   => Array r ix e   -> (MArray (PrimState m) r ix e -> m a)   -> m (Array r ix e) withMArrayS_ arr action = snd <$> withMArrayS arr action {-# INLINE withMArrayS_ #-} - -- | Same as `withMArrayS`, but will work with any loadable array. -- -- @since 0.6.1-withLoadMArrayS ::-     forall r ix e r' m a. (Load r' ix e, Manifest r e, PrimMonad m)+withLoadMArrayS+  :: 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)@@ -1105,28 +1166,28 @@   marr <- loadArrayS arr   a <- action marr   (,) a <$> unsafeFreeze (getComp arr) marr-{-# INLINE[2] withLoadMArrayS #-}+{-# INLINE [2] withLoadMArrayS #-}  -- | Same as `withMArrayS_`, but will work with any loadable array. -- -- @since 0.6.1-withLoadMArrayS_ ::-     forall r ix e r' m a. (Load r' ix e, Manifest r e, PrimMonad m)+withLoadMArrayS_+  :: 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) withLoadMArrayS_ arr action = snd <$> withLoadMArrayS arr action-{-# INLINE[2] withLoadMArrayS_ #-}-+{-# INLINE [2] withLoadMArrayS_ #-}  -- | Same as `withMArrayS` but in `ST`. This is not only pure, but also the safest way to do -- mutation to the array. -- -- @since 0.5.0-withMArrayST ::-     (Manifest r e, Index ix)+withMArrayST+  :: (Manifest r e, Index ix)   => Array r ix e-  -> (forall s . MArray s r ix e -> ST s a)+  -> (forall s. MArray s r ix e -> ST s a)   -> (a, Array r ix e) withMArrayST arr f = runST $ withMArrayS arr f {-# INLINE withMArrayST #-}@@ -1135,59 +1196,63 @@ -- mutation to the array. -- -- @since 0.5.0-withMArrayST_ ::-     (Manifest r e, Index ix) => Array r ix e -> (forall s. MArray s r ix e -> ST s a) -> Array r ix e+withMArrayST_+  :: (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_ #-} - -- | Same as `withMArrayST`, but works with any loadable array. -- -- @since 0.6.1-withLoadMArrayST ::-     forall r ix e r' a. (Load r' ix e, Manifest r e)+withLoadMArrayST+  :: 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) withLoadMArrayST arr f = runST $ withLoadMArrayS arr f-{-# INLINE[2] withLoadMArrayST #-}+{-# INLINE [2] withLoadMArrayST #-}  -- | Same as `withMArrayST_`, but works with any loadable array. -- -- @since 0.6.1-withLoadMArrayST_ ::-     forall r ix e r' a. (Load r' ix e, Manifest r e)+withLoadMArrayST_+  :: 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 withLoadMArrayST_ arr f = runST $ withLoadMArrayS_ arr f-{-# INLINE[2] withLoadMArrayST_ #-}-+{-# INLINE [2] withLoadMArrayST_ #-}  -- | /O(1)/ - Lookup an element in the mutable array. Returns `Nothing` when index is out of bounds. -- -- @since 0.1.0-read :: (Manifest r e, Index ix, PrimMonad m) =>-        MArray (PrimState m) r ix e -> ix -> m (Maybe e)+read+  :: (Manifest r e, Index ix, PrimMonad m)+  => MArray (PrimState m) r ix e+  -> ix+  -> m (Maybe e) read marr ix =   if isSafeIndex (sizeOfMArray marr) ix     then Just <$> unsafeRead marr ix     else return Nothing {-# INLINE read #-} - -- | /O(1)/ - Same as `read`, but throws `IndexOutOfBoundsException` on an invalid index. -- -- @since 0.4.0-readM :: (Manifest r e, Index ix, PrimMonad m, MonadThrow m) =>-        MArray (PrimState m) r ix e -> ix -> m e+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+    Just e -> pure e     Nothing -> throwM $ IndexOutOfBoundsException (sizeOfMArray marr) ix {-# INLINE readM #-} - -- | /O(1)/ - Write an element into the cell of a mutable array. Returns `False` when index is out -- of bounds. --@@ -1195,8 +1260,8 @@ write :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> e -> m Bool write marr ix e =   if isSafeIndex (sizeOfMArray marr) ix-  then unsafeWrite marr ix e >> pure True-  else pure False+    then unsafeWrite marr ix e >> pure True+    else pure False {-# INLINE write #-}  -- | /O(1)/ - Write an element into the cell of a mutable array. Same as `write` function@@ -1212,22 +1277,24 @@ -- | /O(1)/ - Same as `write`, but throws `IndexOutOfBoundsException` on an invalid index. -- -- @since 0.4.0-writeM ::-     (Manifest r e, Index ix, PrimMonad m, MonadThrow m) => MArray (PrimState m) r ix e -> ix -> e -> m ()+writeM+  :: (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 (sizeOfMArray marr) ix)) {-# INLINE 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 ::-     (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.+modify+  :: (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 (sizeOfMArray marr) ix@@ -1240,11 +1307,14 @@ -- just like `modifyM_`, but doesn't throw an exception. -- -- @since 0.4.4-modify_ ::-     (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.+modify_+  :: (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 (sizeOfMArray marr) ix) $ void $ unsafeModify marr f ix {-# INLINE modify_ #-}@@ -1254,11 +1324,14 @@ -- the previous value otherwise. -- -- @since 0.4.0-modifyM ::-     (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.+modifyM+  :: (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 (sizeOfMArray marr) ix = unsafeModify marr f ix@@ -1277,16 +1350,18 @@ --   [ 0, 10, 0 ] -- -- @since 0.4.0-modifyM_ ::-     (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.+modifyM_+  :: (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 () modifyM_ marr f ix = void $ modifyM marr f ix {-# INLINE 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.@@ -1300,7 +1375,6 @@         else pure Nothing {-# INLINE swap #-} - -- | /O(1)/ - Same as `swap`, but instead of returning `Nothing` it does nothing. In other -- words, it is similar to `swapM_`, but does not throw any exceptions. --@@ -1316,13 +1390,15 @@ -- elements under those indices otherwise. -- -- @since 0.4.0-swapM ::-     (Manifest r e, Index ix, PrimMonad m, MonadThrow m)+swapM+  :: (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.-  -> ix -- ^ Index for the second element, which will be returned as the second element in-        -- the tuple.+  -> ix+  -- ^ Index for the first element, which will be returned as the first element in the+  -- tuple.+  -> ix+  -- ^ Index for the second element, which will be returned as the second element in+  -- the tuple.   -> m (e, e) swapM marr ix1 ix2   | not (isSafeIndex sz ix1) = throwM $ IndexOutOfBoundsException (sizeOfMArray marr) ix1@@ -1332,12 +1408,11 @@     !sz = sizeOfMArray marr {-# INLINE swapM #-} - -- | /O(1)/ - Same as `swapM`, but discard the returned elements -- -- @since 0.4.0-swapM_ ::-     (Manifest r e, Index ix, PrimMonad m, MonadThrow m)+swapM_+  :: (Manifest r e, Index ix, PrimMonad m, MonadThrow m)   => MArray (PrimState m) r ix e   -> ix   -> ix@@ -1349,8 +1424,9 @@ -- 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)+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

@@ -1,5 +1,6 @@ {-# LANGUAGE ExplicitForAll #-} {-# LANGUAGE FlexibleContexts #-}+ -- | -- Module      : Data.Massiv.Array.Mutable.Algorithms -- Copyright   : (c) Alexey Kuleshevich 2019-2022@@ -7,19 +8,17 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Mutable.Algorithms-  ( quicksortM_-  , quicksortByM_-  , unstablePartitionM-  , iterateUntilM-  ) where+module Data.Massiv.Array.Mutable.Algorithms (+  quicksortM_,+  quicksortByM_,+  unstablePartitionM,+  iterateUntilM,+) where -import Data.Massiv.Array.Ops.Sort import Data.Massiv.Array.Manifest.Internal (iterateUntilM)+import Data.Massiv.Array.Ops.Sort import Data.Massiv.Core.Common - -- | Partition elements of the supplied mutable vector according to the predicate. -- -- ==== __Example__@@ -35,9 +34,11 @@ --   [ 2, 1, 8, 10, 20, 50 ] -- -- @since 1.0.0-unstablePartitionM ::-     forall r e m. (Manifest r e, PrimMonad m)+unstablePartitionM+  :: forall r e m+   . (Manifest r e, PrimMonad m)   => MVector (PrimState m) r e-  -> (e -> m Bool) -- ^ Predicate+  -> (e -> m Bool)+  -- ^ Predicate   -> m Ix1 unstablePartitionM marr f = unsafeUnstablePartitionRegionM marr f 0 (unSz (sizeOfMArray marr) - 1)

@@ -3,6 +3,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-}+ -- | -- Module      : Data.Massiv.Array.Mutable.Atomic -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -10,20 +11,19 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Mutable.Atomic-  ( -- * Atomic element-wise mutation-    atomicReadIntArray-  , atomicWriteIntArray-  , atomicModifyIntArray-  , atomicAddIntArray-  , atomicSubIntArray-  , atomicAndIntArray-  , atomicNandIntArray-  , atomicOrIntArray-  , atomicXorIntArray-  , casIntArray-  ) where+module Data.Massiv.Array.Mutable.Atomic (+  -- * Atomic element-wise mutation+  atomicReadIntArray,+  atomicWriteIntArray,+  atomicModifyIntArray,+  atomicAddIntArray,+  atomicSubIntArray,+  atomicAndIntArray,+  atomicNandIntArray,+  atomicOrIntArray,+  atomicXorIntArray,+  casIntArray,+) where  import Control.Monad.Primitive import Data.Massiv.Array.Manifest.Primitive@@ -34,114 +34,109 @@ -- | Atomically read an `Int` element from the array -- -- @since 0.3.0-atomicReadIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> m (Maybe Int)+atomicReadIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> m (Maybe Int) atomicReadIntArray marr ix   | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicReadIntArray marr ix   | otherwise = pure Nothing {-# INLINE atomicReadIntArray #-} - -- | Atomically write an `Int` element int the array. Returns `True` if supplied index was correct -- and write was successfull. -- -- @since 0.3.0-atomicWriteIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Bool+atomicWriteIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m Bool atomicWriteIntArray marr ix f   | isSafeIndex (sizeOfMArray marr) ix = unsafeAtomicWriteIntArray marr ix f >> pure True   | otherwise = pure False {-# INLINE atomicWriteIntArray #-} - -- | Atomically CAS (Compare-and-Swap) an `Int` in the array. Returns the old value. -- -- @since 0.3.0-casIntArray ::-     (Index ix, PrimMonad m)-  => MArray (PrimState m) P ix Int -- ^ Array to mutate-  -> ix -- ^ Index at which to mutate-  -> Int -- ^ Expected value-  -> Int -- ^ New value+casIntArray+  :: (Index ix, PrimMonad m)+  => MArray (PrimState m) P ix Int+  -- ^ Array to mutate+  -> ix+  -- ^ Index at which to mutate+  -> Int+  -- ^ Expected value+  -> Int+  -- ^ New value   -> m (Maybe Int) casIntArray marr ix e n   | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeCasIntArray marr ix e n   | otherwise = pure Nothing {-# INLINE casIntArray #-} - -- | Atomically modify an `Int` element of the array. Returns the old value, unless the -- supplied index was out of bounds. -- -- @since 0.3.0-atomicModifyIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> (Int -> Int) -> m (Maybe Int)+atomicModifyIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> (Int -> Int) -> m (Maybe Int) atomicModifyIntArray marr ix f   | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicModifyIntArray marr ix f   | otherwise = pure Nothing {-# INLINE atomicModifyIntArray #-} - -- | Atomically add to an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-atomicAddIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int)+atomicAddIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicAddIntArray marr ix e   | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicAddIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicAddIntArray #-} - -- | Atomically subtract from an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-atomicSubIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int)+atomicSubIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicSubIntArray marr ix e   | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicSubIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicSubIntArray #-} - -- | Atomically AND an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-atomicAndIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int)+atomicAndIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicAndIntArray marr ix e   | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicAndIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicAndIntArray #-} - -- | Atomically NAND an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-atomicNandIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int)+atomicNandIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicNandIntArray marr ix e   | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicNandIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicNandIntArray #-} - -- | Atomically OR an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-atomicOrIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int)+atomicOrIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicOrIntArray marr ix e   | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicOrIntArray marr ix e   | otherwise = pure Nothing {-# INLINE atomicOrIntArray #-} - -- | Atomically XOR an `Int` element in the array. Returns the old value. -- -- @since 0.3.0-atomicXorIntArray ::-     (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int)+atomicXorIntArray+  :: (Index ix, PrimMonad m) => MArray (PrimState m) P ix Int -> ix -> Int -> m (Maybe Int) atomicXorIntArray marr ix e   | isSafeIndex (sizeOfMArray marr) ix = Just <$> unsafeAtomicXorIntArray marr ix e   | otherwise = pure Nothing

@@ -1,4 +1,5 @@ {-# LANGUAGE ExplicitForAll #-}+ -- | -- Module      : Data.Massiv.Array.Mutable.Internal -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -6,12 +7,11 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Mutable.Internal-  ( unsafeCreateArray-  , unsafeCreateArray_-  , unsafeCreateArrayS-  ) where+module Data.Massiv.Array.Mutable.Internal (+  unsafeCreateArray,+  unsafeCreateArray_,+  unsafeCreateArrayS,+) where  import Control.Scheduler import Data.Massiv.Core.Common@@ -20,9 +20,11 @@ -- and for unboxed types might contain garbage. -- -- @since 0.5.0-unsafeCreateArrayS ::-     forall r ix e a m. (Manifest r e, Index ix, PrimMonad m)-  => Sz ix -- ^ Size of the newly created array+unsafeCreateArrayS+  :: 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)@@ -37,10 +39,13 @@ -- and for unboxed types might contain garbage. -- -- @since 0.5.0-unsafeCreateArray ::-     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+unsafeCreateArray+  :: 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 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)@@ -55,10 +60,13 @@ -- and for unboxed types might contain garbage. -- -- @since 0.5.0-unsafeCreateArray_ ::-     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+unsafeCreateArray_+  :: 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 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)

@@ -3,6 +3,7 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-}+ -- | -- Module      : Data.Massiv.Array.Numeric -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -10,122 +11,132 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Numeric-  ( -- * Numeric-    Numeric-  , NumericFloat-  , liftNumArray2M-    -- ** Pointwise addition-  , (.+)-  , (+.)-  , (.+.)-  , (!+!)-  , sumArraysM-  , sumArrays'+module Data.Massiv.Array.Numeric (+  -- * Numeric+  Numeric,+  NumericFloat,+  liftNumArray2M,++  -- ** Pointwise addition+  (.+),+  (+.),+  (.+.),+  (!+!),+  sumArraysM,+  sumArrays',+   -- ** Pointwise subtraction-  , (.-)-  , (-.)-  , (.-.)-  , (!-!)+  (.-),+  (-.),+  (.-.),+  (!-!),+   -- ** Pointwise multiplication-  , (.*)-  , (*.)-  , (.*.)-  , (!*!)-  , (.^)-  , productArraysM-  , productArrays'+  (.*),+  (*.),+  (.*.),+  (!*!),+  (.^),+  productArraysM,+  productArrays',+   -- ** Dot product-  , (!.!)-  , dotM+  (!.!),+  dotM,+   -- ** Matrix multiplication-  , (.><)-  , (!><)-  , multiplyMatrixByVector-  , (><.)-  , (><!)-  , multiplyVectorByMatrix-  , (.><.)-  , (!><!)-  , multiplyMatrices-  , multiplyMatricesTransposed+  (.><),+  (!><),+  multiplyMatrixByVector,+  (><.),+  (><!),+  multiplyVectorByMatrix,+  (.><.),+  (!><!),+  multiplyMatrices,+  multiplyMatricesTransposed,+   -- * Norms-  , normL2+  normL2,+   -- * Simple matrices-  , identityMatrix-  , lowerTriangular-  , upperTriangular-  , negateA-  , absA-  , signumA+  identityMatrix,+  lowerTriangular,+  upperTriangular,+  negateA,+  absA,+  signumA,+   -- * Integral-  , quotA-  , remA-  , divA-  , modA-  , quotRemA-  , divModA+  quotA,+  remA,+  divA,+  modA,+  quotRemA,+  divModA,+   -- * Fractional-  , (./)-  , (/.)-  , (./.)-  , (!/!)-  , (.^^)-  , recipA+  (./),+  (/.),+  (./.),+  (!/!),+  (.^^),+  recipA,+   -- * Floating-  , expA-  , logA-  , sqrtA-  , (.**)-  , logBaseA-  , sinA-  , cosA-  , tanA-  , asinA-  , acosA-  , atanA-  , sinhA-  , coshA-  , tanhA-  , asinhA-  , acoshA-  , atanhA+  expA,+  logA,+  sqrtA,+  (.**),+  logBaseA,+  sinA,+  cosA,+  tanA,+  asinA,+  acosA,+  atanA,+  sinhA,+  coshA,+  tanhA,+  asinhA,+  acoshA,+  atanhA,+   -- * RealFrac-  , truncateA-  , roundA-  , ceilingA-  , floorA+  truncateA,+  roundA,+  ceilingA,+  floorA,+   -- * RealFloat-  , atan2A-  ) where+  atan2A,+) where -import Data.Massiv.Array.Mutable+import Control.Monad (when)+import Control.Scheduler+import qualified Data.Foldable as F+import Data.Function 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.Array.Ops.Map as A import Data.Massiv.Core import Data.Massiv.Core.Common as A import Data.Massiv.Core.Operations-import Prelude as P import System.IO.Unsafe-import Control.Scheduler-import Control.Monad (when)-import qualified Data.Foldable as F-import Data.Function+import Prelude as P -infixr 8  .^, .^^-infixl 7  !*!, .*., .*, *., !/!, ./., ./, /., `quotA`, `remA`, `divA`, `modA`-infixl 6  !+!, .+., .+, +., !-!, .-., .-, -.+infixr 8 .^, .^^+infixl 7 !*!, .*., .*, *., !/!, ./., ./, /., `quotA`, `remA`, `divA`, `modA`+infixl 6 !+!, .+., .+, +., !-!, .-., .-, -.  -- | 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)+liftNumArray2M+  :: (Index ix, Numeric r e, MonadThrow m)   => (e -> e -> e)   -> Array r ix e   -> Array r ix e@@ -139,9 +150,8 @@     !sz2 = size a2 {-# INLINE liftNumArray2M #-} --applyExactSize2M ::-     (Index ix, Size r, 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@@ -155,7 +165,6 @@     !sz2 = size a2 {-# INLINE applyExactSize2M #-} - -- | Add two arrays together pointwise. Same as `!+!` but produces monadic computation -- that allows for handling failure. --@@ -204,12 +213,11 @@ -- /__Throws Exception__/: `SizeMismatchException` when array sizes do not match. -- -- @since 0.4.0-(.-.) ::-     (Index ix, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e)+(.-.)+  :: (Index ix, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e) (.-.) = applyExactSize2M subtractionPointwise {-# INLINE (.-.) #-} - -- | Subtract one array from another pointwise. Prefer to use monadic version of this -- function `.-.` whenever possible, because it is better to avoid partial functions. --@@ -242,19 +250,17 @@ (-.) = scalarMinus {-# INLINE (-.) #-} - -- | Multiply two arrays together pointwise. Same as `!*!` but produces monadic -- computation that allows for handling failure. -- -- /__Throws Exception__/: `SizeMismatchException` when array sizes do not match. -- -- @since 0.4.0-(.*.) ::-     (Index ix, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e)+(.*.)+  :: (Index ix, Numeric r e, MonadThrow m) => Array r ix e -> Array r ix e -> m (Array r ix e) (.*.) = applyExactSize2M multiplicationPointwise {-# INLINE (.*.) #-} - -- | Multiplication of two arrays pointwise, -- i.e. <https://en.wikipedia.org/wiki/Hadamard_product_(matrices) Hadamard product>. -- Prefer to use monadic version of this function `.*.` whenever possible,@@ -275,7 +281,6 @@ (!*!) a1 a2 = throwEither (a1 .*. a2) {-# INLINE (!*!) #-} - -- | Multiply each element of the array by a scalar value. Scalar is on the right. -- -- ====__Example__@@ -293,7 +298,6 @@ (.*) = multiplyScalar {-# INLINE (.*) #-} - -- | Multiply each element of the array by a scalar value. Scalar is on the left. -- -- ====__Example__@@ -311,7 +315,6 @@ (*.) = flip multiplyScalar {-# INLINE (*.) #-} - -- | Raise each element of the array to a power. -- -- ====__Example__@@ -329,7 +332,6 @@ (.^) = powerPointwise {-# INLINE (.^) #-} - -- | Dot product of two vectors. -- -- [Partial] Throws an impure exception when lengths of vectors do not match@@ -353,9 +355,8 @@     comp = getComp v1 <> getComp v2 {-# INLINE dotM #-} --unsafeDotProductIO ::-     (MonadUnliftIO m, Index ix, FoldNumeric r b, Source r b)+unsafeDotProductIO+  :: (MonadUnliftIO m, Index ix, FoldNumeric r b, Source r b)   => Array r ix b   -> Array r ix b   -> m b@@ -366,19 +367,19 @@         let n = SafeSz chunkLength         loopA_ 0 (< slackStart) (+ chunkLength) $ \ !start ->           scheduleWork scheduler $-          pure $! unsafeDotProduct (unsafeLinearSlice start n v1) (unsafeLinearSlice start n v2)+            pure $!+              unsafeDotProduct (unsafeLinearSlice start n v1) (unsafeLinearSlice start n v2)         when (slackStart < totalLength) $ do           let k = SafeSz (totalLength - slackStart)           scheduleWork scheduler $             pure $!-            unsafeDotProduct (unsafeLinearSlice slackStart k v1) (unsafeLinearSlice slackStart k v2)+              unsafeDotProduct (unsafeLinearSlice slackStart k v1) (unsafeLinearSlice slackStart k v2)   pure $! F.foldl' (+) 0 results   where     totalLength = totalElem (size v1)     comp = getComp v1 <> getComp v2 {-# INLINE unsafeDotProductIO #-} - -- | Compute L2 norm of an array. -- -- @since 0.5.6@@ -388,8 +389,8 @@   | otherwise = sqrt $! unsafePerformIO $ powerSumArrayIO v 2 {-# INLINE normL2 #-} -powerSumArrayIO ::-     (MonadUnliftIO m, Index ix, FoldNumeric r b, Source r b)+powerSumArrayIO+  :: (MonadUnliftIO m, Index ix, FoldNumeric r b, Source r b)   => Array r ix b   -> Int   -> m b@@ -408,17 +409,18 @@     totalLength = totalElem (size v) {-# INLINE powerSumArrayIO #-} - -- | Multiply a matrix by a column vector. Same as `!><` but produces monadic -- computation that allows for handling failure. -- -- /__Throws Exception__/: `SizeMismatchException` when inner dimensions of arrays do not match. -- -- @since 0.5.6-(.><) ::-     (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)+(.><)+  :: (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) (.><) mm v   | mCols /= n = throwM $ SizeMismatchException (size mm) (Sz2 n 1)@@ -436,39 +438,44 @@ -- /__Throws Exception__/: `SizeMismatchException` when inner dimensions of arrays do not match. -- -- @since 0.5.7-multiplyMatrixByVector ::-     (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)+multiplyMatrixByVector+  :: (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) multiplyMatrixByVector mm v = compute <$> mm .>< v {-# INLINE multiplyMatrixByVector #-} - -- | Multiply a matrix by a column vector -- -- [Partial] Throws impure exception when inner dimensions do not agree -- -- @since 0.5.6-(!><) ::-     (Numeric r e, Source r e)-  => Matrix r e -- ^ Matrix-  -> Vector r e -- ^ Column vector (Used many times, so make sure it is computed)+(!><)+  :: (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 (!><) mm v = throwEither (mm .>< v) {-# INLINE (!><) #-} - -- | Multiply a row vector by a matrix. Same as `><!` but produces monadic computation -- that allows for handling failure. -- -- /__Throws Exception__/: `SizeMismatchException` when inner dimensions of arrays do not match. -- -- @since 0.5.6-(><.) :: (MonadThrow m, Numeric r e, Manifest r e) =>-         Vector r e -- ^ Row vector-      -> Matrix r e -- ^ Matrix-      -> m (Vector r e)+(><.)+  :: (MonadThrow m, Numeric r e, Manifest r e)+  => Vector r e+  -- ^ Row vector+  -> Matrix r e+  -- ^ Matrix+  -> m (Vector r e) (><.) = multiplyVectorByMatrix {-# INLINE (><.) #-} @@ -478,53 +485,54 @@ -- /__Throws Exception__/: `SizeMismatchException` when inner dimensions of arrays do not match. -- -- @since 0.5.7-multiplyVectorByMatrix ::-     (MonadThrow m, Numeric r e, Manifest r e)-  => Vector r e -- ^ Row vector-  -> Matrix r e -- ^ Matrix+multiplyVectorByMatrix+  :: (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 $ runST (unsafeFreeze comp =<< unsafeNew zeroSz)   | otherwise =-    pure $!-    unsafePerformIO $ do-      mv <- newMArray (Sz mCols) 0-      withMassivScheduler_ comp $ \scheduler -> do-        let loopCols x ivto =-              fix $ \go im iv ->-                when (iv < ivto) $ do-                  _ <- unsafeLinearModify mv (\a -> pure $ a + unsafeLinearIndex mm im * x) iv-                  go (im + 1) (iv + 1)-            loopRows i0 from to =-              flip fix i0 $ \go i ->-                when (i < mRows) $ do-                  loopCols (unsafeLinearIndex v i) to (i * mCols + from) from-                  go (i + 1)-        splitLinearlyM_ scheduler mCols (loopRows 0)-      unsafeFreeze comp mv+      pure $!+        unsafePerformIO $ do+          mv <- newMArray (Sz mCols) 0+          withMassivScheduler_ comp $ \scheduler -> do+            let loopCols x ivto =+                  fix $ \go im iv ->+                    when (iv < ivto) $ do+                      _ <- unsafeLinearModify mv (\a -> pure $ a + unsafeLinearIndex mm im * x) iv+                      go (im + 1) (iv + 1)+                loopRows i0 from to =+                  flip fix i0 $ \go i ->+                    when (i < mRows) $ do+                      loopCols (unsafeLinearIndex v i) to (i * mCols + from) from+                      go (i + 1)+            splitLinearlyM_ scheduler mCols (loopRows 0)+          unsafeFreeze comp mv   where     comp = getComp mm <> getComp v     Sz2 mRows mCols = size mm     Sz1 n = size v {-# INLINE multiplyVectorByMatrix #-} - -- | Multiply a row vector by a matrix. -- -- [Partial] Throws impure exception when inner dimensions do not agree -- -- @since 0.5.6-(><!) ::-     (Numeric r e, Manifest r e)-  => Vector r e -- ^ Row vector (Used many times, so make sure it is computed)-  -> Matrix r e -- ^ Matrix+(><!)+  :: (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 (><!) v mm = throwEither (v ><. mm) {-# INLINE (><!) #-} -- -- | Multiply two matrices together. -- -- [Partial] Inner dimension must agree@@ -558,141 +566,144 @@ (.><.) = multiplyMatrices {-# INLINE (.><.) #-} - -- | Synonym for `.><.` -- -- @since 0.5.6-multiplyMatrices ::-     (Numeric r e, Manifest r e, MonadThrow m) => Matrix r e -> Matrix r e -> m (Matrix r e)+multiplyMatrices+  :: (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+  -- mA == 1 = -- TODO: call multiplyVectorByMatrix+  -- nA == 1 = -- TODO: call multiplyMatrixByVector   | nA /= mB = throwM $ SizeMismatchException (size arrA) (size arrB)   | isEmpty arrA || isEmpty arrB = pure $ runST (unsafeFreeze comp =<< unsafeNew zeroSz)   | otherwise = pure $! unsafePerformIO $ do-    marrC <- newMArray (SafeSz (mA :. nB)) 0-    withScheduler_ comp $ \scheduler -> do-      let withC00 iA jB f = let !ixC00 = iA * nB + jB-                            in f ixC00 =<< unsafeLinearRead marrC ixC00-          withC01 ixC00 f = let !ixC01 = ixC00 + 1-                            in f ixC01 =<< unsafeLinearRead marrC ixC01-          withC10 ixC00 f = let !ixC10 = ixC00 + nB-                            in f ixC10 =<< unsafeLinearRead marrC ixC10-          withC11 ixC01 f = let !ixC11 = ixC01 + nB-                            in f ixC11 =<< unsafeLinearRead marrC ixC11-          withB00 iB jB f = let !ixB00 = iB * nB + jB-                            in f ixB00 $! unsafeLinearIndex arrB ixB00-          withB00B10 iB jB f =-            withB00 iB jB $ \ixB00 b00 -> let !ixB10 = ixB00 + nB-                                          in f ixB00 b00 ixB10 $! unsafeLinearIndex arrB ixB10-          withA00 iA jA f = let !ixA00 = iA * nA + jA-                            in f ixA00 $! unsafeLinearIndex arrA ixA00-          withA00A10 iA jA f =-            withA00 iA jA $ \ixA00 a00 -> let !ixA10 = ixA00 + nA-                                          in f ixA00 a00 ixA10 $! unsafeLinearIndex arrA ixA10-      let loopColsB_UnRowBColA_UnRowA a00 a01 a10 a11 iA iB jB-            | jB < n2B = do-              withB00B10 iB jB $ \ixB00 b00 ixB10 b10 -> do-                let !b01 = unsafeLinearIndex arrB (ixB00 + 1)-                    !b11 = unsafeLinearIndex arrB (ixB10 + 1)-                withC00 iA jB $ \ixC00 c00 -> do-                  unsafeLinearWrite marrC ixC00 (c00 + a00 * b00 + a01 * b10)-                  withC01 ixC00 $ \ixC01 c01 -> do-                    unsafeLinearWrite marrC ixC01 (c01 + a00 * b01 + a01 * b11)+      marrC <- newMArray (SafeSz (mA :. nB)) 0+      withScheduler_ comp $ \scheduler -> do+        let withC00 iA jB f =+              let !ixC00 = iA * nB + jB+               in f ixC00 =<< unsafeLinearRead marrC ixC00+            withC01 ixC00 f =+              let !ixC01 = ixC00 + 1+               in f ixC01 =<< unsafeLinearRead marrC ixC01+            withC10 ixC00 f =+              let !ixC10 = ixC00 + nB+               in f ixC10 =<< unsafeLinearRead marrC ixC10+            withC11 ixC01 f =+              let !ixC11 = ixC01 + nB+               in f ixC11 =<< unsafeLinearRead marrC ixC11+            withB00 iB jB f =+              let !ixB00 = iB * nB + jB+               in f ixB00 $! unsafeLinearIndex arrB ixB00+            withB00B10 iB jB f =+              withB00 iB jB $ \ixB00 b00 ->+                let !ixB10 = ixB00 + nB+                 in f ixB00 b00 ixB10 $! unsafeLinearIndex arrB ixB10+            withA00 iA jA f =+              let !ixA00 = iA * nA + jA+               in f ixA00 $! unsafeLinearIndex arrA ixA00+            withA00A10 iA jA f =+              withA00 iA jA $ \ixA00 a00 ->+                let !ixA10 = ixA00 + nA+                 in f ixA00 a00 ixA10 $! unsafeLinearIndex arrA ixA10+        let loopColsB_UnRowBColA_UnRowA a00 a01 a10 a11 iA iB jB+              | jB < n2B = do+                  withB00B10 iB jB $ \ixB00 b00 ixB10 b10 -> do+                    let !b01 = unsafeLinearIndex arrB (ixB00 + 1)+                        !b11 = unsafeLinearIndex arrB (ixB10 + 1)+                    withC00 iA jB $ \ixC00 c00 -> do+                      unsafeLinearWrite marrC ixC00 (c00 + a00 * b00 + a01 * b10)+                      withC01 ixC00 $ \ixC01 c01 -> do+                        unsafeLinearWrite marrC ixC01 (c01 + a00 * b01 + a01 * b11)+                        withC10 ixC00 $ \ixC10 c10 ->+                          unsafeLinearWrite marrC ixC10 (c10 + a10 * b00 + a11 * b10)+                        withC11 ixC01 $ \ixC11 c11 ->+                          unsafeLinearWrite marrC ixC11 (c11 + a10 * b01 + a11 * b11)+                  loopColsB_UnRowBColA_UnRowA a00 a01 a10 a11 iA iB (jB + 2)+              | jB < nB = withB00B10 iB jB $ \_ b00 _ b10 ->+                  withC00 iA jB $ \ixC00 c00 -> do+                    unsafeLinearWrite marrC ixC00 (c00 + a00 * b00 + a01 * b10)                     withC10 ixC00 $ \ixC10 c10 ->                       unsafeLinearWrite marrC ixC10 (c10 + a10 * b00 + a11 * b10)-                    withC11 ixC01 $ \ixC11 c11 ->-                      unsafeLinearWrite marrC ixC11 (c11 + a10 * b01 + a11 * b11)-              loopColsB_UnRowBColA_UnRowA a00 a01 a10 a11 iA iB (jB + 2)--            | jB < nB = withB00B10 iB jB $ \_ b00 _ b10 ->-                          withC00 iA jB $ \ixC00 c00 -> do-                            unsafeLinearWrite marrC ixC00 (c00 + a00 * b00 + a01 * b10)-                            withC10 ixC00 $ \ixC10 c10 ->-                              unsafeLinearWrite marrC ixC10 (c10 + a10 * b00 + a11 * b10)-            | otherwise = pure ()--          loopColsB_UnRowBColA_RowA a00 a01 iA iB jB-            | jB < n2B = do-              withB00B10 iB jB $ \ixB00 b00 ixB10 b10 -> do-                let !b01 = unsafeLinearIndex arrB (ixB00 + 1)-                    !b11 = unsafeLinearIndex arrB (ixB10 + 1)-                withC00 iA jB $ \ixC00 c00 -> do-                  unsafeLinearWrite marrC ixC00 (c00 + a00 * b00 + a01 * b10)-                  withC01 ixC00 $ \ixC01 c01 ->-                    unsafeLinearWrite marrC ixC01 (c01 + a00 * b01 + a01 * b11)-              loopColsB_UnRowBColA_RowA a00 a01 iA iB (jB + 2)+              | otherwise = pure () -            | jB < nB = withB00B10 iB jB $ \_ b00 _ b10 ->-                          withC00 iA jB $ \ixC00 c00 ->-                            unsafeLinearWrite marrC ixC00 (c00 + a00 * b00 + a01 * b10)-            | otherwise = pure ()+            loopColsB_UnRowBColA_RowA a00 a01 iA iB jB+              | jB < n2B = do+                  withB00B10 iB jB $ \ixB00 b00 ixB10 b10 -> do+                    let !b01 = unsafeLinearIndex arrB (ixB00 + 1)+                        !b11 = unsafeLinearIndex arrB (ixB10 + 1)+                    withC00 iA jB $ \ixC00 c00 -> do+                      unsafeLinearWrite marrC ixC00 (c00 + a00 * b00 + a01 * b10)+                      withC01 ixC00 $ \ixC01 c01 ->+                        unsafeLinearWrite marrC ixC01 (c01 + a00 * b01 + a01 * b11)+                  loopColsB_UnRowBColA_RowA a00 a01 iA iB (jB + 2)+              | jB < nB = withB00B10 iB jB $ \_ b00 _ b10 ->+                  withC00 iA jB $ \ixC00 c00 ->+                    unsafeLinearWrite marrC ixC00 (c00 + a00 * b00 + a01 * b10)+              | otherwise = pure () -          loopColsB_RowBColA_UnRowA a00 a10 iA iB jB-            | jB < n2B = do-              withB00 iB jB $ \ixB00 b00 -> do-                let !b01 = unsafeLinearIndex arrB (ixB00 + 1)-                withC00 iA jB $ \ixC00 c00 -> do-                  unsafeLinearWrite marrC ixC00 (c00 + a00 * b00)-                  withC01 ixC00 $ \ixC01 c01 -> do-                    unsafeLinearWrite marrC ixC01 (c01 + a00 * b01)+            loopColsB_RowBColA_UnRowA a00 a10 iA iB jB+              | jB < n2B = do+                  withB00 iB jB $ \ixB00 b00 -> do+                    let !b01 = unsafeLinearIndex arrB (ixB00 + 1)+                    withC00 iA jB $ \ixC00 c00 -> do+                      unsafeLinearWrite marrC ixC00 (c00 + a00 * b00)+                      withC01 ixC00 $ \ixC01 c01 -> do+                        unsafeLinearWrite marrC ixC01 (c01 + a00 * b01)+                        withC10 ixC00 $ \ixC10 c10 ->+                          unsafeLinearWrite marrC ixC10 (c10 + a10 * b00)+                        withC11 ixC01 $ \ixC11 c11 ->+                          unsafeLinearWrite marrC ixC11 (c11 + a10 * b01)+                  loopColsB_RowBColA_UnRowA a00 a10 iA iB (jB + 2)+              | jB < nB = withB00 iB jB $ \_ b00 ->+                  withC00 iA jB $ \ixC00 c00 -> do+                    unsafeLinearWrite marrC ixC00 (c00 + a00 * b00)                     withC10 ixC00 $ \ixC10 c10 ->                       unsafeLinearWrite marrC ixC10 (c10 + a10 * b00)-                    withC11 ixC01 $ \ixC11 c11 ->-                      unsafeLinearWrite marrC ixC11 (c11 + a10 * b01)-              loopColsB_RowBColA_UnRowA a00 a10 iA iB (jB + 2)--            | jB < nB = withB00 iB jB $ \_ b00 ->-                          withC00 iA jB $ \ixC00 c00 -> do-                            unsafeLinearWrite marrC ixC00 (c00 + a00 * b00)-                            withC10 ixC00 $ \ixC10 c10 ->-                              unsafeLinearWrite marrC ixC10 (c10 + a10 * b00)-            | otherwise = pure ()--          loopColsB_RowBColA_RowA a00 iA iB jB-            | jB < n2B = do-              withB00 iB jB $ \ixB00 b00 -> do-                let !b01 = unsafeLinearIndex arrB (ixB00 + 1)-                withC00 iA jB $ \ixC00 c00 -> do-                  unsafeLinearWrite marrC ixC00 (c00 + a00 * b00)-                  withC01 ixC00 $ \ixC01 c01 -> do-                    unsafeLinearWrite marrC ixC01 (c01 + a00 * b01)-              loopColsB_RowBColA_RowA a00 iA iB (jB + 2)-            | jB < nB = withB00 iB jB $ \_ b00 ->-                          withC00 iA jB $ \ixC00 c00 ->-                            unsafeLinearWrite marrC ixC00 (c00 + a00 * b00)+              | otherwise = pure () -            | otherwise = pure ()+            loopColsB_RowBColA_RowA a00 iA iB jB+              | jB < n2B = do+                  withB00 iB jB $ \ixB00 b00 -> do+                    let !b01 = unsafeLinearIndex arrB (ixB00 + 1)+                    withC00 iA jB $ \ixC00 c00 -> do+                      unsafeLinearWrite marrC ixC00 (c00 + a00 * b00)+                      withC01 ixC00 $ \ixC01 c01 -> do+                        unsafeLinearWrite marrC ixC01 (c01 + a00 * b01)+                  loopColsB_RowBColA_RowA a00 iA iB (jB + 2)+              | jB < nB = withB00 iB jB $ \_ b00 ->+                  withC00 iA jB $ \ixC00 c00 ->+                    unsafeLinearWrite marrC ixC00 (c00 + a00 * b00)+              | otherwise = pure () -          loopRowsB_UnRowA iA iB-            | iB < m2B = do-              withA00A10 iA iB $ \ixA00 a00 ixA10 a10 -> do-                let !a01 = unsafeLinearIndex arrA (ixA00 + 1)-                    !a11 = unsafeLinearIndex arrA (ixA10 + 1)-                loopColsB_UnRowBColA_UnRowA a00 a01 a10 a11 iA iB 0-              loopRowsB_UnRowA iA (iB + 2)-            | iB < mB =-              withA00A10 iA iB $ \_ a00 _ a10 -> loopColsB_RowBColA_UnRowA a00 a10 iA iB 0-            | otherwise = pure ()+            loopRowsB_UnRowA iA iB+              | iB < m2B = do+                  withA00A10 iA iB $ \ixA00 a00 ixA10 a10 -> do+                    let !a01 = unsafeLinearIndex arrA (ixA00 + 1)+                        !a11 = unsafeLinearIndex arrA (ixA10 + 1)+                    loopColsB_UnRowBColA_UnRowA a00 a01 a10 a11 iA iB 0+                  loopRowsB_UnRowA iA (iB + 2)+              | iB < mB =+                  withA00A10 iA iB $ \_ a00 _ a10 -> loopColsB_RowBColA_UnRowA a00 a10 iA iB 0+              | otherwise = pure () -          loopRowsB_RowA iA iB-            | iB < m2B = do-              withA00 iA iB $ \ixA00 a00 -> do-                let !a01 = unsafeLinearIndex arrA (ixA00 + 1)-                loopColsB_UnRowBColA_RowA a00 a01 iA iB 0-              loopRowsB_RowA iA (iB + 2)-            | iB < mB = withA00 iA iB $ \_ a00 -> loopColsB_RowBColA_RowA a00 iA iB 0-            | otherwise = pure ()+            loopRowsB_RowA iA iB+              | iB < m2B = do+                  withA00 iA iB $ \ixA00 a00 -> do+                    let !a01 = unsafeLinearIndex arrA (ixA00 + 1)+                    loopColsB_UnRowBColA_RowA a00 a01 iA iB 0+                  loopRowsB_RowA iA (iB + 2)+              | iB < mB = withA00 iA iB $ \_ a00 -> loopColsB_RowBColA_RowA a00 iA iB 0+              | otherwise = pure () -          loopRowsA iA-            | iA < m2A = do-              scheduleWork_ scheduler $ loopRowsB_UnRowA iA 0-              loopRowsA (iA + 2)-            | iA < mA = scheduleWork_ scheduler $ loopRowsB_RowA iA 0-            | otherwise = pure ()-      loopRowsA 0+            loopRowsA iA+              | iA < m2A = do+                  scheduleWork_ scheduler $ loopRowsB_UnRowA iA 0+                  loopRowsA (iA + 2)+              | iA < mA = scheduleWork_ scheduler $ loopRowsB_RowA iA 0+              | otherwise = pure ()+        loopRowsA 0 -    unsafeFreeze comp marrC+      unsafeFreeze comp marrC   where     comp = getComp arrA <> getComp arrB     m2A = mA - mA `rem` 2@@ -708,8 +719,8 @@ -- > m1 .><. transpose m2 == multiplyMatricesTransposed m1 m2 -- -- @since 0.5.6-multiplyMatricesTransposed ::-     (Numeric r e, Manifest r e, MonadThrow m)+multiplyMatricesTransposed+  :: (Numeric r e, Manifest r e, MonadThrow m)   => Matrix r e   -> Matrix r e   -> m (Matrix D e)@@ -717,9 +728,9 @@   | n1 /= m2 = throwM $ SizeMismatchException (size arr1) (Sz2 m2 n2)   | isEmpty arr1 || isEmpty arr2 = pure $ setComp comp empty   | otherwise =-    pure $-    makeArray comp (SafeSz (m1 :. n2)) $ \(i :. j) ->-      unsafeDotProduct (unsafeLinearSlice (i * n1) n arr1) (unsafeLinearSlice (j * n1) n arr2)+      pure $+        makeArray comp (SafeSz (m1 :. n2)) $ \(i :. j) ->+          unsafeDotProduct (unsafeLinearSlice (i * n1) n arr1) (unsafeLinearSlice (j * n1) n arr2)   where     comp = getComp arr1 <> getComp arr2     n = SafeSz n1@@ -744,7 +755,7 @@ -- @since 0.3.6 identityMatrix :: Num e => Sz1 -> Matrix DL e identityMatrix (Sz n) =-  makeLoadArrayS (Sz2 n n) 0 $ \ w -> loopA_ 0 (< n) (+1) $ \ i -> w (i :. i) 1+  makeLoadArrayS (Sz2 n n) 0 $ \w -> loopA_ 0 (< n) (+ 1) $ \i -> w (i :. i) 1 {-# INLINE identityMatrix #-}  -- | Create a lower triangular (L in LU decomposition) matrix of size @NxN@@@ -828,15 +839,14 @@ -- /__Throws Exception__/: `SizeMismatchException` when array sizes do not match. -- -- @since 0.4.0-(./.) ::-     (Index ix, 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) (./.) = applyExactSize2M divisionPointwise {-# INLINE (./.) #-} - -- | Divide two arrays pointwise. Prefer to use monadic version of this function `./.` -- whenever possible, because it is better to avoid partial functions. --@@ -870,7 +880,7 @@ --   [ 5.0, 4.7619047, 4.5454545, 4.347826, 4.1666665 ] -- -- @since 0.5.6-(/.) ::(Index ix,  NumericFloat r e) => e -> Array r ix e -> Array r ix e+(/.) :: (Index ix, NumericFloat r e) => e -> Array r ix e -> Array r ix e (/.) = scalarDivide {-# INLINE (/.) #-} @@ -887,13 +897,15 @@ --   [ 0.2, 0.21, 0.22, 0.23, 0.24 ] -- -- @since 0.4.0-(./) ::(Index ix,  NumericFloat r e) => Array r ix e -> e -> Array r ix e+(./) :: (Index ix, NumericFloat r e) => Array r ix e -> e -> Array r ix e (./) = divideScalar {-# INLINE (./) #-}  (.^^)   :: (Index ix, Numeric r e, Fractional e, Integral b)-  => Array r ix e -> b -> Array r ix e+  => Array r ix e+  -> b+  -> Array r ix e (.^^) arr n = unsafeLiftArray (^^ n) arr {-# INLINE (.^^) #-} @@ -906,7 +918,6 @@ recipA = recipPointwise {-# INLINE recipA #-} - -- | Apply exponent to each element of the array. -- -- > expA arr == map exp arr@@ -934,7 +945,6 @@ logA = unsafeLiftArray log {-# INLINE logA #-} - -- | Apply logarithm to each element of the array where the base is in the same cell in -- the second array. --@@ -945,16 +955,16 @@ -- @since 0.4.0 logBaseA   :: (Index ix, Source r1 e, Source r2 e, Floating e)-  => Array r1 ix e -> Array r2 ix e -> Array D ix e+  => Array r1 ix e+  -> Array r2 ix e+  -> Array D ix e logBaseA = liftArray2' logBase {-# INLINE logBaseA #-}+ -- TODO: siwtch to -- (breaking) logBaseA :: Array r ix e -> e -> Array D ix e -- logBasesM :: Array r ix e -> Array r ix e -> m (Array D ix e) --- -- | Apply power to each element of the array where the power value is in the same cell -- in the second array. --@@ -965,16 +975,17 @@ -- @since 0.4.0 (.**)   :: (Index ix, Source r1 e, Source r2 e, Floating e)-  => Array r1 ix e -> Array r2 ix e -> Array D ix e+  => Array r1 ix e+  -> Array r2 ix e+  -> Array D ix e (.**) = liftArray2' (**) {-# INLINE (.**) #-}+ -- TODO: -- !**! :: Array r1 ix e -> Array r2 ix e -> Array D ix e -- .**. :: Array r1 ix e -> Array r2 ix e -> m (Array D ix e) -- (breaking) .** :: Array r1 ix e -> e -> Array D ix e -- -- | Apply sine function to each element of the array. -- -- > sinA arr == map sin arr@@ -1083,7 +1094,6 @@ atanhA = unsafeLiftArray atanh {-# INLINE atanhA #-} - -- | Perform a pointwise quotient where first array contains numerators and the second -- one denominators --@@ -1094,11 +1104,12 @@ -- @since 0.1.0 quotA   :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)-  => Array r1 ix e -> Array r2 ix e -> Array D ix e+  => Array r1 ix e+  -> Array r2 ix e+  -> Array D ix e quotA = liftArray2' quot {-# INLINE quotA #-} - -- | Perform a pointwise remainder computation -- -- > remA arr1 arr2 == zipWith rem arr1 arr2@@ -1108,7 +1119,9 @@ -- @since 0.1.0 remA   :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)-  => Array r1 ix e -> Array r2 ix e -> Array D ix e+  => Array r1 ix e+  -> Array r2 ix e+  -> Array D ix e remA = liftArray2' rem {-# INLINE remA #-} @@ -1122,9 +1135,12 @@ -- @since 0.1.0 divA   :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)-  => Array r1 ix e -> Array r2 ix e -> Array D ix e+  => Array r1 ix e+  -> Array r2 ix e+  -> Array D ix e divA = liftArray2' div {-# INLINE divA #-}+ -- TODO: --  * Array r ix e -> Array r ix e -> m (Array r ix e) --  * Array r ix e -> e -> Array r ix e@@ -1139,12 +1155,12 @@ -- @since 0.1.0 modA   :: (HasCallStack, Index ix, Source r1 e, Source r2 e, Integral e)-  => Array r1 ix e -> Array r2 ix e -> Array D ix e+  => Array r1 ix e+  -> Array r2 ix e+  -> Array D ix e modA = liftArray2' mod {-# INLINE modA #-} -- -- | Perform a pointwise quotient with remainder where first array contains numerators -- and the second one denominators --@@ -1155,11 +1171,12 @@ -- @since 0.1.0 quotRemA   :: (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)+  => Array r1 ix e+  -> Array r2 ix e+  -> (Array D ix e, Array D ix e) quotRemA arr1 = A.unzip . liftArray2' quotRem arr1 {-# INLINE quotRemA #-} - -- | Perform a pointwise integer division with modulo where first array contains -- numerators and the second one denominators --@@ -1170,12 +1187,12 @@ -- @since 0.1.0 divModA   :: (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)+  => Array r1 ix e+  -> Array r2 ix e+  -> (Array D ix e, Array D ix e) divModA arr1 = A.unzip . liftArray2' divMod arr1 {-# INLINE divModA #-} -- -- | Truncate each element of the array. -- -- > truncateA arr == map truncate arr@@ -1185,7 +1202,6 @@ truncateA = A.map truncate {-# INLINE truncateA #-} - -- | Round each element of the array. -- -- > truncateA arr == map truncate arr@@ -1195,7 +1211,6 @@ roundA = A.map round {-# INLINE roundA #-} - -- | Ceiling of each element of the array. -- -- > truncateA arr == map truncate arr@@ -1205,7 +1220,6 @@ ceilingA = A.map ceiling {-# INLINE ceilingA #-} - -- | Floor each element of the array. -- -- > truncateA arr == map truncate arr@@ -1222,8 +1236,8 @@ -- /__Throws Exception__/: `SizeMismatchException` when array sizes do not match. -- -- @since 0.1.0-atan2A ::-     (Index ix, Numeric r e, RealFloat e, MonadThrow m)+atan2A+  :: (Index ix, Numeric r e, RealFloat e, MonadThrow m)   => Array r ix e   -> Array r ix e   -> m (Array r ix e)@@ -1291,13 +1305,14 @@ --   ] -- -- @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+  :: (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+    (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@@ -1305,12 +1320,11 @@ -- 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'+  :: (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__@@ -1364,10 +1378,10 @@ --   ] -- -- @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+  :: (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+    (x : xs) -> F.foldlM (.*.) x xs {-# INLINE productArraysM #-}

@@ -1,5 +1,6 @@ {-# LANGUAGE BangPatterns #-} {-# LANGUAGE FlexibleContexts #-}+ -- | -- Module      : Data.Massiv.Array.Numeric.Integral -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -7,30 +8,31 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Numeric.Integral-  (+module Data.Massiv.Array.Numeric.Integral (   -- $integral_intro-  ---  -- * Integral Approximation-  -- ** Midpoint Rule-    midpointRule-  , midpointStencil+  midpointRule,+  midpointStencil,+   -- ** Trapezoid Rule-  , trapezoidRule-  , trapezoidStencil+  trapezoidRule,+  trapezoidStencil,+   -- ** Simpson's Rule-  , simpsonsRule-  , simpsonsStencil+  simpsonsRule,+  simpsonsStencil,+   -- * General Integral approximation-  , integrateWith-  , integralApprox+  integrateWith,+  integralApprox,+   -- * From functions+   -- ** Sampled at the edge-  , fromFunction+  fromFunction,+   -- ** Sampled at the midpoint-  , fromFunctionMidpoint-  ) where+  fromFunctionMidpoint,+) where  import Data.Coerce import Data.Massiv.Array.Delayed.Pull (D)@@ -42,7 +44,6 @@ import Data.Massiv.Array.Unsafe import Data.Massiv.Core.Common - -- | -- -- __Midpoint Rule__@@ -50,18 +51,20 @@ -- \[ -- \int_{{\,a}}^{{\,b}}{{f\left( x \right)\,dx}} \approx \Delta x \cdot \,f\left( {x_1 + \frac{\Delta x}{2}} \right) + \Delta x \cdot \,f\left( {x_2 + \frac{\Delta x}{2}} \right) +  \cdots  + \Delta x \cdot \,f\left( {x_n + \frac{\Delta x}{2}} \right) -- \]-midpointStencil ::-     (Fractional e, Index ix)-  => e -- ^ @Δx@ - distance between sample points-  -> Dim -- ^ Dimension along which to integrate-  -> Int -- ^ @n@ - number of sample points.+midpointStencil+  :: (Fractional e, Index ix)+  => e+  -- ^ @Δx@ - distance between sample points+  -> Dim+  -- ^ Dimension along which to integrate+  -> Int+  -- ^ @n@ - number of sample points.   -> Stencil ix e e midpointStencil dx dim k =   makeUnsafeStencil (Sz (setDim' (pureIndex 1) dim k)) zeroIndex $ \_ g ->     dx * loop 0 (< k) (+ 1) 0 (\i -> (+ g (setDim' zeroIndex dim i))) {-# INLINE midpointStencil #-} - -- | -- -- __Trapezoid Rule__@@ -69,20 +72,23 @@ -- \[ -- \int_{{\,a}}^{{\,b}}{{f\left( x \right)\,dx}} \approx \frac{{\Delta x}}{2}\cdot\left( {f\left( {{x_0}} \right) + f\left( {{x_1}} \right)} \right) + \frac{{\Delta x}}{2}\cdot\left( {f\left( {{x_1}} \right) + f\left( {{x_2}} \right)} \right) +  \cdots  + \frac{{\Delta x}}{2}\cdot\left( {f\left( {{x_{n - 1}}} \right) + f\left( {{x_n}} \right)} \right) -- \]-trapezoidStencil ::-     (Fractional e, Index ix)-  => e -- ^ @Δx@ - distance between sample points-  -> Dim -- ^ Dimension along which to integrate-  -> Int -- ^ @n@ - number of sample points.+trapezoidStencil+  :: (Fractional e, Index ix)+  => e+  -- ^ @Δx@ - distance between sample points+  -> Dim+  -- ^ Dimension along which to integrate+  -> Int+  -- ^ @n@ - number of sample points.   -> Stencil ix e e trapezoidStencil dx dim n =   makeUnsafeStencil (Sz (setDim' (pureIndex 1) dim (n + 1))) zeroIndex $ \_ g ->-    dx / 2 *-    (loop 1 (< n) (+ 1) (g zeroIndex) (\i -> (+ 2 * g (setDim' zeroIndex dim i))) +-     g (setDim' zeroIndex dim n))+    (dx / 2)+      * ( loop 1 (< n) (+ 1) (g zeroIndex) (\i -> (+ 2 * g (setDim' zeroIndex dim i)))+            + g (setDim' zeroIndex dim n)+        ) {-# INLINE trapezoidStencil #-} - -- | -- -- __Simpson's Rule__@@ -90,31 +96,36 @@ -- \[ -- \int_{{\,a}}^{{\,b}}{{f\left( x \right)\,dx}} \approx \frac{{\Delta x}}{3}\cdot\left( {f\left( {{x_0}} \right) + 4\cdot f\left( {{x_1}} \right) + f\left( {{x_2}} \right)} \right) + \frac{{\Delta x}}{3}\cdot\left( {f\left( {{x_2}} \right) + 4\cdot f\left( {{x_3}} \right) + f\left( {{x_4}} \right)} \right) +  \cdots  + \frac{{\Delta x}}{3}\cdot\left( {f\left( {{x_{n - 2}}} \right) + 4\cdot f\left( {{x_{n - 1}}} \right) + f\left( {{x_n}} \right)} \right) -- \]-simpsonsStencil ::-     (Fractional e, Index ix)-  => e -- ^ @Δx@ - distance between sample points-  -> Dim -- ^ Dimension along which to integrate-  -> Int -- ^ @n@ - Number of sample points. This value should be even, otherwise error.+simpsonsStencil+  :: (Fractional e, Index ix)+  => e+  -- ^ @Δx@ - distance between sample points+  -> Dim+  -- ^ Dimension along which to integrate+  -> Int+  -- ^ @n@ - Number of sample points. This value should be even, otherwise error.   -> Stencil ix e e simpsonsStencil dx dim n   | odd n =-    error $-    "Number of sample points for Simpson's rule stencil should be even, but received: " ++ show n+      error $+        "Number of sample points for Simpson's rule stencil should be even, but received: " ++ show n   | otherwise =-    makeUnsafeStencil (Sz (setDim' (pureIndex 1) dim (n + 1))) zeroIndex $ \_ g ->-      let simAcc i (prev, acc) =-            let !fx3 = g (setDim' zeroIndex dim (i + 2))-                !newAcc = acc + prev + 4 * g (setDim' zeroIndex dim (i + 1)) + fx3-             in (fx3, newAcc)-       in dx / 3 * snd (loop 2 (< n - 1) (+ 2) (simAcc 0 (g zeroIndex, 0)) simAcc)+      makeUnsafeStencil (Sz (setDim' (pureIndex 1) dim (n + 1))) zeroIndex $ \_ g ->+        let simAcc i (prev, acc) =+              let !fx3 = g (setDim' zeroIndex dim (i + 2))+                  !newAcc = acc + prev + 4 * g (setDim' zeroIndex dim (i + 1)) + fx3+               in (fx3, newAcc)+         in dx / 3 * snd (loop 2 (< n - 1) (+ 2) (simAcc 0 (g zeroIndex, 0)) simAcc) {-# INLINE simpsonsStencil #-}  -- | Integrate with a stencil along a particular dimension.-integrateWith ::-     (Fractional e, StrideLoad DW ix e, Manifest r e)+integrateWith+  :: (Fractional e, StrideLoad DW ix e, Manifest r e)   => (Dim -> Int -> Stencil ix e e)-  -> Dim -- ^ Dimension along which integration should be estimated.-  -> Int -- ^ @n@ - Number of samples+  -> Dim+  -- ^ Dimension along which integration should be estimated.+  -> Int+  -- ^ @n@ - Number of samples   -> Array r ix e   -> Array r ix e integrateWith stencil dim n arr =@@ -123,15 +134,19 @@     !nsz = setDim' (pureIndex 1) dim n {-# INLINE integrateWith #-} - -- | Compute an approximation of integral using a supplied rule in a form of `Stencil`.-integralApprox ::-     (Fractional e, StrideLoad DW ix e, Manifest r e)-  => (e -> Dim -> Int -> Stencil ix e e) -- ^ Integration Stencil-  -> e -- ^ @d@ - Length of interval per cell-  -> Sz ix -- ^ @sz@ - Result size of the matrix-  -> Int -- ^ @n@ - Number of samples-  -> Array r ix e -- ^ Array with values of @f(x,y,..)@ that will be used as source for integration.+integralApprox+  :: (Fractional e, StrideLoad DW ix e, Manifest r e)+  => (e -> Dim -> Int -> Stencil ix e e)+  -- ^ Integration Stencil+  -> e+  -- ^ @d@ - Length of interval per cell+  -> Sz ix+  -- ^ @sz@ - Result size of the matrix+  -> Int+  -- ^ @n@ - Number of samples+  -> Array r ix e+  -- ^ Array with values of @f(x,y,..)@ that will be used as source for integration.   -> Array D ix e integralApprox stencil d sz n arr =   extract' zeroIndex sz $ loop 1 (<= coerce (dimensions sz)) (+ 1) arr integrateAlong@@ -141,55 +156,73 @@     {-# INLINE integrateAlong #-} {-# INLINE integralApprox #-} - -- | Use midpoint rule to approximate an integral.-midpointRule ::-     (Fractional e, StrideLoad DW ix e, Manifest r e)-  => Comp -- ^ Computation strategy.-  -> r -- ^ Intermediate array representation.-  -> ((Int -> e) -> ix -> e) -- ^ @f(x,y,...)@ - Function to integrate-  -> e -- ^ @a@ - Starting value point.-  -> e -- ^ @d@ - Distance per matrix cell.-  -> Sz ix -- ^ @sz@ - Result matrix size.-  -> Int -- ^ @n@ - Number of sample points per cell in each direction.+midpointRule+  :: (Fractional e, StrideLoad DW ix e, Manifest r e)+  => Comp+  -- ^ Computation strategy.+  -> r+  -- ^ Intermediate array representation.+  -> ((Int -> e) -> ix -> e)+  -- ^ @f(x,y,...)@ - Function to integrate+  -> e+  -- ^ @a@ - Starting value point.+  -> e+  -- ^ @d@ - Distance per matrix cell.+  -> Sz ix+  -- ^ @sz@ - Result matrix size.+  -> Int+  -- ^ @n@ - Number of sample points per cell in each direction.   -> Array D ix e midpointRule comp r f a d sz n =   integralApprox midpointStencil d sz n $ computeAs r $ fromFunctionMidpoint comp f a d sz n {-# INLINE midpointRule #-} - -- | Use trapezoid rule to approximate an integral.-trapezoidRule ::-     (Fractional e, StrideLoad DW ix e, Manifest r e)-  => Comp -- ^ Computation strategy-  -> r -- ^ Intermediate array representation-  -> ((Int -> e) -> ix -> e) -- ^ @f(x,y,...)@ - function to integrate-  -> e -- ^ @a@ - Starting value point.-  -> e -- ^ @d@ - Distance per matrix cell.-  -> Sz ix -- ^ @sz@ - Result matrix size.-  -> Int -- ^ @n@ - Number of sample points per cell in each direction.+trapezoidRule+  :: (Fractional e, StrideLoad DW ix e, Manifest r e)+  => Comp+  -- ^ Computation strategy+  -> r+  -- ^ Intermediate array representation+  -> ((Int -> e) -> ix -> e)+  -- ^ @f(x,y,...)@ - function to integrate+  -> e+  -- ^ @a@ - Starting value point.+  -> e+  -- ^ @d@ - Distance per matrix cell.+  -> Sz ix+  -- ^ @sz@ - Result matrix size.+  -> Int+  -- ^ @n@ - Number of sample points per cell in each direction.   -> Array D ix e trapezoidRule comp r f a d sz n =   integralApprox trapezoidStencil d sz n $ computeAs r $ fromFunction comp f a d sz n {-# INLINE trapezoidRule #-}  -- | Use Simpson's rule to approximate an integral.-simpsonsRule ::-     (Fractional e, StrideLoad DW ix e, Manifest r e)-  => Comp -- ^ Computation strategy-  -> r -- ^ Intermediate array representation-  -> ((Int -> e) -> ix -> e) -- ^ @f(x,y,...)@ - Function to integrate-  -> e -- ^ @a@ - Starting value point.-  -> e -- ^ @d@ - Distance per matrix cell.-  -> Sz ix -- ^ @sz@ - Result matrix size.-  -> Int -- ^ @n@ - Number of sample points per cell in each direction. This value must be even,-         -- otherwise error.+simpsonsRule+  :: (Fractional e, StrideLoad DW ix e, Manifest r e)+  => Comp+  -- ^ Computation strategy+  -> r+  -- ^ Intermediate array representation+  -> ((Int -> e) -> ix -> e)+  -- ^ @f(x,y,...)@ - Function to integrate+  -> e+  -- ^ @a@ - Starting value point.+  -> e+  -- ^ @d@ - Distance per matrix cell.+  -> Sz ix+  -- ^ @sz@ - Result matrix size.+  -> Int+  -- ^ @n@ - Number of sample points per cell in each direction. This value must be even,+  -- otherwise error.   -> Array D ix e simpsonsRule comp r f a d sz n =   integralApprox simpsonsStencil d sz n $ computeAs r $ fromFunction comp f a d sz n {-# INLINE simpsonsRule #-} - -- | Create an array from a function with sample points at the edges -- -- >>> fromFunction Seq (\ scale (i :. j) -> scale i + scale j :: Double) (-2) 1 (Sz 4) 2@@ -204,17 +237,21 @@ --   , [ -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5 ] --   , [ 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0 ] --   ]----fromFunction ::-     (Index ix, Fractional a)-  => Comp -- ^ Computation strategy+fromFunction+  :: (Index ix, Fractional a)+  => Comp+  -- ^ Computation strategy   -> ((Int -> a) -> ix -> e)   -- ^ A function that will produce elements of scaled up array. First argument is a scaling   -- function that should be applied to individual indicies.-  -> a -- ^ @a@ - Starting point-  -> a -- ^ @d@ - Distance per cell-  -> Sz ix -- ^ @sz@ - Size of the desired array-  -> Int -- ^ @n@ - Scaling factor, i.e. number of sample points per cell.+  -> a+  -- ^ @a@ - Starting point+  -> a+  -- ^ @d@ - Distance per cell+  -> Sz ix+  -- ^ @sz@ - Size of the desired array+  -> Int+  -- ^ @n@ - Scaling factor, i.e. number of sample points per cell.   -> Array D ix e fromFunction comp f a d (Sz sz) n =   f scale <$> rangeInclusive comp zeroIndex (liftIndex (n *) sz)@@ -224,7 +261,6 @@     {-# INLINE scale #-} {-# INLINE fromFunction #-} - -- | Similar to `fromFunction`, but will create an array from a function with sample points in the -- middle of cells. --@@ -239,10 +275,15 @@ --   , [ -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0 ] --   , [ 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5 ] --   ]--- fromFunctionMidpoint-  :: (Index ix, Fractional a) =>-     Comp -> ((Int -> a) -> ix -> e) -> a -> a -> Sz ix -> Int -> Array D ix e+  :: (Index ix, Fractional a)+  => Comp+  -> ((Int -> a) -> ix -> e)+  -> a+  -> a+  -> Sz ix+  -> Int+  -> Array D ix e fromFunctionMidpoint comp f a d (Sz sz) n =   f scale <$> rangeInclusive comp zeroIndex (liftIndex (\i -> n * i - 1) sz)   where@@ -251,7 +292,6 @@     scale i = dx2 + a + d * fromIntegral i / nFrac     {-# INLINE scale #-} {-# INLINE fromFunctionMidpoint #-}-  -- $integral_intro --

@@ -5,6 +5,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-}+ -- | -- Module      : Data.Massiv.Array.Ops.Construct -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -12,68 +13,75 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Ops.Construct-  ( -- ** With constant value-    empty-  , singleton-  , replicate-    -- ** With a function-  , makeArray-  , makeArrayLinear-  , makeArrayR-  , makeArrayLinearR-  , makeVectorR-    -- *** Iterating-  , iterateN-  , iiterateN-    -- *** Unfolding-  , unfoldlS_-  , iunfoldlS_-  , unfoldrS_-  , iunfoldrS_-  , makeSplitSeedArray-    -- *** Random-  , uniformArray-  , uniformRangeArray-  , randomArray-  , randomArrayS-  , randomArrayWS-    -- *** Applicative-  , makeArrayA-  , makeArrayAR-  , makeArrayLinearA-    -- ** Enumeration-  , (...)-  , (..:)-  , range-  , rangeStepM-  , rangeStep'-  , rangeInclusive-  , rangeStepInclusiveM-  , rangeStepInclusive'-  , rangeSize-  , rangeStepSize-  , enumFromN-  , enumFromStepN-    -- ** Expansion-  , expandWithin-  , expandWithinM-  , expandWithin'-  , expandOuter-  , expandInner-  ) where+module Data.Massiv.Array.Ops.Construct (+  -- ** With constant value+  empty,+  singleton,+  replicate, +  -- ** With a function+  makeArray,+  makeArrayLinear,+  makeArrayR,+  makeArrayLinearR,+  makeVectorR,++  -- *** Iterating+  iterateN,+  iiterateN,++  -- *** Unfolding+  unfoldlS_,+  iunfoldlS_,+  unfoldrS_,+  iunfoldrS_,+  makeSplitSeedArray,++  -- *** Random+  uniformArray,+  uniformRangeArray,+  randomArray,+  randomArrayS,+  randomArrayWS,++  -- *** Applicative+  makeArrayA,+  makeArrayAR,+  makeArrayLinearA,++  -- ** Enumeration+  (...),+  (..:),+  range,+  rangeStepM,+  rangeStep',+  rangeInclusive,+  rangeStepInclusiveM,+  rangeStepInclusive',+  rangeSize,+  rangeStepSize,+  enumFromN,+  enumFromStepN,++  -- ** Expansion+  expandWithin,+  expandWithinM,+  expandWithin',+  expandOuter,+  expandInner,+) where+ import Control.Applicative hiding (empty)-import Control.Monad (when, void)+import Control.Monad (void, when) import Control.Monad.ST import Data.Massiv.Array.Delayed.Pull import Data.Massiv.Array.Delayed.Push---import Data.Massiv.Array.Delayed.Stream (unfoldr, unfoldrN)++-- import Data.Massiv.Array.Delayed.Stream (unfoldr, unfoldrN) import Data.Massiv.Array.Mutable import Data.Massiv.Core.Common-import Prelude hiding (enumFromTo, replicate) import System.Random.Stateful+import Prelude hiding (enumFromTo, replicate)  -- | Just like `makeArray` but with ability to specify the result representation as an -- argument. Note the `Data.Massiv.Array.U`nboxed type constructor in the below example.@@ -112,12 +120,11 @@ makeVectorR _ = makeArray {-# INLINE makeVectorR #-} - newtype STA r ix a = STA {_runSTA :: forall s. MArray s r ix a -> ST s (Array r ix a)}  runSTA :: (Manifest r e, Index ix) => Sz ix -> STA r ix e -> Array r ix e runSTA !sz (STA m) = runST (unsafeNew sz >>= m)-{-# INLINE runSTA  #-}+{-# INLINE runSTA #-}  -- | Similar to `makeArray`, but construct the array sequentially using an `Applicative` interface. --@@ -126,37 +133,39 @@ -- -- -- @since 0.2.6-makeArrayA ::-     forall r ix e f. (Manifest r e, Index ix, Applicative f)+makeArrayA+  :: forall r ix e f+   . (Manifest r e, Index ix, Applicative f)   => Sz ix   -> (ix -> f e)   -> f (Array r ix e) makeArrayA sz@(Sz n) f =   fmap (runSTA sz) $-  iterF zeroIndex n oneIndex (<) (pure (STA (unsafeFreeze Seq))) $ \ix g ->-    liftA2 (\e (STA st) -> STA (\ma -> unsafeWrite ma ix e >> st ma)) (f ix) g-{-# INLINE makeArrayA  #-}+    iterF zeroIndex n oneIndex (<) (pure (STA (unsafeFreeze Seq))) $ \ix g ->+      liftA2 (\e (STA st) -> STA (\ma -> unsafeWrite ma ix e >> st ma)) (f ix) g+{-# INLINE makeArrayA #-}  -- | Same as `makeArrayA`, but with linear index. -- -- @since 0.4.5-makeArrayLinearA ::-     forall r ix e f. (Manifest r e, Index ix, Applicative f)+makeArrayLinearA+  :: forall r ix e f+   . (Manifest r e, Index ix, Applicative f)   => Sz ix   -> (Int -> f e)   -> f (Array r ix e) makeArrayLinearA !sz f =   fmap (runSTA sz) $-  loopF 0 (< totalElem sz) (+ 1) (pure (STA (unsafeFreeze Seq))) $ \i ->-    liftA2 (\e (STA st) -> STA (\ma -> unsafeLinearWrite ma i e >> st ma)) (f i)-{-# INLINE makeArrayLinearA  #-}-+    loopF 0 (< totalElem sz) (+ 1) (pure (STA (unsafeFreeze Seq))) $ \i ->+      liftA2 (\e (STA st) -> STA (\ma -> unsafeLinearWrite ma i e >> st ma)) (f i)+{-# INLINE makeArrayLinearA #-}  -- | Same as `makeArrayA`, but with ability to supply result array representation. -- -- @since 0.2.6-makeArrayAR ::-     forall r ix e f. (Manifest r e, Index ix, Applicative f)+makeArrayAR+  :: forall r ix e f+   . (Manifest r e, Index ix, Applicative f)   => r   -> Sz ix   -> (ix -> f e)@@ -164,7 +173,6 @@ makeArrayAR _ = makeArrayA {-# INLINE makeArrayAR #-} - -- | Sequentially iterate over each cell in the array in the row-major order while continuously -- aplying the accumulator at each step. --@@ -178,14 +186,14 @@ --   ] -- -- @since 0.3.0-iterateN :: forall ix e . Index ix => Sz ix -> (e -> e) -> e -> Array DL ix e+iterateN :: forall ix e. Index ix => Sz ix -> (e -> e) -> e -> Array DL ix e iterateN sz f = unfoldrS_ sz $ \a -> let !a' = f a in (a', a') {-# INLINE iterateN #-}  -- | Same as `iterateN`, but with index aware function. -- -- @since 0.3.0-iiterateN :: forall ix e . Index ix => Sz ix -> (e -> ix -> e) -> e -> Array DL ix e+iiterateN :: forall ix e. Index ix => Sz ix -> (e -> ix -> e) -> e -> Array DL ix e iiterateN sz f = iunfoldrS_ sz $ \a ix -> let !a' = f a ix in (a', a') {-# INLINE iiterateN #-} @@ -199,8 +207,9 @@ --   [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 ] -- -- @since 0.3.0-unfoldrS_ ::-     forall ix e a. Index ix+unfoldrS_+  :: forall ix e a+   . Index ix   => Sz ix   -> (a -> (e, a))   -> a@@ -211,24 +220,24 @@ -- | Right unfold of a delayed load array with index aware function -- -- @since 0.3.0-iunfoldrS_ ::-     forall ix e a. Index ix+iunfoldrS_+  :: forall ix e a+   . Index ix   => Sz ix   -> (a -> ix -> (e, a))   -> a   -> Array DL ix e-iunfoldrS_ sz f acc0 = DLArray {dlComp = Seq, dlSize = sz, dlLoad = load}+iunfoldrS_ sz f acc0 = DLArray{dlComp = Seq, dlSize = sz, dlLoad = load}   where     load :: Loader e     load _ startAt dlWrite _ =       void $-      iterTargetM defRowMajor startAt sz zeroIndex oneStride acc0 $ \ !i !ix !acc ->-        case f acc ix of-          (e, !acc') -> acc' <$ dlWrite i e+        iterTargetM defRowMajor startAt sz zeroIndex oneStride acc0 $ \ !i !ix !acc ->+          case f acc ix of+            (e, !acc') -> acc' <$ dlWrite i e     {-# INLINE load #-} {-# INLINE iunfoldrS_ #-} - -- | Unfold sequentially from the end. There is no way to save the accumulator after -- unfolding is done, since resulting array is delayed, but it's possible to use -- `Data.Massiv.Array.Mutable.unfoldlPrimM` to achieve such effect.@@ -241,24 +250,24 @@ -- | Unfold sequentially from the right with an index aware function. -- -- @since 0.3.0-iunfoldlS_ ::-     forall ix e a. Index ix+iunfoldlS_+  :: forall ix e a+   . Index ix   => Sz ix   -> (ix -> a -> (a, e))   -> a   -> Array DL ix e-iunfoldlS_ sz f acc0 = DLArray {dlComp = Seq, dlSize = sz, dlLoad = load}+iunfoldlS_ sz f acc0 = DLArray{dlComp = Seq, dlSize = sz, dlLoad = load}   where     load :: Loader e     load _ startAt dlWrite _ =       void $-      loopDeepM startAt (< totalElem sz + startAt) (+ 1) acc0 $ \ !i !acc ->-        let (acc', e) = f (fromLinearIndex sz (i - startAt)) acc-         in acc' <$ dlWrite i e+        loopDeepM startAt (< totalElem sz + startAt) (+ 1) acc0 $ \ !i !acc ->+          let (acc', e) = f (fromLinearIndex sz (i - startAt)) acc+           in acc' <$ dlWrite i e     {-# INLINE load #-} {-# INLINE iunfoldlS_ #-} - -- | Create an array with random values by using a pure splittable random number generator -- such as one provided by either [splitmix](https://www.stackage.org/package/splitmix) or -- [random](https://www.stackage.org/package/random) packages. If you don't have a@@ -292,17 +301,21 @@ --   ] -- -- @since 1.0.0-randomArray ::-     forall ix e g. Index ix-  => g -- ^ Initial random value generator+randomArray+  :: forall ix e g+   . Index ix+  => g+  -- ^ Initial random value generator   -> (g -> (g, g))-     -- ^ A function that can split a generator into two independent-     -- generators. It will only be called if supplied computation strategy-     -- needs more than one worker threads.+  -- ^ A function that can split a generator into two independent+  -- generators. It will only be called if supplied computation strategy+  -- needs more than one worker threads.   -> (g -> (e, g))-     -- ^ A function that produces a random value and the next generator-  -> Comp -- ^ Computation strategy.-  -> Sz ix -- ^ Resulting size of the array.+  -- ^ A function that produces a random value and the next generator+  -> Comp+  -- ^ Computation strategy.+  -> Sz ix+  -- ^ Resulting size of the array.   -> Array DL ix e randomArray gen splitGen nextRandom comp sz = unsafeMakeLoadArray comp sz Nothing load   where@@ -321,16 +334,15 @@                     then (genI, genI)                     else splitGen genI             scheduleWork_ scheduler $-              void $ loopM start (< start + chunkLength) (+ 1) genI0 writeRandom+              void $+                loopM start (< start + chunkLength) (+ 1) genI0 writeRandom             pure genI1         when (slackStart < totalLength) $           scheduleWork_ scheduler $-          void $ loopM slackStartAt (< totalLength + startAt) (+ 1) genForSlack writeRandom+            void $+              loopM slackStartAt (< totalLength + startAt) (+ 1) genForSlack writeRandom {-# INLINE randomArray #-} --- -- | Create a delayed array with an initial seed and a splitting function. It is -- somewhat similar to `iunfoldlS_` function, but it is capable of parallelizing -- computation and iterating over the array accoriding to the supplied@@ -340,41 +352,49 @@ -- `Data.Massiv.Array.Manifest.generateSplitSeedArray` -- -- @since 1.0.2-makeSplitSeedArray ::-     forall ix e g it. (Iterator it, Index ix)-  => it -- ^ Iterator-  -> g -- ^ Initial seed+makeSplitSeedArray+  :: forall ix e g it+   . (Iterator it, Index ix)+  => it+  -- ^ Iterator+  -> g+  -- ^ Initial seed   -> (g -> (g, g))-     -- ^ A function that can split a seed into two independent seeds. It will-     -- be called the same number of times as the number of jobs that will get-     -- scheduled during parallelization. Eg. only once for the sequential case.-  -> Comp -- ^ Computation strategy.-  -> Sz ix -- ^ Resulting size of the array.+  -- ^ A function that can split a seed into two independent seeds. It will+  -- be called the same number of times as the number of jobs that will get+  -- scheduled during parallelization. Eg. only once for the sequential case.+  -> Comp+  -- ^ Computation strategy.+  -> Sz ix+  -- ^ Resulting size of the array.   -> (Ix1 -> ix -> g -> (e, g))-     -- ^ A function that produces a value and the next seed. It takes both-     -- versions of the index, in linear and in multi-dimensional forms, as well as-     -- the current seeding value.+  -- ^ A function that produces a value and the next seed. It takes both+  -- versions of the index, in linear and in multi-dimensional forms, as well as+  -- the current seeding value.   -> Array DL ix e makeSplitSeedArray it seed splitSeed comp sz genFunc =-  DLArray {dlComp = comp, dlSize = sz, dlLoad = load}+  DLArray{dlComp = comp, dlSize = sz, dlLoad = load}   where     load :: Loader e     load scheduler startAt writeAt _ =-      iterTargetFullAccST_ it scheduler startAt sz seed (pure . splitSeed) $ \ i ix g ->+      iterTargetFullAccST_ it scheduler startAt sz seed (pure . splitSeed) $ \i ix g ->         case genFunc (i - startAt) ix g of           (x, g') -> g' <$ writeAt i x     {-# INLINE load #-} {-# INLINE makeSplitSeedArray #-} - -- | Generate a random array where all elements are sampled from a uniform distribution. -- -- @since 1.0.0-uniformArray ::-     forall ix e g. (Index ix, RandomGen g, Uniform e)-  => g -- ^ Initial random value generator.-  -> Comp -- ^ Computation strategy.-  -> Sz ix -- ^ Resulting size of the array.+uniformArray+  :: forall ix e g+   . (Index ix, RandomGen g, Uniform e)+  => g+  -- ^ Initial random value generator.+  -> Comp+  -- ^ Computation strategy.+  -> Sz ix+  -- ^ Resulting size of the array.   -> Array DL ix e uniformArray gen = randomArray gen split uniform {-# INLINE uniformArray #-}@@ -382,17 +402,21 @@ -- | Same as `uniformArray`, but will generate values in a supplied range. -- -- @since 1.0.0-uniformRangeArray ::-     forall ix e g. (Index ix, RandomGen g, UniformRange e)-  => g -- ^ Initial random value generator.-  -> (e, e) -- ^ Inclusive range in which values will be generated in.-  -> Comp -- ^ Computation strategy.-  -> Sz ix -- ^ Resulting size of the array.+uniformRangeArray+  :: forall ix e g+   . (Index ix, RandomGen g, UniformRange e)+  => g+  -- ^ Initial random value generator.+  -> (e, e)+  -- ^ Inclusive range in which values will be generated in.+  -> Comp+  -- ^ Computation strategy.+  -> Sz ix+  -- ^ Resulting size of the array.   -> Array DL ix e uniformRangeArray gen r = randomArray gen split (uniformR r) {-# INLINE uniformRangeArray #-} - -- | Similar to `randomArray` but performs generation sequentially, which means it doesn't -- require splitability property. Another consequence is that it returns the new generator -- together with /manifest/ array of random values.@@ -427,12 +451,15 @@ --   ] -- -- @since 0.3.4-randomArrayS ::-     forall r ix e g. (Manifest r e, Index ix)-  => g -- ^ Initial random value generator-  -> Sz ix -- ^ Resulting size of the array.+randomArrayS+  :: forall r ix e g+   . (Manifest r e, Index ix)+  => g+  -- ^ Initial random value generator+  -> Sz ix+  -- ^ Resulting size of the array.   -> (g -> (e, g))-     -- ^ A function that produces a random value and the next generator+  -- ^ A function that produces a random value and the next generator   -> (g, Array r ix e) randomArrayS gen sz nextRandom =   runST $ unfoldrPrimM sz (pure . nextRandom) gen@@ -471,12 +498,15 @@ --   [ 8, 8, 7, 1, 1, 2 ] -- -- @since 0.3.4-randomArrayWS ::-     forall r ix e g m. (Manifest r e, Index ix, MonadUnliftIO m, PrimMonad m)+randomArrayWS+  :: forall r ix e g m+   . (Manifest r e, Index ix, MonadUnliftIO m, PrimMonad m)   => WorkerStates g   -- ^ Use `Control.Scheduler.initWorkerStates` to initialize you per thread generators-  -> Sz ix -- ^ Resulting size of the array-  -> (g -> m e) -- ^ Generate the value using the per thread generator.+  -> Sz ix+  -- ^ Resulting size of the array+  -> (g -> m e)+  -- ^ Generate the value using the per thread generator.   -> m (Array r ix e) randomArrayWS states sz genRandom = generateArrayLinearWS states sz (const genRandom) {-# INLINE randomArrayWS #-}@@ -505,9 +535,9 @@ (..:) = range Seq {-# INLINE (..:) #-} - -- prop> range comp from to == rangeStep comp from 1 to --+ -- | Create an array of indices with a range from start to finish (not-including), where indices are -- incremeted by one. --@@ -543,20 +573,25 @@ -- *** Exception: IndexZeroException: 0 -- -- @since 0.3.0-rangeStepM ::-     forall ix m. (Index ix, MonadThrow m)-  => Comp -- ^ Computation strategy-  -> ix -- ^ Start-  -> ix -- ^ Step. Negative and positive values are ok, but can't have zeros-  -> ix -- ^ End+rangeStepM+  :: forall ix m+   . (Index ix, MonadThrow m)+  => Comp+  -- ^ Computation strategy+  -> ix+  -- ^ Start+  -> ix+  -- ^ Step. Negative and positive values are ok, but can't have zeros+  -> ix+  -- ^ End   -> m (Array D ix ix) rangeStepM comp !from !step !to   | foldlIndex (\acc i -> acc || i == 0) False step = throwM $ IndexZeroException step   | otherwise =-    let dist = liftIndex2 (-) to from-        sz = liftIndex2 div dist step-        r = liftIndex signum $ liftIndex2 mod dist step-     in pure $ rangeStepSize comp from step (Sz (liftIndex2 (+) sz r))+      let dist = liftIndex2 (-) to from+          sz = liftIndex2 div dist step+          r = liftIndex signum $ liftIndex2 mod dist step+       in pure $ rangeStepSize comp from step (Sz (liftIndex2 (+) sz r)) {-# INLINE rangeStepM #-}  -- | Same as `rangeStepM`, but will throw an error whenever @step@ contains zeros.@@ -581,7 +616,6 @@   rangeSize comp ixFrom (Sz (liftIndex2 (-) (liftIndex (+ 1) ixTo) ixFrom)) {-# INLINE rangeInclusive #-} - -- | Just like `rangeStepM`, except the finish index is included. -- -- @since 0.3.0@@ -596,33 +630,40 @@ rangeStepInclusive' comp ixFrom step = throwEither . rangeStepInclusiveM comp ixFrom step {-# INLINE rangeStepInclusive' #-} - -- | Create an array of specified size with indices starting with some index at position @0@ and -- incremented by @1@ until the end of the array is reached -- -- @since 0.3.0-rangeSize :: Index ix =>-             Comp -- ^ Computation strategy-          -> ix -- ^ @x@ - start value-          -> Sz ix -- ^ @sz@ - Size of resulting array-          -> Array D ix ix+rangeSize+  :: Index ix+  => Comp+  -- ^ Computation strategy+  -> ix+  -- ^ @x@ - start value+  -> Sz ix+  -- ^ @sz@ - Size of resulting array+  -> Array D ix ix rangeSize comp !from !sz = makeArray comp sz (liftIndex2 (+) from) {-# INLINE rangeSize #-}  -- | Same as `rangeSize`, but with ability to specify the step. -- -- @since 0.3.0-rangeStepSize :: Index ix =>-                 Comp -- ^ Computation strategy-              -> ix -- ^ @x@ - start value-              -> ix -- ^ @delta@ - step value-              -> Sz ix -- ^ @sz@ - Size of resulting array-              -> Array D ix ix+rangeStepSize+  :: Index ix+  => Comp+  -- ^ Computation strategy+  -> ix+  -- ^ @x@ - start value+  -> ix+  -- ^ @delta@ - step value+  -> Sz ix+  -- ^ @sz@ - Size of resulting array+  -> Array D ix ix rangeStepSize comp !from !step !sz =   makeArray comp sz (liftIndex2 (+) from . liftIndex2 (*) step) {-# INLINE rangeStepSize #-} - -- | Same as `enumFromStepN` with step @dx = 1@. -- -- /Related/: `Data.Massiv.Vector.senumFromN`, `Data.Massiv.Vector.senumFromStepN`,@@ -643,15 +684,17 @@ -- [@Data.Vector.Generic.`Data.Vector.Generic.enumFromN`@] -- -- @since 0.1.0-enumFromN :: Num e =>-             Comp-          -> e -- ^ @x@ - start value-          -> Sz1 -- ^ @n@ - length of resulting vector.-          -> Vector D e-enumFromN comp !from !sz = makeArrayLinear comp sz $ \ i -> from + fromIntegral i+enumFromN+  :: Num e+  => Comp+  -> e+  -- ^ @x@ - start value+  -> Sz1+  -- ^ @n@ - length of resulting vector.+  -> Vector D e+enumFromN comp !from !sz = makeArrayLinear comp sz $ \i -> from + fromIntegral i {-# INLINE enumFromN #-} - -- | Enumerate from a starting number @x@ exactly @n@ times with a custom step value -- @dx@. Unlike `Data.Massiv.Vector.senumFromStepN`, there is no dependency on neigboring -- elements therefore `enumFromStepN` is parallelizable.@@ -680,16 +723,19 @@ -- -- -- @since 0.1.0-enumFromStepN :: Num e =>-                 Comp-              -> e -- ^ @x@ - start number-              -> e -- ^ @dx@ - step number-              -> Sz1 -- ^ @n@ - length of resulting vector-              -> Vector D e-enumFromStepN comp !from !step !sz = makeArrayLinear comp sz $ \ i -> from + fromIntegral i * step+enumFromStepN+  :: Num e+  => Comp+  -> e+  -- ^ @x@ - start number+  -> e+  -- ^ @dx@ - step number+  -> Sz1+  -- ^ @n@ - length of resulting vector+  -> Vector D e+enumFromStepN comp !from !step !sz = makeArrayLinear comp sz $ \i -> from + fromIntegral i * step {-# INLINE enumFromStepN #-} - -- | Function that expands an array to one with a higher dimension. -- -- This is useful for constructing arrays where there is shared computation@@ -731,8 +777,9 @@ --   ] -- -- @since 0.2.6-expandWithin ::-     forall n ix e r a. (IsIndexDimension ix n, Index (Lower ix), Manifest r a)+expandWithin+  :: forall n ix e r a+   . (IsIndexDimension ix n, Index (Lower ix), Manifest r a)   => Dimension n   -> Sz1   -> (a -> Ix1 -> e)@@ -751,8 +798,9 @@ -- will throw an exception on an invalid dimension. -- -- @since 0.2.6-expandWithin' ::-     forall r ix a b. (HasCallStack, Index ix, Index (Lower ix), Manifest r a)+expandWithin'+  :: forall r ix a b+   . (HasCallStack, Index ix, Index (Lower ix), Manifest r a)   => Dim   -> Sz1   -> (a -> Ix1 -> b)@@ -765,8 +813,9 @@ -- will throw an exception on an invalid dimension. -- -- @since 0.4.0-expandWithinM ::-     forall r ix a b m. (Index ix, Index (Lower ix), Manifest r a, MonadThrow m)+expandWithinM+  :: forall r ix a b m+   . (Index ix, Index (Lower ix), Manifest r a, MonadThrow m)   => Dim   -> Sz1   -> (a -> Ix1 -> b)@@ -783,8 +832,9 @@ -- | Similar to `expandWithin`, except it uses the outermost dimension. -- -- @since 0.2.6-expandOuter ::-     forall r ix a b. (Index ix, Index (Lower ix), Manifest r a)+expandOuter+  :: forall r ix a b+   . (Index ix, Index (Lower ix), Manifest r a)   => Sz1   -> (a -> Ix1 -> b)   -> Array r (Lower ix) a@@ -801,8 +851,9 @@ -- | Similar to `expandWithin`, except it uses the innermost dimension. -- -- @since 0.2.6-expandInner ::-     forall r ix a b. (Index ix, Index (Lower ix), Manifest r a)+expandInner+  :: forall r ix a b+   . (Index ix, Index (Lower ix), Manifest r a)   => Sz1   -> (a -> Ix1 -> b)   -> Array r (Lower ix) a

@@ -3,6 +3,7 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-}+ -- | -- Module      : Data.Massiv.Array.Ops.Fold -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -10,151 +11,156 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Ops.Fold-  (+module Data.Massiv.Array.Ops.Fold (   -- ** Unstructured folds-   -- $unstruct_folds-    fold-  , ifoldMono-  , foldMono-  , ifoldSemi-  , foldSemi-  , foldOuterSlice-  , ifoldOuterSlice-  , foldInnerSlice-  , ifoldInnerSlice-  , minimumM-  , minimum'-  , maximumM-  , maximum'-  , sum-  , product-  , and-  , or-  , all-  , any-  , elem-  , eqArrays-  , compareArrays+  fold,+  ifoldMono,+  foldMono,+  ifoldSemi,+  foldSemi,+  foldOuterSlice,+  ifoldOuterSlice,+  foldInnerSlice,+  ifoldInnerSlice,+  minimumM,+  minimum',+  maximumM,+  maximum',+  sum,+  product,+  and,+  or,+  all,+  any,+  elem,+  eqArrays,+  compareArrays,    -- ** Single dimension folds+   -- *** Safe inner most+   --   -- Folding along the inner most dimension will always be faster when compared to doing the same   -- operation along any other dimension, this is due to the fact that inner most folds follow the   -- memory layout of data.-  , ifoldlInner-  , foldlInner-  , ifoldrInner-  , foldrInner-  , foldInner+  ifoldlInner,+  foldlInner,+  ifoldrInner,+  foldrInner,+  foldInner,+   -- *** Type safe within-  , ifoldlWithin-  , foldlWithin-  , ifoldrWithin-  , foldrWithin-  , foldWithin+  ifoldlWithin,+  foldlWithin,+  ifoldrWithin,+  foldrWithin,+  foldWithin,+   -- *** Partial within-  , ifoldlWithin'-  , foldlWithin'-  , ifoldrWithin'-  , foldrWithin'-  , foldWithin'+  ifoldlWithin',+  foldlWithin',+  ifoldrWithin',+  foldrWithin',+  foldWithin',    -- ** Sequential folds-   -- $seq_folds--  , foldlS-  , foldrS-  , ifoldlS-  , ifoldrS+  foldlS,+  foldrS,+  ifoldlS,+  ifoldrS,    -- *** Monadic-  , foldlM-  , foldrM-  , foldlM_-  , foldrM_-  , ifoldlM-  , ifoldrM-  , ifoldlM_-  , ifoldrM_+  foldlM,+  foldrM,+  foldlM_,+  foldrM_,+  ifoldlM,+  ifoldrM,+  ifoldlM_,+  ifoldrM_,    -- *** Special folds-  , foldrFB-  , lazyFoldlS-  , lazyFoldrS+  foldrFB,+  lazyFoldlS,+  lazyFoldrS,    -- ** Parallel folds-   -- $par_folds--  , foldlP-  , foldrP-  , ifoldlP-  , ifoldrP-  , ifoldlIO-  , ifoldrIO+  foldlP,+  foldrP,+  ifoldlP,+  ifoldrP,+  ifoldlIO,+  ifoldrIO,   -- , splitReduce-  ) where+) where  import Data.Massiv.Array.Delayed.Pull import Data.Massiv.Array.Ops.Construct import Data.Massiv.Array.Ops.Fold.Internal import Data.Massiv.Core import Data.Massiv.Core.Common-import Prelude hiding (all, and, any, foldl, foldr, map, maximum, minimum, or, product, sum, elem)-+import Prelude hiding (all, and, any, elem, foldl, foldr, map, maximum, minimum, or, product, sum)  -- | /O(n)/ - Monoidal fold over an array with an index aware function. Also known as reduce. -- -- @since 0.2.4-ifoldMono ::-     (Index ix, Source r e, Monoid m)-  => (ix -> e -> m) -- ^ Convert each element of an array to an appropriate `Monoid`.-  -> Array r ix e -- ^ Source array+ifoldMono+  :: (Index ix, Source r e, Monoid m)+  => (ix -> e -> m)+  -- ^ Convert each element of an array to an appropriate `Monoid`.+  -> Array r ix e+  -- ^ Source array   -> m ifoldMono f = ifoldlInternal (\a ix e -> a `mappend` f ix e) mempty mappend mempty {-# INLINE ifoldMono #-} - -- | /O(n)/ - Semigroup fold over an array with an index aware function. -- -- @since 0.2.4-ifoldSemi ::-     (Index ix, Source r e, Semigroup m)-  => (ix -> e -> m) -- ^ Convert each element of an array to an appropriate `Semigroup`.-  -> m -- ^ Initial element that must be neutral to the (`<>`) function.-  -> Array r ix e -- ^ Source array+ifoldSemi+  :: (Index ix, Source r e, Semigroup m)+  => (ix -> e -> m)+  -- ^ Convert each element of an array to an appropriate `Semigroup`.   -> m+  -- ^ Initial element that must be neutral to the (`<>`) function.+  -> Array r ix e+  -- ^ Source array+  -> m ifoldSemi f m = ifoldlInternal (\a ix e -> a <> f ix e) m (<>) m {-# INLINE ifoldSemi #-} - -- | /O(n)/ - Semigroup fold over an array. -- -- @since 0.1.6-foldSemi ::-     (Index ix, Source r e, Semigroup m)-  => (e -> m) -- ^ Convert each element of an array to an appropriate `Semigroup`.-  -> m -- ^ Initial element that must be neutral to the (`<>`) function.-  -> Array r ix e -- ^ Source array+foldSemi+  :: (Index ix, Source r e, Semigroup m)+  => (e -> m)+  -- ^ Convert each element of an array to an appropriate `Semigroup`.   -> m+  -- ^ Initial element that must be neutral to the (`<>`) function.+  -> Array r ix e+  -- ^ Source array+  -> m foldSemi f m = foldlInternal (\a e -> a <> f e) m (<>) m {-# INLINE foldSemi #-} - -- | Left fold along a specified dimension with an index aware function. -- -- @since 0.2.4-ifoldlWithin :: (Index (Lower ix), IsIndexDimension ix n, Source r e) =>-  Dimension n -> (ix -> a -> e -> a) -> a -> Array r ix e -> Array D (Lower ix) a+ifoldlWithin+  :: (Index (Lower ix), IsIndexDimension ix n, Source r e)+  => Dimension n+  -> (ix -> a -> e -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a ifoldlWithin dim = ifoldlWithin' (fromDimension dim) {-# INLINE ifoldlWithin #-} - -- | Left fold along a specified dimension. -- -- ====__Example__@@ -175,36 +181,53 @@ --   [ [5,0], [6,1], [7,2], [8,3], [9,4] ] -- -- @since 0.2.4-foldlWithin :: (Index (Lower ix), IsIndexDimension ix n, Source r e) =>-  Dimension n -> (a -> e -> a) -> a -> Array r ix e -> Array D (Lower ix) a+foldlWithin+  :: (Index (Lower ix), IsIndexDimension ix n, Source r e)+  => Dimension n+  -> (a -> e -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a foldlWithin dim f = ifoldlWithin dim (const f) {-# INLINE foldlWithin #-} - -- | Right fold along a specified dimension with an index aware function. -- -- @since 0.2.4-ifoldrWithin :: (Index (Lower ix), IsIndexDimension ix n, Source r e) =>-  Dimension n -> (ix -> e -> a -> a) -> a -> Array r ix e -> Array D (Lower ix) a+ifoldrWithin+  :: (Index (Lower ix), IsIndexDimension ix n, Source r e)+  => Dimension n+  -> (ix -> e -> a -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a ifoldrWithin dim = ifoldrWithin' (fromDimension dim) {-# INLINE ifoldrWithin #-} - -- | Right fold along a specified dimension. -- -- @since 0.2.4-foldrWithin :: (Index (Lower ix), IsIndexDimension ix n, Source r e) =>-  Dimension n -> (e -> a -> a) -> a -> Array r ix e -> Array D (Lower ix) a+foldrWithin+  :: (Index (Lower ix), IsIndexDimension ix n, Source r e)+  => Dimension n+  -> (e -> a -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a foldrWithin dim f = ifoldrWithin dim (const f) {-# INLINE foldrWithin #-} - -- | Similar to `ifoldlWithin`, except that dimension is specified at a value level, which means it -- will throw an exception on an invalid dimension. -- -- @since 0.2.4-ifoldlWithin' :: (HasCallStack, Index (Lower ix), Index ix, Source r e) =>-  Dim -> (ix -> a -> e -> a) -> a -> Array r ix e -> Array D (Lower ix) a+ifoldlWithin'+  :: (HasCallStack, Index (Lower ix), Index ix, Source r e)+  => Dim+  -> (ix -> a -> e -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a ifoldlWithin' dim f acc0 arr =   makeArray (getComp arr) (SafeSz szl) $ \ixl ->     iter@@ -219,24 +242,32 @@     (k, szl) = pullOutDim' sz dim {-# INLINE ifoldlWithin' #-} - -- | Similar to `foldlWithin`, except that dimension is specified at a value level, which means it will -- throw an exception on an invalid dimension. -- -- @since 0.2.4-foldlWithin' :: (HasCallStack, Index (Lower ix), Index ix, Source r e) =>-  Dim -> (a -> e -> a) -> a -> Array r ix e -> Array D (Lower ix) a+foldlWithin'+  :: (HasCallStack, Index (Lower ix), Index ix, Source r e)+  => Dim+  -> (a -> e -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a foldlWithin' dim f = ifoldlWithin' dim (const f) {-# INLINE foldlWithin' #-} - -- | Similar to `ifoldrWithin`, except that dimension is specified at a value level, which means it -- will throw an exception on an invalid dimension. -- -- -- @since 0.2.4-ifoldrWithin' :: (HasCallStack, Index (Lower ix), Index ix, Source r e) =>-  Dim -> (ix -> e -> a -> a) -> a -> Array r ix e -> Array D (Lower ix) a+ifoldrWithin'+  :: (HasCallStack, Index (Lower ix), Index ix, Source r e)+  => Dim+  -> (ix -> e -> a -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a ifoldrWithin' dim f acc0 arr =   makeArray (getComp arr) (SafeSz szl) $ \ixl ->     iter@@ -255,41 +286,61 @@ -- will throw an exception on an invalid dimension. -- -- @since 0.2.4-foldrWithin' :: (HasCallStack, Index (Lower ix), Index ix, Source r e) =>-  Dim -> (e -> a -> a) -> a -> Array r ix e -> Array D (Lower ix) a+foldrWithin'+  :: (HasCallStack, Index (Lower ix), Index ix, Source r e)+  => Dim+  -> (e -> a -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a foldrWithin' dim f = ifoldrWithin' dim (const f) {-# INLINE foldrWithin' #-} - -- | Left fold over the inner most dimension with index aware function. -- -- @since 0.2.4-ifoldlInner :: (Index (Lower ix), Index ix, Source r e) =>-  (ix -> a -> e -> a) -> a -> Array r ix e -> Array D (Lower ix) a+ifoldlInner+  :: (Index (Lower ix), Index ix, Source r e)+  => (ix -> a -> e -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a ifoldlInner = ifoldlWithin' 1 {-# INLINE ifoldlInner #-}  -- | Left fold over the inner most dimension. -- -- @since 0.2.4-foldlInner :: (Index (Lower ix), Index ix, Source r e) =>-  (a -> e -> a) -> a -> Array r ix e -> Array D (Lower ix) a+foldlInner+  :: (Index (Lower ix), Index ix, Source r e)+  => (a -> e -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a foldlInner = foldlWithin' 1 {-# INLINE foldlInner #-}  -- | Right fold over the inner most dimension with index aware function. -- -- @since 0.2.4-ifoldrInner :: (Index (Lower ix), Index ix, Source r e) =>-  (ix -> e -> a -> a) -> a -> Array r ix e -> Array D (Lower ix) a+ifoldrInner+  :: (Index (Lower ix), Index ix, Source r e)+  => (ix -> e -> a -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a ifoldrInner = ifoldrWithin' 1 {-# INLINE ifoldrInner #-}  -- | Right fold over the inner most dimension. -- -- @since 0.2.4-foldrInner :: (Index (Lower ix), Index ix, Source r e) =>-  (e -> a -> a) -> a -> Array r ix e -> Array D (Lower ix) a+foldrInner+  :: (Index (Lower ix), Index ix, Source r e)+  => (e -> a -> a)+  -> a+  -> Array r ix e+  -> Array D (Lower ix) a foldrInner = foldrWithin' 1 {-# INLINE foldrInner #-} @@ -303,8 +354,8 @@ -- | Monoidal fold over some internal dimension. -- -- @since 0.4.3-foldWithin ::-     (Source r a, Monoid a, Index (Lower ix), IsIndexDimension ix n)+foldWithin+  :: (Source r a, Monoid a, Index (Lower ix), IsIndexDimension ix n)   => Dimension n   -> Array r ix a   -> Array D (Lower ix) a@@ -315,15 +366,14 @@ -- result in `IndexDimensionException` if supplied dimension is invalid. -- -- @since 0.4.3-foldWithin' ::-     (HasCallStack, Index ix, Source r a, Monoid a, Index (Lower ix))+foldWithin'+  :: (HasCallStack, Index ix, Source r a, Monoid a, Index (Lower ix))   => Dim   -> Array r ix a   -> Array D (Lower ix) a foldWithin' dim = foldlWithin' dim mappend mempty {-# INLINE foldWithin' #-} - -- | Reduce each outer slice into a monoid and mappend results together -- -- ==== __Example__@@ -342,21 +392,20 @@ -- 1620 -- -- @since 0.4.3-foldOuterSlice ::-     (Index ix, Index (Lower ix), Source r e, Monoid m)+foldOuterSlice+  :: (Index ix, Index (Lower ix), Source r e, Monoid m)   => (Array r (Lower ix) e -> m)   -> Array r ix e   -> m foldOuterSlice f = ifoldOuterSlice (const f) {-# INLINE foldOuterSlice #-} - -- | Reduce each outer slice into a monoid with an index aware function and mappend results -- together -- -- @since 0.4.3-ifoldOuterSlice ::-     (Index ix, Index (Lower ix), Source r e, Monoid m)+ifoldOuterSlice+  :: (Index ix, Index (Lower ix), Source r e, Monoid m)   => (Ix1 -> Array r (Lower ix) e -> m)   -> Array r ix e   -> m@@ -367,7 +416,6 @@     {-# INLINE g #-} {-# INLINE ifoldOuterSlice #-} - -- | Reduce each inner slice into a monoid and mappend results together -- -- ==== __Example__@@ -386,18 +434,17 @@ -- 19575 -- -- @since 0.4.3-foldInnerSlice ::-     (Source r e, Index ix, Monoid m) => (Array D (Lower ix) e -> m) -> Array r ix e -> m+foldInnerSlice+  :: (Source r e, Index ix, Monoid m) => (Array D (Lower ix) e -> m) -> Array r ix e -> m foldInnerSlice f = ifoldInnerSlice (const f) {-# INLINE foldInnerSlice #-} - -- | Reduce each inner slice into a monoid with an index aware function and mappend -- results together -- -- @since 0.4.3-ifoldInnerSlice ::-     (Source r e, Index ix, Monoid m) => (Ix1 -> Array D (Lower ix) e -> m) -> Array r ix e -> m+ifoldInnerSlice+  :: (Source r e, Index ix, Monoid m) => (Ix1 -> Array D (Lower ix) e -> m) -> Array r ix e -> m ifoldInnerSlice f arr = foldMono g $ range (getComp arr) 0 (unSz k)   where     (szL, !k) = unsnocSz (size arr)@@ -412,22 +459,22 @@ maximumM arr =   if isNull arr     then throwM (SizeEmptyException (size arr))-    else let !e0 = unsafeIndex arr zeroIndex-          in pure $ foldlInternal max e0 max e0 arr+    else+      let !e0 = unsafeIndex arr zeroIndex+       in pure $ foldlInternal max e0 max e0 arr {-# INLINE maximumM #-} - -- | /O(n)/ - Compute maximum of all elements. -- -- @since 0.3.0-maximum' ::-     forall r ix e. (HasCallStack, Shape r ix, Source r e, Ord e)+maximum'+  :: forall r ix e+   . (HasCallStack, Shape r ix, Source r e, Ord e)   => Array r ix e   -> e maximum' = throwEither . maximumM {-# INLINE maximum' #-} - -- | /O(n)/ - Compute minimum of all elements. -- -- @since 0.3.0@@ -435,8 +482,9 @@ minimumM arr =   if isNull arr     then throwM (SizeEmptyException (size arr))-    else let !e0 = unsafeIndex arr zeroIndex-          in pure $ foldlInternal min e0 min e0 arr+    else+      let !e0 = unsafeIndex arr zeroIndex+       in pure $ foldlInternal min e0 min e0 arr {-# INLINE minimumM #-}  -- | /O(n)/ - Compute minimum of all elements.@@ -446,7 +494,6 @@ minimum' = throwEither . minimumM {-# INLINE minimum' #-} - -- -- | /O(n)/ - Compute sum of all elements. -- -- -- -- @since 0.1.0@@ -464,7 +511,6 @@ sum = foldlInternal (+) 0 (+) 0 {-# INLINE sum #-} - -- | /O(n)/ - Compute product of all elements. -- -- @since 0.1.0@@ -472,7 +518,6 @@ product = foldlInternal (*) 1 (*) 1 {-# INLINE product #-} - -- | /O(n)/ - Compute conjunction of all elements. -- -- @since 0.1.0@@ -480,7 +525,6 @@ and = all id {-# INLINE and #-} - -- | /O(n)/ - Compute disjunction of all elements. -- -- @since 0.1.0@@ -488,7 +532,6 @@ or = any id {-# INLINE or #-} - -- | /O(n)/ - Determines whether all elements of the array satisfy a predicate. -- -- @since 0.1.0@@ -503,36 +546,28 @@ elem e = any (e ==) {-# INLINE elem #-} --{- $unstruct_folds--Functions in this section will fold any `Source` array with respect to the inner-`Comp`utation strategy setting.---}---{- $seq_folds--Functions in this section will fold any `Source` array sequentially, regardless of the inner-`Comp`utation strategy setting.---}---{- $par_folds--__Note__ It is important to compile with @-threaded -with-rtsopts=-N@ flags, otherwise there will be-no parallelization.--Functions in this section will fold any `Source` array in parallel, regardless of the inner-`Comp`utation strategy setting. All of the parallel structured folds are performed inside `IO`-monad, because referential transparency can't generally be preserved and results will depend on the-number of cores/capabilities that computation is being performed on.+-- $unstruct_folds+--+-- Functions in this section will fold any `Source` array with respect to the inner+-- `Comp`utation strategy setting. -In contrast to sequential folds, each parallel folding function accepts two functions and two-initial elements as arguments. This is necessary because an array is first split into chunks, which-folded individually on separate cores with the first function, and the results of those folds are-further folded with the second function.+-- $seq_folds+--+-- Functions in this section will fold any `Source` array sequentially, regardless of the inner+-- `Comp`utation strategy setting. --}+-- $par_folds+--+-- __Note__ It is important to compile with @-threaded -with-rtsopts=-N@ flags, otherwise+-- there will be no parallelization.+--+-- Functions in this section will fold any `Source` array in parallel, regardless of the+-- inner `Comp`utation strategy setting. All of the parallel structured folds are+-- performed inside `IO` monad, because referential transparency can't generally be+-- preserved and results will depend on the number of cores/capabilities that computation+-- is being performed on.+--+-- In contrast to sequential folds, each parallel folding function accepts two functions+-- and two initial elements as arguments. This is necessary because an array is first+-- split into chunks, which folded individually on separate cores with the first function,+-- and the results of those folds are further folded with the second function.