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 Seq (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

Since: 0.3.0

Since: 0.3.0

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

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

Handy synonym for rangeInclusive Seq

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

Since: 0.3.0

Handy synonym for range Seq

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

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

Same as range, but with a custom step.

Since: 0.1.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

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 delta = 1.

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

Create a vector with length n that has it's 0th value set to x and gradually increasing with step delta until the end. Similar to: fromList' Seq $ take n [x, x + delta ..]. Major difference is that fromList constructs an Array with manifest representation, while enumFromStepN is delayed.

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 ]

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

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

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 usual rectangular shaped one.

Same as fromRaggedArray, but will throw an error if its shape is not rectangular.

Get the size of an immutabe array

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

Infix version of index.

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) not safe for (Sz (2 :. 3))
>>> a !? 0 :. 3 :: Maybe Int
Nothing

Since: 0.1.0

Infix version of index'.

>>> import Data.Massiv.Array as A
>>> a = computeAs U $ iterateN Seq (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) 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.

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. Throws IndexOutOfBoundsException, when index is out of bounds and returns the element at the supplied index otherwise.

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

>>> 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) 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) not safe for (Sz (90 :. 190))

Since: 0.3.0

See evaluate'.

Since: 0.1.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

Same as traverseA, except with ability to specify representation.

Since: 0.2.6

Same as itraverseA, except with ability to specify representation.

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

Same as traverseP, but with ability to specify the desired representation.

Since: 0.3.0

Same as itraverseP, but with ability to specify the desired representation.

Since: 0.3.0

Map a monadic action over an array sequentially.

Since: 0.2.6

Same as mapM, except with ability to specify result representation.

Since: 0.2.6

Same as mapM except with arguments flipped.

Since: 0.2.6

Same as forM, except with ability to specify result representation.

Since: 0.2.6

Map a monadic action over an array sequentially.

Since: 0.2.6

Same as imapM, except with ability to specify result representation.

Since: 0.2.6

Same as forM, except map an index aware action.

Since: 0.2.6

Same as iforM, except with ability to specify result representation.

Since: 0.2.6

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

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.

Since: 0.2.6

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 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 imapIO_ but with arguments flipped.

Since: 0.2.6

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 sequentiall 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

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 minimum of all elements.

Since: 0.1.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 maximum of all elements.

Since: 0.1.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

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

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

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

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

See backpermute'.

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

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.

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

Same as extract, but will throw an error 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

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

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

Since: 0.2.4

O(1) - Add an element to the vector from the left side

Since: 0.3.0

O(1) - Take one element off the vector from the left side.

Since: 0.3.0

O(1) - Add an element to the vector from the right side

Since: 0.3.0

O(1) - Take one element off the vector from the right side.

Since: 0.3.0

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

Append two arrays together along a specified dimension.

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

Since: 0.3.0

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, otherwise it doues result in a SizeMismatchException exception.

Since: 0.3.0

Concat many arrays together along some dimension.

Since: 0.3.0

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

Since: 0.3.0

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

Same as splitAt, but will throw an error instead of returning Nothing on wrong dimension and index out of bounds.

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

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

Create an array by traversing a source array.

Create an array by traversing two source arrays.

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

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]]] :: IO (Array B Ix3 Int)
*** Exception: DimTooShortException: expected (Sz1 3), got (Sz1 2)

Since: 0.3.0

Same as fromLists, but will throw an 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

Similar to fromListsM, but less general.

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