Type synonym for a single dimension array, or simply a flat vector.

Since: 0.5.0

Type synonym for a single dimension mutable array, or simply a flat mutable vector.

Since: 0.5.0

O(1) - Get the length of a Stream array, but only if it is known exactly in constant time without looking at any of the elements in the array.

Related: maxLinearSize, size, elemsCount and totalElem

Examples

>>> slength $ sfromList []
Nothing
>>> slength $ sreplicate 5 ()
Just (Sz1 5)
>>> slength $ makeArrayLinearR D Seq (Sz1 5) id
Just (Sz1 5)
>>> slength $ sunfoldr (\x -> Just (x, x)) (0 :: Int)
Nothing
>>> slength $ sunfoldrN 10 (\x -> Just (x, x)) (0 :: Int)
Nothing
>>> slength $ sunfoldrExactN 10 (\x -> (x, x)) (0 :: Int)
Just (Sz1 10)

Since: 0.5.0

O(1) - Get the possible maximum linear size of an immutabe array. If the lookup of size in constant time is not possible, Nothing will be returned. This value will be used as the initial size of the mutable array into which the loading will happen.

Since: 1.0.0

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

Since: 0.1.0

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

Examples

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

Since: 1.0.0

O(1) - Check if array has elements.

Examples

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

Since: 0.5.1

O(1) - Infix version of indexM.

Exceptions: IndexOutOfBoundsException

Examples

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

Since: 0.1.0

O(1) - Infix version of index'.

Examples

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

Since: 0.1.0

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

Since: 0.1.0

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

Examples

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

Since: 0.1.0

O(1) - Get the first element of a Source vector. Throws an error on empty.

Related: shead', headM, sheadM, unconsM.

Examples

>>> head' (Ix1 10 ..: 10000000000000)
10

Since: 0.5.0

O(1) - Get the first element of a Stream vector. Throws an error on empty.

Related: head', headM, sheadM, unconsM.

Examples

>>> shead' $ sunfoldr (\x -> Just (x, x)) (0 :: Int)
0
>>> shead' (Ix1 3 ... 5)
3

Since: 0.5.0

O(1) - Get the last element of a Source vector. Throws an error on empty.

Related: lastM, unsnocM

Examples

>>> last' (Ix1 10 ... 10000000000000)
10000000000000

Since: 0.5.0

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

Exceptions: IndexOutOfBoundsException

Since: 0.3.0

O(1) - Get the first element of a Source vector.

Related: head', shead', sheadM, unconsM.

Throws Exceptions: SizeEmptyException when array is empty

Examples

>>> headM (Ix1 10 ..: 10000000000000)
10
>>> headM (Ix1 10 ..: 10000000000000) :: Maybe Int
Just 10
>>> headM (empty :: Array D Ix1 Int) :: Maybe Int
Nothing
>>> either show (const "") $ headM (Ix1 10 ..: 10)
"SizeEmptyException: (Sz1 0) corresponds to an empty array"

Since: 0.5.0

O(1) - Get the first element of a Stream vector.

Related: head', shead', headM, unconsM.

Throws Exceptions: SizeEmptyException

Examples

>>> maybe 101 id $ sheadM (empty :: Vector D Int)
101
>>> maybe 101 id $ sheadM (singleton 202 :: Vector D Int)
202
>>> sheadM $ sunfoldr (\x -> Just (x, x)) (0 :: Int)
0
>>> x <- sheadM $ sunfoldr (\_ -> Nothing) (0 :: Int)
*** Exception: SizeEmptyException: (Sz1 0) corresponds to an empty array

Since: 0.5.0

O(1) - Get the last element of a Source vector.

Related: last', unsnocM

Throws Exceptions: SizeEmptyException

Examples

>>> lastM (Ix1 10 ... 10000000000000)
10000000000000
>>> lastM (Ix1 10 ... 10000000000000) :: Maybe Int
Just 10000000000000
>>> either show (const "") $ lastM (fromList Seq [] :: Array P Ix1 Int)
"SizeEmptyException: (Sz1 0) corresponds to an empty array"

Since: 0.5.0

O(1) - Take one element off of the Source vector from the left side, as well as the remaining part of the vector in delayed D representation.

Related: head', shead', headM, sheadM, cons

Throws Exceptions: SizeEmptyException

Examples

