Data.Massiv.Array

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

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

Handy synonym for range Seq

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

Same as enumFromStepN with step dx = 1.

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

Examples

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

Similar:

Prelude.Prelude.enumFromTo

Very similar to

[i .. i + n - 1]

, except that

enumFromN

is faster, but it only works for

Num

and not for

Enum

elements

Data.Vector.Generic.enumFromN

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) 5Array D Seq (Sz1 5)  [ 1.0, 1.1, 1.2, 1.3, 1.4 ]>>> enumFromStepN Seq (-pi :: Float) (pi/4) 9Array D Seq (Sz1 9)  [ -3.1415927, -2.3561945, -1.5707964, -0.78539824, 0.0, 0.78539824, 1.5707963, 2.3561947, 3.1415927 ]

Similar:

Prelude.enumFrom

Similar to

take n [x, x + dx ..]

, except that

enumFromStepN

is parallelizable and it only works for

Num

and not for

Enum

elements. Floating point value will be slightly different as well.

Data.Vector.Generic.enumFromStepN

Similar in the outcome, but very different in the way it works.

Similar to expandWithin, except it uses the innermost dimension.

Similar to expandWithin, except it uses the outermost dimension.

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>>> aArray U Seq (Sz1 6)  [ 10, 11, 12, 13, 14, 15 ]>>> expandWithin Dim1 5 (\ e j -> (j + 1) * 100 + e) a :: Array D Ix2 IntArray 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 IntArray 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 ]  ]

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

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

Same as iterateN, but with index aware function.

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

Unfold sequentially from the right with an index aware function.

Right unfold of a delayed load array with index aware function

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.

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

Same as makeArrayA, but with linear index.

Same as makeArrayLinear, but with ability to supply resulting representation

Just like makeArray but with ability to specify the result representation as an argument. Note the Data.Massiv.Array.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 ]    ]  ]

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 Data.Massiv.Array.Manifest.generateSplitSeedArray

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

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 DoubleArray 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 DoubleArray DL (ParN 2) (Sz (2 :. 3))  [ [ 0.2616843941380331, 0.600959468331641, 0.4382415961606372 ]  , [ 0.27812817813217605, 0.2993277194932741, 0.2774105268603957 ]  ]

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 DoubleArray 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 DoubleArray 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 DoubleArray P Seq (Sz (2 :. 3))  [ [ 0.11217260506402493, 0.8870919238985904, 0.2616843941380331 ]  , [ 0.600959468331641, 0.4382415961606372, 0.8375162573397977 ]  ]

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

In the example below we take a stateful random number generator from wmc-random, which is not thread safe, and safely parallelize it by giving each thread it's own generator. There is a caveat of course, statistical independence will depend on the entropy in your initial seeds, so do not use the example below verbatim, since initial seeds are sequential numbers.

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

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) 6Array 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) ]  ]

Just like range, except the finish index is included.

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

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

Example

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

Just like range, except the finish index is included.

Just like rangeStepM, except the finish index is included.

Same as range, but with a custom step.

Throws Exceptions: IndexZeroException

Examples

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

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

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.

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 ]

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

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

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)) 22Array DL Seq (Sz1 3)  [ 4.0, 5.0, 22.0 ]

Create an Array with a single element.

Examples

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

Instead of specifying type signature we could use TypeApplications

>>> :set -XTypeApplications>>> singleton @U @Ix4 @Double 7Array U Seq (Sz (1 :> 1 :> 1 :. 1))  [ [ [ [ 7.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 IntArray 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 ]  ]

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

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

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

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>>> aArray DL Seq (Sz1 1)  [ 0 ]>>> setComp (ParN 6) a -- use 6 capabilitiesArray DL (ParN 6) (Sz1 1)  [ 0 ]

Append computation strategy using Comp's Monoid instance.

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

Compute array sequentially disregarding predefined computation strategy. Very much the same as computePrimM, but executed in ST, thus pure.

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.

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.

Compute an array in PrimMonad sequentially disregarding predefined computation strategy.

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) 10Array 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

Useful only really for cases when representation constructor or TypeApplications extension aren't desireable for some reason:

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

This is just like convert, but restricted to Source arrays. Will be a noop if resulting type is the same as the input.

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.

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

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

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.

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

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

Convert a ragged array into a common array with rectangular shape. Throws ShapeException whenever supplied ragged array does not have a rectangular shape.

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

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

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

Examples

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

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

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

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

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

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]]>>> aArray U Seq (Sz (2 :. 3))  [ [ 1, 2, 3 ]  , [ 4, 5, 6 ]  ]>>> a !? 0 :. 23>>> a !? 0 :. 3*** Exception: IndexOutOfBoundsException: (0 :. 3) is not safe for (Sz (2 :. 3))>>> a !? 0 :. 3 :: Maybe IntNothing

