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

Replicate the same element

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 achive 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 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.

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 System
>>> gen = System.mkStdGen 217
>>> randomArray gen System.split System.random (ParN 2) (Sz2 2 3) :: Array DL Ix2 Double
Array DL (ParN 2) (Sz (2 :. 3))
  [ [ 0.15191527341922206, 0.2045537167404079, 0.9635356052820256 ]
  , [ 9.308278528094238e-2, 0.7200934018606843, 0.23173694193083583 ]
  ]

Since: 0.3.3

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.7972230393466304, 0.4485860543300083, 0.257773196880671 ]
  , [ 0.19115043859955794, 0.33784788936970034, 3.479381605706322e-2 ]
  ]

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
λ> import System.Random.MWC (createSystemRandom, uniformR)
λ> import System.Random.MWC.Distributions (standard)
λ> gens <- initWorkerStates Par (\_ -> createSystemRandom)
λ> randomArrayWS gens (Sz2 2 3) standard :: IO (Array P Ix2 Double)
Array P Par (Sz (2 :. 3))
  [ [ -0.9066144845415213, 0.5264323240310042, -1.320943607597422 ]
  , [ -0.6837929005619592, -0.3041255565826211, 6.53353089112833e-2 ]
  ]
λ> randomArrayWS gens (Sz1 10) (uniformR (0, 9)) :: IO (Array P Ix1 Int)
Array P Par (Sz1 10)
  [ 3, 6, 1, 2, 1, 7, 6, 0, 8, 8 ]

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

>>> 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 rangeStep, 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 ]

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

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 numer of elements in the source array and k is number of elemts 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 a pure exception if its shape is not rectangular.

Since: 0.1.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 maxSize and slength for more info.

Since: 0.1.0

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

Note - It is always a constant time operation except for some arrays with DS representation. See slength for more info.

Examples

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

Since: 0.1.0

O(1) - Check if an array has no elements.

Examples

>>> import Data.Massiv.Array
>>> isEmpty $ range Seq (Ix2 10 20) (11 :. 21)
False
>>> isEmpty $ range Seq (Ix2 10 20) (10 :. 21)
True