>>> unconsM (fromList Seq [1,2,3] :: Array P Ix1 Int)
(1,Array P Seq (Sz1 2)
  [ 2, 3 ])

Since: 0.3.0

O(1) - Take one element off of the vector from the right side, as well as the remaining part of the vector.

Related: last', lastM, snoc

Throws Exceptions: SizeEmptyException

Examples

>>> unsnocM (fromList Seq [1,2,3] :: Array P Ix1 Int)
(Array P Seq (Sz1 2)
  [ 1, 2 ],3)

Since: 0.3.0

O(1) - Take a slice of a Source vector. Never fails, instead adjusts the indices.

Examples

>>> slice 10 5 (Ix1 0 ... 10000000000000)
Array D Seq (Sz1 5)
  [ 10, 11, 12, 13, 14 ]
>>> slice (-10) 5 (Ix1 0 ... 10000000000000)
Array D Seq (Sz1 5)
  [ 0, 1, 2, 3, 4 ]
>>> slice 9999999999998 50 (Ix1 0 ... 10000000000000)
Array D Seq (Sz1 3)
  [ 9999999999998, 9999999999999, 10000000000000 ]

Since: 0.5.0

O(1) - Take a slice of a Source vector. Throws an error on incorrect indices.

Examples

>>> slice' 10 5 (Ix1 0 ... 100)
Array D Seq (Sz1 5)
  [ 10, 11, 12, 13, 14 ]
>>> slice' 9999999999998 3 (Ix1 0 ... 10000000000000)
Array D Seq (Sz1 3)
  [ 9999999999998, 9999999999999, 10000000000000 ]

Since: 0.5.0

O(1) - Take a slice of a Source vector. Throws an error on incorrect indices.

Throws Exceptions: SizeSubregionException

Examples

>>> sliceM 10 5 (Ix1 0 ... 100)
Array D Seq (Sz1 5)
  [ 10, 11, 12, 13, 14 ]
>>> sliceM (-10) 5 (Ix1 0 ... 100)
*** Exception: SizeSubregionException: (Sz1 101) is to small for -10 (Sz1 5)
>>> sliceM 98 50 (Ix1 0 ... 100)
*** Exception: SizeSubregionException: (Sz1 101) is to small for 98 (Sz1 50)
>>> sliceM 9999999999998 3 (Ix1 0 ... 10000000000000)
Array D Seq (Sz1 3)
  [ 9999999999998, 9999999999999, 10000000000000 ]

Since: 0.5.0

Take a slice of a Stream vector. Never fails, instead adjusts the indices.

Examples

>>> sslice 10 5 (Ix1 0 ... 10000000000000)
Array DS Seq (Sz1 5)
  [ 10, 11, 12, 13, 14 ]
>>> sslice 10 5 (sfromList [0 :: Int .. ])
Array DS Seq (Sz1 5)
  [ 10, 11, 12, 13, 14 ]
>>> sslice (-10) 5 (Ix1 0 ... 10000000000000)
Array DS Seq (Sz1 5)
  [ 0, 1, 2, 3, 4 ]

>>> import System.Timeout (timeout)
>>> let smallArr = sslice 9999999999998 50 (Ix1 0 ... 10000000000000)
>>> timeout 500000 (computeIO smallArr :: IO (Array P Ix1 Int))
Nothing

Since: 0.5.0

Same as sliceAt', except it never fails.

Examples

Since: 0.5.0

Same as splitAt', except for a flat vector.

Examples

Since: 0.5.0

Same as splitAtM, except for a flat vector.

Examples

Since: 0.5.0

O(1) - Get a vector without the last element. Never fails.

Examples

>>> import Data.Massiv.Array as A
>>> A.init (0 ..: 10)
Array D Seq (Sz1 9)
  [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]
>>> A.init (empty :: Array D Ix1 Int)
Array D Seq (Sz1 0)
  [  ]

Since: 0.5.0

O(1) - Get a vector without the last element. Throws an error on empty

Examples

>>> init' (0 ..: 10)
Array D Seq (Sz1 9)
  [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]

Since: 0.5.0

O(1) - Get a vector without the last element. Throws an error on empty

Examples

>>> import Data.Massiv.Array as A
>>> initM (0 ..: 10)
Array D Seq (Sz1 9)
  [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]
