massiv 0.2.6.0 → 0.2.7.0

raw patch · 20 files changed

+121/−100 lines, 20 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• massiv.cabal +1/−1
• src/Data/Massiv/Array/Delayed/Windowed.hs +1/−1
• src/Data/Massiv/Array/Manifest/Internal.hs +1/−1
• src/Data/Massiv/Array/Manifest/Vector.hs +2/−2
• src/Data/Massiv/Array/Mutable.hs +12/−12
• src/Data/Massiv/Array/Numeric/Integral.hs +5/−5
• src/Data/Massiv/Array/Ops/Construct.hs +5/−5
• src/Data/Massiv/Array/Ops/Transform.hs +7/−7
• src/Data/Massiv/Array/Stencil.hs +1/−1
• src/Data/Massiv/Array/Stencil/Convolution.hs +2/−2
• src/Data/Massiv/Array/Stencil/Internal.hs +15/−12
• src/Data/Massiv/Array/Stencil/Unsafe.hs +1/−1
• src/Data/Massiv/Array/Unsafe.hs +5/−6
• src/Data/Massiv/Core/Common.hs +15/−15
• src/Data/Massiv/Core/Index.hs +7/−6
• src/Data/Massiv/Core/Index/Class.hs +32/−18
• src/Data/Massiv/Core/Index/Stride.hs +1/−1
• src/Data/Massiv/Core/List.hs +2/−2
• tests/Data/Massiv/Core/IndexSpec.hs +3/−1
• tests/Data/Massiv/CoreArbitrary.hs +3/−1

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

@@ -107,7 +107,7 @@   :: Source r ix e   => Array r ix e -- ^ Source array that will have a window inserted into it   -> ix -- ^ Start index for the window-  -> ix -- ^ Size of the window+  -> Sz ix -- ^ Size of the window   -> (ix -> e) -- ^ Inside window indexing function   -> Array DW ix e makeWindowedArray !arr !windowStart !windowSize windowIndex

