massiv 1.0.4.1 → 1.0.5.0

raw patch · 22 files changed

+533/−431 lines, 22 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• massiv.cabal +1/−1
• src/Data/Massiv/Array/Delayed/Push.hs +111/−72
• src/Data/Massiv/Array/Delayed/Windowed.hs +124/−100
• src/Data/Massiv/Array/Manifest.hs +128/−105
• src/Data/Massiv/Array/Manifest/Boxed.hs +89/−111
• src/Data/Massiv/Array/Manifest/Storable.hs +3/−4
• src/Data/Massiv/Array/Manifest/Unboxed.hs +1/−0
• src/Data/Massiv/Array/Mutable.hs +10/−5
• src/Data/Massiv/Array/Numeric.hs +4/−1
• src/Data/Massiv/Array/Ops/Construct.hs +0/−1
• src/Data/Massiv/Array/Ops/Fold.hs +2/−1
• src/Data/Massiv/Core/Common.hs +1/−1
• src/Data/Massiv/Core/Index.hs +24/−21
• src/Data/Massiv/Core/Index/Internal.hs +9/−1
• src/Data/Massiv/Core/Index/Iterator.hs +2/−0
• src/Data/Massiv/Core/Index/Ix.hs +1/−0
• src/Data/Massiv/Core/Index/Tuple.hs +3/−0
• src/Data/Massiv/Core/List.hs +1/−1
• src/Data/Massiv/Core/Loop.hs +6/−2
• src/Data/Massiv/Vector.hs +2/−2
• src/Data/Massiv/Vector/Stream.hs +6/−2

@@ -1,3 +1,8 @@+# 1.0.5++* Add `Functor` instance for `Border`+* Improve performance and reduce allocations during computation of higher dimension `DW` arrays [#142](https://github.com/lehins/massiv/issues/142)+ # 1.0.4  * Improve performance of sorting algorithm and its parallelization. Fix huge slow down on

@@ -1,5 +1,5 @@ name:                massiv-version:             1.0.4.1+version:             1.0.5.0 synopsis:            Massiv (Массив) is an Array Library. description:         Multi-dimensional Arrays with fusion, stencils and parallel computation. homepage:            https://github.com/lehins/massiv

@@ -9,6 +9,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}+ -- | -- Module      : Data.Massiv.Array.Delayed.Push -- Copyright   : (c) Alexey Kuleshevich 2019-2022@@ -16,20 +17,19 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Delayed.Push-  ( DL(..)-  , Array(..)-  , Loader-  , toLoadArray-  , makeLoadArrayS-  , makeLoadArray-  , unsafeMakeLoadArray-  , unsafeMakeLoadArrayAdjusted-  , fromStrideLoad-  , appendOuterM-  , concatOuterM-  ) where+module Data.Massiv.Array.Delayed.Push (+  DL (..),+  Array (..),+  Loader,+  toLoadArray,+  makeLoadArrayS,+  makeLoadArray,+  unsafeMakeLoadArray,+  unsafeMakeLoadArrayAdjusted,+  fromStrideLoad,+  appendOuterM,+  concatOuterM,+) where  import Control.Monad import Control.Scheduler as S (traverse_)@@ -40,45 +40,48 @@ #include "massiv.h"  -- | Delayed load representation. Also known as Push array.-data DL = DL deriving Show+data DL = DL deriving (Show)  type Loader e =-  forall s. Scheduler s () -- ^ Scheduler that will be used for loading-         -> Ix1 -- ^ Start loading at this linear index-         -> (Ix1 -> e -> ST s ()) -- ^ Linear element writing action-         -> (Ix1 -> Sz1 -> e -> ST s ()) -- ^ Linear region setting action-         -> ST s ()-+  forall s+   . Scheduler s ()+  -- ^ Scheduler that will be used for loading+  -> Ix1+  -- ^ Start loading at this linear index+  -> (Ix1 -> e -> ST s ())+  -- ^ Linear element writing action+  -> (Ix1 -> Sz1 -> e -> ST s ())+  -- ^ Linear region setting action+  -> ST s ()  data instance Array DL ix e = DLArray-  { dlComp    :: !Comp-  , dlSize    :: !(Sz ix)-  , dlLoad    :: Loader e+  { dlComp :: !Comp+  , dlSize :: !(Sz ix)+  , dlLoad :: Loader e   }  instance Strategy DL where   getComp = dlComp   {-# INLINE getComp #-}-  setComp c arr = arr {dlComp = c}+  setComp c arr = arr{dlComp = c}   {-# INLINE setComp #-}   repr = DL - instance Index ix => Shape DL ix where   maxLinearSize = Just . SafeSz . elemsCount   {-# INLINE maxLinearSize #-} - instance Size DL where   size = dlSize   {-# INLINE size #-}-  unsafeResize !sz !arr = arr { dlSize = sz }+  unsafeResize !sz !arr = arr{dlSize = sz}   {-# INLINE unsafeResize #-}  instance Semigroup (Array DL Ix1 e) where   (<>) = mappendDL   {-# INLINE (<>) #-} +{- FOURMOLU_DISABLE -} instance Monoid (Array DL Ix1 e) where   mempty = DLArray {dlComp = mempty, dlSize = zeroSz, dlLoad = \_ _ _ _ -> pure ()}   {-# INLINE mempty #-}@@ -91,16 +94,22 @@   mconcat [x, y] = x <> y   mconcat xs = mconcatDL xs   {-# INLINE mconcat #-}+{- FOURMOLU_ENABLE -} -mconcatDL :: forall e . [Array DL Ix1 e] -> Array DL Ix1 e+mconcatDL :: forall e. [Array DL Ix1 e] -> Array DL Ix1 e mconcatDL !arrs =-  DLArray {dlComp = foldMap getComp arrs, dlSize = SafeSz k, dlLoad = load}+  DLArray{dlComp = foldMap getComp arrs, dlSize = SafeSz k, dlLoad = load}   where     !k = F.foldl' (+) 0 (unSz . size <$> arrs)-    load :: forall s .-      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()+    load+      :: forall s+       . Scheduler s ()+      -> Ix1+      -> (Ix1 -> e -> ST s ())+      -> (Ix1 -> Sz1 -> e -> ST s ())+      -> ST s ()     load scheduler startAt dlWrite dlSet =-      let loadArr !startAtCur DLArray {dlSize = SafeSz kCur, dlLoad} = do+      let loadArr !startAtCur DLArray{dlSize = SafeSz kCur, dlLoad} = do             let !endAtCur = startAtCur + kCur             scheduleWork_ scheduler $ dlLoad scheduler startAtCur dlWrite dlSet             pure endAtCur@@ -109,15 +118,19 @@     {-# INLINE load #-} {-# INLINE mconcatDL #-} --mappendDL :: forall e . Array DL Ix1 e -> Array DL Ix1 e -> Array DL Ix1 e+mappendDL :: forall e. Array DL Ix1 e -> Array DL Ix1 e -> Array DL Ix1 e mappendDL (DLArray c1 sz1 load1) (DLArray c2 sz2 load2) =-  DLArray {dlComp = c1 <> c2, dlSize = SafeSz (k1 + k2), dlLoad = load}+  DLArray{dlComp = c1 <> c2, dlSize = SafeSz (k1 + k2), dlLoad = load}   where     !k1 = unSz sz1     !k2 = unSz sz2-    load :: forall s.-      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()+    load+      :: forall s+       . Scheduler s ()+      -> Ix1+      -> (Ix1 -> e -> ST s ())+      -> (Ix1 -> Sz1 -> e -> ST s ())+      -> ST s ()     load scheduler !startAt dlWrite dlSet = do       scheduleWork_ scheduler $ load1 scheduler startAt dlWrite dlSet       scheduleWork_ scheduler $ load2 scheduler (startAt + k1) dlWrite dlSet@@ -128,8 +141,9 @@ -- agree, otherwise `SizeMismatchException`. -- -- @since 0.4.4-appendOuterM ::-     forall ix e m. (Index ix, MonadThrow m)+appendOuterM+  :: forall ix e m+   . (Index ix, MonadThrow m)   => Array DL ix e   -> Array DL ix e   -> m (Array DL ix e)@@ -138,7 +152,7 @@       (!i2, !szl2) = unconsSz sz2   unless (szl1 == szl2) $ throwM $ SizeMismatchException sz1 sz2   pure $-    DLArray {dlComp = c1 <> c2, dlSize = consSz (liftSz2 (+) i1 i2) szl1, dlLoad = load}+    DLArray{dlComp = c1 <> c2, dlSize = consSz (liftSz2 (+) i1 i2) szl1, dlLoad = load}   where     load :: Loader e     load scheduler !startAt dlWrite dlSet = do@@ -151,23 +165,24 @@ -- for all arrays in the list, otherwise `SizeMismatchException`. -- -- @since 0.4.4-concatOuterM ::-     forall ix e m. (Index ix, MonadThrow m)+concatOuterM+  :: forall ix e m+   . (Index ix, MonadThrow m)   => [Array DL ix e]   -> m (Array DL ix e) concatOuterM =   \case-    []     -> pure empty-    (x:xs) -> F.foldlM appendOuterM x xs+    [] -> pure empty+    (x : xs) -> F.foldlM appendOuterM x xs {-# INLINE concatOuterM #-} - -- | Describe how an array should be loaded into memory sequentially. For parallelizable -- version see `makeLoadArray`. -- -- @since 0.3.1-makeLoadArrayS ::-     forall ix e. Index ix+makeLoadArrayS+  :: forall ix e+   . Index ix   => Sz ix   -- ^ Size of the resulting array   -> e@@ -183,8 +198,9 @@ -- of this function see `unsafeMakeLoadArray`. -- -- @since 0.4.0-makeLoadArray ::-     forall ix e. Index ix+makeLoadArray+  :: forall ix e+   . Index ix   => Comp   -- ^ Computation strategy to use. Directly affects the scheduler that gets created for   -- the loading function.@@ -199,8 +215,13 @@   -> Array DL ix e makeLoadArray comp sz defVal writer = DLArray comp sz load   where-    load :: forall s.-      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()+    load+      :: forall s+       . Scheduler s ()+      -> Ix1+      -> (Ix1 -> e -> ST s ())+      -> (Ix1 -> Sz1 -> e -> ST s ())+      -> ST s ()     load scheduler !startAt uWrite uSet = do       uSet startAt (toLinearSz sz) defVal       let safeWrite !ix !e@@ -217,8 +238,9 @@ -- function does not perform any bounds checking. -- -- @since 0.3.1-unsafeMakeLoadArray ::-     forall ix e. Index ix+unsafeMakeLoadArray+  :: forall ix e+   . Index ix   => Comp   -- ^ Computation strategy to use. Directly affects the scheduler that gets created for   -- the loading function.@@ -250,8 +272,9 @@ -- adjusted. Which means the writing function gets one less argument. -- -- @since 0.5.2-unsafeMakeLoadArrayAdjusted ::-     forall ix e. Index ix+unsafeMakeLoadArrayAdjusted+  :: forall ix e+   . Index ix   => Comp   -> Sz ix   -> Maybe e@@ -259,8 +282,13 @@   -> Array DL ix e unsafeMakeLoadArrayAdjusted comp sz mDefVal writer = DLArray comp sz load   where-    load :: forall s.-      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()+    load+      :: forall s+       . Scheduler s ()+      -> Ix1+      -> (Ix1 -> e -> ST s ())+      -> (Ix1 -> Sz1 -> e -> ST s ())+      -> ST s ()     load scheduler !startAt uWrite dlSet = do       S.traverse_ (dlSet startAt (toLinearSz sz)) mDefVal       writer scheduler (\i -> uWrite (startAt + i))@@ -270,26 +298,38 @@ -- | Convert any `Load`able array into `DL` representation. -- -- @since 0.3.0-toLoadArray ::-     forall r ix e. (Size r, Load r ix e)+toLoadArray+  :: forall r ix e+   . (Size r, Load r ix e)   => Array r ix e   -> Array DL ix e toLoadArray arr = DLArray (getComp arr) sz load   where     !sz = size arr-    load :: forall s.-      Scheduler s () -> Ix1 -> (Ix1 -> e -> ST s ()) -> (Ix1 -> Sz1 -> e -> ST s ()) -> ST s ()+    load+      :: forall s+       . Scheduler s ()+      -> Ix1+      -> (Ix1 -> e -> ST s ())+      -> (Ix1 -> Sz1 -> e -> ST s ())+      -> ST s ()     load scheduler !startAt dlWrite dlSet =-      iterArrayLinearWithSetST_ scheduler arr (dlWrite . (+ startAt)) (\offset -> dlSet (offset + startAt))+      iterArrayLinearWithSetST_+        scheduler+        arr+        (dlWrite . (+ startAt))+        (\offset -> dlSet (offset + startAt))     {-# INLINE load #-}-{-# INLINE[1] toLoadArray #-}+{-# INLINE [1] toLoadArray #-}+ {-# RULES "toLoadArray/id" toLoadArray = id #-}  -- | Convert an array that can be loaded with stride into `DL` representation. -- -- @since 0.3.0-fromStrideLoad ::-     forall r ix e. (StrideLoad r ix e)+fromStrideLoad+  :: forall r ix e+   . StrideLoad r ix e   => Stride ix   -> Array r ix e   -> Array DL ix e@@ -313,26 +353,25 @@   {-# INLINE makeArrayLinear #-}   replicate comp !sz !e = makeLoadArray comp sz e $ \_ _ -> pure ()   {-# INLINE replicate #-}-  iterArrayLinearWithSetST_ scheduler DLArray {dlLoad} = dlLoad scheduler 0+  iterArrayLinearWithSetST_ scheduler DLArray{dlLoad} = dlLoad scheduler 0   {-# INLINE iterArrayLinearWithSetST_ #-}  instance Index ix => Functor (Array DL ix) where-  fmap f arr = arr {dlLoad = loadFunctor arr f}+  fmap f arr = arr{dlLoad = loadFunctor arr f}   {-# INLINE fmap #-}   (<$) = overwriteFunctor   {-# INLINE (<$) #-}  overwriteFunctor :: forall ix a b. Index ix => a -> Array DL ix b -> Array DL ix a-overwriteFunctor e arr = arr {dlLoad = load}+overwriteFunctor e arr = arr{dlLoad = load}   where     load :: Loader a     load _ !startAt _ dlSet = dlSet startAt (linearSize arr) e     {-# INLINE load #-} {-# INLINE overwriteFunctor #-} --loadFunctor ::-     Array DL ix a+loadFunctor+  :: Array DL ix a   -> (a -> b)   -> Scheduler s ()   -> Ix1