>>> maybe 0 A.sum $ initM (0 ..: 10)
36
>>> maybe 0 A.sum $ initM (empty :: Array D Ix1 Int)
0

Since: 0.5.0

O(1) - Get a vector without the first element. Never fails

Examples

>>> import Data.Massiv.Array as A
>>> A.tail (0 ..: 10)
Array D Seq (Sz1 9)
  [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
>>> A.tail (empty :: Array D Ix1 Int)
Array D Seq (Sz1 0)
  [  ]

Since: 0.5.0

O(1) - Get a vector without the first element. Throws an error on empty

Examples

Since: 0.5.0

O(1) - Get the vector without the first element. Throws an error on empty

Examples

>>> import Data.Massiv.Array as A
>>> tailM (0 ..: 10)
Array D Seq (Sz1 9)
  [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
>>> maybe 0 A.sum $ tailM (0 ..: 10)
45
>>> maybe 0 A.sum $ tailM (empty :: Array D Ix1 Int)
0

Since: 0.5.0

O(1) - Take first n elements from a vector. This function never fails and has similar semantics as the take for lists.

Examples

>>> import Data.Massiv.Array as A
>>> A.take 5 (0 ..: 10)
Array D Seq (Sz1 5)
  [ 0, 1, 2, 3, 4 ]
>>> A.take 0 (0 ..: 10)
Array D Seq (Sz1 0)
  [  ]
>>> A.take 100 (0 ..: 10)
Array D Seq (Sz1 10)
  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Since: 0.5.0

O(1) - Get the vector with the first n elements. Throws an error size is less than n.

Examples

>>> take' 0 (0 ..: 0)
Array D Seq (Sz1 0)
  [  ]
>>> take' 5 (0 ..: 10)
Array D Seq (Sz1 5)
  [ 0, 1, 2, 3, 4 ]

Since: 0.5.0

O(1) - Get the vector with the first n elements. Throws an error size is less than n

Examples

>>> import Data.Massiv.Array as A
>>> takeM 5 (0 ..: 10)
Array D Seq (Sz1 5)
  [ 0, 1, 2, 3, 4 ]
>>> maybe 0 A.sum $ takeM 5 (0 ..: 10)
10
>>> maybe (-1) A.sum $ takeM 15 (0 ..: 10)
-1
>>> takeM 15 (0 ..: 10)
*** Exception: SizeSubregionException: (Sz1 10) is to small for 0 (Sz1 15)

Since: 0.5.0

Slice a manifest vector in such a way that it will contain all initial elements that satisfy the supplied predicate.

Since: 0.5.5

O(1) - Create a Stream vector with the first n elements. Never fails

Examples

Since: 0.5.0

O(1) - Drop n elements from a vector. This function never fails and has similar semantics as the drop for lists.

Examples

>>> import Data.Massiv.Array as A
>>> v = makeVectorR D Seq 10 id
>>> v
Array D Seq (Sz1 10)
  [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
>>> A.drop 5 v
Array D Seq (Sz1 5)
  [ 5, 6, 7, 8, 9 ]
>>> A.drop 25 v
Array D Seq (Sz1 0)
  [  ]

Since: 0.5.0

Slice a manifest vector in such a way that it will not contain all initial elements that satisfy the supplied predicate.

Since: 0.5.5

O(1) - Drop n elements from a vector. Unlike drop, this function will produce an error when supplied number of elements to drop is larger than size of the supplied vector

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Keep all but the first n elements from the delayed stream vector.

Examples

Since: 0.5.0

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 empty delayed stream vector

Examples

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

Create a delayed stream vector with a single element

Examples

Since: 0.5.0

O(1) - Add an element to 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

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

Since: 0.3.0

Replicate the same element n times

Examples

Since: 0.5.0

Create a delayed vector of length n with a function that maps an index to an element. Same as makeLinearArray

Examples

Since: 0.5.0

Create a delayed stream vector of length n with a function that maps an index to an element. Same as makeLinearArray

Examples

Since: 0.5.0

Create a delayed stream vector of infinite length by repeatedly applying a function to the initial value.

Examples

>>> stake 10 $ siterate succ 'a'
Array DS Seq (Sz1 10)
  [ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' ]

Since: 0.5.2

Create a delayed stream vector of length n by repeatedly applying a function to the initial value.

Examples

>>> siterateN 10 succ 'a'
Array DS Seq (Sz1 10)
  [ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' ]

Since: 0.5.0

Create a vector by using the same monadic action n times

Examples

Since: 0.5.0

Create a delayed stream vector of length n with a monadic action that from an index generates an element.

Examples

Since: 0.5.0

Create a delayed stream vector of length n by repeatedly apply a monadic action to the initial value.

Examples

Since: 0.5.0

Right unfolding function. Useful when it is unknown ahead of time how many elements a vector will have.

Example

>>> import Data.Massiv.Array as A
>>> sunfoldr (\i -> if i < 9 then Just (i * i, i + 1) else Nothing) (0 :: Int)
Array DS Seq (Sz1 9)
  [ 0, 1, 4, 9, 16, 25, 36, 49, 64 ]

Since: 0.5.0

O(n) - Same as sunfoldr, but with monadic generating function.

Examples

>>> import Control.Monad (when, guard)
>>> sunfoldrM (\i -> when (i == 0) (Left "Zero denominator") >> Right (guard (i < 5) >> Just (100 `div` i, i + 1))) (-10 :: Int)
Left "Zero denominator"
>>> sunfoldrM (\i -> when (i == 0) (Left "Zero denominator") >> Right (guard (i < -5) >> Just (100 `div` i, i + 1))) (-10 :: Int)
Right (Array DS Seq (Sz1 5)
  [ -10, -12, -13, -15, -17 ]
)

Since: 0.5.0

O(n) - Right unfolding function with at most n number of elements.

Example

>>> import Data.Massiv.Array as A
>>> sunfoldrN 9 (\i -> Just (i*i, i + 1)) (0 :: Int)
Array DS Seq (Sz1 9)
  [ 0, 1, 4, 9, 16, 25, 36, 49, 64 ]

Since: 0.5.0

O(n) - Same as sunfoldrN, but with monadic generating function.

Examples

>>> import Control.Monad (guard)
>>> sunfoldrNM 6 (\i -> print i >> pure (guard (i < 5) >> Just (i * i, i + 1))) (10 :: Int)
10
Array DS Seq (Sz1 0)
  [  ]
>>> sunfoldrNM 6 (\i -> print i >> pure (guard (i < 15) >> Just (i * i, i + 1))) (10 :: Int)
10
11
12
13
14
15
Array DS Seq (Sz1 5)
  [ 100, 121, 144, 169, 196 ]

Since: 0.5.0

O(n) - Similar to sunfoldrN, except the length of the resulting vector will be exactly n

Examples

>>> sunfoldrExactN 10 (\i -> (i * i, i + 1)) (10 :: Int)
Array DS Seq (Sz1 10)
  [ 100, 121, 144, 169, 196, 225, 256, 289, 324, 361 ]

Since: 0.5.0

O(n) - Similar to sunfoldrNM, except the length of the resulting vector will be exactly n

Examples

Since: 0.5.0

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

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

Since: 0.3.0

Handy synonym for range Seq

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

Since: 0.3.0

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

O(n) - Enumerate from a starting number x exactly n times with a step 1.

Related: senumFromStepN, enumFromN, enumFromStepN, rangeSize, rangeStepSize, range, rangeStep'

Examples

>>> senumFromN (10 :: Int) 9
Array DS Seq (Sz1 9)
  [ 10, 11, 12, 13, 14, 15, 16, 17, 18 ]

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

O(n) - Enumerate from a starting number x exactly n times with a custom step value dx

Examples

>>> senumFromStepN (5 :: Int) 2 10
Array DS Seq (Sz1 10)
  [ 5, 7, 9, 11, 13, 15, 17, 19, 21, 23 ]

Since: 0.5.0

Append two vectors together

Related: appendM, appendOuterM,

Examples

Since: 0.5.0

Concat vectors together

Related: concatM, concatOuterM,

Examples

>>> sconcat [2 ... 6, empty, singleton 1, generate Seq 5 id]
Array DS Seq (Sz1 11)
  [ 2, 3, 4, 5, 6, 1, 0, 1, 2, 3, 4 ]
>>> sconcat [senumFromN 2 5, sempty, ssingleton 1, sgenerate 5 id]
Array DS Seq (Sz1 11)
  [ 2, 3, 4, 5, 6, 1, 0, 1, 2, 3, 4 ]

Since: 0.5.0

Map a function over a stream vector

Examples

Since: 0.5.0

Map an index aware function over a stream vector

Examples

Since: 0.5.0

Traverse a stream vector with an applicative function.

Examples

Since: 0.5.0

Traverse a stream vector with an index aware applicative function.

Examples

Since: 0.5.0

Traverse a stream vector with a monadic function.

Examples

Since: 0.5.0

Traverse a stream vector with a monadic function, while discarding the result

Examples

Since: 0.5.0

Traverse a stream vector with a monadic index aware function.

Corresponds to: mapM (uncurry f) . imap (,) v

Examples

Since: 0.5.0

Traverse a stream vector with a monadic index aware function, while discarding the result

Examples

Since: 0.5.0

Same as smapM, but with arguments flipped.

Examples

Since: 0.5.0

Same as smapM_, but with arguments flipped.

Examples

Since: 0.5.0

Same as simapM, but with arguments flipped.

Examples

Since: 0.5.0

Same as simapM_, but with arguments flipped.

Examples

Since: 0.5.0

Zip two vectors together into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Examples

Since: 0.5.0

Zip three vectors together into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip four vectors together into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip five vectors together into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip six vectors together into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip two vectors together with a binary function into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Examples

Since: 0.5.0

Zip three vectors together with a ternary function into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip four vectors together with a quaternary function into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip five vectors together with a quinary function into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip six vectors together with a senary function into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Just like szipWith, zip two vectors together, but with an index aware function. The length of a resulting vector will be the smallest length of the supplied vectors.

Examples

Since: 0.5.0

Just like szipWith3, zip three vectors together, but with an index aware function. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Just like szipWith4, zip four vectors together, but with an index aware function. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Just like szipWith5, zip five vectors together, but with an index aware function. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Just like szipWith6, zip six vectors together, but with an index aware function. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip two vectors together with a binary monadic action into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Examples

Since: 0.5.0

Zip three vectors together with a ternary monadic action into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip four vectors together with a quaternary monadic action into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip five vectors together with a quinary monadic action into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Zip six vectors together with a senary monadic action into a vector. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Just like szipWithM, zip two vectors together, but with an index aware monadic action. The length of a resulting vector will be the smallest length of the supplied vectors.

Examples

Since: 0.5.0

Just like szipWith3M, zip three vectors together, but with an index aware monadic action. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Just like szipWith4M, zip four vectors together, but with an index aware monadic action. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Just like szipWith6M, zip five vectors together, but with an index aware monadic action. The length of a resulting vector will be the smallest length of the supplied vectors.

Since: 0.5.0

Just like szipWith6M, zip six vectors together, but with an index aware monadic action. The length of a resulting vector will be the smallest length of the supplied vectors.

Examples

Since: 0.5.0

Similar to szipWithM, zip two vectors together with a binary monadic action, while discarding its result. The action will be invoked as many times as the length of the smallest vector.

Examples

Since: 0.5.0

Similar to szipWith3M, zip three vectors together with a ternary monadic action, while discarding its result. The action will be invoked as many times as the length of the smallest vector.

Since: 0.5.0

Similar to szipWith4M, zip four vectors together with a quaternary monadic action, while discarding its result. The action will be invoked as many times as the length of the smallest vector.

Since: 0.5.0

Similar to szipWith5M, zip five vectors together with a quinary monadic action, while discarding its result. The action will be invoked as many times as the length of the smallest vector.

Since: 0.5.0

Similar to szipWith6M, zip six vectors together with a senary monadic action, while discarding its result. The action will be invoked as many times as the length of the smallest vector.

Since: 0.5.0

Same as szipWithM_, zip two vectors together, but with an index aware monadic action. The action will be invoked as many times as the length of the smallest vector.

Examples

Since: 0.5.0

Same as szipWith3M_, zip three vectors together, but with an index aware monadic action. The action will be invoked as many times as the length of the smallest vector.

Since: 0.5.0

Same as szipWith4M_, zip four vectors together, but with an index aware monadic action. The action will be invoked as many times as the length of the smallest vector.

Since: 0.5.0

Same as szipWith5M_, zip five vectors together, but with an index aware monadic action. The action will be invoked as many times as the length of the smallest vector.

Since: 0.5.0

Same as szipWith6M_, zip six vectors together, but with an index aware monadic action. The action will be invoked as many times as the length of the smallest vector.

Since: 0.5.0

Sequentially filter out elements from the array according to the supplied predicate.

Example

>>> import Data.Massiv.Array as A
>>> arr = makeArrayR D Seq (Sz2 3 4) fromIx2
>>> arr
Array D Seq (Sz (3 :. 4))
  [ [ (0,0), (0,1), (0,2), (0,3) ]
  , [ (1,0), (1,1), (1,2), (1,3) ]
  , [ (2,0), (2,1), (2,2), (2,3) ]
  ]
>>> sfilter (even . fst) arr
Array DS Seq (Sz1 8)
  [ (0,0), (0,1), (0,2), (0,3), (2,0), (2,1), (2,2), (2,3) ]

Since: 0.5.0

Similar to sfilter, but filter with an index aware function.

Examples

Since: 0.5.0

Sequentially filter out elements from the array according to the supplied applicative predicate.

Example

>>> import Data.Massiv.Array as A
>>> arr = makeArrayR D Seq (Sz2 3 4) fromIx2
>>> arr
Array D Seq (Sz (3 :. 4))
  [ [ (0,0), (0,1), (0,2), (0,3) ]
  , [ (1,0), (1,1), (1,2), (1,3) ]
  , [ (2,0), (2,1), (2,2), (2,3) ]
  ]
>>> sfilterM (Just . odd . fst) arr
Just (Array DS Seq (Sz1 4)
  [ (1,0), (1,1), (1,2), (1,3) ]
)
>>> sfilterM (\ix@(_, j) -> print ix >> return (even j)) arr
(0,0)
(0,1)
(0,2)
(0,3)
(1,0)
(1,1)
(1,2)
(1,3)
(2,0)
(2,1)
(2,2)
(2,3)
Array DS Seq (Sz1 6)
  [ (0,0), (0,2), (1,0), (1,2), (2,0), (2,2) ]

Since: 0.5.0

Similar to filterM, but filter with an index aware function.

Corresponds to: filterM (uncurry f) . simap (,)

Since: 0.5.0

Apply a function to each element of the array, while discarding Nothing and keeping the Maybe result.

Examples

Since: 0.5.0

Similar to smapMaybe, but with the Applicative function.

Similar to mapMaybe id $ mapM f arr

Examples

Since: 0.5.0

Keep all Maybes and discard the Nothings.

Examples

Since: 0.5.0

Similar to smapMaybe, but map with an index aware function.

Examples

Since: 0.5.0

Similar to smapMaybeM, but map with an index aware function.

Examples

Since: 0.5.0

O(n) - Perform a row-major search starting at 0 for an element. Returns the index of the first occurance of an element or Nothing if a predicate could not be satisifed after it was applyied to all elements of the array.

Since: 0.5.5

Streaming fold over an array in a row-major fashion with a left biased function and a strict accumulator.

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Examples

Since: 0.5.0

Add all elements of the array together

Related: sum.

Examples

>>> import Data.Massiv.Vector as V
>>> V.ssum $ V.sfromList [10, 3, 70, 5 :: Int]
88

Since: 0.5.0

Multiply all elements of the array together

Related: product.

Examples

>>> import Data.Massiv.Vector as V
>>> V.sproduct $ V.sfromList [10, 3, 70, 5 :: Int]
10500

Since: 0.5.0

O(n) - Find the largest value in the array. Throws an error on empty.

Related: smaximumM, maximum, maximumM.

Examples

>>> import Data.Massiv.Vector as V
>>> V.smaximum' $ V.sfromList [10, 3, 70, 5 :: Int]
70

Since: 0.5.0

O(n) - Find the largest value in the array.

Related: smaximum, maximum, maximumM.

Throws Exceptions: SizeEmptyException when array is empty

Examples

>>> import Data.Massiv.Vector as V
>>> V.smaximumM $ V.sfromList [10, 3, 70, 5 :: Int]
70
>>> V.smaximumM (V.empty :: Vector D Int) :: Maybe Int
Nothing

Since: 0.5.0

O(n) - Find the smallest value in the array. Throws an error on empty.

Related: sminimumM, minimum, minimumM.

Examples

>>> import Data.Massiv.Vector as V
>>> V.sminimum' $ V.sfromList [10, 3, 70, 5 :: Int]
3

Since: 0.5.0

O(n) - Find the smallest value in the array.

Related: sminimum', minimum, minimumM.

Throws Exceptions: SizeEmptyException when array is empty

Examples

>>> import Data.Massiv.Vector as V
>>> V.sminimumM $ V.sfromList [10, 3, 70, 5 :: Int]
3
>>> V.sminimumM (V.empty :: Array D Ix2 Int) :: Maybe Int
Nothing

Since: 0.5.0

O(n) - left scan with strict accumulator. First element is the value of the accumulator. Last element is not included.

Examples

>>> import Data.Massiv.Vector
>>> sprescanl min 6 $ sfromList [10, 5, 70, 3 :: Int]
Array DS Seq (Sz1 4)
  [ 6, 6, 5, 5 ]
>>> sprescanl (+) 0 $ sfromList [10, 5, 70, 3 :: Int]
Array DS Seq (Sz1 4)
  [ 0, 10, 15, 85 ]

Since: 1.0.3

O(n) - left scan with strict accumulator. First element is the result of applying the supplied function.

Examples

>>> import Data.Massiv.Vector
>>> spostscanl min 6 $ sfromList [10, 5, 70, 3 :: Int]
Array DS Seq (Sz1 4)
  [ 6, 5, 5, 3 ]
>>> spostscanl (+) 0 $ sfromList [10, 5, 70, 3 :: Int]
Array DS Seq (Sz1 4)
  [ 10, 15, 85, 88 ]

Since: 1.0.3

O(n) - Just like spostscanl except it is possible to produce a vector with an element type that differes from accumulator type.

Examples

>>> import Data.Massiv.Vector
>>> spostscanlAcc (\x y -> if x < y then (True, x) else (False, y)) 6 $ sfromList [10, 5, 70, 3 :: Int]
Array DS Seq (Sz1 4)
  [ True, False, True, False ]

Since: 1.0.3

O(n) - left scan with strict accumulator. First element is the value of the accumulator.

Examples

>>> import Data.Massiv.Vector
>>> sscanl min 6 $ sfromList [10, 5, 70, 3 :: Int]
Array DS Seq (Sz1 5)
  [ 6, 6, 5, 5, 3 ]
>>> sscanl (+) 0 $ sfromList [10, 5, 70, 3 :: Int]
Array DS Seq (Sz1 5)
  [ 0, 10, 15, 85, 88 ]

Since: 1.0.3

O(n) - left scan with strict accumulator and no initial value for the accumulator.

Examples

>>> import Data.Massiv.Vector
>>> sscanl1 min $ sfromList [10, 5, 70, 3 :: Int]
Array DS Seq (Sz1 4)
  [ 10, 5, 5, 3 ]
>>> sscanl1 (+) $ sfromList [10, 5, 70, 3 :: Int]
Array DS Seq (Sz1 4)
  [ 10, 15, 85, 88 ]
>>> sscanl1 (+) $ sfromList ([] :: [Int])
Array DS Seq (Sz1 0)
  [  ]

Since: 1.0.3

Convert an array to a list by the means of a delayed stream vector.

Related: toList

Examples

Since: 0.5.0

Convert a flat list into a vector

Since: 0.1.0

Convert a list to a delayed stream vector

Related: fromList, fromListN, sfromListN

Examples

>>> sfromList ([] :: [Int])
Array DS Seq (Sz1 0)
  [  ]
>>> sfromList ([1,2,3] :: [Int])
Array DS Seq (Sz1 3)
  [ 1, 2, 3 ]

Since: 0.5.0

Convert a list to a delayed stream vector. Length of the resulting vector will be at most n. This version isn't really more efficient then sfromList, but there is unsafeFromListN

Related: fromList, fromListN, sfromList

Examples

>>> sfromListN 10 [1 :: Int ..]
Array DS Seq (Sz1 10)
  [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
>>> sfromListN 10 [1 :: Int .. 5]
Array DS Seq (Sz1 5)
  [ 1, 2, 3, 4, 5 ]

Since: 0.5.1

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 number of elements in the source array and k is number of elements in the stride.

Since: 0.3.0

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

Since: 0.3.0

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

Since: 0.1.0

O(n) - conversion between array types. A full copy will occur, unless when the source and result arrays are of the same representation, in which case it is an O(1) operation.

Since: 0.1.0

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

Since: 0.1.0

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

Since: 0.1.1