O(1) - Infix version of index'.

Examples

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

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]]]>>> maJust (Array U Seq (Sz (2 :> 1 :. 3))  [ [ [ 1, 2, 3 ]    ]  , [ [ 4, 5, 6 ]    ]  ])>>> ma ??> 1Just (Array U Seq (Sz (1 :. 3))  [ [ 4, 5, 6 ]  ])>>> ma ??> 1 ?? 0 :. 2Just 6>>> ma ?? 1 :> 0 :. 2Just 6

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

Exceptions: IndexOutOfBoundsException

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.

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 5050

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 100100>>> defaultIndex 999 xs 101999

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 104Array D Seq (Sz1 5)  [ 99, 100, 0, 1, 2 ]

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 Ix2Right (60 :. 70)>>> evaluateM (range Seq (Ix2 10 20) (100 :. 210)) 150 :: Either SomeException Ix2Left (IndexOutOfBoundsException: (150 :. 150) is not safe for (Sz (90 :. 190)))

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)) 5060 :. 70

Map an index aware function over an array

Same as mapIO but with arguments flipped.

Same as mapIO_ but with arguments flipped.

Example

This is the same example as in forM_, with important difference that accumulator ref will be modified concurrently by as many threads as there are capabilities.

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

Same as mapM except with arguments flipped.

Just like mapM_, except with flipped arguments.

Examples

Here is a common way of iterating N times using a for loop in an imperative language with mutation being an obvious side effect:

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

Same as iforWS, but without the index.

Same as imapIO but with arguments flipped.

Same as imapIO_ but with arguments flipped.

Same as forM, except with an index aware action.

Just like imapM_, except with flipped arguments.

Same as imapM_, but will use the supplied scheduler.

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

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

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

Map an index aware monadic action over an array sequentially.

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)

Same as imapM_, but will use the supplied scheduler.

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

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

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

Same as traversePrim, but traverse with index aware action.

Just like zipWith, except with an index aware function.

Just like zipWith3, except with an index aware function.

Same as izipWithA, but for three arrays.

Just like zipWith4, except with an index aware function.

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

Map a function over an array

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.

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.

Map a monadic action over an array sequentially.

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

Same as imapWS, but without the index.

Sequence actions in a source array.

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

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.

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

Traverse sequentially within PrimMonad over an array with an action.

Unzip two arrays

Unzip three arrays

Unzip four arrays

Zip two arrays

Zip three arrays

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

Same as zipWithA, but for three arrays.

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

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

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.

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

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

O(n) - Compute conjunction of all elements.

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

Monoidal fold over the inner most dimension.

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)>>> arrArray P Seq (Sz (2 :. 3))  [ [ 11, 12, 13 ]  , [ 14, 15, 16 ]  ]>>> getProduct $ foldInnerSlice (\column -> Product (A.sum column)) arr19575>>> (11 + 14) * (12 + 15) * (13 + 16) :: Int19575

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)>>> arrArray P Seq (Sz (2 :. 3))  [ [ 11, 12, 13 ]  , [ 14, 15, 16 ]  ]>>> getProduct $ foldOuterSlice (\row -> Product (A.sum row)) arr1620>>> (11 + 12 + 13) * (14 + 15 + 16) :: Int1620

O(n) - Semigroup fold over an array.

Monoidal fold over some internal dimension.

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

Left fold over the inner most dimension.

Left fold along a specified dimension.

Example

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

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

Right fold over the inner most dimension.

Right fold along a specified dimension.

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

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

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

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

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

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

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

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

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

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

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

O(n) - Compute maximum of all elements.

O(n) - Compute maximum of all elements.

O(n) - Compute minimum of all elements.

O(n) - Compute minimum of all elements.

O(n) - Compute disjunction of all elements.

O(n) - Compute product of all elements.

O(n) - Compute sum of all elements.

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

O(n) - Unstructured fold of an array.

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.

O(n) - Monadic left fold.

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

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]

O(n) - Left fold, computed sequentially.

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