Create an Array with no elements. By itself it is not particularly useful, but it serves as a nice base for constructing larger arrays.

Examples

>>> import Data.Massiv.Array as A
>>> :set -XTypeApplications
>>> xs = empty @DL @Ix1 @Double
>>> snoc (cons 4 (cons 5 xs)) 22
Array DL Seq (Sz1 3)
  [ 4.0, 5.0, 22.0 ]

Since: 0.3.0

Create an Array with a single element.

Examples

>>> import Data.Massiv.Array as A
>>> singleton 7 :: Array D Ix4 Double
Array D Seq (Sz (1 :> 1 :> 1 :. 1))
  [ [ [ [ 7.0 ]
      ]
    ]
  ]

>>> :set -XTypeApplications
>>> singleton @U @Ix4 @Double 7
Array U Seq (Sz (1 :> 1 :> 1 :. 1))
  [ [ [ [ 7.0 ]
      ]
    ]
  ]

Since: 0.1.0

Construct an array of the specified size that contains the same element in all of the cells.

Since: 0.3.0

Construct an Array. Resulting type either has to be unambiguously inferred or restricted manually, like in the example below. Use "Data.Massiv.Array.makeArrayR" if you'd like to specify representation as an argument.

>>> import Data.Massiv.Array
>>> makeArray Seq (Sz (3 :. 4)) (\ (i :. j) -> if i == j then i else 0) :: Array D Ix2 Int
Array D Seq (Sz (3 :. 4))
  [ [ 0, 0, 0, 0 ]
  , [ 0, 1, 0, 0 ]
  , [ 0, 0, 2, 0 ]
  ]

Instead of restricting the full type manually we can use TypeApplications as convenience:

>>> :set -XTypeApplications
>>> makeArray @P @_ @Double Seq (Sz2 3 4) $ \(i :. j) -> logBase (fromIntegral i) (fromIntegral j)
Array P Seq (Sz (3 :. 4))
  [ [ NaN, -0.0, -0.0, -0.0 ]
  , [ -Infinity, NaN, Infinity, Infinity ]
  , [ -Infinity, 0.0, 1.0, 1.5849625007211563 ]
  ]

Since: 0.1.0

Same as makeArray, but produce elements using linear row-major index.

>>> import Data.Massiv.Array
>>> makeArrayLinear Seq (Sz (2 :. 4)) id :: Array D Ix2 Int
Array D Seq (Sz (2 :. 4))
  [ [ 0, 1, 2, 3 ]
  , [ 4, 5, 6, 7 ]
  ]

Since: 0.3.0

Just like makeArray but with ability to specify the result representation as an argument. Note the Unboxed type constructor in the below example.

Examples

>>> import Data.Massiv.Array
>>> makeArrayR U Par (Sz (2 :> 3 :. 4)) (\ (i :> j :. k) -> i * i + j * j == k * k)
Array U Par (Sz (2 :> 3 :. 4))
  [ [ [ True, False, False, False ]
    , [ False, True, False, False ]
    , [ False, False, True, False ]
    ]
  , [ [ False, True, False, False ]
    , [ False, False, False, False ]
    , [ False, False, False, False ]
    ]
  ]

Since: 0.1.0

Same as makeArrayLinear, but with ability to supply resulting representation

Since: 0.3.0

Same as makeArrayR, but restricted to 1-dimensional arrays.

Since: 0.1.0

Sequentially iterate over each cell in the array in the row-major order while continuously aplying the accumulator at each step.

Example

>>> import Data.Massiv.Array
>>> iterateN (Sz2 2 10) succ (10 :: Int)
Array DL Seq (Sz (2 :. 10))
  [ [ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]
  , [ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 ]
  ]

Since: 0.3.0

Same as iterateN, but with index aware function.

Since: 0.3.0

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 unfoldlPrimM to achieve such effect.

Since: 0.3.0

Unfold sequentially from the right with an index aware function.

Since: 0.3.0

Right unfold into a delayed load array. For the opposite direction use unfoldlS_.

Examples

>>> import Data.Massiv.Array
>>> unfoldrS_ (Sz1 10) (\xs -> (Prelude.head xs, Prelude.tail xs)) ([10 ..] :: [Int])
Array DL Seq (Sz1 10)
  [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 ]

Since: 0.3.0

Right unfold of a delayed load array with index aware function

Since: 0.3.0

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 Iterator. Upon parallelization every job will get the second part of the result produced by the split function, while the first part will be used for subsequent splits. This function is similar to generateSplitSeedArray

Since: 1.0.2

Generate a random array where all elements are sampled from a uniform distribution.

Since: 1.0.0

Same as uniformArray, but will generate values in a supplied range.

Since: 1.0.0

Create an array with random values by using a pure splittable random number generator such as one provided by either splitmix or random packages. If you don't have a splittable generator consider using randomArrayS or randomArrayWS instead.

Because of the pure nature of the generator and its splitability we are not only able to parallelize the random value generation, but also guarantee that it will be deterministic, granted none of the arguments have changed.

Note: Starting with massiv-1.1.0 this function will be deprecated in favor of a more general genSplitArray

Examples

>>> import Data.Massiv.Array
>>> import System.Random.SplitMix as SplitMix
>>> gen = SplitMix.mkSMGen 217
>>> randomArray gen SplitMix.splitSMGen SplitMix.nextDouble (ParN 2) (Sz2 2 3) :: Array DL Ix2 Double
Array DL (ParN 2) (Sz (2 :. 3))
  [ [ 0.7383156058619669, 0.39904053166835896, 0.5617584038393628 ]
  , [ 0.7218718218678238, 0.7006722805067258, 0.7225894731396042 ]
  ]

>>> import Data.Massiv.Array
>>> import System.Random as Random
>>> gen = Random.mkStdGen 217
>>> randomArray gen Random.split Random.random (ParN 2) (Sz2 2 3) :: Array DL Ix2 Double
Array DL (ParN 2) (Sz (2 :. 3))
  [ [ 0.2616843941380331, 0.600959468331641, 0.4382415961606372 ]
  , [ 0.27812817813217605, 0.2993277194932741, 0.2774105268603957 ]
  ]

Since: 1.0.0

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.

Examples

>>> import Data.Massiv.Array
>>> import System.Random.SplitMix as SplitMix
>>> gen = SplitMix.mkSMGen 217
>>> snd $ randomArrayS gen (Sz2 2 3) SplitMix.nextDouble :: Array P Ix2 Double
Array P Seq (Sz (2 :. 3))
  [ [ 0.8878273949359751, 0.11290807610140963, 0.7383156058619669 ]
  , [ 0.39904053166835896, 0.5617584038393628, 0.16248374266020216 ]
  ]