@@ -11,7 +11,7 @@  -- | -- Module      : Data.Massiv.Array.Delayed.Windowed--- Copyright   : (c) Alexey Kuleshevich 2018-2022+-- Copyright   : (c) Alexey Kuleshevich 2018-2025 -- License     : BSD3 -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental@@ -27,6 +27,7 @@ ) where  import Control.Monad (when)+import Control.Scheduler (trivialScheduler_) import Data.Massiv.Array.Delayed.Pull import Data.Massiv.Array.Manifest.Boxed import Data.Massiv.Array.Manifest.Internal@@ -34,6 +35,7 @@ import Data.Massiv.Core.Common import Data.Massiv.Core.List (showArrayList, showsArrayPrec) import Data.Maybe (fromMaybe)+import GHC.Base (modInt) import GHC.TypeLits  -- | Delayed Windowed Array representation.@@ -56,7 +58,9 @@   fmap f arr@Window{windowIndex} = arr{windowIndex = f . windowIndex}  data instance Array DW ix e = DWArray-  { dwArray :: !(Array D ix e)+  { dwComp :: !Comp+  , dwSize :: !(Sz ix)+  , dwIndex :: ix -> e   , dwWindow :: !(Maybe (Window ix e))   } @@ -65,16 +69,16 @@   showList = showArrayList  instance Strategy DW where-  setComp c arr = arr{dwArray = (dwArray arr){dComp = c}}+  setComp c arr = arr{dwComp = c}   {-# INLINE setComp #-}-  getComp = dComp . dwArray+  getComp = dwComp   {-# INLINE getComp #-}   repr = DW  instance Functor (Array DW ix) where-  fmap f arr@DWArray{dwArray, dwWindow} =+  fmap f arr@DWArray{dwIndex, dwWindow} =     arr-      { dwArray = fmap f dwArray+      { dwIndex = f . dwIndex       , dwWindow = fmap f <$> dwWindow       }   {-# INLINE fmap #-}@@ -147,7 +151,9 @@   -> Array DW ix e insertWindow !arr !window =   DWArray-    { dwArray = delay arr+    { dwComp = getComp arr+    , dwSize = arrSize+    , dwIndex = unsafeIndex arr     , dwWindow =         Just $!           Window@@ -159,7 +165,7 @@     }   where     wStart' = unSz (Sz (liftIndex2 min wStart (liftIndex (subtract 1) sz)))-    Sz sz = size arr+    arrSize@(Sz sz) = size arr     Window       { windowStart = wStart       , windowSize = Sz wSize@@ -179,7 +185,12 @@ -- -- @since 0.3.0 dropWindow :: Array DW ix e -> Array D ix e-dropWindow = dwArray+dropWindow DWArray{..} =+  DArray+    { dComp = dwComp+    , dSize = dwSize+    , dPrefIndex = PrefIndex dwIndex+    } {-# INLINE dropWindow #-}  zeroWindow :: Index ix => Window ix e@@ -191,34 +202,34 @@ instance Exception EmptyWindowException where   displayException _ = "Index of zero size Window" -windowError :: a-windowError = throwImpossible EmptyWindowException+windowError :: ix -> a+windowError _ = throwImpossible EmptyWindowException {-# NOINLINE windowError #-}  loadWithIx1-  :: (Monad m)+  :: Monad m   => (m () -> m ())   -> Array DW Ix1 e   -> (Ix1 -> e -> m a)   -> m (Ix1 -> Ix1 -> m (), Ix1, Ix1)-loadWithIx1 with (DWArray a@(DArray _ sz _) mWindow) uWrite = do-  let Window it wk indexW _ = fromMaybe zeroWindow mWindow+loadWithIx1 with (DWArray _ sz uIndex mWindow) uWrite = do+  let Window it wk uwIndex _ = fromMaybe zeroWindow mWindow       wEnd = it + unSz wk-  with $ iterA_ 0 it 1 (<) $ \ !i -> uWrite i (unsafeIndex a i)-  with $ iterA_ wEnd (unSz sz) 1 (<) $ \ !i -> uWrite i (unsafeIndex a i)-  return (\from to -> with $ iterA_ from to 1 (<) $ \ !i -> uWrite i (indexW i), it, wEnd)+  with $ iterA_ 0 it 1 (<) $ \ !i -> uWrite i (uIndex i)+  with $ iterA_ wEnd (unSz sz) 1 (<) $ \ !i -> uWrite i (uIndex i)+  return (\from to -> with $ iterA_ from to 1 (<) $ \ !i -> uWrite i (uwIndex i), it, wEnd) {-# INLINE loadWithIx1 #-}  instance Index ix => Shape DW ix where   maxLinearSize = Just . linearSize   {-# INLINE maxLinearSize #-}-  linearSize = SafeSz . totalElem . dSize . dwArray+  linearSize = SafeSz . totalElem . dwSize   {-# INLINE linearSize #-}-  outerSize = dSize . dwArray+  outerSize = dwSize   {-# INLINE outerSize #-}  instance Load DW Ix1 e where-  makeArray c sz f = DWArray (makeArray c sz f) Nothing+  makeArray c sz f = DWArray c sz f Nothing   {-# INLINE makeArray #-}   iterArrayLinearST_ scheduler arr uWrite = do     (loadWindow, wStart, wEnd) <- loadWithIx1 (scheduleWork scheduler) arr uWrite@@ -244,26 +255,26 @@   {-# INLINE iterArrayLinearWithStrideST_ #-}  loadArrayWithIx1-  :: (Monad m)+  :: Monad m   => (m () -> m ())   -> Array DW Ix1 e   -> Stride Ix1   -> Sz1   -> (Ix1 -> e -> m a)   -> m ((Ix1, Ix1) -> m (), (Ix1, Ix1))-loadArrayWithIx1 with (DWArray darr@(DArray _ arrSz _) mWindow) stride _ uWrite = do-  let Window it wk indexW _ = fromMaybe zeroWindow mWindow+loadArrayWithIx1 with (DWArray _ arrSz uIndex mWindow) stride _ uWrite = do+  let Window it wk uwIndex _ = fromMaybe zeroWindow mWindow       wEnd = it + unSz wk       strideIx = unStride stride-  with $ iterA_ 0 it strideIx (<) $ \ !i -> uWrite (i `div` strideIx) (unsafeIndex darr i)+  with $ iterA_ 0 it strideIx (<) $ \ !i -> uWrite (i `div` strideIx) (uIndex i)   with $     iterA_ (strideStart stride wEnd) (unSz arrSz) strideIx (<) $ \ !i ->-      uWrite (i `div` strideIx) (unsafeIndex darr i)+      uWrite (i `div` strideIx) (uIndex i)   return     ( \(from, to) ->         with $           iterA_ (strideStart stride from) to strideIx (<) $ \ !i ->-            uWrite (i `div` strideIx) (indexW i)+            uWrite (i `div` strideIx) (uwIndex i)     , (it, wEnd)     ) {-# INLINE loadArrayWithIx1 #-}@@ -275,16 +286,14 @@   -> (Int -> t1 -> m ())   -> m (Ix2 -> m (), Ix2) loadWithIx2 with arr uWrite = do-  let DWArray darr window = arr-      Sz (m :. n) = dSize darr-      Window (it :. jt) (Sz (wm :. wn)) indexW mUnrollHeight = fromMaybe zeroWindow window+  let DWArray _ (Sz (m :. n)) uIndex window = arr+      Window (it :. jt) (Sz (wm :. wn)) uwIndex mUnrollHeight = fromMaybe zeroWindow window       ib :. jb = (wm + it) :. (wn + jt)       !blockHeight = maybe 1 (min 7 . max 1) mUnrollHeight-      stride = oneStride-      !sz = strideSize stride $ outerSize arr-      writeB !ix = uWrite (toLinearIndex sz ix) (unsafeIndex darr ix)+      !sz = strideSize oneStride $ outerSize arr+      writeB !ix = uWrite (toLinearIndex sz ix) (uIndex ix)       {-# INLINE writeB #-}-      writeW !ix = uWrite (toLinearIndex sz ix) (indexW ix)+      writeW !ix = uWrite (toLinearIndex sz ix) (uwIndex ix)       {-# INLINE writeW #-}   with $ iterA_ (0 :. 0) (it :. n) (1 :. 1) (<) writeB   with $ iterA_ (ib :. 0) (m :. n) (1 :. 1) (<) writeB@@ -304,15 +313,14 @@   -> (Int -> e -> m ())   -> m (Ix2 -> m (), Ix2) loadArrayWithIx2 with arr stride sz uWrite = do-  let DWArray darr window = arr-      Sz (m :. n) = dSize darr-      Window (it :. jt) (Sz (wm :. wn)) indexW mUnrollHeight = fromMaybe zeroWindow window+  let DWArray _ (Sz (m :. n)) uIndex window = arr+      Window (it :. jt) (Sz (wm :. wn)) uwIndex mUnrollHeight = fromMaybe zeroWindow window       ib :. jb = (wm + it) :. (wn + jt)       !blockHeight = maybe 1 (min 7 . max 1) mUnrollHeight       strideIx@(is :. js) = unStride stride-      writeB !ix = uWrite (toLinearIndexStride stride sz ix) (unsafeIndex darr ix)+      writeB !ix = uWrite (toLinearIndexStride stride sz ix) (uIndex ix)       {-# INLINE writeB #-}-      writeW !ix = uWrite (toLinearIndexStride stride sz ix) (indexW ix)+      writeW !ix = uWrite (toLinearIndexStride stride sz ix) (uwIndex ix)       {-# INLINE writeW #-}   with $ iterA_ (0 :. 0) (it :. n) strideIx (<) writeB   with $ iterA_ (strideStart stride (ib :. 0)) (m :. n) strideIx (<) writeB@@ -340,7 +348,7 @@ {-# INLINE loadWindowIx2 #-}  instance Load DW Ix2 e where-  makeArray c sz f = DWArray (makeArray c sz f) Nothing+  makeArray c sz f = DWArray c sz f Nothing   {-# INLINE makeArray #-}   iterArrayLinearST_ scheduler arr uWrite =     loadWithIx2 (scheduleWork scheduler) arr uWrite@@ -354,7 +362,7 @@   {-# 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+  makeArray c sz f = DWArray c sz f Nothing   {-# INLINE makeArray #-}   iterArrayLinearST_ = loadWithIxN   {-# INLINE iterArrayLinearST_ #-}@@ -372,47 +380,53 @@   -> (Int -> e -> ST s ())   -> ST s () loadArrayWithIxN scheduler stride szResult arr uWrite = do-  let DWArray darr window = arr+  let DWArray _ sz uIndex window = arr       Window{windowStart, windowSize, windowIndex, windowUnrollIx2} = fromMaybe zeroWindow window-      !(headSourceSize, lowerSourceSize) = unconsSz (dSize darr)+      !(!headSourceSize, !lowerSourceSize) = unconsSz sz       !lowerSize = snd $ unconsSz szResult-      !(s, lowerStrideIx) = unconsDim $ unStride stride-      !(curWindowStart, lowerWindowStart) = unconsDim windowStart-      !(headWindowSz, tailWindowSz) = unconsSz windowSize+      !(!s, !lowerStrideIx) = unconsDim $ unStride stride+      !(!curWindowStart, lowerWindowStart) = unconsDim windowStart+      !(!headWindowSz, tailWindowSz) = unconsSz windowSize       !curWindowEnd = curWindowStart + unSz headWindowSz       !pageElements = totalElem lowerSize-      mkLowerWindow i =+      lowerWindow =         Window           { windowStart = lowerWindowStart           , windowSize = tailWindowSz-          , windowIndex = windowIndex . consDim i+          , windowIndex = \_ -> error "Window index uninitialized"           , windowUnrollIx2 = windowUnrollIx2           }-      mkLowerArray mw i =-        DWArray-          { dwArray =-              darr-                { dComp = Seq-                , dSize = lowerSourceSize-                , dPrefIndex = PrefIndex (unsafeIndex darr . consDim i)-                }-          , dwWindow = ($ i) <$> mw+      mkLowerWindow !i =+        lowerWindow+          { windowIndex = windowIndex . consDim i           }-      loadLower mw !i =-        iterArrayLinearWithStrideST_-          scheduler-          (Stride lowerStrideIx)-          lowerSize-          (mkLowerArray mw i)-          (\k -> uWrite (k + pageElements * (i `div` s)))-      {-# NOINLINE loadLower #-}-  loopA_ 0 (< headDim windowStart) (+ s) (loadLower Nothing)+      loadLower mkWindow !i =+        let !lowerArray =+              DWArray+                { dwComp = Seq+                , dwSize = lowerSourceSize+                , dwIndex = uIndex . consDim i+                , dwWindow = mkWindow i+                }+            !innerScheduler =+              if numWorkers scheduler <= unSz (strideSize (Stride s) headSourceSize)+                then trivialScheduler_+                else scheduler+         in scheduleWork_ scheduler $+              iterArrayLinearWithStrideST_ innerScheduler (Stride lowerStrideIx) lowerSize lowerArray $ \k ->+                uWrite (k + pageElements * (i `div` s))+      {-# INLINE loadLower #-}+  loopA_ 0 (< headDim windowStart) (+ s) (loadLower (const Nothing))   loopA_     (strideStart (Stride s) curWindowStart)     (< curWindowEnd)     (+ s)-    (loadLower (Just mkLowerWindow))-  loopA_ (strideStart (Stride s) curWindowEnd) (< unSz headSourceSize) (+ s) (loadLower Nothing)+    (loadLower (Just . mkLowerWindow))+  loopA_+    (strideStart (Stride s) curWindowEnd)+    (< unSz headSourceSize)+    (+ s)+    (loadLower (const Nothing)) {-# INLINE loadArrayWithIxN #-}  loadWithIxN@@ -422,38 +436,47 @@   -> (Int -> e -> ST s ())   -> ST s () loadWithIxN scheduler arr uWrite = do-  let DWArray darr window = arr+  let DWArray _ sz uIndex window = arr       Window{windowStart, windowSize, windowIndex, windowUnrollIx2} = fromMaybe zeroWindow window-      !(si, szL) = unconsSz (dSize darr)+      !(!si, !szL) = unconsSz sz       !windowEnd = liftIndex2 (+) windowStart (unSz windowSize)-      !(t, windowStartL) = unconsDim windowStart+      !(!t, windowStartL) = unconsDim windowStart       !pageElements = totalElem szL-      mkLowerWindow i =+      lowerWindow =         Window           { windowStart = windowStartL           , windowSize = snd $ unconsSz windowSize-          , windowIndex = windowIndex . consDim i+          , windowIndex = \_ -> error "Window index uninitialized"           , windowUnrollIx2 = windowUnrollIx2           }-      mkLowerArray mw i =-        DWArray-          { dwArray =-              darr{dComp = Seq, dSize = szL, dPrefIndex = PrefIndex (unsafeIndex darr . consDim i)}-          , dwWindow = ($ i) <$> mw+      mkLowerWindow !i =+        lowerWindow+          { windowIndex = windowIndex . consDim i           }-      loadLower mw !i =-        scheduleWork_ scheduler $-          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)+      loadLower mkWindow !i =+        let !lowerArray =+              DWArray+                { dwComp = Seq+                , dwSize = szL+                , dwIndex = uIndex . consDim i+                , dwWindow = mkWindow i+                }+            !innerScheduler =+              if numWorkers scheduler <= unSz si+                then trivialScheduler_+                else scheduler+         in scheduleWork_ scheduler $+              iterArrayLinearST_ innerScheduler lowerArray (\k -> uWrite (k + pageElements * i))+      {-# INLINE loadLower #-}+  loopA_ 0 (< headDim windowStart) (+ 1) (loadLower (const Nothing))+  loopA_ t (< headDim windowEnd) (+ 1) (loadLower (Just . mkLowerWindow))+  loopA_ (headDim windowEnd) (< unSz si) (+ 1) (loadLower (const Nothing)) {-# INLINE loadWithIxN #-}  unrollAndJam   :: Monad m   => Int-  -- ^ Block height+  -- ^ Block height. Must not be zero.   -> Ix2   -- ^ Top corner   -> Ix2@@ -464,21 +487,22 @@   -- ^ Writing function   -> m () unrollAndJam !bH (it :. jt) (ib :. jb) js f = do-  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-  let !ibS = ib - ((ib - it) `mod` bH)+  let+    f2 (i :. j) = f (i :. j) >> f ((i + 1) :. j)+    f3 (i :. j) = f (i :. j) >> f2 ((i + 1) :. j)+    f4 (i :. j) = f (i :. j) >> f3 ((i + 1) :. j)+    f5 (i :. j) = f (i :. j) >> f4 ((i + 1) :. j)+    f6 (i :. j) = f (i :. j) >> f5 ((i + 1) :. j)+    f7 (i :. j) = f (i :. j) >> f6 ((i + 1) :. j)+    f' = case bH of+      1 -> f+      2 -> f2+      3 -> f3+      4 -> f4+      5 -> f5+      6 -> f6+      _ -> f7+    !ibS = ib - ((ib - it) `modInt` bH)   loopA_ it (< ibS) (+ bH) $ \ !i ->     loopA_ jt (< jb) (+ js) $ \ !j ->       f' (i :. j)

@@ -6,6 +6,7 @@ {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-}+ -- | -- Module      : Data.Massiv.Array.Manifest -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -13,125 +14,145 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Manifest-  ( -- * Manifest-    Manifest+module Data.Massiv.Array.Manifest (+  -- * Manifest+  Manifest,+   -- ** 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_,+   -- * Boxed-  , B(..)-  , BL(..)-  , BN(..)-  , N-  , pattern N-  , Uninitialized(..)+  B (..),+  BL (..),+  BN (..),+  N,+  pattern N,+  Uninitialized (..),+   -- ** Access-  , findIndex+  findIndex,+   -- ** Conversion   -- $boxed_conversion_note-  , toLazyArray-  , evalLazyArray-  , forceLazyArray-  , unwrapNormalForm-  , evalNormalForm+  toLazyArray,+  evalLazyArray,+  forceLazyArray,+  unwrapNormalForm,+  evalNormalForm,+   -- *** Primitive Boxed Array-  , unwrapLazyArray-  , wrapLazyArray-  , unwrapArray-  , evalArray-  , unwrapMutableArray-  , unwrapMutableLazyArray-  , evalMutableArray-  , unwrapNormalFormArray-  , evalNormalFormArray-  , unwrapNormalFormMutableArray-  , evalNormalFormMutableArray+  unwrapLazyArray,+  wrapLazyArray,+  unwrapArray,+  evalArray,+  unwrapMutableArray,+  unwrapMutableLazyArray,+  evalMutableArray,+  unwrapNormalFormArray,+  evalNormalFormArray,+  unwrapNormalFormMutableArray,+  evalNormalFormMutableArray,+   -- *** Boxed Vector-  , toBoxedVector-  , toBoxedMVector-  , fromBoxedVector-  , fromBoxedMVector-  , evalBoxedVector-  , evalBoxedMVector+  toBoxedVector,+  toBoxedMVector,+  fromBoxedVector,+  fromBoxedMVector,+  evalBoxedVector,+  evalBoxedMVector,+   -- * Primitive-  , P(..)-  , Prim+  P (..),+  Prim,+   -- ** Conversion+   -- *** Primitive ByteArray-  , toByteArray-  , toByteArrayM-  , unwrapByteArray-  , unwrapByteArrayOffset-  , fromByteArray-  , fromByteArrayM-  , fromByteArrayOffsetM-  , toMutableByteArray-  , unwrapMutableByteArray-  , unwrapMutableByteArrayOffset-  , fromMutableByteArray-  , fromMutableByteArrayM-  , fromMutableByteArrayOffsetM+  toByteArray,+  toByteArrayM,+  unwrapByteArray,+  unwrapByteArrayOffset,+  fromByteArray,+  fromByteArrayM,+  fromByteArrayOffsetM,+  toMutableByteArray,+  unwrapMutableByteArray,+  unwrapMutableByteArrayOffset,+  fromMutableByteArray,+  fromMutableByteArrayM,+  fromMutableByteArrayOffsetM,+   -- *** Primitive Vector-  , toPrimitiveVector-  , toPrimitiveMVector-  , fromPrimitiveVector-  , fromPrimitiveMVector+  toPrimitiveVector,+  toPrimitiveMVector,+  fromPrimitiveVector,+  fromPrimitiveMVector,+   -- * Storable-  , S(..)-  , Storable-  , mallocCompute-  , mallocCopy+  S (..),+  Storable,+  mallocCompute,+  mallocCopy,+   -- ** Conversion+   -- *** Storable Vector-  , toStorableVector-  , toStorableMVector-  , fromStorableVector-  , fromStorableMVector+  toStorableVector,+  toStorableMVector,+  fromStorableVector,+  fromStorableMVector,+   -- *** Direct Pointer Access-  , withPtr+  withPtr,+   -- * Unboxed-  , U(..)-  , Unbox+  U (..),+  Unbox,+   -- ** Conversion+   -- *** Unboxed Vector-  , toUnboxedVector-  , toUnboxedMVector-  , fromUnboxedVector-  , fromUnboxedMVector+  toUnboxedVector,+  toUnboxedMVector,+  fromUnboxedVector,+  fromUnboxedMVector,+   -- * ByteString Conversion-  , fromByteString-  , castFromByteString-  , toByteString-  , castToByteString-  , toBuilder-  , castToBuilder-  ) where+  fromByteString,+  castFromByteString,+  toByteString,+  castToByteString,+  toBuilder,+  castToBuilder,+) where  import Control.Monad import Data.ByteString as S hiding (findIndex)@@ -152,14 +173,17 @@ -- doesn't match the total number of elements of new array. -- -- @since 0.2.1-fromByteString ::-     Load r Ix1 Word8-  => Comp -- ^ Computation strategy-  -> ByteString -- ^ Strict ByteString to use as a source.+fromByteString+  :: Load r Ix1 Word8+  => Comp+  -- ^ Computation strategy+  -> ByteString+  -- ^ Strict ByteString to use as a source.   -> Vector r Word8 fromByteString comp bs = makeArrayLinear comp (SafeSz (S.length bs)) (SU.unsafeIndex bs) {-# INLINE fromByteString #-} +{- FOURMOLU_DISABLE -} -- | /O(n)/ - Convert any source array into a strict `ByteString`. In case when the source array is -- actually storable, no memory copy will occur. --@@ -176,6 +200,7 @@   compute #endif {-# INLINE toByteString #-}+{- FOURMOLU_ENABLE -}  -- | /O(n)/ - Conversion of array monoidally into a ByteString `Builder`. --@@ -212,8 +237,6 @@ -- kept as the same array. Conversion to Massiv boxed array will undergo evaluation during which -- computation strategies will be respected. -- -- | /O(n)/ - Perform a row-major search starting at @0@ for an element. Returns the index -- of the first occurance of an element or `Nothing` if a predicate could not be satisifed -- after it was applyied to all elements of the array.@@ -231,13 +254,13 @@         else go (i + 1) {-# INLINE findIndex #-} - -- | Very similar to @`computeAs` `S`@ except load the source array into memory allocated -- with @malloc@ on C heap. It can potentially be useful when iteroperating with some C -- programs. -- -- @since 0.5.9-mallocCompute :: forall r ix e. (Size r, Load r ix e, Storable e) => Array r ix e -> IO (Array S ix e)+mallocCompute+  :: forall r ix e. (Size r, Load r ix e, Storable e) => Array r ix e -> IO (Array S ix e) mallocCompute arr = do   let sz = size arr   marr <- unsafeMallocMArray sz

@@ -1,4 +1,3 @@-{-# OPTIONS_GHC -fno-warn-orphans #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-}@@ -9,6 +8,8 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+ -- | -- Module      : Data.Massiv.Array.Manifest.Boxed -- Copyright   : (c) Alexey Kuleshevich 2018-2022@@ -16,50 +17,49 @@ -- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru> -- Stability   : experimental -- Portability : non-portable----module Data.Massiv.Array.Manifest.Boxed-  ( B(..)-  , BL(..)-  , BN(..)-  , N-  , pattern N-  , Array(..)-  , MArray(..)-  , wrapLazyArray-  , unwrapLazyArray-  , unwrapNormalForm-  , evalNormalForm-  , unwrapArray-  , evalArray-  , toLazyArray-  , evalLazyArray-  , forceLazyArray-  , unwrapMutableArray-  , unwrapMutableLazyArray-  , evalMutableArray-  , unwrapNormalFormArray-  , evalNormalFormArray-  , unwrapNormalFormMutableArray-  , evalNormalFormMutableArray-  , toBoxedVector-  , toBoxedMVector-  , fromBoxedVector-  , fromBoxedMVector-  , evalBoxedVector-  , evalBoxedMVector-  , evalNormalBoxedVector-  , evalNormalBoxedMVector-  , coerceBoxedArray-  , coerceNormalBoxedArray-  , seqArray-  , deepseqArray-  ) where+module Data.Massiv.Array.Manifest.Boxed (+  B (..),+  BL (..),+  BN (..),+  N,+  pattern N,+  Array (..),+  MArray (..),+  wrapLazyArray,+  unwrapLazyArray,+  unwrapNormalForm,+  evalNormalForm,+  unwrapArray,+  evalArray,+  toLazyArray,+  evalLazyArray,+  forceLazyArray,+  unwrapMutableArray,+  unwrapMutableLazyArray,+  evalMutableArray,+  unwrapNormalFormArray,+  evalNormalFormArray,+  unwrapNormalFormMutableArray,+  evalNormalFormMutableArray,+  toBoxedVector,+  toBoxedMVector,+  fromBoxedVector,+  fromBoxedMVector,+  evalBoxedVector,+  evalBoxedMVector,+  evalNormalBoxedVector,+  evalNormalBoxedMVector,+  coerceBoxedArray,+  coerceNormalBoxedArray,+  seqArray,+  deepseqArray,+) where -import Control.DeepSeq (NFData(..), deepseq)+import Control.DeepSeq (NFData (..), deepseq) import Control.Exception import Control.Monad ((>=>)) import Control.Monad.Primitive-import qualified Data.Foldable as F (Foldable(..))+import qualified Data.Foldable as F (Foldable (..)) import Data.Massiv.Array.Delayed.Pull (D) import Data.Massiv.Array.Delayed.Push (DL) import Data.Massiv.Array.Delayed.Stream (DS)@@ -77,8 +77,8 @@ import qualified Data.Vector as VB import qualified Data.Vector.Mutable as MVB import GHC.Exts as GHC-import Prelude hiding (mapM, replicate) import System.IO.Unsafe (unsafePerformIO)+import Prelude hiding (mapM, replicate) #if !MIN_VERSION_vector(0,13,0) import Unsafe.Coerce (unsafeCoerce) #endif@@ -112,17 +112,18 @@ -- 30414093201713378043612608166064768844377641568960512000000000000 -- >>> length $ show $ fact 5000 -- 16326----data BL = BL deriving Show+data BL = BL deriving (Show) -data instance Array BL ix e = BLArray { blComp   :: !Comp-                                      , blSize   :: !(Sz ix)-                                      , blOffset :: {-# UNPACK #-} !Int-                                      , blData   :: {-# UNPACK #-} !(A.Array e)-                                      }-data instance MArray s BL ix e =-  MBLArray !(Sz ix) {-# UNPACK #-} !Int {-# UNPACK #-} !(A.MutableArray s e)+data instance Array BL ix e = BLArray+  { blComp :: !Comp+  , blSize :: !(Sz ix)+  , blOffset :: {-# UNPACK #-} !Int+  , blData :: {-# UNPACK #-} !(A.Array e)+  } +data instance MArray s BL ix e+  = MBLArray !(Sz ix) {-# UNPACK #-} !Int {-# UNPACK #-} !(A.MutableArray s e)+ instance (Ragged L ix e, Show e) => Show (Array BL ix e) where   showsPrec = showsArrayPrec id   showList = showArrayList@@ -135,7 +136,6 @@   showsPrec = showsArrayPrec (computeAs BL)   showList = showArrayList - instance (Index ix, NFData e) => NFData (Array BL ix e) where   rnf = (`deepseqArray` ())   {-# INLINE rnf #-}@@ -149,13 +149,12 @@   {-# INLINE compare #-}  instance Strategy BL where-  setComp c arr = arr { blComp = c }+  setComp c arr = arr{blComp = c}   {-# INLINE setComp #-}   getComp = blComp   {-# INLINE getComp #-}   repr = BL - instance Source BL e where   unsafeLinearIndex (BLArray _ _sz o a) i =     indexAssert "BL.unsafeLinearIndex" (SafeSz . A.sizeofArray) A.indexArray a (i + o)@@ -168,7 +167,6 @@   {-# INLINE unsafeLinearSlice #-}  instance Manifest BL e where-   unsafeLinearIndexM (BLArray _ _sz o a) i =     indexAssert "BL.unsafeLinearIndexM" (SafeSz . A.sizeofArray) A.indexArray a (i + o)   {-# INLINE unsafeLinearIndexM #-}@@ -208,10 +206,9 @@ instance Size BL where   size = blSize   {-# INLINE size #-}-  unsafeResize !sz !arr = arr { blSize = sz }+  unsafeResize !sz !arr = arr{blSize = sz}   {-# INLINE unsafeResize #-} - instance Index ix => Shape BL ix where   maxLinearSize = Just . SafeSz . elemsCount   {-# INLINE maxLinearSize #-}@@ -238,7 +235,6 @@   toStreamIx = S.isteps   {-# INLINE toStreamIx #-} - -- | Row-major sequential folding over a Boxed array. instance Index ix => Foldable (Array BL ix) where   fold = fold@@ -257,10 +253,9 @@   {-# INLINE null #-}   length = totalElem . size   {-# INLINE length #-}-  toList arr = build (\ c n -> foldrFB c n arr)+  toList arr = build (\c n -> foldrFB c n arr)   {-# INLINE toList #-} - instance Index ix => Functor (Array BL ix) where   fmap f arr = makeArrayLinear (blComp arr) (blSize arr) (f . unsafeLinearIndex arr)   {-# INLINE fmap #-}@@ -292,15 +287,13 @@   unsafeLiftArray2 = defaultUnsafeLiftArray2   {-# INLINE unsafeLiftArray2 #-} -- ------------------ -- Boxed Strict -- ------------------  -- | Array representation for Boxed elements. Its elements are strict to Weak -- Head Normal Form (WHNF) only.-data B = B deriving Show+data B = B deriving (Show)  newtype instance Array B ix e = BArray (Array BL ix e) @@ -322,7 +315,6 @@   compare = compareArrays compare   {-# INLINE compare #-} - instance Source B e where   unsafeLinearIndex arr = unsafeLinearIndex (toLazyArray arr)   {-# INLINE unsafeLinearIndex #-}@@ -336,11 +328,10 @@ instance Strategy B where   getComp = blComp . coerce   {-# INLINE getComp #-}-  setComp c arr = coerceBoxedArray (coerce arr) { blComp = c }+  setComp c arr = coerceBoxedArray (coerce arr){blComp = c}   {-# INLINE setComp #-}   repr = B - instance Index ix => Shape B ix where   maxLinearSize = Just . SafeSz . elemsCount   {-# INLINE maxLinearSize #-}@@ -348,12 +339,10 @@ instance Size B where   size = blSize . coerce   {-# INLINE size #-}-  unsafeResize sz = coerce (\arr -> arr { blSize = sz })+  unsafeResize sz = coerce (\arr -> arr{blSize = sz})   {-# INLINE unsafeResize #-} - instance Manifest B e where-   unsafeLinearIndexM = coerce unsafeLinearIndexM   {-# INLINE unsafeLinearIndexM #-} @@ -408,7 +397,6 @@   toStreamIx = S.isteps   {-# INLINE toStreamIx #-} - -- | Row-major sequential folding over a Boxed array. instance Index ix => Foldable (Array B ix) where   fold = fold@@ -427,10 +415,9 @@   {-# INLINE null #-}   length = totalElem . size   {-# INLINE length #-}-  toList arr = build (\ c n -> foldrFB c n arr)+  toList arr = build (\c n -> foldrFB c n arr)   {-# INLINE toList #-} - instance Index ix => Functor (Array B ix) where   fmap f arr = makeArrayLinear (getComp arr) (size arr) (f . unsafeLinearIndex arr)   {-# INLINE fmap #-}@@ -466,21 +453,25 @@ -- Boxed Normal Form -- ----------------------- -  -- | Array representation for Boxed elements. Its elements are always in Normal+-- | Array representation for Boxed elements. Its elements are always in Normal -- Form (NF), therefore `NFData` instance is required.-data BN = BN deriving Show+data BN = BN deriving (Show)  -- | Type and pattern `N` have been added for backwards compatibility and will be replaced -- in the future in favor of `BN`. -- -- /Deprecated/ - since 1.0.0 type N = BN+ pattern N :: N pattern N = BN+ {-# COMPLETE N #-}+ {-# DEPRECATED N "In favor of more consistently named `BN`" #-}  newtype instance Array BN ix e = BNArray (Array BL ix e)+ newtype instance MArray s BN ix e = MBNArray (MArray s BL ix e)  instance (Ragged L ix e, Show e, NFData e) => Show (Array BN ix e) where@@ -515,7 +506,6 @@   unsafeOuterSlice (BNArray a) i = coerce (unsafeOuterSlice a i)   {-# INLINE unsafeOuterSlice #-} - instance Index ix => Shape BN ix where   maxLinearSize = Just . SafeSz . elemsCount   {-# INLINE maxLinearSize #-}@@ -580,7 +570,6 @@   toStreamIx = toStreamIx . coerce   {-# INLINE toStreamIx #-} - instance (NFData e, IsList (Array L ix e), Ragged L ix e) => IsList (Array BN ix e) where   type Item (Array BN ix e) = Item (Array L ix e)   fromList = L.fromLists' Seq@@ -624,14 +613,15 @@ -- | /O(n)/ - Wrap a boxed array and evaluate all elements to a WHNF. -- -- @since 0.2.1-evalArray ::-     Comp -- ^ Computation strategy-  -> A.Array e -- ^ Lazy boxed array from @primitive@ package.+evalArray+  :: Comp+  -- ^ Computation strategy+  -> A.Array e+  -- ^ Lazy boxed array from @primitive@ package.   -> Vector B e evalArray comp a = evalLazyArray $ setComp comp $ wrapLazyArray a {-# INLINE evalArray #-} - -- | /O(1)/ - Unwrap boxed array. This will discard any possible slicing that has been -- applied to the array. --@@ -647,7 +637,6 @@ wrapLazyArray a = BLArray Seq (SafeSz (A.sizeofArray a)) 0 a {-# INLINE wrapLazyArray #-} - -- | /O(1)/ - Cast a strict boxed array into a lazy boxed array. -- -- @since 0.6.0@@ -677,7 +666,6 @@ unwrapMutableArray (MBArray (MBLArray _ _ marr)) = marr {-# INLINE unwrapMutableArray #-} - -- | /O(1)/ - Unwrap mutable boxed lazy array. This will discard any possible slicing that has been -- applied to the array. --@@ -686,13 +674,13 @@ unwrapMutableLazyArray (MBLArray _ _ marr) = marr {-# INLINE unwrapMutableLazyArray #-} - -- | /O(n)/ - Wrap mutable boxed array and evaluate all elements to WHNF. -- -- @since 0.2.1-evalMutableArray ::-     PrimMonad m-  => A.MutableArray (PrimState m) e -- ^ Mutable array that will get wrapped+evalMutableArray+  :: PrimMonad m+  => A.MutableArray (PrimState m) e+  -- ^ Mutable array that will get wrapped   -> m (MArray (PrimState m) B Ix1 e) evalMutableArray = fmap MBArray . fromMutableArraySeq seq {-# INLINE evalMutableArray #-}@@ -712,15 +700,16 @@ -- | /O(n)/ - Wrap a boxed array and evaluate all elements to a Normal Form (NF). -- -- @since 0.2.1-evalNormalFormArray ::-     NFData e-  => Comp -- ^ Computation strategy-  -> A.Array e -- ^ Lazy boxed array+evalNormalFormArray+  :: NFData e+  => Comp+  -- ^ Computation strategy+  -> A.Array e+  -- ^ Lazy boxed array   -> Array N Ix1 e evalNormalFormArray comp = forceLazyArray . setComp comp . wrapLazyArray {-# INLINE evalNormalFormArray #-} - -- | /O(1)/ - Unwrap a fully evaluated mutable boxed array. This will discard any possible -- slicing that has been applied to the array. --@@ -729,24 +718,22 @@ unwrapNormalFormMutableArray = unwrapMutableLazyArray . coerce {-# INLINE unwrapNormalFormMutableArray #-} - -- | /O(n)/ - Wrap mutable boxed array and evaluate all elements to NF. -- -- @since 0.2.1-evalNormalFormMutableArray ::-     (PrimMonad m, NFData e)+evalNormalFormMutableArray+  :: (PrimMonad m, NFData e)   => A.MutableArray (PrimState m) e   -> m (MArray (PrimState m) N Ix1 e) evalNormalFormMutableArray marr = MBNArray <$> fromMutableArraySeq deepseq marr {-# INLINE evalNormalFormMutableArray #-} - ---------------------- -- Helper functions -- ---------------------- -fromMutableArraySeq ::-     PrimMonad m+fromMutableArraySeq+  :: PrimMonad m   => (e -> m () -> m a)   -> A.MutableArray (PrimState m) e   -> m (MArray (PrimState m) BL Ix1 e)@@ -756,17 +743,14 @@   return $! MBLArray (SafeSz sz) 0 ma {-# INLINE fromMutableArraySeq #-} - seqArray :: Index ix => Array BL ix a -> t -> t seqArray !arr t = foldlInternal (flip seq) () (flip seq) () arr `seq` t {-# INLINE seqArray #-} - deepseqArray :: (NFData a, Index ix) => Array BL ix a -> t -> t deepseqArray !arr t = foldlInternal (flip deepseq) () (flip seq) () arr `seq` t {-# INLINE deepseqArray #-} - -- | /O(1)/ - Converts array from `N` to `B` representation. -- -- @since 0.5.0@@ -781,6 +765,7 @@ evalNormalForm (BArray arr) = arr `deepseqArray` BNArray arr {-# INLINE evalNormalForm #-} +{- FOURMOLU_DISABLE -} -- | /O(1)/ - Converts a boxed `Array` into a `VB.Vector` without touching any -- elements. --@@ -798,8 +783,7 @@ fromVectorCast :: VectorCast a -> VB.Vector a fromVectorCast = unsafeCoerce #endif--+{- FOURMOLU_ENABLE -}  -- | /O(1)/ - Converts a boxed `MArray` into a `MVB.MVector`. --@@ -816,7 +800,6 @@ evalBoxedVector comp = evalLazyArray . setComp comp . fromBoxedVector {-# INLINE evalBoxedVector #-} - -- | /O(n)/ - Convert mutable boxed vector and evaluate all elements to WHNF -- sequentially. Both keep pointing to the same memory --@@ -827,14 +810,13 @@    in marr <$ loopA_ o (< k) (+ 1) (A.readArray ma >=> (`seq` pure ())) {-# INLINE evalBoxedMVector #-} - -- | /O(1)/ - Cast a boxed vector without touching any elements. -- -- @since 0.6.0 fromBoxedVector :: VB.Vector a -> Vector BL a {-# INLINE fromBoxedVector #-} fromBoxedVector v =-  BLArray {blComp = Seq, blSize = SafeSz n, blOffset = offset, blData = arr}+  BLArray{blComp = Seq, blSize = SafeSz n, blOffset = offset, blData = arr}   where #if MIN_VERSION_vector(0,13,0)     (arr, offset, n) = VB.toArraySlice v@@ -850,7 +832,6 @@ toVectorCast = unsafeCoerce #endif - -- | /O(1)/ - Convert mutable boxed vector to a lazy mutable boxed array. Both keep -- pointing to the same memory --@@ -859,7 +840,6 @@ fromBoxedMVector (MVB.MVector o k ma) = MBLArray (SafeSz k) o ma {-# INLINE fromBoxedMVector #-} - -- | /O(1)/ - Cast a boxed lazy array. It is unsafe because it can violate the invariant -- that all elements of `N` array are in NF. --@@ -868,7 +848,6 @@ coerceNormalBoxedArray = coerce {-# INLINE coerceNormalBoxedArray #-} - -- | /O(1)/ - Cast a boxed lazy array. It is unsafe because it can violate the invariant -- that all elements of `B` array are in WHNF. --@@ -881,8 +860,8 @@ -- sequentially. Both keep pointing to the same memory -- -- @since 0.5.0-evalNormalBoxedMVector ::-     (NFData a, PrimMonad m) => MVB.MVector (PrimState m) a -> m (MArray (PrimState m) N Ix1 a)+evalNormalBoxedMVector+  :: (NFData a, PrimMonad m) => MVB.MVector (PrimState m) a -> m (MArray (PrimState m) N Ix1 a) evalNormalBoxedMVector (MVB.MVector o k ma) =   let marr = MBNArray (MBLArray (SafeSz k) o ma)    in marr <$ loopA_ o (< k) (+ 1) (A.readArray ma >=> pure . rnf)@@ -898,4 +877,3 @@     MVB.MVector o k ma <- VB.unsafeThaw v     forceLazyArray <$> unsafeFreeze comp (MBLArray (SafeSz k) o ma) {-# INLINE evalNormalBoxedVector #-}-

@@ -50,6 +50,9 @@ import Data.Massiv.Vector.Stream as S (isteps, steps) import Data.Primitive.ByteArray import Data.Primitive.Ptr (setPtr)+import qualified Data.Vector.Generic.Mutable as MVG+import qualified Data.Vector.Storable as VS+import qualified Data.Vector.Storable.Mutable as MVS import Data.Word import Foreign.ForeignPtr import Foreign.Marshal.Alloc@@ -61,10 +64,6 @@ 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  -- | Representation for `Storable` elements data S = S deriving (Show)

@@ -50,6 +50,7 @@   , 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

@@ -291,7 +291,8 @@ --   ] -- -- @since 0.1.0-thaw :: forall r ix e m. (Manifest r e, Index ix, MonadIO m) => Array r ix e -> m (MArray RealWorld r ix e)+thaw+  :: forall r ix e m. (Manifest r e, Index ix, MonadIO m) => Array r ix e -> m (MArray RealWorld r ix e) thaw arr =   liftIO $ do     let sz = size arr@@ -982,7 +983,8 @@ -- action to it. There is no mutation to the array, unless the action itself modifies it. -- -- @since 0.4.0-forPrimM_ :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m ()) -> m ()+forPrimM_+  :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m ()) -> m () forPrimM_ marr f =   loopA_ 0 (< totalElem (sizeOfMArray marr)) (+ 1) (unsafeLinearRead marr >=> f) {-# INLINE forPrimM_ #-}@@ -990,7 +992,8 @@ -- | Sequentially loop over a mutable array while modifying each element with an action. -- -- @since 0.4.0-forPrimM :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m e) -> m ()+forPrimM+  :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> (e -> m e) -> m () forPrimM marr f =   loopA_ 0 (< totalElem (sizeOfMArray marr)) (+ 1) (unsafeLinearModify marr f) {-# INLINE forPrimM #-}@@ -1278,7 +1281,8 @@ -- -- @since 0.4.0 writeM-  :: (Manifest r e, Index ix, PrimMonad m, MonadThrow m) => MArray (PrimState m) r ix e -> ix -> e -> m ()+  :: (Manifest r e, Index ix, PrimMonad m, MonadThrow m)+  => MArray (PrimState m) r ix e -> ix -> e -> m () writeM marr ix e =   write marr ix e >>= (`unless` throwM (IndexOutOfBoundsException (sizeOfMArray marr) ix)) {-# INLINE writeM #-}@@ -1367,7 +1371,8 @@ -- otherwise. -- -- @since 0.1.0-swap :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m (Maybe (e, e))+swap+  :: (Manifest r e, Index ix, PrimMonad m) => MArray (PrimState m) r ix e -> ix -> ix -> m (Maybe (e, e)) swap marr ix1 ix2 =   let !sz = sizeOfMArray marr    in if isSafeIndex sz ix1 && isSafeIndex sz ix2

@@ -128,7 +128,9 @@ import Prelude as P  infixr 8 .^, .^^+ infixl 7 !*!, .*., .*, *., !/!, ./., ./, /., `quotA`, `remA`, `divA`, `modA`+ infixl 6 !+!, .+., .+, +., !-!, .-., .-, -.  -- | Similar to `liftArray2M`, except it can be applied only to representations@@ -1248,7 +1250,8 @@ -- size, otherwise it will result in an error. -- -- @since 1.0.0-sumArrays' :: (HasCallStack, Foldable t, Load r ix e, Numeric r e) => t (Array r ix e) -> Array r ix e+sumArrays'+  :: (HasCallStack, Foldable t, Load r ix e, Numeric r e) => t (Array r ix e) -> Array r ix e sumArrays' = throwEither . sumArraysM {-# INLINE sumArrays' #-} 

@@ -76,7 +76,6 @@ 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.Mutable import Data.Massiv.Core.Common

@@ -347,7 +347,8 @@ -- | Monoidal fold over the inner most dimension. -- -- @since 0.4.3-foldInner :: (Monoid e, Index (Lower ix), Index ix, Source r e) => Array r ix e -> Array D (Lower ix) e+foldInner+  :: (Monoid e, Index (Lower ix), Index ix, Source r e) => Array r ix e -> Array D (Lower ix) e foldInner = foldlInner mappend mempty {-# INLINE foldInner #-} 

@@ -116,8 +116,8 @@ import Data.Massiv.Core.Exception import Data.Massiv.Core.Index import Data.Massiv.Core.Index.Internal (Sz (SafeSz))-import Data.Typeable import qualified Data.Stream.Monadic as S (Stream)+import Data.Typeable import Data.Vector.Fusion.Util import GHC.Exts (IsList) 

@@ -3,6 +3,7 @@ {-# LANGUAGE DataKinds #-} {-# LANGUAGE ExplicitNamespaces #-} {-# LANGUAGE GADTs #-}+{-# LANGUAGE LambdaCase #-} {-# LANGUAGE PatternSynonyms #-}  -- |@@ -121,6 +122,7 @@ import Data.Massiv.Core.Index.Stride import Data.Massiv.Core.Index.Tuple import Data.Massiv.Core.Loop+import GHC.Base (modInt) import GHC.TypeLits  #include "massiv.h"@@ -193,13 +195,21 @@   deriving (Eq, Show)  instance NFData e => NFData (Border e) where-  rnf b = case b of+  rnf = \case     Fill e -> rnf e     Wrap -> ()     Edge -> ()     Reflect -> ()     Continue -> () +instance Functor Border where+  fmap f = \case+    Fill e -> Fill (f e)+    Wrap -> Wrap+    Edge -> Edge+    Reflect -> Reflect+    Continue -> Continue+ -- | Apply a border resolution technique to an index -- -- ==== __Examples__@@ -225,28 +235,21 @@   -> e handleBorderIndex border !sz getVal !ix =   case border of-    Fill val -> if isSafeIndex sz ix then getVal ix else val-    Wrap -> getVal (repairIndex sz ix wrap wrap)-    Edge -> getVal (repairIndex sz ix (const (const 0)) (\(SafeSz k) _ -> k - 1))+    Fill val+      | isSafeIndex sz ix -> getVal ix+      | otherwise -> val+    Wrap ->+      getVal $+        repairIndex sz ix (\(SafeSz k) i -> i `modInt` k) (\(SafeSz k) i -> i `modInt` k)+    Edge ->+      getVal $+        repairIndex sz ix (const (const 0)) (\(SafeSz k) _ -> k - 1)     Reflect ->-      getVal-        ( repairIndex-            sz-            ix-            (\(SafeSz k) !i -> (abs i - 1) `mod` k)-            (\(SafeSz k) !i -> (-i - 1) `mod` k)-        )+      getVal $+        repairIndex sz ix (\(SafeSz k) i -> (-i - 1) `modInt` k) (\(SafeSz k) i -> (-i - 1) `modInt` k)     Continue ->-      getVal-        ( repairIndex-            sz-            ix-            (\(SafeSz k) !i -> abs i `mod` k)-            (\(SafeSz k) !i -> (-i - 2) `mod` k)-        )-  where-    wrap (SafeSz k) i = i `mod` k-    {-# INLINE [1] wrap #-}+      getVal $+        repairIndex sz ix (\(SafeSz k) i -> negate i `modInt` k) (\(SafeSz k) i -> (-i - 2) `modInt` k) {-# INLINE [1] handleBorderIndex #-}  -- | Index with all zeros

@@ -739,6 +739,9 @@    -- | Similar to `iterM`, but no restriction on a Monad.   --+  -- iterF (-10) 20 4 (<) [] (:) :: [Int]+  -- [-10,-6,-2,2,6,10,14,18]+  --   -- @since 1.0.2   iterF :: ix -> ix -> ix -> (Int -> Int -> Bool) -> f a -> (ix -> f a -> f a) -> f a   default iterF@@ -1000,6 +1003,11 @@  type instance Lower Int = Ix0 +-- This is needed to avoid GHC from doing redundant allocations+throwIndexZeroException :: Int -> a+throwIndexZeroException = throw . IndexZeroException+{-# NOINLINE throwIndexZeroException #-}+ instance Index Ix1 where   type Dimensions Ix1 = 1   dimensions _ = 1@@ -1017,7 +1025,7 @@   fromLinearIndexAcc n k = k `quotRem` n   {-# INLINE [1] fromLinearIndexAcc #-}   repairIndex k@(SafeSz ksz) !i rBelow rOver-    | ksz <= 0 = throw $ IndexZeroException ksz+    | ksz <= 0 = throwIndexZeroException ksz     | i < 0 = rBelow k i     | i >= ksz = rOver k i     | otherwise = i

@@ -284,6 +284,7 @@ pattern RowMajor f <- RowMajorInternal f   where     RowMajor = RowMajorInternal . max 1+ {-# COMPLETE RowMajor #-}  instance Iterator RowMajor where@@ -369,6 +370,7 @@ pattern RowMajorUnbalanced f <- RowMajorUnbalancedInternal f   where     RowMajorUnbalanced = RowMajorUnbalancedInternal . max 1+ {-# COMPLETE RowMajorUnbalanced #-}  instance Iterator RowMajorUnbalanced where

@@ -157,6 +157,7 @@   Ix n = IxN n  type instance Lower Ix2 = Ix1+ type instance Lower (IxN n) = Ix (n - 1)  instance Show Ix2 where

@@ -65,8 +65,11 @@ type Ix5T = (Int, Int, Int, Int, Int)  type instance Lower Ix2T = Ix1T+ type instance Lower Ix3T = Ix2T+ type instance Lower Ix4T = Ix3T+ type instance Lower Ix5T = Ix4T  -- | Convert an `Int` tuple to `Ix2`

@@ -37,7 +37,7 @@ import qualified Data.Massiv.Vector.Stream as S import Data.Monoid import Data.Typeable-import GHC.Exts (IsList(..))+import GHC.Exts (IsList (..)) import GHC.TypeLits import System.IO.Unsafe (unsafePerformIO) 

@@ -454,8 +454,12 @@ {-# INLINE [0] scheduleMassivWork #-}  {-# RULES-"scheduleWork/scheduleWork_/ST" forall (scheduler :: Scheduler s ()) (action :: ST s ()). scheduleMassivWork scheduler action = scheduleWork_ scheduler action-"scheduleWork/scheduleWork_/IO" forall (scheduler :: Scheduler RealWorld ()) (action :: IO ()). scheduleMassivWork scheduler action = scheduleWork_ scheduler action+"scheduleWork/scheduleWork_/ST" forall (scheduler :: Scheduler s ()) (action :: ST s ()).+  scheduleMassivWork scheduler action =+    scheduleWork_ scheduler action+"scheduleWork/scheduleWork_/IO" forall (scheduler :: Scheduler RealWorld ()) (action :: IO ()).+  scheduleMassivWork scheduler action =+    scheduleWork_ scheduler action   #-}  -- | Selects an optimal scheduler for the supplied strategy, but it works only in `IO`

@@ -979,7 +979,8 @@ -- ==== __Examples__ -- -- @since 0.5.0-sliceAtM :: forall r e m. (Source r e, MonadThrow m) => Sz1 -> Vector r e -> m (Vector r e, Vector r e)+sliceAtM+  :: forall r e m. (Source r e, MonadThrow m) => Sz1 -> Vector r e -> m (Vector r e, Vector r e) sliceAtM k v = do   l <- takeM k v   pure (l, unsafeDrop k v)@@ -2800,7 +2801,6 @@ spostscanlAcc :: Stream r ix e => (c -> e -> (a, c)) -> c -> Array r ix e -> Vector DS a spostscanlAcc f acc = DSArray . S.postscanlAccM (\a b -> pure (f a b)) acc . toStream {-# INLINE spostscanlAcc #-}-  -- | /O(n)/ - left scan with strict accumulator. First element is the value of the accumulator. --

@@ -479,7 +479,9 @@   -> Steps m e   -> Steps m f zipWith5 f (Steps sa ka) (Steps sb kb) (Steps sc kc) (Steps sd kd) (Steps se ke) =-  Steps (S.zipWith5 f sa sb sc sd se) (minLengthHint ka (minLengthHint kb (minLengthHint kc (minLengthHint kd ke))))+  Steps+    (S.zipWith5 f sa sb sc sd se)+    (minLengthHint ka (minLengthHint kb (minLengthHint kc (minLengthHint kd ke)))) {-# INLINE zipWith5 #-}  zipWith6@@ -529,7 +531,9 @@   -> Steps m e   -> Steps m f zipWith5M f (Steps sa ka) (Steps sb kb) (Steps sc kc) (Steps sd kd) (Steps se ke) =-  Steps (S.zipWith5M f sa sb sc sd se) (minLengthHint ka (minLengthHint kb (minLengthHint kc (minLengthHint kd ke))))+  Steps+    (S.zipWith5M f sa sb sc sd se)+    (minLengthHint ka (minLengthHint kb (minLengthHint kc (minLengthHint kd ke)))) {-# INLINE zipWith5M #-}  zipWith6M