@@ -107,7 +107,7 @@   {-# INLINE unsafeMakeArray #-}  -- | Create a boxed from usual size and index to element function-makeBoxedVector :: Index ix => ix -> (ix -> a) -> V.Vector a+makeBoxedVector :: Index ix => Sz ix -> (ix -> a) -> V.Vector a makeBoxedVector !sz f = V.generate (totalElem sz) (f . fromLinearIndex sz) {-# INLINE makeBoxedVector #-} 

@@ -57,7 +57,7 @@ -- been sliced before or if some non-standard vector type is supplied. castFromVector :: forall v r ix e. (VG.Vector v e, Typeable v, Mutable r ix e, ARepr v ~ r)                => Comp-               -> ix -- ^ Size of the result Array+               -> Sz ix -- ^ Size of the result Array                -> v e -- ^ Source Vector                -> Maybe (Array r ix e) castFromVector comp sz vector = do@@ -88,7 +88,7 @@ fromVector ::      (Typeable v, VG.Vector v a, Mutable (ARepr v) ix a, Mutable r ix a)   => Comp-  -> ix -- ^ Resulting size of the array+  -> Sz ix -- ^ Resulting size of the array   -> v a -- ^ Source Vector   -> Array r ix a fromVector comp sz v =

@@ -60,7 +60,7 @@ import           Data.Massiv.Core.Scheduler  -- | Initialize a new mutable array. Negative size will result in an empty array.-new :: (Mutable r ix e, PrimMonad m) => ix -> m (MArray (PrimState m) r ix e)+new :: (Mutable r ix e, PrimMonad m) => Sz ix -> m (MArray (PrimState m) r ix e) new sz = unsafeNewZero (liftIndex (max 0) sz) {-# INLINE new #-} @@ -80,7 +80,7 @@ -- -- ====__Examples__ ----- >>> createArray_ Seq (Ix1 2) (\ marr -> write marr 0 10 >> write marr 1 11) :: IO (Array P Ix1 Int)+-- >>> createArray_ Seq (Sz1 2) (\ marr -> write marr 0 10 >> write marr 1 11) :: IO (Array P Ix1 Int) -- (Array P Seq (2) --   [ 10,11 ]) --@@ -89,7 +89,7 @@ createArray_ ::      (Mutable r ix e, PrimMonad m)   => Comp -- ^ Computation strategy to use after `MArray` gets frozen and onward.-  -> ix -- ^ Size of the newly created array+  -> 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)@@ -103,7 +103,7 @@ createArray ::      (Mutable r ix e, PrimMonad m)   => Comp -- ^ Computation strategy to use after `MArray` gets frozen and onward.-  -> ix -- ^ Size of the newly created array+  -> 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)@@ -119,7 +119,7 @@ -- @since 0.2.6 -- createArrayST_ ::-     Mutable r ix e => Comp -> ix -> (forall s. MArray s r ix e -> ST s a) -> Array r ix e+     Mutable r ix e => Comp -> Sz ix -> (forall s. MArray s r ix e -> ST s a) -> Array r ix e createArrayST_ comp sz action = runST $ createArray_ comp sz action {-# INLINE createArrayST_ #-} @@ -129,7 +129,7 @@ -- @since 0.2.6 -- createArrayST ::-     Mutable r ix e => Comp -> ix -> (forall s. MArray s r ix e -> ST s a) -> (a, Array r ix e)+     Mutable r ix e => Comp -> Sz ix -> (forall s. MArray s r ix e -> ST s a) -> (a, Array r ix e) createArrayST comp sz action = runST $ createArray comp sz action {-# INLINE createArrayST #-} @@ -146,7 +146,7 @@ -- -- >>> import Data.IORef -- >>> ref <- newIORef (0 :: Int)--- >>> generateArray Seq (Ix1 6) (\ i -> modifyIORef' ref (+i) >> print i >> pure i) :: IO (Array U Ix1 Int)+-- >>> generateArray Seq (Sz1 6) (\ i -> modifyIORef' ref (+i) >> print i >> pure i) :: IO (Array U Ix1 Int) -- 0 -- 1 -- 2@@ -161,7 +161,7 @@ generateArray ::      (Mutable r ix e, PrimMonad m)   => Comp -- ^ Computation strategy (ingored during generation)-  -> ix -- ^ Resulting size of the array+  -> Sz ix -- ^ Resulting size of the array   -> (ix -> m e) -- ^ Element producing generator   -> m (Array r ix e) generateArray comp sz' gen = do@@ -179,7 +179,7 @@ generateArrayIO ::      (Mutable r ix e)   => Comp-  -> ix+  -> Sz ix   -> (ix -> IO e)   -> IO (Array r ix e) generateArrayIO comp sz' gen = do@@ -224,7 +224,7 @@ unfoldlPrim_ ::      (Mutable r ix e, PrimMonad m)   => Comp -- ^ Computation strategy (ignored during initial creation)-  -> ix -- ^ Size of the desired array+  -> Sz ix -- ^ Size of the desired array   -> (a -> ix -> m (a, e)) -- ^ Unfolding action   -> a -- ^ Initial accumulator   -> m (Array r ix e)@@ -232,14 +232,14 @@ {-# INLINE unfoldlPrim_ #-}  --- | Just like `unfoldlPrim`, but also returns the final value of the accumulator.+-- | Just like `unfoldlPrim_`, but also returns the final value of the accumulator. -- -- @since 0.2.6 -- unfoldlPrim ::      (Mutable r ix e, PrimMonad m)   => Comp -- ^ Computation strategy (ignored during initial creation)-  -> ix -- ^ Size of the desired array+  -> Sz ix -- ^ Size of the desired array   -> (a -> ix -> m (a, e)) -- ^ Unfolding action   -> a -- ^ Initial accumulator   -> m (a, Array r ix e)

@@ -118,7 +118,7 @@      (Fractional e, Load DW ix e, Mutable r ix e)   => (e -> Dim -> Int -> Stencil ix e e) -- ^ Integration Stencil   -> e -- ^ @d@ - Length of interval per cell-  -> ix -- ^ @sz@ - Result size of the matrix+  -> 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 M ix e@@ -139,7 +139,7 @@   -> ((Int -> e) -> ix -> e) -- ^ @f(x,y,...)@ - Function to integrate   -> e -- ^ @a@ - Starting value point.   -> e -- ^ @d@ - Distance per matrix cell.-  -> ix -- ^ @sz@ - Result matrix size.+  -> Sz ix -- ^ @sz@ - Result matrix size.   -> Int -- ^ @n@ - Number of sample points per cell in each direction.   -> Array M ix e midpointRule comp r f a d sz n =@@ -155,7 +155,7 @@   -> ((Int -> e) -> ix -> e) -- ^ @f(x,y,...)@ - function to integrate   -> e -- ^ @a@ - starting point   -> e -- ^ @d@ - distance per matrix cell-  -> ix -- ^ @sz@ - end matrix size+  -> Sz ix -- ^ @sz@ - end matrix size   -> Int -- ^ @n@ - number of sample points per cell in each direction   -> Array M ix e trapezoidRule comp r f a d sz n =@@ -170,7 +170,7 @@   -> ((Int -> e) -> ix -> e) -- ^ @f(x,y,...)@ - function to integrate   -> e -- ^ @a@ - starting point   -> e -- ^ @d@ - distance per matrix cell-  -> ix -- ^ @sz@ - end matrix size+  -> Sz ix -- ^ @sz@ - end matrix size   -> Int -- ^ @n@ - number of sample points per cell in each direction. This value must be even,          -- otherwise error..   -> Array M ix e@@ -202,7 +202,7 @@   -- function that should be applied to individual indicies.   -> a -- ^ @a@ - Starting point   -> a -- ^ @d@ - Distance per cell-  -> ix -- ^ @sz@ - Size of the desired array+  -> 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 n =

@@ -44,7 +44,7 @@ -- | 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. ----- >>> makeArrayR U Par (2 :> 3 :. 4) (\ (i :> j :. k) -> i * i + j * j == k * k)+-- >>> makeArrayR U Par (Sz (2 :> 3 :. 4)) (\ (i :> j :. k) -> i * i + j * j == k * k) -- (Array U Par (2 :> 3 :. 4) --   [ [ [ True,False,False,False ] --     , [ False,True,False,False ]@@ -56,13 +56,13 @@ --     ] --   ]) ---makeArrayR :: Construct r ix e => r -> Comp -> ix -> (ix -> e) -> Array r ix e+makeArrayR :: Construct r ix e => r -> Comp -> Sz ix -> (ix -> e) -> Array r ix e makeArrayR _ = makeArray {-# INLINE makeArrayR #-}   -- | Same as `makeArrayR`, but restricted to 1-dimensional arrays.-makeVectorR :: Construct r Ix1 e => r -> Comp -> Ix1-> (Ix1 -> e) -> Array r Ix1 e+makeVectorR :: Construct r Ix1 e => r -> Comp -> Sz1 -> (Ix1 -> e) -> Array r Ix1 e makeVectorR _ = makeArray {-# INLINE makeVectorR #-} @@ -71,7 +71,7 @@ -- -- @since 0.2.6 ---makeArrayA :: (Mutable r a b, Applicative f) => Comp -> a -> (a -> f b) -> f (Array r a b)+makeArrayA :: (Mutable r ix b, Applicative f) => Comp -> Sz ix -> (ix -> f b) -> f (Array r ix b) makeArrayA comp sz f = traverseA f $ makeArrayR D comp sz id {-# INLINE makeArrayA #-} @@ -79,7 +79,7 @@ -- -- @since 0.2.6 ---makeArrayAR :: (Mutable r a b, Applicative f) => r -> Comp -> a -> (a -> f b) -> f (Array r a b)+makeArrayAR :: (Mutable r ix b, Applicative f) => r -> Comp -> Sz ix -> (ix -> f b) -> f (Array r ix b) makeArrayAR _ = makeArrayA {-# INLINE makeArrayAR #-} 

@@ -47,7 +47,7 @@ -- fully encapsulated in a source array, otherwise `Nothing` is returned, extract :: Size r ix e         => ix -- ^ Starting index-        -> ix -- ^ Size of the resulting array+        -> Sz ix -- ^ Size of the resulting array         -> Array r ix e -- ^ Source array         -> Maybe (Array (EltRepr r ix) ix e) extract !sIx !newSz !arr@@ -63,7 +63,7 @@ -- | Same as `extract`, but will throw an error if supplied dimensions are incorrect. extract' :: Size r ix e         => ix -- ^ Starting index-        -> ix -- ^ Size of the resulting array+        -> Sz ix -- ^ Size of the resulting array         -> Array r ix e -- ^ Source array         -> Array (EltRepr r ix) ix e extract' !sIx !newSz !arr =@@ -100,14 +100,14 @@  -- | /O(1)/ - Changes the shape of an array. Returns `Nothing` if total -- number of elements does not match the source array.-resize :: (Index ix', Size r ix e) => ix' -> Array r ix e -> Maybe (Array r ix' e)+resize :: (Index ix', Size r ix e) => Sz ix' -> Array r ix e -> Maybe (Array r ix' e) resize !sz !arr   | totalElem sz == totalElem (size arr) = Just $ unsafeResize sz arr   | otherwise = Nothing {-# INLINE resize #-}  -- | Same as `resize`, but will throw an error if supplied dimensions are incorrect.-resize' :: (Index ix', Size r ix e) => ix' -> Array r ix e -> Array r ix' e+resize' :: (Index ix', Size r ix e) => Sz ix' -> Array r ix e -> Array r ix' e resize' !sz !arr =   maybe     (error $@@ -261,7 +261,7 @@ --   ]) -- backpermute :: (Source r' ix' e, Index ix) =>-               ix -- ^ Size of the result array+               Sz ix -- ^ Size of the result array             -> (ix -> ix') -- ^ A function that maps indices of the new array into the source one.             -> Array r' ix' e -- ^ Source array.             -> Array D ix e@@ -373,7 +373,7 @@ -- | Create an array by traversing a source array. traverse   :: (Source r1 ix1 e1, Index ix)-  => ix -- ^ Size of the result array+  => Sz ix -- ^ Size of the result array   -> ((ix1 -> e1) -> ix -> e) -- ^ Function that will receive a source array safe index function and                               -- an index for an element it should return a value of.   -> Array r1 ix1 e1 -- ^ Source array@@ -385,7 +385,7 @@ -- | Create an array by traversing two source arrays. traverse2   :: (Source r1 ix1 e1, Source r2 ix2 e2, Index ix)-  => ix+  => Sz ix   -> ((ix1 -> e1) -> (ix2 -> e2) -> ix -> e)   -> Array r1 ix1 e1   -> Array r2 ix2 e2

@@ -96,7 +96,7 @@ makeStencilDef   :: Index ix   => e-  -> ix -- ^ Size of the stencil+  -> Sz ix -- ^ Size of the stencil   -> ix -- ^ Center of the stencil   -> ((ix -> Value e) -> Value a)   -- ^ Stencil function.

@@ -36,7 +36,7 @@ -- makeConvolutionStencil   :: (Index ix, Num e)-  => ix+  => Sz ix   -> ix   -> ((ix -> Value e -> Value e -> Value e) -> Value e -> Value e)   -> Stencil ix e e@@ -71,7 +71,7 @@ -- | Make a <https://en.wikipedia.org/wiki/Cross-correlation cross-correlation> stencil. makeCorrelationStencil   :: (Index ix, Num e)-  => ix+  => Sz ix   -> ix   -> ((ix -> Value e -> Value e -> Value e) -> Value e -> Value e)   -> Stencil ix e e

@@ -135,28 +135,31 @@ instance Functor (Stencil ix e) where   fmap = rmapStencil   {-# INLINE fmap #-}-  --  f stencil@(Stencil {stencilFunc = g}) = stencil {stencilFunc = stF}-  --   where-  --     stF s = Value . f . unValue . g s-  --     {-# INLINE stF #-} + -- Profunctor  -dimapStencil :: (t -> e) -> (b -> a) -> Stencil ix e b -> Stencil ix t a-dimapStencil f g stencil@(Stencil {stencilFunc = sf}) =-  stencil {stencilFunc = \s -> Value . g . unValue . sf (Value . f . unValue . s)}+dimapStencil :: (c -> d) -> (a -> b) -> Stencil ix d a -> Stencil ix c b+dimapStencil f g stencil@(Stencil {stencilFunc = sf}) = stencil {stencilFunc = sf'}+  where+    sf' s = Value . g . unValue . sf (Value . f . unValue . s)+    {-# INLINE sf' #-} {-# INLINE dimapStencil #-}  -lmapStencil :: (b -> e) -> Stencil ix e a -> Stencil ix b a-lmapStencil f stencil@(Stencil {stencilFunc = sf}) =-  stencil {stencilFunc = \s -> sf (Value . f . unValue . s)}+lmapStencil :: (c -> d) -> Stencil ix d a -> Stencil ix c a+lmapStencil f stencil@(Stencil {stencilFunc = sf}) = stencil {stencilFunc = sf'}+  where+    sf' s = sf (Value . f . unValue . s)+    {-# INLINE sf' #-} {-# INLINE lmapStencil #-}  rmapStencil :: (a -> b) -> Stencil ix e a -> Stencil ix e b-rmapStencil g stencil@(Stencil {stencilFunc = sf}) =-  stencil {stencilFunc = \s -> Value . g . unValue . sf s}+rmapStencil f stencil@(Stencil {stencilFunc = sf}) = stencil {stencilFunc = sf'}+  where+    sf' s = Value . f . unValue . sf s+    {-# INLINE sf' #-} {-# INLINE rmapStencil #-}  -- TODO: Figure out interchange law (u <*> pure y = pure ($ y) <*> u) and issue

@@ -30,7 +30,7 @@ forStencilUnsafe ::      (Source r ix e, Manifest r ix e)   => Array r ix e-  -> ix -- ^ Size of the stencil+  -> Sz ix -- ^ Size of the stencil   -> ix -- ^ Center of the stencil   -> ((ix -> Maybe e) -> a)   -- ^ Stencil function that receives a "get" function as it's argument that can

@@ -50,7 +50,7 @@   unsafeBackpermute :: (Source r' ix' e, Index ix) =>-                     ix -> (ix -> ix') -> Array r' ix' e -> Array D ix e+                     Sz ix -> (ix -> ix') -> Array r' ix' e -> Array D ix e unsafeBackpermute !sz ixF !arr =   unsafeMakeArray (getComp arr) sz $ \ !ix -> unsafeIndex arr (ixF ix) {-# INLINE unsafeBackpermute #-}@@ -58,7 +58,7 @@  unsafeTraverse   :: (Source r1 ix1 e1, Index ix)-  => ix+  => Sz ix   -> ((ix1 -> e1) -> ix -> e)   -> Array r1 ix1 e1   -> Array D ix e@@ -69,7 +69,7 @@  unsafeTraverse2   :: (Source r1 ix1 e1, Source r2 ix2 e2, Index ix)-  => ix+  => Sz ix   -> ((ix1 -> e1) -> (ix2 -> e2) -> ix -> e)   -> Array r1 ix1 e1   -> Array r2 ix2 e2@@ -93,7 +93,7 @@   -- | Create an array sequentially using mutable interface-unsafeGenerateArray :: Mutable r ix e => ix -> (ix -> e) -> Array r ix e+unsafeGenerateArray :: Mutable r ix e => Sz ix -> (ix -> e) -> Array r ix e unsafeGenerateArray !sz f = runST $ do   marr <- unsafeNew sz   iterLinearM_ sz 0 (totalElem sz) 1 (<) $ \ !k !ix ->@@ -101,11 +101,10 @@   unsafeFreeze Seq marr {-# INLINE unsafeGenerateArray #-} - -- | Create an array in parallel using mutable interface -- -- @since 0.1.5-unsafeGenerateArrayP :: Mutable r ix e => [Int] -> ix -> (ix -> e) -> Array r ix e+unsafeGenerateArrayP :: Mutable r ix e => [Int] -> Sz ix -> (ix -> e) -> Array r ix e unsafeGenerateArrayP wIds !sz f = unsafePerformIO $ do   marr <- unsafeNew sz   divideWork_ wIds sz $ \ !scheduler !chunkLength !totalLength !slackStart -> do

@@ -87,7 +87,7 @@   setComp :: Comp -> Array r ix e -> Array r ix e    -- | Construct an array. No size validation is performed.-  unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array r ix e+  unsafeMakeArray :: Comp -> Sz ix -> (ix -> e) -> Array r ix e   -- | An array that contains size information. They can be resized and new arrays extracted from it@@ -95,14 +95,14 @@ class Construct r ix e => Size r ix e where    -- | /O(1)/ - Get the size of an array-  size :: Array r ix e -> ix+  size :: Array r ix e -> Sz ix    -- | /O(1)/ - Change the size of an array. New size is not validated.-  unsafeResize :: Index ix' => ix' -> Array r ix e -> Array r ix' e+  unsafeResize :: Index ix' => Sz ix' -> Array r ix e -> Array r ix' e    -- | /O(1)/ - Extract a portion of an array. Staring index and new size are   -- not validated.-  unsafeExtract :: ix -> ix -> Array r ix e -> Array (EltRepr r ix) ix e+  unsafeExtract :: ix -> Sz ix -> Array r ix e -> Array (EltRepr r ix) ix e   -- | Arrays that can be used as source to practically any manipulation function.@@ -157,7 +157,7 @@     -> (m () -> m ()) -- ^ A monadic action that will schedule work for the workers (for `Seq` it's                       -- always `id`)     -> Stride ix -- ^ Stride to use-    -> ix -- ^ Size of the target array affected by the stride.+    -> Sz ix -- ^ Size of the target array affected by the stride.     -> Array r ix e -- ^ Array that is being loaded     -> (Int -> m e) -- ^ Function that reads an element from target array     -> (Int -> e -> m ()) -- ^ Function that writes an element into target array@@ -167,7 +167,7 @@        Int     -> (m () -> m ())     -> Stride ix-    -> ix+    -> Sz ix     -> Array r ix e     -> (Int -> m e)     -> (Int -> e -> m ())@@ -215,10 +215,10 @@   outerLength = headDim . size  class Size r ix e => InnerSlice r ix e where-  unsafeInnerSlice :: Array r ix e -> (Lower ix, Int) -> Int -> Elt r ix e+  unsafeInnerSlice :: Array r ix e -> (Sz (Lower ix), Sz1) -> Int -> Elt r ix e  class Size r ix e => Slice r ix e where-  unsafeSlice :: Array r ix e -> ix -> ix -> Dim -> Maybe (Elt r ix e)+  unsafeSlice :: Array r ix e -> ix -> Sz ix -> Dim -> Maybe (Elt r ix e)   -- | Manifest arrays are backed by actual memory and values are looked up versus@@ -238,7 +238,7 @@   data MArray s r ix e :: *    -- | Get the size of a mutable array.-  msize :: MArray s r ix e -> ix+  msize :: MArray s r ix e -> Sz ix    unsafeThaw :: PrimMonad m =>                 Array r ix e -> m (MArray (PrimState m) r ix e)@@ -249,12 +249,12 @@   -- | Create new mutable array, leaving it's elements uninitialized. Size isn't validated   -- either.   unsafeNew :: PrimMonad m =>-               ix -> m (MArray (PrimState m) r ix e)+               Sz ix -> m (MArray (PrimState m) r ix e)    -- | Create new mutable array, leaving it's elements uninitialized. Size isn't validated   -- either.   unsafeNewZero :: PrimMonad m =>-                   ix -> m (MArray (PrimState m) r ix e)+                   Sz ix -> m (MArray (PrimState m) r ix e)    unsafeLinearRead :: PrimMonad m =>                       MArray (PrimState m) r ix e -> Int -> m e@@ -313,9 +313,9 @@    -- tail :: Array r ix e -> Maybe (Elt r ix e, Array r ix e) -  unsafeGenerateM :: Monad m => Comp -> ix -> (ix -> m e) -> m (Array r ix e)+  unsafeGenerateM :: Monad m => Comp -> Sz ix -> (ix -> m e) -> m (Array r ix e) -  edgeSize :: Array r ix e -> ix+  edgeSize :: Array r ix e -> Sz ix    flatten :: Array r ix e -> Array r Ix1 e @@ -331,7 +331,7 @@ -- | Create an Array. Resulting type either has to be unambiguously inferred or restricted manually, -- like in the example below. ----- >>> makeArray Seq (3 :. 4) (\ (i :. j) -> if i == j then i else 0) :: Array D Ix2 Int+-- >>> makeArray Seq (Sz (3 :. 4)) (\ (i :. j) -> if i == j then i else 0) :: Array D Ix2 Int -- (Array D Seq (3 :. 4) -- [ [ 0,0,0,0 ] -- , [ 0,1,0,0 ]@@ -340,7 +340,7 @@ -- makeArray :: Construct r ix e =>              Comp -- ^ Computation strategy. Useful constructors are `Seq` and `Par`-          -> ix -- ^ Size of the result array. Negative values will result in an empty array.+          -> Sz ix -- ^ Size of the result array. Negative values will result in an empty array.           -> (ix -> e) -- ^ Function to generate elements at a particular index           -> Array r ix e makeArray !c = unsafeMakeArray c . liftIndex (max 0)

@@ -55,7 +55,6 @@ import           Data.Massiv.Core.Iterator import           GHC.TypeLits - -- | Approach to be used near the borders during various transformations. -- Whenever a function needs information not only about an element of interest, but -- also about it's neighbors, it will go out of bounds near the array edges,@@ -111,7 +110,7 @@ handleBorderIndex ::      Index ix   => Border e -- ^ Broder resolution technique-  -> ix -- ^ Size+  -> Sz ix -- ^ Size   -> (ix -> e) -- ^ Index function that produces an element   -> ix -- ^ Index   -> e@@ -132,13 +131,15 @@ {-# INLINE [1] zeroIndex #-}  -- | Checks whether the size is valid.-isSafeSize :: Index ix => ix -> Bool+--+-- __Note__ Will be removed in /massiv-0.3.0/+isSafeSize :: Index ix => Sz ix -> Bool isSafeSize = (zeroIndex >=) {-# INLINE [1] isSafeSize #-}   -- | Checks whether array with this size can hold at least one element.-isNonEmpty :: Index ix => ix -> Bool+isNonEmpty :: Index ix => Sz ix -> Bool isNonEmpty !sz = isSafeIndex sz zeroIndex {-# INLINE [1] isNonEmpty #-} @@ -264,7 +265,7 @@ -- | Iterate over N-dimensional space lenarly from start to end in row-major fashion with an -- accumulator iterLinearM :: (Index ix, Monad m)-            => ix -- ^ Size+            => Sz ix -- ^ Size             -> Int -- ^ Linear start             -> Int -- ^ Linear end             -> Int -- ^ Increment@@ -278,7 +279,7 @@  -- | Same as `iterLinearM`, except without an accumulator. iterLinearM_ :: (Index ix, Monad m) =>-                ix -- ^ Size+                Sz ix -- ^ Size              -> Int -- ^ Start              -> Int -- ^ End              -> Int -- ^ Increment

@@ -7,6 +7,7 @@ {-# LANGUAGE GADTs                      #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE MultiParamTypeClasses      #-}+{-# LANGUAGE PatternSynonyms            #-} {-# LANGUAGE TypeFamilies               #-} {-# LANGUAGE TypeOperators              #-} -- |@@ -24,6 +25,19 @@ import           Data.Massiv.Core.Iterator import           GHC.TypeLits ++-- | Helpful type synonym for migrating to newer version @0.3@+type Sz ix = ix++-- | Helpful pattern synonym for migrating to newer version @0.3@+pattern Sz :: ix -> Sz ix+pattern Sz ix = ix++type Sz1 = Sz Int+pattern Sz1 :: Int -> Int+pattern Sz1 ix = ix++ -- | A way to select Array dimension at a value level. newtype Dim = Dim Int deriving (Show, Eq, Ord, Num, Real, Integral, Enum) @@ -79,7 +93,7 @@   dimensions :: ix -> Dim    -- | Total number of elements in an array of this size.-  totalElem :: ix -> Int+  totalElem :: Sz ix -> Int    -- | Prepend a dimension to the index   consDim :: Int -> Lower ix -> ix@@ -144,7 +158,7 @@   {-# INLINE [1] foldlIndex #-}    -- | Check whether index is within the size.-  isSafeIndex :: ix -- ^ Size+  isSafeIndex :: Sz ix -- ^ Size               -> ix -- ^ Index               -> Bool   default isSafeIndex :: Index (Lower ix) => ix -> ix -> Bool@@ -155,7 +169,7 @@   {-# INLINE [1] isSafeIndex #-}    -- | Convert linear index from size and index-  toLinearIndex :: ix -- ^ Size+  toLinearIndex :: Sz ix -- ^ Size                 -> ix -- ^ Index                 -> Int   default toLinearIndex :: Index (Lower ix) => ix -> ix -> Int@@ -174,16 +188,16 @@   {-# INLINE [1] toLinearIndexAcc #-}    -- | Compute an index from size and linear index-  fromLinearIndex :: ix -> Int -> ix-  default fromLinearIndex :: Index (Lower ix) => ix -> Int -> ix+  fromLinearIndex :: Sz ix -> Int -> ix+  default fromLinearIndex :: Index (Lower ix) => Sz ix -> Int -> ix   fromLinearIndex sz k = consDim q ixL     where !(q, ixL) = fromLinearIndexAcc (snd (unconsDim sz)) k   {-# INLINE [1] fromLinearIndex #-}    -- | Compute an index from size and linear index using an accumulator, thus trying to optimize for   -- tail recursion while getting the index computed.-  fromLinearIndexAcc :: ix -> Int -> (Int, ix)-  default fromLinearIndexAcc :: Index (Lower ix) => ix -> Int -> (Int, ix)+  fromLinearIndexAcc ::Sz  ix -> Int -> (Int, ix)+  default fromLinearIndexAcc :: Index (Lower ix) => Sz ix -> Int -> (Int, ix)   fromLinearIndexAcc ix' !k = (q, consDim r ixL)     where !(m, ix) = unconsDim ix'           !(kL, ixL) = fromLinearIndexAcc ix k@@ -192,13 +206,13 @@    -- | A way to make sure index is withing the bounds for the supplied size. Takes two functions   -- that will be invoked whenever index (2nd arg) is outsize the supplied size (1st arg)-  repairIndex :: ix -- ^ Size+  repairIndex :: Sz ix -- ^ Size               -> ix -- ^ Index               -> (Int -> Int -> Int) -- ^ Repair when below zero               -> (Int -> Int -> Int) -- ^ Repair when higher than size               -> ix   default repairIndex :: Index (Lower ix)-    => ix -> ix -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> ix+    => Sz ix -> ix -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> ix   repairIndex !sz !ix rBelow rOver =     consDim (repairIndex n i rBelow rOver) (repairIndex szL ixL rBelow rOver)     where !(n, szL) = unconsDim sz@@ -330,15 +344,15 @@   {-# INLINE [1] unsnocDim #-}   getIndex (i2,  _) 2 = Just i2   getIndex ( _, i1) 1 = Just i1-  getIndex _      _ = Nothing+  getIndex _      _   = Nothing   {-# INLINE [1] getIndex #-}   setIndex (_, i1) 2 i2 = Just (i2, i1)   setIndex (i2, _) 1 i1 = Just (i2, i1)-  setIndex _      _ _ = Nothing+  setIndex _      _ _   = Nothing   {-# INLINE [1] setIndex #-}   dropDim (_, i1) 2 = Just i1   dropDim (i2, _) 1 = Just i2-  dropDim _      _ = Nothing+  dropDim _      _  = Nothing   {-# INLINE [1] dropDim #-}   pullOutDim (i2, i1) 2 = Just (i2, i1)   pullOutDim (i2, i1) 1 = Just (i1, i2)@@ -376,22 +390,22 @@   setIndex ( _, i2, i1) 3 i3 = Just (i3, i2, i1)   setIndex (i3,  _, i1) 2 i2 = Just (i3, i2, i1)   setIndex (i3, i2,  _) 1 i1 = Just (i3, i2, i1)-  setIndex _      _ _    = Nothing+  setIndex _      _ _        = Nothing   {-# INLINE [1] setIndex #-}   dropDim ( _, i2, i1) 3 = Just (i2, i1)   dropDim (i3,  _, i1) 2 = Just (i3, i1)   dropDim (i3, i2,  _) 1 = Just (i3, i2)-  dropDim _      _    = Nothing+  dropDim _      _       = Nothing   {-# INLINE [1] dropDim #-}   pullOutDim (i3, i2, i1) 3 = Just (i3, (i2, i1))   pullOutDim (i3, i2, i1) 2 = Just (i2, (i3, i1))   pullOutDim (i3, i2, i1) 1 = Just (i1, (i3, i2))-  pullOutDim _      _    = Nothing+  pullOutDim _      _       = Nothing   {-# INLINE [1] pullOutDim #-}   insertDim (i2, i1) 3 i3 = Just (i3, i2, i1)   insertDim (i3, i1) 2 i2 = Just (i3, i2, i1)   insertDim (i3, i2) 1 i1 = Just (i3, i2, i1)-  insertDim _      _ _ = Nothing+  insertDim _      _ _    = Nothing   pureIndex i = (i, i, i)   {-# INLINE [1] pureIndex #-}   liftIndex2 f (i3, i2, i1) (i3', i2', i1') = (f i3 i3', f i2 i2', f i1 i1')@@ -504,7 +518,7 @@   {-# INLINE [1] liftIndex2 #-}  -- | Helper function for throwing out of bounds errors-errorIx :: (Show ix, Show ix') => String -> ix -> ix' -> a+errorIx :: (Show ix, Show ix') => String -> Sz ix -> ix' -> a errorIx fName sz ix =   error $   fName ++@@ -513,7 +527,7 @@   -- | Helper function for throwing error when sizes do not match-errorSizeMismatch :: (Show ix, Show ix') => String -> ix -> ix' -> a+errorSizeMismatch :: (Show ix, Show ix') => String -> Sz ix -> ix' -> a errorSizeMismatch fName sz sz' =   error $ fName ++ ": Mismatch in size of arrays " ++ show sz ++ " vs " ++ show sz' {-# NOINLINE errorSizeMismatch #-}

@@ -96,7 +96,7 @@ {-# INLINE strideStart #-}  -- | Adjust size according to the stride.-strideSize :: Index ix => Stride ix -> ix -> ix+strideSize :: Index ix => Stride ix -> Sz ix -> ix strideSize (SafeStride stride) sz = liftIndex (+ 1) $ liftIndex2 div (liftIndex (subtract 1) sz) stride {-# INLINE strideSize #-} 

@@ -239,7 +239,7 @@ unsafeGenerateParM ::      (Elt LN ix e ~ Array LN (Lower ix) e, Index ix, Monad m, Ragged L (Lower ix) e)   => [Int]-  -> ix+  -> Sz ix   -> (ix -> m e)   -> m (Array L ix e) unsafeGenerateParM wws !sz f = do@@ -323,7 +323,7 @@   , Ragged r (Lower ix) e   , Elt r ix e ~ Array r (Lower ix) e )   => Comp-  -> ix+  -> Sz ix   -> (ix -> e)   -> Array r ix e unsafeGenerateN Seq sz f = runIdentity $ unsafeGenerateM Seq sz (return . f)

@@ -1,3 +1,5 @@+{-# LANGUAGE ExplicitNamespaces #-}+{-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE FlexibleContexts    #-} {-# LANGUAGE FlexibleInstances   #-} {-# LANGUAGE GADTs               #-}@@ -7,7 +9,7 @@ module Data.Massiv.Core.IndexSpec (Sz(..), SzZ(..), SzIx(..), DimIx(..), spec) where  import           Control.Monad-import           Data.Massiv.Core.Index+import           Data.Massiv.Core.Index          hiding (type Sz, pattern Sz) import           Data.Functor.Identity import           Test.Hspec import           Test.QuickCheck

@@ -1,3 +1,5 @@+{-# LANGUAGE ExplicitNamespaces #-}+{-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE FlexibleContexts      #-} {-# LANGUAGE FlexibleInstances     #-} {-# LANGUAGE MultiParamTypeClasses #-}@@ -25,7 +27,7 @@  import           Control.DeepSeq            (NFData, deepseq) import           Control.Exception          (Exception, SomeException, catch)-import           Data.Massiv.Array+import           Data.Massiv.Array          hiding (type Sz, pattern Sz) import           Data.Massiv.Core.IndexSpec hiding (spec) import           Data.Typeable import           Test.QuickCheck