>>> import Data.Massiv.Array
>>> import System.Random.Mersenne.Pure64 as MT
>>> gen = MT.pureMT 217
>>> snd $ randomArrayS gen (Sz2 2 3) MT.randomDouble :: Array P Ix2 Double
Array P Seq (Sz (2 :. 3))
  [ [ 0.5504018416543631, 0.22504666452851707, 0.4480480867867128 ]
  , [ 0.7139711572975297, 0.49401087853770953, 0.9397201599368645 ]
  ]

>>> import Data.Massiv.Array
>>> import System.Random as System
>>> gen = System.mkStdGen 217
>>> snd $ randomArrayS gen (Sz2 2 3) System.random :: Array P Ix2 Double
Array P Seq (Sz (2 :. 3))
  [ [ 0.11217260506402493, 0.8870919238985904, 0.2616843941380331 ]
  , [ 0.600959468331641, 0.4382415961606372, 0.8375162573397977 ]
  ]

Since: 0.3.4

This is a stateful approach of generating random values. If your generator is pure and splittable, it is better to use randomArray instead, which will give you a pure, deterministic and parallelizable generation of arrays. On the other hand, if your generator is not thread safe, which is most likely the case, instead of using some sort of global mutex, WorkerStates allows you to keep track of individual state per worker (thread), which fits parallelization of random value generation perfectly. All that needs to be done is generators need to be initialized once per worker and then they can be reused as many times as necessary.

Examples

>>> import Data.Massiv.Array as A
>>> import System.Random.MWC as MWC (initialize)
>>> import System.Random.Stateful (uniformRM)
>>> import Control.Scheduler (initWorkerStates, getWorkerId)
>>> :set -XTypeApplications
>>> gens <- initWorkerStates Par (MWC.initialize . A.toPrimitiveVector . A.singleton @P @Ix1 . fromIntegral . getWorkerId)
>>> randomArrayWS gens (Sz2 2 3) (uniformRM (0, 9)) :: IO (Matrix P Double)
Array P Par (Sz (2 :. 3))
  [ [ 8.999240522095299, 6.832223390653755, 3.065728078741671 ]
  , [ 7.242581103346686, 2.4565807301968623, 0.4514262066689775 ]
  ]
>>> randomArrayWS gens (Sz1 6) (uniformRM (0, 9)) :: IO (Vector P Int)
Array P Par (Sz1 6)
  [ 8, 8, 7, 1, 1, 2 ]

Since: 0.3.4

Similar to makeArray, but construct the array sequentially using an Applicative interface.

Note - using generateArray or generateArrayS will always be faster, althought not always possible.

Since: 0.2.6

Same as makeArrayA, but with ability to supply result array representation.

Since: 0.2.6

Same as makeArrayA, but with linear index.

Since: 0.4.5

Handy synonym for rangeInclusive Seq. Similar to .. for list.

>>> Ix1 4 ... 10
Array D Seq (Sz1 7)
  [ 4, 5, 6, 7, 8, 9, 10 ]

Since: 0.3.0

Handy synonym for range Seq

>>> Ix1 4 ..: 10
Array D Seq (Sz1 6)
  [ 4, 5, 6, 7, 8, 9 ]

Since: 0.3.0

Create an array of indices with a range from start to finish (not-including), where indices are incremeted by one.

Examples

>>> import Data.Massiv.Array
>>> range Seq (Ix1 1) 6
Array D Seq (Sz1 5)
  [ 1, 2, 3, 4, 5 ]
>>> fromIx2 <$> range Seq (-1) (2 :. 2)
Array D Seq (Sz (3 :. 3))
  [ [ (-1,-1), (-1,0), (-1,1) ]
  , [ (0,-1), (0,0), (0,1) ]
  , [ (1,-1), (1,0), (1,1) ]
  ]

Since: 0.1.0

Same as range, but with a custom step.

Throws Exceptions: IndexZeroException

Examples

>>> import Data.Massiv.Array
>>> rangeStepM Seq (Ix1 1) 2 8
Array D Seq (Sz1 4)
  [ 1, 3, 5, 7 ]
>>> rangeStepM Seq (Ix1 1) 0 8
*** Exception: IndexZeroException: 0

Since: 0.3.0

Same as rangeStepM, but will throw an error whenever step contains zeros.

Example

>>> import Data.Massiv.Array
>>> rangeStep' Seq (Ix1 1) 2 6
Array D Seq (Sz1 3)
  [ 1, 3, 5 ]

Since: 0.3.0

Just like range, except the finish index is included.

Since: 0.3.0

Just like rangeStepM, except the finish index is included.

Since: 0.3.0

Just like range, except the finish index is included.

Since: 0.3.1

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

Same as rangeSize, but with ability to specify the step.

Since: 0.3.0

Same as enumFromStepN with step dx = 1.

Related: senumFromN, senumFromStepN, enumFromStepN, rangeSize, rangeStepSize, range

Examples

>>> import Data.Massiv.Array
>>> enumFromN Seq (5 :: Double) 3
Array D Seq (Sz1 3)
  [ 5.0, 6.0, 7.0 ]

Since: 0.1.0

Enumerate from a starting number x exactly n times with a custom step value dx. Unlike senumFromStepN, there is no dependency on neigboring elements therefore enumFromStepN is parallelizable.

Related: senumFromN, senumFromStepN, enumFromN, rangeSize, rangeStepSize, range, rangeStepM

Examples

>>> import Data.Massiv.Array
>>> enumFromStepN Seq 1 (0.1 :: Double) 5
Array D Seq (Sz1 5)
  [ 1.0, 1.1, 1.2, 1.3, 1.4 ]
>>> enumFromStepN Seq (-pi :: Float) (pi/4) 9
Array D Seq (Sz1 9)
  [ -3.1415927, -2.3561945, -1.5707964, -0.78539824, 0.0, 0.78539824, 1.5707963, 2.3561947, 3.1415927 ]

Since: 0.1.0

Function that expands an array to one with a higher dimension.

This is useful for constructing arrays where there is shared computation between multiple cells. The makeArray method of constructing arrays:

makeArray :: Construct r ix e => Comp -> ix -> (ix -> e) -> Array r ix e