Since: 0.1.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: 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
>>> a ! 0 :. 3
*** Exception: IndexOutOfBoundsException: (0 :. 3) is not safe for (Sz (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 M 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 can throw IndexOutOfBoundsException inside pure code. It is safer to use index instead.

Examples

>>> import Data.Massiv.Array
>>> :set -XOverloadedLists
>>> xs = [0..100] :: Array U Ix1 Int
>>> index' xs 50
50
>>> index' xs 150
*** Exception: IndexOutOfBoundsException: 150 is not safe for (Sz1 101)

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 exception in pure code.

Examples

>>> import Data.Massiv.Array
>>> evaluate' (range Seq (Ix2 10 20) (100 :. 210)) 50
60 :. 70
>>> evaluate' (range Seq (Ix2 10 20) (100 :. 210)) 150
*** Exception: IndexOutOfBoundsException: (150 :. 150) is not safe for (Sz (90 :. 190))

Since: 0.3.0

Map a function over an array

Map an index aware function over an array

Traverse with an Applicative action over an array sequentially.

Note - using traversePrim will always be faster, althought not always possible.

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.

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

Zip three arrays

Unzip two arrays

Unzip three arrays

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 with an index aware function.

Just like zipWith3, except with an index aware function.

Similar to zipWith, except dimensions of both arrays either have to be the same, or at least one of the two array must be a singleton array, in which case it will behave as a map.

Since: 0.1.4

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

Since: 0.3.0

Similar to zipWith, except does it sequentiall and using the Applicative. Note that resulting array has Mutable 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 element of the array satisfy the predicate.

Since: 0.1.0

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

Since: 0.1.0

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) - Changes the shape of an array. Returns Nothing if total number of elements does not match the source 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.

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.

Since: 0.3.0

Same as extractFromTo, 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

O(1) - Split an array into two at an index along a specified dimension.

Related: splitAt', splitExtractM, sliceAt', sliceAtM

Exceptions: IndexDimensionException, SizeSubregionException

Since: 0.3.0

O(1) - Split an array into two at an index along a specified dimension. Throws an error for a wrong dimension or incorrect indices.

Related: splitAtM, splitExtractM, sliceAt', sliceAtM

Examples

Since: 0.1.0

Split an array in three parts across some dimension

Since: 0.3.5

Insert the same element into a Loadable array according to the stride.

Since: 0.3.0

Discard elements from the source array according to the stride.

Since: 0.3.0

Increaze the size of the array accoridng to the stride multiplier while replicating the same element to fill the neighbors. It is exactly the same as zoomWithGrid, but without the grid.

Example

>>> import Data.Massiv.Array as A
>>> arr = resize' (Sz3 1 3 2) (Ix1 1 ... 6)
>>> arr
Array D Seq (Sz (1 :> 3 :. 2))
  [ [ [ 1, 2 ]
    , [ 3, 4 ]
    , [ 5, 6 ]
    ]
  ]
>>> zoom (Stride (2 :> 2 :. 3)) arr
Array DL Seq (Sz (2 :> 6 :. 6))
  [ [ [ 1, 1, 1, 2, 2, 2 ]
    , [ 1, 1, 1, 2, 2, 2 ]
    , [ 3, 3, 3, 4, 4, 4 ]
    , [ 3, 3, 3, 4, 4, 4 ]
    , [ 5, 5, 5, 6, 6, 6 ]
    , [ 5, 5, 5, 6, 6, 6 ]
    ]
  , [ [ 1, 1, 1, 2, 2, 2 ]
    , [ 1, 1, 1, 2, 2, 2 ]
    , [ 3, 3, 3, 4, 4, 4 ]
    , [ 3, 3, 3, 4, 4, 4 ]
    , [ 5, 5, 5, 6, 6, 6 ]
    , [ 5, 5, 5, 6, 6, 6 ]
    ]
  ]

Since: 0.4.4

Replicate each element of the array by a factor in stride along each dimension and surround each such group with a box of supplied grid value. It will essentially zoom up an array and create a grid around each element from the original array. Very useful for zooming up images to inspect individual pixels.

Example

>>> import Data.Massiv.Array as A
>>> arr = resize' (Sz2 3 2) (Ix1 1 ... 6)
>>> arr
Array D Seq (Sz (3 :. 2))
  [ [ 1, 2 ]
  , [ 3, 4 ]
  , [ 5, 6 ]
  ]
>>> zoomWithGrid 0 (Stride (2 :. 3)) arr
Array DL Seq (Sz (10 :. 9))
  [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 1, 1, 1, 0, 2, 2, 2, 0 ]
  , [ 0, 1, 1, 1, 0, 2, 2, 2, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 3, 3, 3, 0, 4, 4, 4, 0 ]
  , [ 0, 3, 3, 3, 0, 4, 4, 4, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 5, 5, 5, 0, 6, 6, 6, 0 ]
  , [ 0, 5, 5, 5, 0, 6, 6, 6, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
  ]

Since: 0.3.1

General array transformation, that forces computation and produces a manifest array.

Since: 0.3.0

General array transformation

Since: 0.3.0

Same as transformM, but operates on two arrays

Since: 0.3.0

Same as transform', but operates on two arrays

Since: 0.3.0

O(1) - Slices the array from the outside. For 2-dimensional array this will be equivalent of taking a row. Throws an error when index is out of bounds.

Examples

>>> import Data.Massiv.Array
>>> arr = makeArrayR U Seq (Sz (3 :> 2 :. 4)) fromIx3
>>> arr
Array U Seq (Sz (3 :> 2 :. 4))
  [ [ [ (0,0,0), (0,0,1), (0,0,2), (0,0,3) ]
    , [ (0,1,0), (0,1,1), (0,1,2), (0,1,3) ]
    ]
  , [ [ (1,0,0), (1,0,1), (1,0,2), (1,0,3) ]
    , [ (1,1,0), (1,1,1), (1,1,2), (1,1,3) ]
    ]
  , [ [ (2,0,0), (2,0,1), (2,0,2), (2,0,3) ]
    , [ (2,1,0), (2,1,1), (2,1,2), (2,1,3) ]
    ]
  ]
>>> arr !> 2
Array M Seq (Sz (2 :. 4))
  [ [ (2,0,0), (2,0,1), (2,0,2), (2,0,3) ]
  , [ (2,1,0), (2,1,1), (2,1,2), (2,1,3) ]
  ]

>>> arr !> 2 !> 0 !> 3
(2,0,3)
>>> arr !> 2 <! 3 ! 0
(2,0,3)
>>> (arr !> 2 !> 0 !> 3) == (arr ! 2 :> 0 :. 3)
True

Since: 0.1.0

O(1) - Just like !> slices the array from the outside, but returns Nothing when index is out of bounds.

Since: 0.1.0

O(1) - Safe slicing continuation from the outside. Similarly to (!>) slices the array from the outside, but takes Maybe array as input and returns Nothing when index is out of bounds.

Examples

>>> import Data.Massiv.Array
>>> arr = makeArrayR U Seq (Sz (3 :> 2 :. 4)) fromIx3
>>> arr !?> 2 ??> 0 ??> 3 :: Maybe Ix3T
Just (2,0,3)
>>> arr !?> 2 ??> 0 ??> -1 :: Maybe Ix3T
Nothing
>>> arr !?> 2 ??> -10 ?? 1
*** Exception: IndexOutOfBoundsException: -10 is not safe for (Sz1 2)

Since: 0.1.0

O(1) - Similarly to (!>) slice an array from an opposite direction.

Since: 0.1.0

O(1) - Safe slice from the inside

Since: 0.1.0

O(1) - Safe slicing continuation from the inside

Since: 0.1.0

O(1) - Slices the array in any available dimension. Throws an error when index is out of bounds or dimensions is invalid.

Since: 0.1.0

O(1) - Same as (<!>), but fails gracefully with a Nothing, instead of an error

Since: 0.1.0

O(1) - Safe slicing continuation from within.

Since: 0.1.0

This is an implementation of Quicksort, which is an efficient, but unstable sort that uses Median-of-three for pivot choosing, as such it performs very well not only for random values, but also for common edge cases like already sorted, reversed sorted and arrays with many duplicate elements. It will also respect the computation strategy and will result in a nice speed up for systems with multiple CPUs.

Since: 0.3.2

Count how many occurance of each element there is in the array. Results will be sorted in ascending order of the element.

Example

>>> import Data.Massiv.Array as A
>>> xs = fromList Seq [2, 4, 3, 2, 4, 5, 2, 1] :: Array P Ix1 Int
>>> xs
Array P Seq (Sz1 8)
  [ 2, 4, 3, 2, 4, 5, 2, 1 ]
>>> tally xs
Array DS Seq (Sz1 5)
  [ (1,1), (2,3), (3,1), (4,2), (5,1) ]

Since: 0.4.4

Efficiently iterate a function until a convergence condition is satisfied. If the size of array doesn't change between iterations then no more than two new arrays will be allocated, regardless of the number of iterations. If the size does change from one iteration to another, an attempt will be made to grow/shrink the intermediate mutable array instead of allocating a new one.

Example

>>> import Data.Massiv.Array
>>> a = computeAs P $ makeLoadArrayS (Sz2 8 8) (0 :: Int) $ \ w -> w (0 :. 0) 1 >> pure ()
>>> a
Array P Seq (Sz (8 :. 8))
  [ [ 1, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 0, 0, 0, 0, 0, 0, 0, 0 ]
  ]
>>> nextPascalRow cur above = if cur == 0 then above else cur
>>> pascal = makeStencil (Sz2 2 2) 1 $ \ get -> nextPascalRow <$> get (0 :. 0) <*> get (-1 :. -1) + get (-1 :. 0)
>>> iterateUntil (\_ _ a -> (a ! (7 :. 7)) /= 0) (\ _ -> mapStencil (Fill 0) pascal) a
Array P Seq (Sz (8 :. 8))
  [ [ 1, 0, 0, 0, 0, 0, 0, 0 ]
  , [ 1, 1, 0, 0, 0, 0, 0, 0 ]
  , [ 1, 2, 1, 0, 0, 0, 0, 0 ]
  , [ 1, 3, 3, 1, 0, 0, 0, 0 ]
  , [ 1, 4, 6, 4, 1, 0, 0, 0 ]
  , [ 1, 5, 10, 10, 5, 1, 0, 0 ]
  , [ 1, 6, 15, 20, 15, 6, 1, 0 ]
  , [ 1, 7, 21, 35, 35, 21, 7, 1 ]
  ]

Since: 0.3.6

Convert a flat list into a vector

Since: 0.1.0

O(n) - Convert a nested list into an array. Nested list must be of a rectangular shape, otherwise a runtime error will occur. Also, nestedness must match the rank of resulting array, which should be specified through an explicit type signature.

Examples

>>> import Data.Massiv.Array as A
>>> fromListsM Seq [[1,2,3],[4,5,6]] :: Maybe (Array U Ix2 Int)
Just (Array U Seq (Sz (2 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  ]
)

>>> fromListsM Par [[[1,2,3]],[[4,5,6]]] :: Maybe (Array U Ix3 Int)
Just (Array U Par (Sz (2 :> 1 :. 3))
  [ [ [ 1, 2, 3 ]
    ]
  , [ [ 4, 5, 6 ]
    ]
  ]
)

>>> fromListsM Seq [[[1,2,3]],[[4,5]]] :: Maybe (Array B Ix2 [Int])
Just (Array B Seq (Sz (2 :. 1))
  [ [ [1,2,3] ]
  , [ [4,5] ]
  ]
)
>>> fromListsM Seq [[[1,2,3]],[[4,5]]] :: Maybe (Array B Ix3 Int)
Nothing
>>> fromListsM Seq [[[1,2,3]],[[4,5]]] :: IO (Array B Ix3 Int)
*** Exception: DimTooShortException: expected (Sz1 3), got (Sz1 2)

Since: 0.3.0

Same as fromListsM, but will throw a pure error on irregular shaped lists.

Note: This function is the same as if you would turn on {-# LANGUAGE OverloadedLists #-} extension. For that reason you can also use fromList.

Examples

>>> import Data.Massiv.Array as A
>>> fromLists' Seq [[1,2,3],[4,5,6]] :: Array U Ix2 Int
Array U Seq (Sz (2 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  ]

>>> :set -XOverloadedLists
>>> [[1,2,3],[4,5,6]] :: Array U Ix2 Int
Array U Seq (Sz (2 :. 3))
  [ [ 1, 2, 3 ]
  , [ 4, 5, 6 ]
  ]

>>> fromLists' Seq [[1],[3,4]] :: Array U Ix2 Int
Array U *** Exception: DimTooLongException

Since: 0.1.0

Convert any array to a flat list.

Examples

>>> import Data.Massiv.Array
>>> toList $ makeArrayR U Seq (Sz (2 :. 3)) fromIx2
[(0,0),(0,1),(0,2),(1,0),(1,1),(1,2)]

Since: 0.1.0

O(n) - Convert an array into a nested list. Number of array dimensions and list nestedness will always match, but you can use toList, toLists2, etc. if flattening of inner dimensions is desired.

Note: This function is almost the same as toList.

Examples

>>> import Data.Massiv.Array
>>> arr = makeArrayR U Seq (Sz (2 :> 1 :. 3)) id
>>> arr
Array U Seq (Sz (2 :> 1 :. 3))
  [ [ [ 0 :> 0 :. 0, 0 :> 0 :. 1, 0 :> 0 :. 2 ]
    ]
  , [ [ 1 :> 0 :. 0, 1 :> 0 :. 1, 1 :> 0 :. 2 ]
    ]
  ]
>>> toLists arr
[[[0 :> 0 :. 0,0 :> 0 :. 1,0 :> 0 :. 2]],[[1 :> 0 :. 0,1 :> 0 :. 1,1 :> 0 :. 2]]]

Since: 0.1.0

Convert an array with at least 2 dimensions into a list of lists. Inner dimensions will get flattened.

Examples

>>> import Data.Massiv.Array
>>> toLists2 $ makeArrayR U Seq (Sz2 2 3) fromIx2
[[(0,0),(0,1),(0,2)],[(1,0),(1,1),(1,2)]]
>>> toLists2 $ makeArrayR U Seq (Sz3 2 1 3) fromIx3
[[(0,0,0),(0,0,1),(0,0,2)],[(1,0,0),(1,0,1),(1,0,2)]]

Since: 0.1.0

Convert an array with at least 3 dimensions into a 3 deep nested list. Inner dimensions will get flattened.

Since: 0.1.0

Convert an array with at least 4 dimensions into a 4 deep nested list. Inner dimensions will get flattened.

Since: 0.1.0