...runs a function ix -> e at every array index. This is inefficient if there is a substantial amount of repeated computation that could be shared while constructing elements on the same dimension. The expand functions make this possible. First you construct an Array r (Lower ix) a of one fewer dimensions where a is something like Array r Ix1 a or Array r Ix2 a. Then you use expandWithin and a creation function a -> Int -> b to create an Array D Ix2 b or Array D Ix3 b respectfully.

Examples

>>> import Data.Massiv.Array
>>> a = makeArrayR U Seq (Sz1 6) (+10) -- Imagine (+10) is some expensive function
>>> a
Array U Seq (Sz1 6)
  [ 10, 11, 12, 13, 14, 15 ]
>>> expandWithin Dim1 5 (\ e j -> (j + 1) * 100 + e) a :: Array D Ix2 Int
Array D Seq (Sz (6 :. 5))
  [ [ 110, 210, 310, 410, 510 ]
  , [ 111, 211, 311, 411, 511 ]
  , [ 112, 212, 312, 412, 512 ]
  , [ 113, 213, 313, 413, 513 ]
  , [ 114, 214, 314, 414, 514 ]
  , [ 115, 215, 315, 415, 515 ]
  ]
>>> expandWithin Dim2 5 (\ e j -> (j + 1) * 100 + e) a :: Array D Ix2 Int
Array D Seq (Sz (5 :. 6))
  [ [ 110, 111, 112, 113, 114, 115 ]
  , [ 210, 211, 212, 213, 214, 215 ]
  , [ 310, 311, 312, 313, 314, 315 ]
  , [ 410, 411, 412, 413, 414, 415 ]
  , [ 510, 511, 512, 513, 514, 515 ]
  ]

Since: 0.2.6

Similar to expandWithin, except that dimension is specified at a value level, which means it will throw an exception on an invalid dimension.

Since: 0.4.0

Similar to expandWithin, except that dimension is specified at a value level, which means it will throw an exception on an invalid dimension.

Since: 0.2.6

Similar to expandWithin, except it uses the outermost dimension.

Since: 0.2.6

Similar to expandWithin, except it uses the innermost dimension.

Since: 0.2.6

Get computation strategy of this array

Since: 0.1.0

Set computation strategy for this array

Example

>>> :set -XTypeApplications
>>> import Data.Massiv.Array
>>> a = singleton @DL @Ix1 @Int 0
>>> a
Array DL Seq (Sz1 1)
  [ 0 ]
>>> setComp (ParN 6) a -- use 6 capabilities
Array DL (ParN 6) (Sz1 1)
  [ 0 ]

Append computation strategy using Comp's Monoid instance.

Since: 0.6.0

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 array sequentially disregarding predefined computation strategy. Very much the same as computePrimM, but executed in ST, thus pure.

Since: 0.1.0

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

Very similar to compute, but computes an array inside the IO monad. Despite being deterministic and referentially transparent, because this is an IO action it can be very useful for enforcing the order of evaluation. Should be a prefered way of computing an array during benchmarking.

Since: 0.4.5

Compute an array in PrimMonad sequentially disregarding predefined computation strategy.

Since: 0.4.5

Just as compute, but let's you supply resulting representation type as an argument.

Examples

>>> import Data.Massiv.Array
>>> computeAs P $ range Seq (Ix1 0) 10
Array P Seq (Sz1 10)
  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Same as compute and computeAs, but let's you supply resulting representation type as a proxy argument.

Examples

>>> import Data.Proxy
>>> import Data.Massiv.Array
>>> computeProxy (Proxy :: Proxy P) $ (^ (2 :: Int)) <$> range Seq (Ix1 0) 10
Array P Seq (Sz1 10)
  [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 ]

Since: 0.1.1

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

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

Same as computeWithStride, but with ability to specify resulting array representation.

Since: 0.3.0

O(n) - Make an exact immutable copy of an Array.

Since: 0.1.0

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

Same as convert, but let's you supply resulting representation type as an argument.

Since: 0.1.0

Same as convert and convertAs, but let's you supply resulting representation type as a proxy argument.

Since: 0.1.1

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

Same as fromRaggedArrayM, but will throw an impure exception if its shape is not rectangular.

Since: 0.1.1

O(1) - Get the exact size of an immutabe array. Most of the time will produce the size in constant time, except for DS representation, which could result in evaluation of the whole stream. See maxLinearSize and slength for more info.

Since: 0.1.0

O(1) - Get the number of elements in the array.

Examples

>>> import Data.Massiv.Array
>>> elemsCount $ range Seq (Ix1 10) 15
5

Since: 0.1.0

O(1) - Check if array has elements.

Examples

>>> import Data.Massiv.Array
>>> isEmpty (singleton 1 :: Array D Ix2 Int)
False
>>> isEmpty (empty :: Array D Ix2 Int)
True

Since: 1.0.0

O(1) - Check if array has elements.

Examples

>>> import Data.Massiv.Array
>>> isNotEmpty (singleton 1 :: Array D Ix2 Int)
True
>>> isNotEmpty (empty :: Array D Ix2 Int)
False

Since: 1.0.0

O(1) - Check whether an array is empty or not.

Examples

>>> import Data.Massiv.Array
>>> isNull $ range Seq (Ix2 10 20) (11 :. 21)
False
>>> isNull $ range Seq (Ix2 10 20) (10 :. 21)
True
>>> isNull (empty :: Array D Ix5 Int)
True
>>> isNull $ sfromList []
True

Since: 1.0.0

O(1) - Check if array has elements.

Examples

>>> import Data.Massiv.Array
>>> isNotNull (singleton 1 :: Array D Ix2 Int)
True
>>> isNotNull (empty :: Array D Ix2 Int)
False

Since: 0.5.1

O(1) - Infix version of indexM.

Exceptions: IndexOutOfBoundsException

Examples

>>> import Data.Massiv.Array as A
>>> :set -XTypeApplications
>>> a <- fromListsM @U @Ix2 @Int Seq [[1,2,3],[4,5,6]]
>>> a
Array U Seq (Sz (2 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  ]
>>> a !? 0 :. 2
3
>>> a !? 0 :. 3
*** Exception: IndexOutOfBoundsException: (0 :. 3) is not safe for (Sz (2 :. 3))
>>> a !? 0 :. 3 :: Maybe Int
Nothing

Since: 0.1.0

O(1) - Infix version of index'.

Examples

>>> import Data.Massiv.Array as A
>>> a = computeAs U $ iterateN (Sz (2 :. 3)) succ (0 :: Int)
>>> a
Array U Seq (Sz (2 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  ]
>>> a ! 0 :. 2
3

Since: 0.1.0

O(1) - Lookup an element in the array, where array itself is wrapped with MonadThrow. This operator is useful when used together with slicing or other functions that can fail.

Exceptions: IndexOutOfBoundsException

Examples

>>> import Data.Massiv.Array as A
>>> :set -XTypeApplications
>>> ma = fromListsM @U @Ix3 @Int @Maybe Seq [[[1,2,3]],[[4,5,6]]]
>>> ma
Just (Array U Seq (Sz (2 :> 1 :. 3))
  [ [ [ 1, 2, 3 ]
    ]
  , [ [ 4, 5, 6 ]
    ]
  ]
)
>>> ma ??> 1
Just (Array U Seq (Sz (1 :. 3))
  [ [ 4, 5, 6 ]
  ]
)
>>> ma ??> 1 ?? 0 :. 2
Just 6
>>> ma ?? 1 :> 0 :. 2
Just 6

Since: 0.1.0

O(1) - Lookup an element in the array.

Exceptions: IndexOutOfBoundsException

Since: 0.3.0

O(1) - Lookup an element in the array. Returns Nothing, when index is out of bounds and returns the element at the supplied index otherwise. Use indexM instead, since it is more general and it can just as well be used with Maybe.

Since: 0.1.0

O(1) - Lookup an element in the array. This is a partial function and it will throw an error when index is out of bounds. It is safer to use indexM instead.

Examples

>>> import Data.Massiv.Array
>>> :set -XOverloadedLists
>>> xs = [0..100] :: Array U Ix1 Int
>>> index' xs 50
50

Since: 0.1.0

O(1) - Lookup an element in the array, while using default element when index is out of bounds.

Examples

>>> import Data.Massiv.Array
>>> :set -XOverloadedLists
>>> xs = [0..100] :: Array P Ix1 Int
>>> defaultIndex 999 xs 100
100
>>> defaultIndex 999 xs 101
999

Since: 0.1.0

O(1) - Lookup an element in the array. Use a border resolution technique when index is out of bounds.

Examples

>>> import Data.Massiv.Array as A
>>> :set -XOverloadedLists
>>> xs = [0..100] :: Array U Ix1 Int
>>> borderIndex Wrap xs <$> range Seq 99 104
Array D Seq (Sz1 5)
  [ 99, 100, 0, 1, 2 ]

Since: 0.1.0

This is just like indexM function, but it allows getting values from delayed arrays as well as Manifest. As the name suggests, indexing into a delayed array at the same index multiple times will cause evaluation of the value each time and can destroy the performace if used without care.

Examples

>>> import Control.Exception
>>> import Data.Massiv.Array
>>> evaluateM (range Seq (Ix2 10 20) (100 :. 210)) 50 :: Either SomeException Ix2
Right (60 :. 70)
>>> evaluateM (range Seq (Ix2 10 20) (100 :. 210)) 150 :: Either SomeException Ix2
Left (IndexOutOfBoundsException: (150 :. 150) is not safe for (Sz (90 :. 190)))

Since: 0.3.0

Similar to evaluateM, but will throw an error on out of bounds indices.

Examples

>>> import Data.Massiv.Array
>>> evaluate' (range Seq (Ix2 10 20) (100 :. 210)) 50
60 :. 70

Since: 0.3.0

Map a function over an array

Since: 0.1.0

Map an index aware function over an array

Since: 0.1.0

Traverse with an Applicative action over an array sequentially.

Note - using traversePrim instead will always be significantly faster, roughly about 30 times faster in practice.

Since: 0.2.6

Traverse sequentially over a source array, while discarding the result.

Since: 0.3.0

Traverse with an Applicative index aware action over an array sequentially.

Since: 0.2.6

Traverse with an Applicative index aware action over an array sequentially.

Since: 0.2.6

Sequence actions in a source array.

Since: 0.3.0

Sequence actions in a source array, while discarding the result.

Since: 0.3.0

Traverse sequentially within PrimMonad over an array with an action.

Since: 0.3.0

Same as traversePrim, but traverse with index aware action.

Since: 0.3.0

Map a monadic action over an array sequentially.

Since: 0.2.6

Same as mapM except with arguments flipped.

Since: 0.2.6

Map an index aware monadic action over an array sequentially.

Since: 0.2.6

Same as forM, except with an index aware action.

Since: 0.5.1

Map a monadic function over an array sequentially, while discarding the result.

Examples

>>> import Data.Massiv.Array as A
>>> rangeStepM Par (Ix1 10) 12 60 >>= A.mapM_ print
10
22
34
46
58

Since: 0.1.0

Just like mapM_, except with flipped arguments.

Examples

>>> import Data.Massiv.Array as A
>>> import Data.IORef
>>> ref <- newIORef 0 :: IO (IORef Int)
>>> A.forM_ (range Seq (Ix1 0) 1000) $ \ i -> modifyIORef' ref (+i)
>>> readIORef ref
499500

Map a monadic index aware function over an array sequentially, while discarding the result.

Examples

>>> import Data.Massiv.Array
>>> imapM_ (curry print) $ range Seq (Ix1 10) 15
(0,10)
(1,11)
(2,12)
(3,13)
(4,14)

Since: 0.1.0

Just like imapM_, except with flipped arguments.

Map an IO action over an Array. Underlying computation strategy is respected and will be parallelized when requested. Unfortunately no fusion is possible and new array will be create upon each call.

Since: 0.2.6

Same as imapWS, but without the index.

Since: 0.3.4

Similar to mapIO, but ignores the result of mapping action and does not create a resulting array, therefore it is faster. Use this instead of mapIO when result is irrelevant. Most importantly it will follow the iteration logic outlined by the supplied array.

Since: 0.2.6

Same as mapIO but map an index aware action instead. Respects computation strategy.

Since: 0.2.6

Same as imapIO, but ignores the inner computation strategy and uses stateful workers during computation instead. Use initWorkerStates for the WorkerStates initialization.

Since: 0.3.4

Same as mapIO_, but map an index aware action instead.

Since: 0.2.6

Same as mapIO but with arguments flipped.

Since: 0.2.6

Same as iforWS, but without the index.

Since: 0.3.4

Same as mapIO_ but with arguments flipped.

Example

>>> import Data.Massiv.Array
>>> import Data.IORef
>>> ref <- newIORef 0 :: IO (IORef Int)
>>> forIO_ (range Par (Ix1 0) 1000) $ \ i -> atomicModifyIORef' ref (\v -> (v+i, ()))
>>> readIORef ref
499500

Since: 0.2.6

Same as imapIO but with arguments flipped.

Since: 0.2.6

Same as imapWS, but with source array and mapping action arguments flipped.

Since: 0.3.4

Same as imapIO_ but with arguments flipped.

Since: 0.2.6

Same as imapM_, but will use the supplied scheduler.

Since: 0.3.1

Same as imapM_, but will use the supplied scheduler.

Since: 0.3.1

Zip two arrays

Since: 0.1.0

Zip three arrays

Since: 0.1.0

Zip four arrays

Since: 0.5.4

Unzip two arrays

Since: 0.1.0

Unzip three arrays

Since: 0.1.0

Unzip four arrays

Since: 0.5.4

Zip two arrays with a function. Resulting array will be an intersection of source arrays in case their dimensions do not match.

Just like zipWith, except zip three arrays with a function.

Just like zipWith, except zip four arrays with a function.

Since: 0.5.4

Just like zipWith, except with an index aware function.

Just like zipWith3, except with an index aware function.

Just like zipWith4, except with an index aware function.

Since: 0.5.4

Similar to zipWith, except does it sequentially and using the Applicative. Note that resulting array has Manifest representation.

Since: 0.3.0

Similar to zipWith, except does it sequentially and using the Applicative. Note that resulting array has Manifest representation.

Since: 0.3.0

Same as zipWithA, but for three arrays.

Since: 0.3.0

Same as izipWithA, but for three arrays.

Since: 0.3.0

O(n) - Unstructured fold of an array.

Since: 0.3.0

O(n) - Monoidal fold over an array with an index aware function. Also known as reduce.

Since: 0.2.4

O(n) - This is exactly like foldMap, but for arrays. Fold over an array, while converting each element into a Monoid. Also known as map-reduce. If elements of the array are already a Monoid you can use fold instead.

Since: 0.1.4

O(n) - Semigroup fold over an array with an index aware function.

Since: 0.2.4

O(n) - Semigroup fold over an array.

Since: 0.1.6

Reduce each outer slice into a monoid and mappend results together

Example

>>> import Data.Massiv.Array as A
>>> import Data.Monoid (Product(..))
>>> arr = computeAs P $ iterateN (Sz2 2 3) (+1) (10 :: Int)
>>> arr
Array P Seq (Sz (2 :. 3))
  [ [ 11, 12, 13 ]
  , [ 14, 15, 16 ]
  ]
>>> getProduct $ foldOuterSlice (\row -> Product (A.sum row)) arr
1620
>>> (11 + 12 + 13) * (14 + 15 + 16) :: Int
1620

Since: 0.4.3

Reduce each outer slice into a monoid with an index aware function and mappend results together

Since: 0.4.3

Reduce each inner slice into a monoid and mappend results together

Example

>>> import Data.Massiv.Array as A
>>> import Data.Monoid (Product(..))
>>> arr = computeAs P $ iterateN (Sz2 2 3) (+1) (10 :: Int)
>>> arr
Array P Seq (Sz (2 :. 3))
  [ [ 11, 12, 13 ]
  , [ 14, 15, 16 ]
  ]
>>> getProduct $ foldInnerSlice (\column -> Product (A.sum column)) arr
19575
>>> (11 + 14) * (12 + 15) * (13 + 16) :: Int
19575

Since: 0.4.3

Reduce each inner slice into a monoid with an index aware function and mappend results together

Since: 0.4.3

O(n) - Compute minimum of all elements.

Since: 0.3.0

O(n) - Compute minimum of all elements.

Since: 0.3.0

O(n) - Compute maximum of all elements.

Since: 0.3.0

O(n) - Compute maximum of all elements.

Since: 0.3.0

O(n) - Compute sum of all elements.

Since: 0.1.0

O(n) - Compute product of all elements.

Since: 0.1.0

O(n) - Compute conjunction of all elements.

Since: 0.1.0

O(n) - Compute disjunction of all elements.

Since: 0.1.0

O(n) - Determines whether all elements of the array satisfy a predicate.

Since: 0.1.0

O(n) - Determines whether any element of the array satisfies a predicate.

Since: 0.1.0

O(n) - Determines whether an element is present in the array.

Since: 0.5.5

Compute array equality by applying a comparing function to each element. Empty arrays are always equal, regardless of their size.

Since: 0.5.7

Compute array ordering by applying a comparing function to each element. The exact ordering is unspecified so this is only intended for use in maps and the like where you need an ordering but do not care about which one is used.

Since: 0.5.7

Left fold over the inner most dimension with index aware function.

Since: 0.2.4

Left fold over the inner most dimension.

Since: 0.2.4

Right fold over the inner most dimension with index aware function.

Since: 0.2.4

Right fold over the inner most dimension.

Since: 0.2.4

Monoidal fold over the inner most dimension.

Since: 0.4.3

Left fold along a specified dimension with an index aware function.

Since: 0.2.4

Left fold along a specified dimension.

Example

>>> import Data.Massiv.Array
>>> :set -XTypeApplications
>>> arr = makeArrayLinear @U Seq (Sz (2 :. 5)) id
>>> arr
Array U Seq (Sz (2 :. 5))
  [ [ 0, 1, 2, 3, 4 ]
  , [ 5, 6, 7, 8, 9 ]
  ]
>>> foldlWithin Dim1 (flip (:)) [] arr
Array D Seq (Sz1 2)
  [ [4,3,2,1,0], [9,8,7,6,5] ]
>>> foldlWithin Dim2 (flip (:)) [] arr
Array D Seq (Sz1 5)
  [ [5,0], [6,1], [7,2], [8,3], [9,4] ]

Since: 0.2.4

Right fold along a specified dimension with an index aware function.

Since: 0.2.4

Right fold along a specified dimension.

Since: 0.2.4

Monoidal fold over some internal dimension.

Since: 0.4.3

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

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

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

Similar to foldrWithin, except that dimension is specified at a value level, which means it will throw an exception on an invalid dimension.

Since: 0.2.4

Monoidal fold over some internal dimension. This is a pratial function and will result in IndexDimensionException if supplied dimension is invalid.

Since: 0.4.3

O(n) - Left fold, computed sequentially.

Since: 0.1.0

O(n) - Right fold, computed sequentially.

Since: 0.1.0

O(n) - Left fold with an index aware function, computed sequentially.

Since: 0.1.0

O(n) - Right fold with an index aware function, computed sequentially.

Since: 0.1.0

O(n) - Monadic left fold.

Since: 0.1.0

O(n) - Monadic right fold.

Since: 0.1.0

O(n) - Monadic left fold, that discards the result.

Since: 0.1.0

O(n) - Monadic right fold, that discards the result.

Since: 0.1.0

O(n) - Monadic left fold with an index aware function.

Since: 0.1.0

O(n) - Monadic right fold with an index aware function.

Since: 0.1.0

O(n) - Monadic left fold with an index aware function, that discards the result.

Since: 0.1.0

O(n) - Monadic right fold with an index aware function, that discards the result.

Since: 0.1.0

Version of foldr that supports foldr/build list fusion implemented by GHC.

Since: 0.1.0

O(n) - Left fold, computed sequentially with lazy accumulator.

Since: 0.1.0

O(n) - Right fold, computed sequentially with lazy accumulator.

Since: 0.1.0

O(n) - Left fold, computed with respect of array's computation strategy. Because we do potentially split the folding among many threads, we also need a combining function and an accumulator for the results. Depending on the number of threads being used, results can be different, hence is the MonadIO constraint.

Examples

>>> import Data.Massiv.Array
>>> foldlP (flip (:)) [] (flip (:)) [] $ makeArrayR D Seq (Sz1 6) id
[[5,4,3,2,1,0]]
>>> foldlP (flip (:)) [] (++) [] $ makeArrayR D Seq (Sz1 6) id
[5,4,3,2,1,0]
>>> foldlP (flip (:)) [] (flip (:)) [] $ makeArrayR D (ParN 3) (Sz1 6) id
[[5,4],[3,2],[1,0]]
>>> foldlP (flip (:)) [] (++) [] $ makeArrayR D (ParN 3) (Sz1 6) id
[1,0,3,2,5,4]

Since: 0.1.0

O(n) - Right fold, computed with respect to computation strategy. Same as foldlP, except directed from the last element in the array towards beginning.

Examples

>>> import Data.Massiv.Array
>>> foldrP (:) [] (++) [] $ makeArrayR D (ParN 2) (Sz2 2 3) fromIx2
[(0,0),(0,1),(0,2),(1,0),(1,1),(1,2)]
>>> foldrP (:) [] (:) [] $ makeArrayR D Seq (Sz1 6) id
[[0,1,2,3,4,5]]
>>> foldrP (:) [] (:) [] $ makeArrayR D (ParN 3) (Sz1 6) id
[[0,1],[2,3],[4,5]]

Since: 0.1.0

O(n) - Left fold with an index aware function, computed in parallel. Just like foldlP, except that folding function will receive an index of an element it is being applied to.

Since: 0.1.0

O(n) - Right fold with an index aware function, while respecting the computation strategy. Same as ifoldlP, except directed from the last element in the array towards beginning, but also row-major.

Since: 0.1.0

Similar to ifoldlP, except that folding functions themselves do live in IO

Since: 0.1.0

Similar to ifoldrP, except that folding functions themselves do live in IO

Since: 0.1.0

Transpose a 2-dimensional array

Examples

>>> import Data.Massiv.Array
>>> arr = makeArrayLinearR D Seq (Sz (2 :. 3)) id
>>> arr
Array D Seq (Sz (2 :. 3))
  [ [ 0, 1, 2 ]
  , [ 3, 4, 5 ]
  ]
>>> transpose arr
Array D Seq (Sz (3 :. 2))
  [ [ 0, 3 ]
  , [ 1, 4 ]
  , [ 2, 5 ]
  ]

Since: 0.1.0

Transpose inner two dimensions of at least rank-2 array.

Examples

>>> import Data.Massiv.Array
>>> arr = makeArrayLinearR U Seq (Sz (2 :> 3 :. 4)) id
>>> arr
Array U Seq (Sz (2 :> 3 :. 4))
  [ [ [ 0, 1, 2, 3 ]
    , [ 4, 5, 6, 7 ]
    , [ 8, 9, 10, 11 ]
    ]
  , [ [ 12, 13, 14, 15 ]
    , [ 16, 17, 18, 19 ]
    , [ 20, 21, 22, 23 ]
    ]
  ]
>>> transposeInner arr
Array D Seq (Sz (3 :> 2 :. 4))
  [ [ [ 0, 1, 2, 3 ]
    , [ 12, 13, 14, 15 ]
    ]
  , [ [ 4, 5, 6, 7 ]
    , [ 16, 17, 18, 19 ]
    ]
  , [ [ 8, 9, 10, 11 ]
    , [ 20, 21, 22, 23 ]
    ]
  ]

Since: 0.1.0

Transpose outer two dimensions of at least rank-2 array.

Examples

>>> import Data.Massiv.Array
>>> :set -XTypeApplications
>>> arr = makeArrayLinear @U Seq (Sz (2 :> 3 :. 4)) id
>>> arr
Array U Seq (Sz (2 :> 3 :. 4))
  [ [ [ 0, 1, 2, 3 ]
    , [ 4, 5, 6, 7 ]
    , [ 8, 9, 10, 11 ]
    ]
  , [ [ 12, 13, 14, 15 ]
    , [ 16, 17, 18, 19 ]
    , [ 20, 21, 22, 23 ]
    ]
  ]
>>> transposeOuter arr
Array D Seq (Sz (2 :> 4 :. 3))
  [ [ [ 0, 4, 8 ]
    , [ 1, 5, 9 ]
    , [ 2, 6, 10 ]
    , [ 3, 7, 11 ]
    ]
  , [ [ 12, 16, 20 ]
    , [ 13, 17, 21 ]
    , [ 14, 18, 22 ]
    , [ 15, 19, 23 ]
    ]
  ]

Since: 0.1.0

Reverse an array along some dimension. Dimension supplied is checked at compile time.

Example

>>> import Data.Massiv.Array as A
>>> arr = makeArrayLinear Seq (Sz2 4 5) (+10) :: Array D Ix2 Int
>>> arr
Array D Seq (Sz (4 :. 5))
  [ [ 10, 11, 12, 13, 14 ]
  , [ 15, 16, 17, 18, 19 ]
  , [ 20, 21, 22, 23, 24 ]
  , [ 25, 26, 27, 28, 29 ]
  ]
>>> A.reverse Dim1 arr
Array D Seq (Sz (4 :. 5))
  [ [ 14, 13, 12, 11, 10 ]
  , [ 19, 18, 17, 16, 15 ]
  , [ 24, 23, 22, 21, 20 ]
  , [ 29, 28, 27, 26, 25 ]
  ]
>>> A.reverse Dim2 arr
Array D Seq (Sz (4 :. 5))
  [ [ 25, 26, 27, 28, 29 ]
  , [ 20, 21, 22, 23, 24 ]
  , [ 15, 16, 17, 18, 19 ]
  , [ 10, 11, 12, 13, 14 ]
  ]

Since: 0.4.1

Reverse an array along some dimension. Same as reverseM, but throws the IndexDimensionException from pure code.

Since: 0.4.1

Similarly to reverse, flip an array along a particular dimension, but throws IndexDimensionException for an incorrect dimension.

Since: 0.4.1

Rearrange elements of an array into a new one by using a function that maps indices of the newly created one into the old one. This function can throw IndexOutOfBoundsException.

Examples

>>> import Data.Massiv.Array
>>> :set -XTypeApplications
>>> arr = makeArrayLinear @D Seq (Sz (2 :> 3 :. 4)) id
>>> arr
Array D Seq (Sz (2 :> 3 :. 4))
  [ [ [ 0, 1, 2, 3 ]
    , [ 4, 5, 6, 7 ]
    , [ 8, 9, 10, 11 ]
    ]
  , [ [ 12, 13, 14, 15 ]
    , [ 16, 17, 18, 19 ]
    , [ 20, 21, 22, 23 ]
    ]
  ]
>>> backpermuteM @U (Sz (4 :. 2)) (\(i :. j) -> j :> j :. i) arr
Array U Seq (Sz (4 :. 2))
  [ [ 0, 16 ]
  , [ 1, 17 ]
  , [ 2, 18 ]
  , [ 3, 19 ]
  ]

Since: 0.3.0

Similar to backpermuteM, with a few notable differences:

• Creates a delayed array, instead of manifest, therefore it can be fused
• Respects computation strategy, so it can be parallelized
• Throws a runtime IndexOutOfBoundsException from pure code.

Since: 0.3.0

O(1) - Change the size of an array. Throws SizeElementsMismatchException if total number of elements does not match the supplied array.

Since: 0.3.0

Same as resizeM, but will throw an error if supplied dimensions are incorrect.

Since: 0.1.0

O(1) - Reduce a multi-dimensional array into a flat vector

Since: 0.3.1

Extract a sub-array from within a larger source array. Array that is being extracted must be fully encapsulated in a source array, otherwise SizeSubregionException will be thrown.

Examples

>>> import Data.Massiv.Array as A
>>> m <- resizeM (Sz (3 :. 3)) $ Ix1 1 ... 9
>>> m
Array D Seq (Sz (3 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  , [ 7, 8, 9 ]
  ]
>>> extractM (0 :. 1) (Sz (2 :. 2)) m
Array D Seq (Sz (2 :. 2))
  [ [ 2, 3 ]
  , [ 5, 6 ]
  ]
>>> a <- resizeM (Sz (3 :> 2 :. 4)) $ Ix1 11 ... 34
>>> a
Array D Seq (Sz (3 :> 2 :. 4))
  [ [ [ 11, 12, 13, 14 ]
    , [ 15, 16, 17, 18 ]
    ]
  , [ [ 19, 20, 21, 22 ]
    , [ 23, 24, 25, 26 ]
    ]
  , [ [ 27, 28, 29, 30 ]
    , [ 31, 32, 33, 34 ]
    ]
  ]
>>> extractM (0 :> 1 :. 1) (Sz (3 :> 1 :. 2)) a
Array D Seq (Sz (3 :> 1 :. 2))
  [ [ [ 16, 17 ]
    ]
  , [ [ 24, 25 ]
    ]
  , [ [ 32, 33 ]
    ]
  ]

Since: 0.3.0

Same as extractM, but will throw a runtime exception from pure code if supplied dimensions are incorrect.

Since: 0.1.0

Similar to extractM, except it takes starting and ending index. Result array will not include the ending index.

Examples

>>> a <- resizeM (Sz (3 :> 2 :. 4)) $ Ix1 11 ... 34
>>> a
Array D Seq (Sz (3 :> 2 :. 4))
  [ [ [ 11, 12, 13, 14 ]
    , [ 15, 16, 17, 18 ]
    ]
  , [ [ 19, 20, 21, 22 ]
    , [ 23, 24, 25, 26 ]
    ]
  , [ [ 27, 28, 29, 30 ]
    , [ 31, 32, 33, 34 ]
    ]
  ]
>>> extractFromToM (1 :> 0 :. 1) (3 :> 2 :. 4) a
Array D Seq (Sz (2 :> 2 :. 3))
  [ [ [ 20, 21, 22 ]
    , [ 24, 25, 26 ]
    ]
  , [ [ 28, 29, 30 ]
    , [ 32, 33, 34 ]
    ]
  ]

Since: 0.3.0

Same as extractFromToM, but throws an error on invalid indices.

Since: 0.2.4

Similar to deleteRegionM, but drop a specified number of rows from an array that has at least 2 dimensions.

Example

>>> import Data.Massiv.Array
>>> arr = fromIx2 <$> (0 :. 0 ..: 3 :. 6)
>>> arr
Array D Seq (Sz (3 :. 6))
  [ [ (0,0), (0,1), (0,2), (0,3), (0,4), (0,5) ]
  , [ (1,0), (1,1), (1,2), (1,3), (1,4), (1,5) ]
  , [ (2,0), (2,1), (2,2), (2,3), (2,4), (2,5) ]
  ]
>>> deleteRowsM 1 1 arr
Array DL Seq (Sz (2 :. 6))
  [ [ (0,0), (0,1), (0,2), (0,3), (0,4), (0,5) ]
  , [ (2,0), (2,1), (2,2), (2,3), (2,4), (2,5) ]
  ]

Since: 0.3.5

Similar to deleteRegionM, but drop a specified number of columns an array.

Example

>>> import Data.Massiv.Array
>>> arr = fromIx2 <$> (0 :. 0 ..: 3 :. 6)
>>> arr
Array D Seq (Sz (3 :. 6))
  [ [ (0,0), (0,1), (0,2), (0,3), (0,4), (0,5) ]
  , [ (1,0), (1,1), (1,2), (1,3), (1,4), (1,5) ]
  , [ (2,0), (2,1), (2,2), (2,3), (2,4), (2,5) ]
  ]
>>> deleteColumnsM 2 3 arr
Array DL Seq (Sz (3 :. 3))
  [ [ (0,0), (0,1), (0,5) ]
  , [ (1,0), (1,1), (1,5) ]
  , [ (2,0), (2,1), (2,5) ]
  ]

Since: 0.3.5

Delete a region from an array along the specified dimension.

Examples

>>> import Data.Massiv.Array
>>> arr = fromIx3 <$> (0 :> 0 :. 0 ..: 3 :> 2 :. 6)
>>> deleteRegionM 1 2 3 arr
Array DL Seq (Sz (3 :> 2 :. 3))
  [ [ [ (0,0,0), (0,0,1), (0,0,5) ]
    , [ (0,1,0), (0,1,1), (0,1,5) ]
    ]
  , [ [ (1,0,0), (1,0,1), (1,0,5) ]
    , [ (1,1,0), (1,1,1), (1,1,5) ]
    ]
  , [ [ (2,0,0), (2,0,1), (2,0,5) ]
    , [ (2,1,0), (2,1,1), (2,1,5) ]
    ]
  ]
>>> v = Ix1 0 ... 10
>>> deleteRegionM 1 3 5 v
Array DL Seq (Sz1 6)
  [ 0, 1, 2, 8, 9, 10 ]

Since: 0.3.5

Append two arrays together along the outer most dimension. Inner dimensions must agree, otherwise SizeMismatchException.

Since: 0.4.4

Append two arrays together along a particular dimension. Sizes of both arrays must match, with an allowed exception of the dimension they are being appended along, otherwise Nothing is returned.

Examples

>>> import Data.Massiv.Array
>>> arrA = makeArrayR U Seq (Sz2 2 3) (\(i :. j) -> ('A', i, j))
>>> arrB = makeArrayR U Seq (Sz2 2 3) (\(i :. j) -> ('B', i, j))
>>> appendM 1 arrA arrB
Array DL Seq (Sz (2 :. 6))
  [ [ ('A',0,0), ('A',0,1), ('A',0,2), ('B',0,0), ('B',0,1), ('B',0,2) ]
  , [ ('A',1,0), ('A',1,1), ('A',1,2), ('B',1,0), ('B',1,1), ('B',1,2) ]
  ]
>>> appendM 2 arrA arrB
Array DL Seq (Sz (4 :. 3))
  [ [ ('A',0,0), ('A',0,1), ('A',0,2) ]
  , [ ('A',1,0), ('A',1,1), ('A',1,2) ]
  , [ ('B',0,0), ('B',0,1), ('B',0,2) ]
  , [ ('B',1,0), ('B',1,1), ('B',1,2) ]
  ]

>>> arrC = makeArrayR U Seq (Sz (2 :. 4)) (\(i :. j) -> ('C', i, j))
>>> appendM 1 arrA arrC
Array DL Seq (Sz (2 :. 7))
  [ [ ('A',0,0), ('A',0,1), ('A',0,2), ('C',0,0), ('C',0,1), ('C',0,2), ('C',0,3) ]
  , [ ('A',1,0), ('A',1,1), ('A',1,2), ('C',1,0), ('C',1,1), ('C',1,2), ('C',1,3) ]
  ]
>>> appendM 2 arrA arrC
*** Exception: SizeMismatchException: (Sz (2 :. 3)) vs (Sz (2 :. 4))

Since: 0.3.0

Same as appendM, but will throw an exception in pure code on mismatched sizes.

Since: 0.3.0

Concat arrays together along the outer most dimension. Inner dimensions must agree for all arrays in the list, otherwise SizeMismatchException.

Since: 0.4.4

Concatenate many arrays together along some dimension. It is important that all sizes are equal, with an exception of the dimensions along which concatenation happens.

Exceptions: IndexDimensionException, SizeMismatchException

Since: 0.3.0

Concat many arrays together along some dimension.

Since: 0.3.0

Stack slices on top of each other along the specified dimension.

Exceptions: IndexDimensionException, SizeMismatchException

Examples

>>> import Data.Massiv.Array as A
>>> x = compute (iterateN 3 succ 0) :: Matrix P Int
>>> y = compute (iterateN 3 succ 9) :: Matrix P Int
>>> x
Array P Seq (Sz (3 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  , [ 7, 8, 9 ]
  ]
>>> y
Array P Seq (Sz (3 :. 3))
  [ [ 10, 11, 12 ]
  , [ 13, 14, 15 ]
  , [ 16, 17, 18 ]
  ]
>>> stackSlicesM 1 [x, y] :: IO (Array DL Ix3 Int)
Array DL Seq (Sz (3 :> 3 :. 2))
  [ [ [ 1, 10 ]
    , [ 2, 11 ]
    , [ 3, 12 ]
    ]
  , [ [ 4, 13 ]
    , [ 5, 14 ]
    , [ 6, 15 ]
    ]
  , [ [ 7, 16 ]
    , [ 8, 17 ]
    , [ 9, 18 ]
    ]
  ]
>>> stackSlicesM 2 [x, y] :: IO (Array DL Ix3 Int)
Array DL Seq (Sz (3 :> 2 :. 3))
  [ [ [ 1, 2, 3 ]
    , [ 10, 11, 12 ]
    ]
  , [ [ 4, 5, 6 ]
    , [ 13, 14, 15 ]
    ]
  , [ [ 7, 8, 9 ]
    , [ 16, 17, 18 ]
    ]
  ]
>>> stackSlicesM 3 [x, y] :: IO (Array DL Ix3 Int)
Array DL Seq (Sz (2 :> 3 :. 3))
  [ [ [ 1, 2, 3 ]
    , [ 4, 5, 6 ]
    , [ 7, 8, 9 ]
    ]
  , [ [ 10, 11, 12 ]
    , [ 13, 14, 15 ]
    , [ 16, 17, 18 ]
    ]
  ]

Since: 0.5.4

Specialized stackSlicesM to handling stacking from the outside. It is the inverse of outerSlices.

Exceptions: SizeMismatchException

Examples

>>> import Data.Massiv.Array as A
>>> x = compute (iterateN 3 succ 0) :: Matrix P Int
>>> x
Array P Seq (Sz (3 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  , [ 7, 8, 9 ]
  ]
>>> rows = outerSlices x
>>> A.mapM_ print rows
Array P Seq (Sz1 3)
  [ 1, 2, 3 ]
Array P Seq (Sz1 3)
  [ 4, 5, 6 ]
Array P Seq (Sz1 3)
  [ 7, 8, 9 ]
>>> stackOuterSlicesM rows :: IO (Matrix DL Int)
Array DL Seq (Sz (3 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  , [ 7, 8, 9 ]
  ]