Data.Massiv.Array

Massiv is a library, that allows creation and manipulation of arrays in parallel and sequentially. Depending on the representation (r), an Array r ix e will have certain properties that are unique to that particular representation, but all of them will share the same trait, that an array is simply a mapping from an index (ix) of an arbitrary dimension to an element (e) of some value. Which means that some of the array types are pretty classic and are represented by a contiguous chunk of memory reserved for the elements, namely arrays with Manifest representations:

• B - The most basic type of array that can hold any type of element in a boxed form, i.e. each element is a pointer to the actual value, therefore it is also the slowest representation. Elements are kept in a Weak Head Normal Form (WHNF).
• N - Similar to B, is also a boxed type, except it's elements are always kept in a Normal Form (NF). This property is very useful for parallel processing, i.e. when calling compute you do want all of your elements to be fully evaluated.
• S - Is a type of array that is backed by pinned memory, therefore pointers to those arrays can be passed to FFI calls, because Garbage Collector (GC) is guaranteed not to move it. Elements must be an instance of Storable class. It is just as efficient as P and U arrays, except it is subject to fragmentation.
• U - Unboxed representation. Elements must be an instance of Unbox class.
• P - Array that can hold Haskell primitives, such as Int, Word, Double, etc. Any element must be an instance of Prim class.
• M - General manifest array type, that any of the above representations can be converted to in constant time using toManifest.

While at the same time, there are arrays that only describe how values for it's elements can be computed, and have no memory overhead on their own.

• D - delayed array that is a mere function from an index to an element. Crucial representation for fusing computation. Use computeAs in order to load array into Manifest representation.
• DI - delayed interleaved array. Same as D, but performced better with unbalanced computation, when evaluation one element takes much longer than it's neighbor.
• DW - delayed windowed array. This peculiar representation allows for very fast Stencil computation.

Other Array types:

• L and LN - those types aren't particularly useful on their own, but because of their unique ability to be converted to and from nested lists in constant time, provide an amazing intermediary for list/array conversion.

Most of the Manifest arrays are capable of in-place mutation. Check out Data.Massiv.Array.Mutable module for available functionality.

Many of the function names exported by this package will clash with the ones from Prelude, hence it can be more convenient to import like this:

import Prelude as P
import Data.Massiv.Array as A

Construct

makeArray

Arguments

:: Construct r ix e

=> Comp

Computation strategy. Useful constructors are Seq and Par

-> ix

Size of the result array. Negative values will result in an empty array.

-> (ix -> e)

Function to generate elements at a particular index

-> Array r ix e

Create an Array. Resulting type either has to be unambiguously inferred or restricted manually, like in the example below.

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

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

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

>>> makeArrayR U Par (2 :> 3 :. 4) (\ (i :> j :. k) -> i * i + j * j == k * k)
(Array U Par (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 ]
    ]
  ])

makeVectorR :: Construct r Ix1 e => r -> Comp -> Ix1 -> (Ix1 -> e) -> Array r Ix1 e

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

singleton

Arguments

:: Construct r ix e

=> Comp

Computation strategy

-> e

The element

-> Array r ix e

Create an Array with a single element.

range :: Comp -> Int -> Int -> Array D Ix1 Int

Create a vector with a range of Ints incremented by 1. range k0 k1 == rangeStep k0 k1 1

>>> range Seq 1 6
(Array D Seq (5)
  [ 1,2,3,4,5 ])
>>> range Seq (-2) 3
(Array D Seq (5)
  [ -2,-1,0,1,2 ])

rangeStep

Arguments

:: Comp

Computation strategy

-> Int

Start

-> Int

Step (Can't be zero)

-> Int

End

-> Array D Ix1 Int

Same as range, but with a custom step.

>>> rangeStep Seq 1 2 6
(Array D Seq (3)
  [ 1,3,5 ])

enumFromN

Arguments

:: Num e

=> Comp

-> e

x - start value

-> Int

n - length of resulting vector.

-> Array D Ix1 e

Same as enumFromStepN with step delta = 1.

>>> enumFromN Seq (5 :: Double) 3
(Array D Seq (3)
  [ 5.0,6.0,7.0 ])

enumFromStepN

Arguments

:: Num e

=> Comp

-> e

x - start value

-> e

delta - step value

-> Int

n - length of resulting vector

-> Array D Ix1 e

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.

>>> enumFromStepN Seq 1 (0.1 :: Double) 5
(Array D Seq (5)
  [ 1.0,1.1,1.2,1.3,1.4 ])

Compute

getComp :: Construct r ix e => Array r ix e -> Comp

Get computation strategy of this array

setComp :: Construct r ix e => Comp -> Array r ix e -> Array r ix e

Set computation strategy for this array

compute :: (Load r' ix e, Mutable r ix e) => Array r' ix e -> Array r ix e

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

computeAs :: (Load r' ix e, Mutable r ix e) => r -> Array r' ix e -> Array r ix e

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

Examples

>>> computeAs P $ range Seq 0 10
(Array P Seq (10)
  [ 0,1,2,3,4,5,6,7,8,9 ])

computeProxy :: (Load r' ix e, Mutable r ix e) => proxy r -> Array r' ix e -> Array r ix e

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

Examples

Useful for cases when representation constructor isn't available for some reason:

>>> computeProxy (Nothing :: Maybe P) $ range Seq 0 10
(Array P Seq (10)
  [ 0,1,2,3,4,5,6,7,8,9 ])

Since: massiv-0.1.1

computeSource :: forall r' r ix e. (Source r' ix e, Mutable r ix e) => Array r' ix e -> Array r ix e

This is just like compute, but can be applied to Source arrays and will be a noop if resulting type is the same as the input.

computeWithStride :: (Load r' ix e, Mutable r ix e) => Stride ix -> Array r' ix e -> Array r ix e

Same as compute, but with Stride.

computeWithStrideAs :: (Load r' ix e, Mutable r ix e) => r -> Stride ix -> Array r' ix e -> Array r ix e

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

clone :: Mutable r ix e => Array r ix e -> Array r ix e

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

convert :: (Manifest r' ix e, Mutable r ix e) => Array r' ix e -> Array r ix e

O(n) - conversion between manifest types, except when source and result arrays are of the same representation, in which case it is an O(1) operation.

convertAs :: (Manifest r' ix e, Mutable r ix e) => r -> Array r' ix e -> Array r ix e

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

convertProxy :: (Manifest r' ix e, Mutable r ix e) => proxy r -> Array r' ix e -> Array r ix e

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

Since: massiv-0.1.1

fromRaggedArray :: (Ragged r' ix e, Mutable r ix e) => Array r' ix e -> Either ShapeError (Array r ix e)

Convert a ragged array into a usual rectangular shaped one.

fromRaggedArray' :: (Ragged r' ix e, Mutable r ix e) => Array r' ix e -> Array r ix e

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

Size

size :: Size r ix e => Array r ix e -> ix

O(1) - Get the size of an array

elemsCount :: Size r ix e => Array r ix e -> Int

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

isEmpty :: Size r ix e => Array r ix e -> Bool

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

Indexing

(!?) :: Manifest r ix e => Array r ix e -> ix -> Maybe e infixl 4

Infix version of index.

(!) :: Manifest r ix e => Array r ix e -> ix -> e infixl 4

Infix version of index'.

(??) :: Manifest r ix e => Maybe (Array r ix e) -> ix -> Maybe e infixl 4

O(1) - Lookup an element in the array, where array can itself be Nothing. This operator is useful when used together with slicing or other functions that return Maybe array:

>>> (fromList Seq [[[1,2,3]],[[4,5,6]]] :: Maybe (Array U Ix3 Int)) ??> 1 ?? (0 :. 2)
Just 6

index :: Manifest r ix e => Array r ix e -> ix -> Maybe e

O(1) - Lookup an element in the array. Returns Nothing, when index is out of bounds, Just element otherwise.

index' :: Manifest r ix e => Array r ix e -> ix -> e

O(1) - Lookup an element in the array. Throw an error if index is out of bounds.

defaultIndex :: Manifest r ix e => e -> Array r ix e -> ix -> e

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

borderIndex :: Manifest r ix e => Border e -> Array r ix e -> ix -> e

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

evaluateAt :: Source r ix e => Array r ix e -> ix -> e

This is just like index' 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.

Mapping

map :: Source r ix e' => (e' -> e) -> Array r ix e' -> Array D ix e

Map a function over an array

imap :: Source r ix e' => (ix -> e' -> e) -> Array r ix e' -> Array D ix e

Map an index aware function over an array

Monadic

mapM_ :: (Source r ix a, Monad m) => (a -> m b) -> Array r ix a -> m ()

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

Examples

>>> mapM_ print $ rangeStep 10 12 60
10
22
34
46
58

forM_ :: (Source r ix a, Monad m) => Array r ix a -> (a -> m b) -> m ()

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:

>>> :m + Data.IORef
>>> var <- newIORef 0 :: IO (IORef Int)
>>> forM_ (range 0 1000) $ \ i -> modifyIORef' var (+i)
>>> readIORef var
499500

imapM_ :: (Source r ix a, Monad m) => (ix -> a -> m b) -> Array r ix a -> m ()

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

Examples

>>> imapM_ (curry print) $ range 10 15
(0,10)
(1,11)
(2,12)
(3,13)
(4,14)

iforM_ :: (Source r ix a, Monad m) => Array r ix a -> (ix -> a -> m b) -> m ()

Just like imapM_, except with flipped arguments.

mapP_ :: Source r ix a => (a -> IO b) -> Array r ix a -> IO ()

Map an IO action, over an array in parallel, while discarding the result.

imapP_ :: Source r ix a => (ix -> a -> IO b) -> Array r ix a -> IO ()

Map an index aware IO action, over an array in parallel, while discarding the result.

Zipping

zip :: (Source r1 ix e1, Source r2 ix e2) => Array r1 ix e1 -> Array r2 ix e2 -> Array D ix (e1, e2)

Zip two arrays

zip3 :: (Source r1 ix e1, Source r2 ix e2, Source r3 ix e3) => Array r1 ix e1 -> Array r2 ix e2 -> Array r3 ix e3 -> Array D ix (e1, e2, e3)

Zip three arrays

unzip :: Source r ix (e1, e2) => Array r ix (e1, e2) -> (Array D ix e1, Array D ix e2)

Unzip two arrays

unzip3 :: Source r ix (e1, e2, e3) => Array r ix (e1, e2, e3) -> (Array D ix e1, Array D ix e2, Array D ix e3)

Unzip three arrays

zipWith :: (Source r1 ix e1, Source r2 ix e2) => (e1 -> e2 -> e) -> Array r1 ix e1 -> Array r2 ix e2 -> Array D ix e

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

zipWith3 :: (Source r1 ix e1, Source r2 ix e2, Source r3 ix e3) => (e1 -> e2 -> e3 -> e) -> Array r1 ix e1 -> Array r2 ix e2 -> Array r3 ix e3 -> Array D ix e

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

izipWith :: (Source r1 ix e1, Source r2 ix e2) => (ix -> e1 -> e2 -> e) -> Array r1 ix e1 -> Array r2 ix e2 -> Array D ix e

Just like zipWith, except with an index aware function.

izipWith3 :: (Source r1 ix e1, Source r2 ix e2, Source r3 ix e3) => (ix -> e1 -> e2 -> e3 -> e) -> Array r1 ix e1 -> Array r2 ix e2 -> Array r3 ix e3 -> Array D ix e

Just like zipWith3, except with an index aware function.

liftArray2 :: (Source r1 ix a, Source r2 ix b) => (a -> b -> e) -> Array r1 ix a -> Array r2 ix b -> Array D ix e

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: massiv-0.1.4

Folding

All folding is done in a row-major order.

Unstructured folds

Functions in this section will fold any Source array with respect to the inner Computation strategy setting.

fold

Arguments

:: Source r ix e

=> (e -> e -> e)

Folding function (like with left fold, first argument is an accumulator)

-> e

Initial element. Has to be neutral with respect to the folding function.

-> Array r ix e

Source array

-> e

O(n) - Unstructured fold of an array.

foldMono

Arguments

:: (Source r ix e, Monoid m)

=> (e -> m)

Convert each element of an array to an appropriate Monoid.

-> Array r ix e

Source array

-> m

O(n) - Monoidal fold over an array. Also known as reduce.

Since: massiv-0.1.4

foldSemi

Arguments

:: (Source r ix e, Semigroup m)

=> (e -> m)

Convert each element of an array to an appropriate Semigroup.

-> m

Initial element that must be neutral to the (<>) function.

-> Array r ix e

Source array

-> m

O(n) - Semigroup fold over an array.

Since: massiv-0.1.6

minimum :: (Source r ix e, Ord e) => Array r ix e -> e

O(n) - Compute minimum of all elements.

maximum :: (Source r ix e, Ord e) => Array r ix e -> e

O(n) - Compute maximum of all elements.

sum :: (Source r ix e, Num e) => Array r ix e -> e

O(n) - Compute sum of all elements.

product :: (Source r ix e, Num e) => Array r ix e -> e

O(n) - Compute product of all elements.

and :: Source r ix Bool => Array r ix Bool -> Bool

O(n) - Compute conjunction of all elements.

or :: Source r ix Bool => Array r ix Bool -> Bool

O(n) - Compute disjunction of all elements.

all :: Source r ix e => (e -> Bool) -> Array r ix e -> Bool

Determines whether all element of the array satisfy the predicate.

any :: Source r ix e => (e -> Bool) -> Array r ix e -> Bool

Determines whether any element of the array satisfies the predicate.

Sequential folds

Functions in this section will fold any Source array sequentially, regardless of the inner Computation strategy setting.

foldlS :: Source r ix e => (a -> e -> a) -> a -> Array r ix e -> a

O(n) - Left fold, computed sequentially.

foldrS :: Source r ix e => (e -> a -> a) -> a -> Array r ix e -> a

O(n) - Right fold, computed sequentially.

ifoldlS :: Source r ix e => (a -> ix -> e -> a) -> a -> Array r ix e -> a

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

ifoldrS :: Source r ix e => (ix -> e -> a -> a) -> a -> Array r ix e -> a

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

Monadic

foldlM :: (Source r ix e, Monad m) => (a -> e -> m a) -> a -> Array r ix e -> m a

O(n) - Monadic left fold.

foldrM :: (Source r ix e, Monad m) => (e -> a -> m a) -> a -> Array r ix e -> m a

O(n) - Monadic right fold.

foldlM_ :: (Source r ix e, Monad m) => (a -> e -> m a) -> a -> Array r ix e -> m ()

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

foldrM_ :: (Source r ix e, Monad m) => (e -> a -> m a) -> a -> Array r ix e -> m ()

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

ifoldlM :: (Source r ix e, Monad m) => (a -> ix -> e -> m a) -> a -> Array r ix e -> m a

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

ifoldrM :: (Source r ix e, Monad m) => (ix -> e -> a -> m a) -> a -> Array r ix e -> m a

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

ifoldlM_ :: (Source r ix e, Monad m) => (a -> ix -> e -> m a) -> a -> Array r ix e -> m ()

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

ifoldrM_ :: (Source r ix e, Monad m) => (ix -> e -> a -> m a) -> a -> Array r ix e -> m ()

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

Special folds

foldrFB :: Source r ix e => (e -> b -> b) -> b -> Array r ix e -> b

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

lazyFoldlS :: Source r ix e => (a -> e -> a) -> a -> Array r ix e -> a

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

lazyFoldrS :: Source r ix e => (e -> a -> a) -> a -> Array r ix e -> a

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

Parallel folds

Note It is important to compile with -threaded -with-rtsopts=-N flags, otherwise there will be no parallelization.

Functions in this section will fold any Source array in parallel, regardless of the inner Computation strategy setting. All of the parallel structured folds are performed inside IO monad, because referential transparency can't generally be preserved and results will depend on the number of cores/capabilities that computation is being performed on.

In contrast to sequential folds, each parallel folding function accepts two functions and two initial elements as arguments. This is necessary because an array is first split into chunks, which folded individually on separate cores with the first function, and the results of those folds are further folded with the second function.

foldlP

Arguments

:: Source r ix e

=> (a -> e -> a)

Folding function g.

-> a

Accumulator. Will be applied to g multiple times, thus must be neutral.

-> (b -> a -> b)

Chunk results folding function f.

-> b

Accumulator for results of chunks folding.

-> Array r ix e

-> IO b

O(n) - Left fold, computed in parallel. Parallelization of folding is implemented in such a way that an array is split into a number of chunks of equal length, plus an extra one for the left over. Number of chunks is the same as number of available cores (capabilities) plus one, and each chunk is individually folded by a separate core with a function g. Results from folding each chunk are further folded with another function f, thus allowing us to use information about the structure of an array during folding.

Examples

>>> foldlP (flip (:)) [] (flip (:)) [] $ makeArrayR U Seq (Ix1 11) id
[[10,9,8,7,6,5,4,3,2,1,0]]

And this is how the result would look like if the above computation would be performed in a program executed with +RTS -N3, i.e. with 3 capabilities:

>>> foldlOnP [1,2,3] (flip (:)) [] (flip (:)) [] $ makeArrayR U Seq (Ix1 11) id
[[10,9],[8,7,6],[5,4,3],[2,1,0]]

foldrP :: Source r ix e => (e -> a -> a) -> a -> (a -> b -> b) -> b -> Array r ix e -> IO b

O(n) - Right fold, computed in parallel. Same as foldlP, except directed from the last element in the array towards beginning.

Examples

>>> foldrP (++) [] (:) [] $ makeArray2D (3,4) id
[(0,0),(0,1),(0,2),(0,3),(1,0),(1,1),(1,2),(1,3),(2,0),(2,1),(2,2),(2,3)]

ifoldlP :: Source r ix e => (a -> ix -> e -> a) -> a -> (b -> a -> b) -> b -> Array r ix e -> IO b

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.

ifoldrP :: Source r ix e => (ix -> e -> a -> a) -> a -> (a -> b -> b) -> b -> Array r ix e -> IO b

Just like ifoldrOnP, but allows you to specify which cores to run computation on.

foldlOnP :: Source r ix e => [Int] -> (a -> e -> a) -> a -> (b -> a -> b) -> b -> Array r ix e -> IO b

Just like foldlP, but allows you to specify which cores (capabilities) to run computation on. The order in which chunked results will be supplied to function f is guaranteed to be consecutive and aligned with the folding direction.

ifoldlIO

Arguments

:: Source r ix e

=> [Int]

List of capabilities

-> (a -> ix -> e -> IO a)

Index aware folding IO action

-> a

Accumulator

-> (b -> a -> IO b)

Folding action that is applied to results of parallel fold

-> b

Accumulator for chunks folding

-> Array r ix e

-> IO b

Parallel left fold.

foldrOnP :: Source r ix e => [Int] -> (e -> a -> a) -> a -> (a -> b -> b) -> b -> Array r ix e -> IO b

Just like foldrP, but allows you to specify which cores to run computation on.

Examples

Number of wokers dictate the result structure:

>>> foldrOnP [1,2,3] (:) [] (:) [] $ makeArray1D 9 id
[[0,1,2],[3,4,5],[6,7,8]]
>>> foldrOnP [1,2,3] (:) [] (:) [] $ makeArray1D 10 id
[[0,1,2],[3,4,5],[6,7,8],[9]]
>>> foldrOnP [1,2,3] (:) [] (:) [] $ makeArray1D 12 id
[[0,1,2,3],[4,5,6,7],[8,9,10,11]]

But most of the time that structure is of no importance:

>>> foldrOnP [1,2,3] (++) [] (:) [] $ makeArray1D 10 id
[0,1,2,3,4,5,6,7,8,9]

Same as foldlOnP, order is guaranteed to be consecutive and in proper direction:

>>> fmap snd $ foldrOnP [1,2,3] (\x (i, acc) -> (i + 1, (i, x):acc)) (1, []) (:) [] $ makeArray1D 11 id
[(4,[0,1,2]),(3,[3,4,5]),(2,[6,7,8]),(1,[9,10])]
>>> fmap (P.zip [4,3..]) <$> foldrOnP [1,2,3] (:) [] (:) [] $ makeArray1D 11 id
[(4,[0,1,2]),(3,[3,4,5]),(2,[6,7,8]),(1,[9,10])]

ifoldlOnP :: Source r ix e => [Int] -> (a -> ix -> e -> a) -> a -> (b -> a -> b) -> b -> Array r ix e -> IO b

Just like ifoldlP, but allows you to specify which cores to run computation on.

ifoldrOnP :: Source r ix e => [Int] -> (ix -> e -> a -> a) -> a -> (a -> b -> b) -> b -> Array r ix e -> IO b

O(n) - Right fold with an index aware function, computed in parallel. Same as ifoldlP, except directed from the last element in the array towards beginning.

ifoldrIO :: Source r ix e => [Int] -> (ix -> e -> a -> IO a) -> a -> (a -> b -> IO b) -> b -> Array r ix e -> IO b

Parallel right fold. Differs from ifoldrP in that it accepts IO actions instead of the usual pure functions as arguments.

Transforming

Transpose

transpose :: Source r Ix2 e => Array r Ix2 e -> Array D Ix2 e

Transpose a 2-dimensional array

Examples

>>> let arr = makeArrayR U Seq (2 :. 3) (toLinearIndex (2 :. 3))
>>> arr
(ArrayU Seq (2 :. 3)
  [ [ 0,1,2 ]
  , [ 3,4,5 ]
  ])
>>> transpose arr
(Array D Seq (3 :. 2)
  [ [ 0,3 ]
  , [ 1,4 ]
  , [ 2,5 ]
  ])

transposeInner :: (Index (Lower ix), Source r' ix e) => Array r' ix e -> Array D ix e

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

Examples

>>> let arr = makeArrayR U Seq (2 :> 3 :. 4) fromIx3
>>> arr
(Array U Seq (2 :> 3 :. 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) ]
    , [ (0,2,0),(0,2,1),(0,2,2),(0,2,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) ]
    , [ (1,2,0),(1,2,1),(1,2,2),(1,2,3) ]
    ]
  ])
>>> transposeInner arr
(Array D Seq (3 :> 2 :. 4)
  [ [ [ (0,0,0),(0,0,1),(0,0,2),(0,0,3) ]
    , [ (1,0,0),(1,0,1),(1,0,2),(1,0,3) ]
    ]
  , [ [ (0,1,0),(0,1,1),(0,1,2),(0,1,3) ]
    , [ (1,1,0),(1,1,1),(1,1,2),(1,1,3) ]
    ]
  , [ [ (0,2,0),(0,2,1),(0,2,2),(0,2,3) ]
    , [ (1,2,0),(1,2,1),(1,2,2),(1,2,3) ]
    ]
  ])

transposeOuter :: (Index (Lower ix), Source r' ix e) => Array r' ix e -> Array D ix e

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

Examples

>>> let arr = makeArrayR U Seq (2 :> 3 :. 4) fromIx3
>>> arr
(Array U Seq (2 :> 3 :. 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) ]
    , [ (0,2,0),(0,2,1),(0,2,2),(0,2,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) ]
    , [ (1,2,0),(1,2,1),(1,2,2),(1,2,3) ]
    ]
  ])
>>> transposeOuter arr
(Array D Seq (2 :> 4 :. 3)
  [ [ [ (0,0,0),(0,1,0),(0,2,0) ]
    , [ (0,0,1),(0,1,1),(0,2,1) ]
    , [ (0,0,2),(0,1,2),(0,2,2) ]
    , [ (0,0,3),(0,1,3),(0,2,3) ]
    ]
  , [ [ (1,0,0),(1,1,0),(1,2,0) ]
    , [ (1,0,1),(1,1,1),(1,2,1) ]
    , [ (1,0,2),(1,1,2),(1,2,2) ]
    , [ (1,0,3),(1,1,3),(1,2,3) ]
    ]
  ])

Backpermute

backpermute

Arguments

:: (Source r' ix' e, Index ix)

=> ix

Size of the result array

-> (ix -> ix')

A function that maps indices of the new array into the source one.

-> Array r' ix' e

Source array.

-> Array D ix e

Rearrange elements of an array into a new one.

Examples

>>> let arr = makeArrayR U Seq (2 :> 3 :. 4) fromIx3
>>> arr
(Array U Seq (2 :> 3 :. 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) ]
    , [ (0,2,0),(0,2,1),(0,2,2),(0,2,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) ]
    , [ (1,2,0),(1,2,1),(1,2,2),(1,2,3) ]
    ]
  ])
>>> backpermute (4 :. 3) (\(i :. j) -> 0 :> j :. i) arr
(Array D Seq (4 :. 3)
  [ [ (0,0,0),(0,1,0),(0,2,0) ]
  , [ (0,0,1),(0,1,1),(0,2,1) ]
  , [ (0,0,2),(0,1,2),(0,2,2) ]
  , [ (0,0,3),(0,1,3),(0,2,3) ]
  ])

Resize

resize :: (Index ix', Size r ix e) => ix' -> Array r ix e -> Maybe (Array r ix' e)

O(1) - Changes the shape of an array. Returns Nothing if total number of elements does not match the source array.

resize' :: (Index ix', Size r ix e) => ix' -> Array r ix e -> Array r ix' e

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

Extract

extract

Arguments

:: Size r ix e

=> ix

Starting index

-> ix

Size fo the resulting array

-> Array r ix e

Source array

-> Maybe (Array (EltRepr r ix) ix e)

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,

extract'

Arguments

:: Size r ix e

=> ix

Starting index

-> ix

Size fo the resulting array

-> Array r ix e

Source array

-> Array (EltRepr r ix) ix e

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

extractFromTo

Arguments

:: Size r ix e

=> ix

Starting index

-> ix

Index up to which elmenets should be extracted.

-> Array r ix e

Source array.

-> Maybe (Array (EltRepr r ix) ix e)

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

Append/Split

append :: (Source r1 ix e, Source r2 ix e) => Dim -> Array r1 ix e -> Array r2 ix e -> Maybe (Array D ix e)

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

Append two 2D arrays along both dimensions. Note that they have the same shape.

>>> let arrA = makeArrayR U Seq (2 :. 3) (\(i :. j) -> ('A', i, j))
>>> let arrB = makeArrayR U Seq (2 :. 3) (\(i :. j) -> ('B', i, j))
>>> append 1 arrA arrB
Just (Array D Seq (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) ]
  ])
>>> append 2 arrA arrB
Just (Array D Seq (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) ]
  ])

Now appending arrays with different sizes:

>>> let arrC = makeArrayR U Seq (2 :. 4) (\(i :. j) -> ('C', i, j))
>>> append 1 arrA arrC
Just (Array D Seq (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) ]
  ])
>>> append 2 arrA arrC
Nothing

append' :: (Source r1 ix e, Source r2 ix e) => Dim -> Array r1 ix e -> Array r2 ix e -> Array D ix e

Same as append, but will throw an error instead of returning Nothing on mismatched sizes.

splitAt

Arguments

:: (Size r ix e, r' ~ EltRepr r ix)

=> Dim

Dimension along which to split

-> Int

Index along the dimension to split at

-> Array r ix e

Source array

-> Maybe (Array r' ix e, Array r' ix e)

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

splitAt' :: (Size r ix e, r' ~ EltRepr r ix) => Dim -> Int -> Array r ix e -> (Array r' ix e, Array r' ix e)

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

Traverse

traverse

Arguments

:: (Source r1 ix1 e1, Index ix)

=> ix

Size of the result array

-> ((ix1 -> e1) -> ix -> e)

Function that will receive a source array safe index function and an index for an element it should return a value of.

-> Array r1 ix1 e1

Source array

-> Array D ix e

Create an array by traversing a source array.

traverse2 :: (Source r1 ix1 e1, Source r2 ix2 e2, Index ix) => ix -> ((ix1 -> e1) -> (ix2 -> e2) -> ix -> e) -> Array r1 ix1 e1 -> Array r2 ix2 e2 -> Array D ix e

Create an array by traversing two source arrays.

Slicing

From the outside

(!>) :: OuterSlice r ix e => Array r ix e -> Int -> Elt r ix e infixl 4

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

You could say that slicing from outside is synonymous to slicing from the end or slicing at the highermost dimension. For example with rank-3 arrays outer slice would be equivalent to getting a page:

>>> let arr = makeArrayR U Seq (3 :> 2 :. 4) fromIx3
>>> arr
(Array U Seq (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 (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) ]
  ])

There is nothing wrong with chaining, mixing and matching slicing operators, or even using them to index arrays:

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

(!?>) :: OuterSlice r ix e => Array r ix e -> Int -> Maybe (Elt r ix e) infixl 4

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

(??>) :: OuterSlice r ix e => Maybe (Array r ix e) -> Int -> Maybe (Elt r ix e) infixl 4

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

>>> let arr = makeArrayR U Seq (3 :> 2 :. 4) fromIx3
>>> arr !?> 2 ??> 0 ??> 3
Just (2,0,3)
>>> arr !?> 2 ??> 0 ??> -1
Nothing
>>> arr !?> -2 ??> 0 ?? 1
Nothing

From the inside

(<!) :: InnerSlice r ix e => Array r ix e -> Int -> Elt r ix e infixl 4

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

(<!?) :: InnerSlice r ix e => Array r ix e -> Int -> Maybe (Elt r ix e) infixl 4

O(1) - Safe slice from the inside

(<??) :: InnerSlice r ix e => Maybe (Array r ix e) -> Int -> Maybe (Elt r ix e) infixl 4

O(1) - Safe slicing continuation from the inside

From within

(<!>) :: Slice r ix e => Array r ix e -> (Dim, Int) -> Elt r ix e infixl 4

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

arr !> i == arr <!> (dimensions (size arr), i)

arr <! i == arr <!> (1,i)

(<!?>) :: Slice r ix e => Array r ix e -> (Dim, Int) -> Maybe (Elt r ix e) infixl 4

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

(<??>) :: Slice r ix e => Maybe (Array r ix e) -> (Dim, Int) -> Maybe (Elt r ix e) infixl 4

O(1) - Safe slicing continuation from within.

Conversion

List

fromList

Arguments

:: (Nested LN Ix1 e, Nested L Ix1 e, Ragged L Ix1 e, Mutable r Ix1 e)

=> Comp

Computation startegy to use

-> [e]

Nested list

-> Array r Ix1 e

Convert a flat list into a vector

fromLists :: (Nested LN ix e, Nested L ix e, Ragged L ix e, Mutable r ix e) => Comp -> [ListItem ix e] -> Maybe (Array r ix e)

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.

Note: This function is almost the same (modulo customizable computation strategy) if you would turn on {--}. For that reason you can also use fromList.

Examples

>>> fromLists Seq [[1,2],[3,4]] :: Maybe (Array U Ix2 Int)
Just (Array U Seq (2 :. 2)
  [ [ 1,2 ]
  , [ 3,4 ]
  ])

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

Elements of a boxed array could be lists themselves if necessary, but cannot be ragged:

>>> fromLists Seq [[[1,2,3]],[[4,5]]] :: Maybe (Array B Ix2 [Int])
Just (Array B Seq (2 :. 1)
  [ [ [1,2,3] ]
  , [ [4,5] ]
  ])
>>> fromLists Seq [[[1,2,3]],[[4,5]]] :: Maybe (Array B Ix3 Int)
Nothing

fromLists'

Arguments

:: (Nested LN ix e, Nested L ix e, Ragged L ix e, Mutable r ix e)

=> Comp

Computation startegy to use

-> [ListItem ix e]

Nested list

-> Array r ix e

Same as fromLists, but will throw an error on irregular shaped lists.

Examples

Convert a list of lists into a 2D Array

>>> fromLists' Seq [[1,2],[3,4]] :: Array U Ix2 Int
(Array U Seq (2 :. 2)
  [ [ 1,2 ]
  , [ 3,4 ]
  ])

Above example implemented using GHC's OverloadedLists extension:

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

Example of failure on ceonversion of an irregular nested list.

>>> fromLists' Seq [[1],[3,4]] :: Array U Ix2 Int
(Array U *** Exception: Too many elements in a row

toList :: Source r ix e => Array r ix e -> [e]

Convert any array to a flat list.

Examples

>>> toList $ makeArrayR U Seq (2 :. 3) fromIx2
[(0,0),(0,1),(0,2),(1,0),(1,1),(1,2)]

toLists :: (Nested LN ix e, Nested L ix e, Construct L ix e, Source r ix e) => Array r ix e -> [ListItem ix e]

O(n) - Convert an array into a nested list. Array rank 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

>>> let arr = makeArrayR U Seq (2 :> 1 :. 3) fromIx3
>>> print arr
(Array U Seq (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)]]]

toLists2 :: (Source r ix e, Index (Lower ix)) => Array r ix e -> [[e]]

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

Examples

>>> toList2 $ makeArrayR U Seq (2 :. 3) fromIx2
[[(0,0),(0,1),(0,2)],[(1,0),(1,1),(1,2)]]
>>> toList2 $ makeArrayR U Seq (2 :> 1 :. 3) fromIx3
[[(0,0,0),(0,0,1),(0,0,2)],[(1,0,0),(1,0,1),(1,0,2)]]

toLists3 :: (Index (Lower (Lower ix)), Index (Lower ix), Source r ix e) => Array r ix e -> [[[e]]]

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

toLists4 :: (Index (Lower (Lower (Lower ix))), Index (Lower (Lower ix)), Index (Lower ix), Source r ix e) => Array r ix e -> [[[[e]]]]

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

Mutable

module Data.Massiv.Array.Mutable

Core

data family MVector s a :: *

Instances

MVector MVector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Bool -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool

basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool)

basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool)

MVector MVector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Char -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char

basicOverlaps :: MVector s Char -> MVector s Char -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char)

basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char)

MVector MVector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Double -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double

basicOverlaps :: MVector s Double -> MVector s Double -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double)

basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Double -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double)

MVector MVector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Float -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float

basicOverlaps :: MVector s Float -> MVector s Float -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float)

basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Float -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float)

MVector MVector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int

basicOverlaps :: MVector s Int -> MVector s Int -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int)

MVector MVector Int8

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int8 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8

basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int8)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int8 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m (MVector (PrimState m) Int8)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m Int8

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> Int8 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int8 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int8 -> Int8 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m (MVector (PrimState m) Int8)

MVector MVector Int16

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int16 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16

basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int16)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int16 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m (MVector (PrimState m) Int16)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m Int16

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> Int16 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int16 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int16 -> Int16 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m (MVector (PrimState m) Int16)

MVector MVector Int32

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int32 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32

basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int32)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int32 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m (MVector (PrimState m) Int32)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m Int32

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> Int32 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int32 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int32 -> Int32 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m (MVector (PrimState m) Int32)

MVector MVector Int64

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int64 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64

basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int64)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64)

MVector MVector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word

basicOverlaps :: MVector s Word -> MVector s Word -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word)

MVector MVector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word8 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8

basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8)

MVector MVector Word16

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word16 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16

basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word16)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word16 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m (MVector (PrimState m) Word16)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m Word16

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> Word16 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word16 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word16 -> Word16 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m (MVector (PrimState m) Word16)

MVector MVector Word32

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word32 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32

basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word32)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word32 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m (MVector (PrimState m) Word32)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m Word32

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> Word32 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word32 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word32 -> Word32 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m (MVector (PrimState m) Word32)

MVector MVector Word64

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word64 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64

basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word64)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word64 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m (MVector (PrimState m) Word64)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m Word64

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> Word64 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word64 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word64 -> Word64 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m (MVector (PrimState m) Word64)

MVector MVector ()

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s () -> Int

basicUnsafeSlice :: Int -> Int -> MVector s () -> MVector s ()

basicOverlaps :: MVector s () -> MVector s () -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) ())

basicInitialize :: PrimMonad m => MVector (PrimState m) () -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> () -> m (MVector (PrimState m) ())

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) () -> Int -> m ()

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) () -> Int -> () -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) () -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) () -> () -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) () -> Int -> m (MVector (PrimState m) ())

MVector MVector Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

basicLength :: MVector s Ix2 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Ix2 -> MVector s Ix2

basicOverlaps :: MVector s Ix2 -> MVector s Ix2 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Ix2)

basicInitialize :: PrimMonad m => MVector (PrimState m) Ix2 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Ix2 -> m (MVector (PrimState m) Ix2)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Ix2 -> Int -> m Ix2

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Ix2 -> Int -> Ix2 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Ix2 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Ix2 -> Ix2 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Ix2 -> MVector (PrimState m) Ix2 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Ix2 -> MVector (PrimState m) Ix2 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Ix2 -> Int -> m (MVector (PrimState m) Ix2)

Unbox a => MVector MVector (Complex a)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Complex a) -> MVector s (Complex a)

basicOverlaps :: MVector s (Complex a) -> MVector s (Complex a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Complex a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Complex a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Complex a -> m (MVector (PrimState m) (Complex a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (Complex a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> Complex a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Complex a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Complex a) -> Complex a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (MVector (PrimState m) (Complex a))

(3 <= n, Unbox (Ix (n - 1))) => MVector MVector (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

basicLength :: MVector s (IxN n) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (IxN n) -> MVector s (IxN n)

basicOverlaps :: MVector s (IxN n) -> MVector s (IxN n) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (IxN n))

basicInitialize :: PrimMonad m => MVector (PrimState m) (IxN n) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> IxN n -> m (MVector (PrimState m) (IxN n))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (IxN n) -> Int -> m (IxN n)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (IxN n) -> Int -> IxN n -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (IxN n) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (IxN n) -> IxN n -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (IxN n) -> MVector (PrimState m) (IxN n) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (IxN n) -> MVector (PrimState m) (IxN n) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (IxN n) -> Int -> m (MVector (PrimState m) (IxN n))

(Unbox a, Unbox b) => MVector MVector (a, b)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b) -> MVector s (a, b)

basicOverlaps :: MVector s (a, b) -> MVector s (a, b) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b) -> m (MVector (PrimState m) (a, b))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (a, b)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> (a, b) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b) -> (a, b) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (MVector (PrimState m) (a, b))

(Unbox a, Unbox b, Unbox c) => MVector MVector (a, b, c)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c) -> MVector s (a, b, c)

basicOverlaps :: MVector s (a, b, c) -> MVector s (a, b, c) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c) -> m (MVector (PrimState m) (a, b, c))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (a, b, c)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> (a, b, c) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c) -> (a, b, c) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (MVector (PrimState m) (a, b, c))

(Unbox a, Unbox b, Unbox c, Unbox d) => MVector MVector (a, b, c, d)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d) -> MVector s (a, b, c, d)

basicOverlaps :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d) -> m (MVector (PrimState m) (a, b, c, d))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (a, b, c, d)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> (a, b, c, d) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> (a, b, c, d) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (MVector (PrimState m) (a, b, c, d))

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector MVector (a, b, c, d, e)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d, e) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e)

basicOverlaps :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e) -> m (MVector (PrimState m) (a, b, c, d, e))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (a, b, c, d, e)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> (a, b, c, d, e) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> (a, b, c, d, e) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (MVector (PrimState m) (a, b, c, d, e))

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector MVector (a, b, c, d, e, f)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b, c, d, e, f) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f)

basicOverlaps :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e, f))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e, f) -> m (MVector (PrimState m) (a, b, c, d, e, f))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> (a, b, c, d, e, f) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (MVector (PrimState m) (a, b, c, d, e, f))

NFData (MVector s a)

Defined in Data.Vector.Unboxed.Base

Methods

rnf :: MVector s a -> ()

data MVector s Ix2

Defined in Data.Massiv.Core.Index.Ix

data MVector s Ix2 = MV_Ix2 (MVector s Ix2T)

data MVector s Bool

Defined in Data.Vector.Unboxed.Base

data MVector s Bool = MV_Bool (MVector s Word8)

data MVector s Char

Defined in Data.Vector.Unboxed.Base

data MVector s Char = MV_Char (MVector s Char)

data MVector s Double

Defined in Data.Vector.Unboxed.Base

data MVector s Double = MV_Double (MVector s Double)

data MVector s Float

Defined in Data.Vector.Unboxed.Base

data MVector s Float = MV_Float (MVector s Float)

data MVector s Word64

Defined in Data.Vector.Unboxed.Base

data MVector s Word64 = MV_Word64 (MVector s Word64)

data MVector s Word32

Defined in Data.Vector.Unboxed.Base

data MVector s Word32 = MV_Word32 (MVector s Word32)

data MVector s Word16

Defined in Data.Vector.Unboxed.Base

data MVector s Word16 = MV_Word16 (MVector s Word16)

data MVector s Word8

Defined in Data.Vector.Unboxed.Base

data MVector s Word8 = MV_Word8 (MVector s Word8)

data MVector s Word

Defined in Data.Vector.Unboxed.Base

data MVector s Word = MV_Word (MVector s Word)

data MVector s Int64

Defined in Data.Vector.Unboxed.Base

data MVector s Int64 = MV_Int64 (MVector s Int64)

data MVector s Int32

Defined in Data.Vector.Unboxed.Base

data MVector s Int32 = MV_Int32 (MVector s Int32)

data MVector s Int16

Defined in Data.Vector.Unboxed.Base

data MVector s Int16 = MV_Int16 (MVector s Int16)

data MVector s Int8

Defined in Data.Vector.Unboxed.Base

data MVector s Int8 = MV_Int8 (MVector s Int8)

data MVector s Int

Defined in Data.Vector.Unboxed.Base

data MVector s Int = MV_Int (MVector s Int)

data MVector s ()

Defined in Data.Vector.Unboxed.Base

data MVector s () = MV_Unit Int

data MVector s (Complex a)

Defined in Data.Vector.Unboxed.Base

data MVector s (Complex a) = MV_Complex (MVector s (a, a))

data MVector s (IxN n)

Defined in Data.Massiv.Core.Index.Ix

data MVector s (IxN n) = MV_IxN (MVector s Int, MVector s (Ix (n - 1)))

data MVector s (a, b)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b) = MV_2 !Int !(MVector s a) !(MVector s b)

data MVector s (a, b, c)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c) = MV_3 !Int !(MVector s a) !(MVector s b) !(MVector s c)

data MVector s (a, b, c, d)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c, d) = MV_4 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d)

data MVector s (a, b, c, d, e)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c, d, e) = MV_5 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e)

data MVector s (a, b, c, d, e, f)

Defined in Data.Vector.Unboxed.Base

data MVector s (a, b, c, d, e, f) = MV_6 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e) !(MVector s f)

data family Vector a :: *

Instances

Vector Vector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool)

basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool)

basicLength :: Vector Bool -> Int

basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool

basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m ()

elemseq :: Vector Bool -> Bool -> b -> b

Vector Vector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char)

basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char)

basicLength :: Vector Char -> Int

basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char

basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m ()

elemseq :: Vector Char -> Char -> b -> b

Vector Vector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double)

basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double)

basicLength :: Vector Double -> Int

basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double

basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m ()

elemseq :: Vector Double -> Double -> b -> b

Vector Vector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float)

basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float)

basicLength :: Vector Float -> Int

basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float

basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m ()

elemseq :: Vector Float -> Float -> b -> b

Vector Vector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int)

basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int)

basicLength :: Vector Int -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int

basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m ()

elemseq :: Vector Int -> Int -> b -> b

Vector Vector Int8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> m (Vector Int8)

basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m (Mutable Vector (PrimState m) Int8)

basicLength :: Vector Int8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8

basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> Vector Int8 -> m ()

elemseq :: Vector Int8 -> Int8 -> b -> b

Vector Vector Int16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> m (Vector Int16)

basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m (Mutable Vector (PrimState m) Int16)

basicLength :: Vector Int16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16

basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> Vector Int16 -> m ()

elemseq :: Vector Int16 -> Int16 -> b -> b

Vector Vector Int32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32)

basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32)

basicLength :: Vector Int32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32

basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m ()

elemseq :: Vector Int32 -> Int32 -> b -> b

Vector Vector Int64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64)

basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64)

basicLength :: Vector Int64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64

basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m ()

elemseq :: Vector Int64 -> Int64 -> b -> b

Vector Vector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word)

basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word)

basicLength :: Vector Word -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word

basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m ()

elemseq :: Vector Word -> Word -> b -> b

Vector Vector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8)

basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8)

basicLength :: Vector Word8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8

basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m ()

elemseq :: Vector Word8 -> Word8 -> b -> b

Vector Vector Word16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16)

basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16)

basicLength :: Vector Word16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16

basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m ()

elemseq :: Vector Word16 -> Word16 -> b -> b

Vector Vector Word32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32)

basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32)

basicLength :: Vector Word32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32

basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m ()

elemseq :: Vector Word32 -> Word32 -> b -> b

Vector Vector Word64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64)

basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64)

basicLength :: Vector Word64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64

basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m ()

elemseq :: Vector Word64 -> Word64 -> b -> b

Vector Vector ()

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) () -> m (Vector ())

basicUnsafeThaw :: PrimMonad m => Vector () -> m (Mutable Vector (PrimState m) ())

basicLength :: Vector () -> Int

basicUnsafeSlice :: Int -> Int -> Vector () -> Vector ()

basicUnsafeIndexM :: Monad m => Vector () -> Int -> m ()

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) () -> Vector () -> m ()

elemseq :: Vector () -> () -> b -> b

Vector Vector Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Ix2 -> m (Vector Ix2)

basicUnsafeThaw :: PrimMonad m => Vector Ix2 -> m (Mutable Vector (PrimState m) Ix2)

basicLength :: Vector Ix2 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Ix2 -> Vector Ix2

basicUnsafeIndexM :: Monad m => Vector Ix2 -> Int -> m Ix2

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Ix2 -> Vector Ix2 -> m ()

elemseq :: Vector Ix2 -> Ix2 -> b -> b

Unbox a => Vector Vector (Complex a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> m (Vector (Complex a))

basicUnsafeThaw :: PrimMonad m => Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a))

basicLength :: Vector (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a)

basicUnsafeIndexM :: Monad m => Vector (Complex a) -> Int -> m (Complex a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> Vector (Complex a) -> m ()

elemseq :: Vector (Complex a) -> Complex a -> b -> b

(3 <= n, Unbox (Ix (n - 1))) => Vector Vector (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (IxN n) -> m (Vector (IxN n))

basicUnsafeThaw :: PrimMonad m => Vector (IxN n) -> m (Mutable Vector (PrimState m) (IxN n))

basicLength :: Vector (IxN n) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (IxN n) -> Vector (IxN n)

basicUnsafeIndexM :: Monad m => Vector (IxN n) -> Int -> m (IxN n)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (IxN n) -> Vector (IxN n) -> m ()

elemseq :: Vector (IxN n) -> IxN n -> b -> b

(Unbox a, Unbox b) => Vector Vector (a, b)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> m (Vector (a, b))

basicUnsafeThaw :: PrimMonad m => Vector (a, b) -> m (Mutable Vector (PrimState m) (a, b))

basicLength :: Vector (a, b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b)

basicUnsafeIndexM :: Monad m => Vector (a, b) -> Int -> m (a, b)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> Vector (a, b) -> m ()

elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0

(Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> m (Vector (a, b, c))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c) -> m (Mutable Vector (PrimState m) (a, b, c))

basicLength :: Vector (a, b, c) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c)

basicUnsafeIndexM :: Monad m => Vector (a, b, c) -> Int -> m (a, b, c)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> Vector (a, b, c) -> m ()

elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0

(Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> m (Vector (a, b, c, d))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d) -> m (Mutable Vector (PrimState m) (a, b, c, d))

basicLength :: Vector (a, b, c, d) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d) -> Vector (a, b, c, d)

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d) -> Int -> m (a, b, c, d)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> Vector (a, b, c, d) -> m ()

elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector Vector (a, b, c, d, e)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> m (Vector (a, b, c, d, e))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e) -> m (Mutable Vector (PrimState m) (a, b, c, d, e))

basicLength :: Vector (a, b, c, d, e) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e) -> Vector (a, b, c, d, e)

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e) -> Int -> m (a, b, c, d, e)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> Vector (a, b, c, d, e) -> m ()

elemseq :: Vector (a, b, c, d, e) -> (a, b, c, d, e) -> b0 -> b0

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector Vector (a, b, c, d, e, f)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> m (Vector (a, b, c, d, e, f))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e, f) -> m (Mutable Vector (PrimState m) (a, b, c, d, e, f))

basicLength :: Vector (a, b, c, d, e, f) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f)

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> m ()

elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0

(Data a, Unbox a) => Data (Vector a)

Defined in Data.Vector.Unboxed.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a)

toConstr :: Vector a -> Constr

dataTypeOf :: Vector a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a))

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a)

NFData (Vector a)

Defined in Data.Vector.Unboxed.Base

Methods

rnf :: Vector a -> ()

data Vector Bool

Defined in Data.Vector.Unboxed.Base

data Vector Bool = V_Bool (Vector Word8)

data Vector Char

Defined in Data.Vector.Unboxed.Base

data Vector Char = V_Char (Vector Char)

data Vector Double

Defined in Data.Vector.Unboxed.Base

data Vector Double = V_Double (Vector Double)

data Vector Float

Defined in Data.Vector.Unboxed.Base

data Vector Float = V_Float (Vector Float)

data Vector Int

Defined in Data.Vector.Unboxed.Base

data Vector Int = V_Int (Vector Int)

data Vector Int8

Defined in Data.Vector.Unboxed.Base

data Vector Int8 = V_Int8 (Vector Int8)

data Vector Int16

Defined in Data.Vector.Unboxed.Base

data Vector Int16 = V_Int16 (Vector Int16)

data Vector Int32

Defined in Data.Vector.Unboxed.Base

data Vector Int32 = V_Int32 (Vector Int32)

data Vector Int64

Defined in Data.Vector.Unboxed.Base

data Vector Int64 = V_Int64 (Vector Int64)

data Vector Word

Defined in Data.Vector.Unboxed.Base

data Vector Word = V_Word (Vector Word)

data Vector Word8

Defined in Data.Vector.Unboxed.Base

data Vector Word8 = V_Word8 (Vector Word8)

data Vector Word16

Defined in Data.Vector.Unboxed.Base

data Vector Word16 = V_Word16 (Vector Word16)

data Vector Word32

Defined in Data.Vector.Unboxed.Base

data Vector Word32 = V_Word32 (Vector Word32)

data Vector Word64

Defined in Data.Vector.Unboxed.Base

data Vector Word64 = V_Word64 (Vector Word64)

data Vector ()

Defined in Data.Vector.Unboxed.Base

data Vector () = V_Unit Int

data Vector Ix2

Defined in Data.Massiv.Core.Index.Ix

data Vector Ix2 = V_Ix2 (Vector Ix2T)

type Mutable Vector

Defined in Data.Vector.Unboxed.Base

type Mutable Vector = MVector

type ARepr Vector

Defined in Data.Massiv.Array.Manifest.Vector

type ARepr Vector = U

type Item (Vector e)

Defined in Data.Vector.Unboxed

type Item (Vector e) = e

data Vector (Complex a)

Defined in Data.Vector.Unboxed.Base

data Vector (Complex a) = V_Complex (Vector (a, a))

data Vector (IxN n)

Defined in Data.Massiv.Core.Index.Ix

data Vector (IxN n) = V_IxN (Vector Int, Vector (Ix (n - 1)))

data Vector (a, b)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b) = V_2 !Int !(Vector a) !(Vector b)

data Vector (a, b, c)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b, c) = V_3 !Int !(Vector a) !(Vector b) !(Vector c)

data Vector (a, b, c, d)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b, c, d) = V_4 !Int !(Vector a) !(Vector b) !(Vector c) !(Vector d)

data Vector (a, b, c, d, e)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b, c, d, e) = V_5 !Int !(Vector a) !(Vector b) !(Vector c) !(Vector d) !(Vector e)

data Vector (a, b, c, d, e, f)

Defined in Data.Vector.Unboxed.Base

data Vector (a, b, c, d, e, f) = V_6 !Int !(Vector a) !(Vector b) !(Vector c) !(Vector d) !(Vector e) !(Vector f)

data Comp

Computation type to use.

Constructors

Seq

Sequential computation

ParOn [Int]

Use Par instead to use your CPU to the fullest. Also don't forget to compile the program with -threaded flag.

Parallel computation with a list of capabilities to run computation on. Specifying an empty list (ParOn []) or using Par will result in utilization of all available capabilities, which are set at runtime by +RTS -Nx or at compile time by GHC flag -with-rtsopts=-Nx, where x is the number of capabilities. Ommiting x in above flags defaults to number available cores.

Bundled Patterns

pattern Par :: Comp

Parallel computation using all available cores.

Instances

Eq Comp

Defined in Data.Massiv.Core.Computation

Methods

(==) :: Comp -> Comp -> Bool

(/=) :: Comp -> Comp -> Bool

Show Comp

Defined in Data.Massiv.Core.Computation

Methods

showsPrec :: Int -> Comp -> ShowS

show :: Comp -> String

showList :: [Comp] -> ShowS

Semigroup Comp

Defined in Data.Massiv.Core.Computation

Methods

(<>) :: Comp -> Comp -> Comp

sconcat :: NonEmpty Comp -> Comp

stimes :: Integral b => b -> Comp -> Comp

Monoid Comp

Defined in Data.Massiv.Core.Computation

Methods

mempty :: Comp

mappend :: Comp -> Comp -> Comp

mconcat :: [Comp] -> Comp

NFData Comp

Defined in Data.Massiv.Core.Computation

Methods

rnf :: Comp -> ()

loop :: Int -> (Int -> Bool) -> (Int -> Int) -> a -> (Int -> a -> a) -> a

Efficient loop with an accumulator

loopM :: Monad m => Int -> (Int -> Bool) -> (Int -> Int) -> a -> (Int -> a -> m a) -> m a

Very efficient monadic loop with an accumulator

loopM_ :: Monad m => Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m a) -> m ()

Efficient monadic loop. Result of each iteration is discarded.

loopDeepM :: Monad m => Int -> (Int -> Bool) -> (Int -> Int) -> a -> (Int -> a -> m a) -> m a

Less efficient monadic loop with an accumulator that reverses the direction of action application

splitLinearly :: Int -> Int -> (Int -> Int -> a) -> a

splitLinearlyWith_ :: Monad m => Int -> (m () -> m a) -> Int -> (Int -> b) -> (Int -> b -> m ()) -> m a

class (Eq ix, Ord ix, Show ix, NFData ix) => Index ix where

This is bread and butter of multi-dimensional array indexing. It is unlikely that any of the functions in this class will be useful to a regular user, unless general algorithms are being implemented that do span multiple dimensions.

Minimal complete definition

dimensions, totalElem, consDim, unconsDim, snocDim, unsnocDim, dropDim, getIndex, setIndex, pureIndex, liftIndex2

Associated Types

type Dimensions ix :: Nat

Methods

dimensions :: ix -> Dim

Dimensions of an array that has this index type, i.e. what is the dimensionality.

totalElem :: ix -> Int

Total number of elements in an array of this size.

consDim :: Int -> Lower ix -> ix

Prepend a dimension to the index

unconsDim :: ix -> (Int, Lower ix)

Take a dimension from the index from the outside

snocDim :: Lower ix -> Int -> ix

Apppend a dimension to the index

unsnocDim :: ix -> (Lower ix, Int)

Take a dimension from the index from the inside

dropDim :: ix -> Dim -> Maybe (Lower ix)

Remove a dimension from the index

getIndex :: ix -> Dim -> Maybe Int

Extract the value index has at specified dimension.

setIndex :: ix -> Dim -> Int -> Maybe ix

Set the value for an index at specified dimension.

pureIndex :: Int -> ix

Lift an Int to any index by replicating the value as many times as there are dimensions.

liftIndex2 :: (Int -> Int -> Int) -> ix -> ix -> ix

Zip together two indices with a function

liftIndex :: (Int -> Int) -> ix -> ix

Map a function over an index

foldlIndex :: (a -> Int -> a) -> a -> ix -> a

foldlIndex :: Index (Lower ix) => (a -> Int -> a) -> a -> ix -> a

isSafeIndex

Arguments

:: ix

Size

-> ix

Index

-> Bool

Check whether index is within the size.

isSafeIndex

Arguments

:: Index (Lower ix)

=> ix

Size

-> ix

Index

-> Bool

Check whether index is within the size.

toLinearIndex

Arguments

:: ix

Size

-> ix

Index

-> Int

Convert linear index from size and index

toLinearIndex

Arguments

:: Index (Lower ix)

=> ix

Size

-> ix

Index

-> Int

Convert linear index from size and index

toLinearIndexAcc :: Int -> ix -> ix -> Int

Convert linear index from size and index with an accumulator. Currently is useless and will likley be removed in future versions.

toLinearIndexAcc :: Index (Lower ix) => Int -> ix -> ix -> Int

Convert linear index from size and index with an accumulator. Currently is useless and will likley be removed in future versions.

fromLinearIndex :: ix -> Int -> ix

Compute an index from size and linear index

fromLinearIndex :: Index (Lower ix) => ix -> Int -> ix

Compute an index from size and linear index

fromLinearIndexAcc :: ix -> Int -> (Int, ix)

Compute an index from size and linear index using an accumulator, thus trying to optimize for tail recursion while getting the index computed.

fromLinearIndexAcc :: Index (Lower ix) => ix -> Int -> (Int, ix)

Compute an index from size and linear index using an accumulator, thus trying to optimize for tail recursion while getting the index computed.

repairIndex

Arguments

:: ix

Size

-> ix

Index

-> (Int -> Int -> Int)

Repair when below zero

-> (Int -> Int -> Int)

Repair when higher than size

-> ix

A way to make sure index is withing the bounds for the supplied size. Takes two functions that will be invoked whenever index (2nd arg) is outsize the supplied size (1st arg)

repairIndex

Arguments

:: Index (Lower ix)

=> ix

Size

-> ix

Index

-> (Int -> Int -> Int)

Repair when below zero

-> (Int -> Int -> Int)

Repair when higher than size

-> ix

A way to make sure index is withing the bounds for the supplied size. Takes two functions that will be invoked whenever index (2nd arg) is outsize the supplied size (1st arg)

iter :: ix -> ix -> ix -> (Int -> Int -> Bool) -> a -> (ix -> a -> a) -> a

Iterator for the index. Same as iterM, but pure.

iterM

Arguments

:: Monad m

=> ix

Start index

-> ix

End index

-> ix

Increment

-> (Int -> Int -> Bool)

Continue iterating while predicate is True (eg. until end of row)

-> a

Initial value for an accumulator

-> (ix -> a -> m a)

Accumulator function

-> m a

This function is what makes it possible to iterate over an array of any dimension.

iterM

Arguments

:: (Index (Lower ix), Monad m)

=> ix

Start index

-> ix

End index

-> ix

Increment

-> (Int -> Int -> Bool)

Continue iterating while predicate is True (eg. until end of row)

-> a

Initial value for an accumulator

-> (ix -> a -> m a)

Accumulator function

-> m a

This function is what makes it possible to iterate over an array of any dimension.

iterM_ :: Monad m => ix -> ix -> ix -> (Int -> Int -> Bool) -> (ix -> m a) -> m ()

Same as iterM, but don't bother with accumulator and return value.

iterM_ :: (Index (Lower ix), Monad m) => ix -> ix -> ix -> (Int -> Int -> Bool) -> (ix -> m a) -> m ()

Same as iterM, but don't bother with accumulator and return value.

Instances

Index Ix5T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix5T :: Nat

Methods

dimensions :: Ix5T -> Dim

totalElem :: Ix5T -> Int

consDim :: Int -> Lower Ix5T -> Ix5T

unconsDim :: Ix5T -> (Int, Lower Ix5T)

snocDim :: Lower Ix5T -> Int -> Ix5T

unsnocDim :: Ix5T -> (Lower Ix5T, Int)

dropDim :: Ix5T -> Dim -> Maybe (Lower Ix5T)

getIndex :: Ix5T -> Dim -> Maybe Int

setIndex :: Ix5T -> Dim -> Int -> Maybe Ix5T

pureIndex :: Int -> Ix5T

liftIndex2 :: (Int -> Int -> Int) -> Ix5T -> Ix5T -> Ix5T

liftIndex :: (Int -> Int) -> Ix5T -> Ix5T

foldlIndex :: (a -> Int -> a) -> a -> Ix5T -> a

isSafeIndex :: Ix5T -> Ix5T -> Bool

toLinearIndex :: Ix5T -> Ix5T -> Int

toLinearIndexAcc :: Int -> Ix5T -> Ix5T -> Int

fromLinearIndex :: Ix5T -> Int -> Ix5T

fromLinearIndexAcc :: Ix5T -> Int -> (Int, Ix5T)

repairIndex :: Ix5T -> Ix5T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix5T

iter :: Ix5T -> Ix5T -> Ix5T -> (Int -> Int -> Bool) -> a -> (Ix5T -> a -> a) -> a

iterM :: Monad m => Ix5T -> Ix5T -> Ix5T -> (Int -> Int -> Bool) -> a -> (Ix5T -> a -> m a) -> m a

iterM_ :: Monad m => Ix5T -> Ix5T -> Ix5T -> (Int -> Int -> Bool) -> (Ix5T -> m a) -> m ()

Index Ix4T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix4T :: Nat

Methods

dimensions :: Ix4T -> Dim

totalElem :: Ix4T -> Int

consDim :: Int -> Lower Ix4T -> Ix4T

unconsDim :: Ix4T -> (Int, Lower Ix4T)

snocDim :: Lower Ix4T -> Int -> Ix4T

unsnocDim :: Ix4T -> (Lower Ix4T, Int)

dropDim :: Ix4T -> Dim -> Maybe (Lower Ix4T)

getIndex :: Ix4T -> Dim -> Maybe Int

setIndex :: Ix4T -> Dim -> Int -> Maybe Ix4T

pureIndex :: Int -> Ix4T

liftIndex2 :: (Int -> Int -> Int) -> Ix4T -> Ix4T -> Ix4T

liftIndex :: (Int -> Int) -> Ix4T -> Ix4T

foldlIndex :: (a -> Int -> a) -> a -> Ix4T -> a

isSafeIndex :: Ix4T -> Ix4T -> Bool

toLinearIndex :: Ix4T -> Ix4T -> Int

toLinearIndexAcc :: Int -> Ix4T -> Ix4T -> Int

fromLinearIndex :: Ix4T -> Int -> Ix4T

fromLinearIndexAcc :: Ix4T -> Int -> (Int, Ix4T)

repairIndex :: Ix4T -> Ix4T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix4T

iter :: Ix4T -> Ix4T -> Ix4T -> (Int -> Int -> Bool) -> a -> (Ix4T -> a -> a) -> a

iterM :: Monad m => Ix4T -> Ix4T -> Ix4T -> (Int -> Int -> Bool) -> a -> (Ix4T -> a -> m a) -> m a

iterM_ :: Monad m => Ix4T -> Ix4T -> Ix4T -> (Int -> Int -> Bool) -> (Ix4T -> m a) -> m ()

Index Ix3T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix3T :: Nat

Methods

dimensions :: Ix3T -> Dim

totalElem :: Ix3T -> Int

consDim :: Int -> Lower Ix3T -> Ix3T

unconsDim :: Ix3T -> (Int, Lower Ix3T)

snocDim :: Lower Ix3T -> Int -> Ix3T

unsnocDim :: Ix3T -> (Lower Ix3T, Int)

dropDim :: Ix3T -> Dim -> Maybe (Lower Ix3T)

getIndex :: Ix3T -> Dim -> Maybe Int

setIndex :: Ix3T -> Dim -> Int -> Maybe Ix3T

pureIndex :: Int -> Ix3T

liftIndex2 :: (Int -> Int -> Int) -> Ix3T -> Ix3T -> Ix3T

liftIndex :: (Int -> Int) -> Ix3T -> Ix3T

foldlIndex :: (a -> Int -> a) -> a -> Ix3T -> a

isSafeIndex :: Ix3T -> Ix3T -> Bool

toLinearIndex :: Ix3T -> Ix3T -> Int

toLinearIndexAcc :: Int -> Ix3T -> Ix3T -> Int

fromLinearIndex :: Ix3T -> Int -> Ix3T

fromLinearIndexAcc :: Ix3T -> Int -> (Int, Ix3T)

repairIndex :: Ix3T -> Ix3T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix3T

iter :: Ix3T -> Ix3T -> Ix3T -> (Int -> Int -> Bool) -> a -> (Ix3T -> a -> a) -> a

iterM :: Monad m => Ix3T -> Ix3T -> Ix3T -> (Int -> Int -> Bool) -> a -> (Ix3T -> a -> m a) -> m a

iterM_ :: Monad m => Ix3T -> Ix3T -> Ix3T -> (Int -> Int -> Bool) -> (Ix3T -> m a) -> m ()

Index Ix2T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix2T :: Nat

Methods

dimensions :: Ix2T -> Dim

totalElem :: Ix2T -> Int

consDim :: Int -> Lower Ix2T -> Ix2T

unconsDim :: Ix2T -> (Int, Lower Ix2T)

snocDim :: Lower Ix2T -> Int -> Ix2T

unsnocDim :: Ix2T -> (Lower Ix2T, Int)

dropDim :: Ix2T -> Dim -> Maybe (Lower Ix2T)

getIndex :: Ix2T -> Dim -> Maybe Int

setIndex :: Ix2T -> Dim -> Int -> Maybe Ix2T

pureIndex :: Int -> Ix2T

liftIndex2 :: (Int -> Int -> Int) -> Ix2T -> Ix2T -> Ix2T

liftIndex :: (Int -> Int) -> Ix2T -> Ix2T

foldlIndex :: (a -> Int -> a) -> a -> Ix2T -> a

isSafeIndex :: Ix2T -> Ix2T -> Bool

toLinearIndex :: Ix2T -> Ix2T -> Int

toLinearIndexAcc :: Int -> Ix2T -> Ix2T -> Int

fromLinearIndex :: Ix2T -> Int -> Ix2T

fromLinearIndexAcc :: Ix2T -> Int -> (Int, Ix2T)

repairIndex :: Ix2T -> Ix2T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix2T

iter :: Ix2T -> Ix2T -> Ix2T -> (Int -> Int -> Bool) -> a -> (Ix2T -> a -> a) -> a

iterM :: Monad m => Ix2T -> Ix2T -> Ix2T -> (Int -> Int -> Bool) -> a -> (Ix2T -> a -> m a) -> m a

iterM_ :: Monad m => Ix2T -> Ix2T -> Ix2T -> (Int -> Int -> Bool) -> (Ix2T -> m a) -> m ()

Index Ix1T

Defined in Data.Massiv.Core.Index.Class

Associated Types

type Dimensions Ix1T :: Nat

Methods

dimensions :: Ix1T -> Dim

totalElem :: Ix1T -> Int

consDim :: Int -> Lower Ix1T -> Ix1T

unconsDim :: Ix1T -> (Int, Lower Ix1T)

snocDim :: Lower Ix1T -> Int -> Ix1T

unsnocDim :: Ix1T -> (Lower Ix1T, Int)

dropDim :: Ix1T -> Dim -> Maybe (Lower Ix1T)

getIndex :: Ix1T -> Dim -> Maybe Int

setIndex :: Ix1T -> Dim -> Int -> Maybe Ix1T

pureIndex :: Int -> Ix1T

liftIndex2 :: (Int -> Int -> Int) -> Ix1T -> Ix1T -> Ix1T

liftIndex :: (Int -> Int) -> Ix1T -> Ix1T

foldlIndex :: (a -> Int -> a) -> a -> Ix1T -> a

isSafeIndex :: Ix1T -> Ix1T -> Bool

toLinearIndex :: Ix1T -> Ix1T -> Int

toLinearIndexAcc :: Int -> Ix1T -> Ix1T -> Int

fromLinearIndex :: Ix1T -> Int -> Ix1T

fromLinearIndexAcc :: Ix1T -> Int -> (Int, Ix1T)

repairIndex :: Ix1T -> Ix1T -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix1T

iter :: Ix1T -> Ix1T -> Ix1T -> (Int -> Int -> Bool) -> a -> (Ix1T -> a -> a) -> a

iterM :: Monad m => Ix1T -> Ix1T -> Ix1T -> (Int -> Int -> Bool) -> a -> (Ix1T -> a -> m a) -> m a

iterM_ :: Monad m => Ix1T -> Ix1T -> Ix1T -> (Int -> Int -> Bool) -> (Ix1T -> m a) -> m ()

Index Ix2

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions Ix2 :: Nat

Methods

dimensions :: Ix2 -> Dim

totalElem :: Ix2 -> Int

consDim :: Int -> Lower Ix2 -> Ix2

unconsDim :: Ix2 -> (Int, Lower Ix2)

snocDim :: Lower Ix2 -> Int -> Ix2

unsnocDim :: Ix2 -> (Lower Ix2, Int)

dropDim :: Ix2 -> Dim -> Maybe (Lower Ix2)

getIndex :: Ix2 -> Dim -> Maybe Int

setIndex :: Ix2 -> Dim -> Int -> Maybe Ix2

pureIndex :: Int -> Ix2

liftIndex2 :: (Int -> Int -> Int) -> Ix2 -> Ix2 -> Ix2

liftIndex :: (Int -> Int) -> Ix2 -> Ix2

foldlIndex :: (a -> Int -> a) -> a -> Ix2 -> a

isSafeIndex :: Ix2 -> Ix2 -> Bool

toLinearIndex :: Ix2 -> Ix2 -> Int

toLinearIndexAcc :: Int -> Ix2 -> Ix2 -> Int

fromLinearIndex :: Ix2 -> Int -> Ix2

fromLinearIndexAcc :: Ix2 -> Int -> (Int, Ix2)

repairIndex :: Ix2 -> Ix2 -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix2

iter :: Ix2 -> Ix2 -> Ix2 -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> a) -> a

iterM :: Monad m => Ix2 -> Ix2 -> Ix2 -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> m a) -> m a

iterM_ :: Monad m => Ix2 -> Ix2 -> Ix2 -> (Int -> Int -> Bool) -> (Ix2 -> m a) -> m ()

(4 <= n, KnownNat n, Index (Ix (n - 1)), IxN (n - 1) ~ Ix (n - 1)) => Index (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions (IxN n) :: Nat

Methods

dimensions :: IxN n -> Dim

totalElem :: IxN n -> Int

consDim :: Int -> Lower (IxN n) -> IxN n

unconsDim :: IxN n -> (Int, Lower (IxN n))

snocDim :: Lower (IxN n) -> Int -> IxN n

unsnocDim :: IxN n -> (Lower (IxN n), Int)

dropDim :: IxN n -> Dim -> Maybe (Lower (IxN n))

getIndex :: IxN n -> Dim -> Maybe Int

setIndex :: IxN n -> Dim -> Int -> Maybe (IxN n)

pureIndex :: Int -> IxN n

liftIndex2 :: (Int -> Int -> Int) -> IxN n -> IxN n -> IxN n

liftIndex :: (Int -> Int) -> IxN n -> IxN n

foldlIndex :: (a -> Int -> a) -> a -> IxN n -> a

isSafeIndex :: IxN n -> IxN n -> Bool

toLinearIndex :: IxN n -> IxN n -> Int

toLinearIndexAcc :: Int -> IxN n -> IxN n -> Int

fromLinearIndex :: IxN n -> Int -> IxN n

fromLinearIndexAcc :: IxN n -> Int -> (Int, IxN n)

repairIndex :: IxN n -> IxN n -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> IxN n

iter :: IxN n -> IxN n -> IxN n -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> a) -> a

iterM :: Monad m => IxN n -> IxN n -> IxN n -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> m a) -> m a

iterM_ :: Monad m => IxN n -> IxN n -> IxN n -> (Int -> Int -> Bool) -> (IxN n -> m a) -> m ()

Index (IxN 3)

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions (IxN 3) :: Nat

Methods

dimensions :: IxN 3 -> Dim

totalElem :: IxN 3 -> Int

consDim :: Int -> Lower (IxN 3) -> IxN 3

unconsDim :: IxN 3 -> (Int, Lower (IxN 3))

snocDim :: Lower (IxN 3) -> Int -> IxN 3

unsnocDim :: IxN 3 -> (Lower (IxN 3), Int)

dropDim :: IxN 3 -> Dim -> Maybe (Lower (IxN 3))

getIndex :: IxN 3 -> Dim -> Maybe Int

setIndex :: IxN 3 -> Dim -> Int -> Maybe (IxN 3)

pureIndex :: Int -> IxN 3

liftIndex2 :: (Int -> Int -> Int) -> IxN 3 -> IxN 3 -> IxN 3

liftIndex :: (Int -> Int) -> IxN 3 -> IxN 3

foldlIndex :: (a -> Int -> a) -> a -> IxN 3 -> a

isSafeIndex :: IxN 3 -> IxN 3 -> Bool

toLinearIndex :: IxN 3 -> IxN 3 -> Int

toLinearIndexAcc :: Int -> IxN 3 -> IxN 3 -> Int

fromLinearIndex :: IxN 3 -> Int -> IxN 3

fromLinearIndexAcc :: IxN 3 -> Int -> (Int, IxN 3)

repairIndex :: IxN 3 -> IxN 3 -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> IxN 3

iter :: IxN 3 -> IxN 3 -> IxN 3 -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> a) -> a

iterM :: Monad m => IxN 3 -> IxN 3 -> IxN 3 -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> m a) -> m a

iterM_ :: Monad m => IxN 3 -> IxN 3 -> IxN 3 -> (Int -> Int -> Bool) -> (IxN 3 -> m a) -> m ()

type family Lower ix :: *

This type family will always point to a type for a dimension that is one lower than the type argument.

Instances

type Lower Ix5T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix5T = Ix4T

type Lower Ix4T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix4T = Ix3T

type Lower Ix3T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix3T = Ix2T

type Lower Ix2T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix2T = Ix1T

type Lower Ix1T

Defined in Data.Massiv.Core.Index.Class

type Lower Ix1T = Ix0

type Lower Ix2

Defined in Data.Massiv.Core.Index.Ix

type Lower Ix2 = Ix1

type Lower (IxN n)

Defined in Data.Massiv.Core.Index.Ix

type Lower (IxN n) = Ix (n - 1)

type Ix5T = (Int, Int, Int, Int, Int)

5-dimensional index as 5-tuple of Ints.

type Ix4T = (Int, Int, Int, Int)

4-dimensional index as 4-tuple of Ints.

type Ix3T = (Int, Int, Int)

3-dimensional index as 3-tuple of Ints.

type Ix2T = (Int, Int)

2-dimensional index as tuple of Ints.

type Ix1T = Int

1-dimensional index. Synonym for Int and Ix1.

data Ix0

Zero-dimension, i.e. a scalar. Can't really be used directly as there are no instances of Index for it, and is included for completeness.

Constructors

Ix0

Instances

Eq Ix0

Defined in Data.Massiv.Core.Index.Class

Methods

(==) :: Ix0 -> Ix0 -> Bool

(/=) :: Ix0 -> Ix0 -> Bool

Ord Ix0

Defined in Data.Massiv.Core.Index.Class

Methods

compare :: Ix0 -> Ix0 -> Ordering

(<) :: Ix0 -> Ix0 -> Bool

(<=) :: Ix0 -> Ix0 -> Bool

(>) :: Ix0 -> Ix0 -> Bool

(>=) :: Ix0 -> Ix0 -> Bool

max :: Ix0 -> Ix0 -> Ix0

min :: Ix0 -> Ix0 -> Ix0

Show Ix0

Defined in Data.Massiv.Core.Index.Class

Methods

showsPrec :: Int -> Ix0 -> ShowS

show :: Ix0 -> String

showList :: [Ix0] -> ShowS

newtype Dim

A way to select Array dimension.

Constructors

Dim Int

Instances

Enum Dim

Defined in Data.Massiv.Core.Index.Class

Methods

succ :: Dim -> Dim

pred :: Dim -> Dim

toEnum :: Int -> Dim

fromEnum :: Dim -> Int

enumFrom :: Dim -> [Dim]

enumFromThen :: Dim -> Dim -> [Dim]

enumFromTo :: Dim -> Dim -> [Dim]

enumFromThenTo :: Dim -> Dim -> Dim -> [Dim]

Eq Dim

Defined in Data.Massiv.Core.Index.Class

Methods

(==) :: Dim -> Dim -> Bool

(/=) :: Dim -> Dim -> Bool

Integral Dim

Defined in Data.Massiv.Core.Index.Class

Methods

quot :: Dim -> Dim -> Dim

rem :: Dim -> Dim -> Dim

div :: Dim -> Dim -> Dim

mod :: Dim -> Dim -> Dim

quotRem :: Dim -> Dim -> (Dim, Dim)

divMod :: Dim -> Dim -> (Dim, Dim)

toInteger :: Dim -> Integer

Num Dim

Defined in Data.Massiv.Core.Index.Class

Methods

(+) :: Dim -> Dim -> Dim

(-) :: Dim -> Dim -> Dim

(*) :: Dim -> Dim -> Dim

negate :: Dim -> Dim

abs :: Dim -> Dim

signum :: Dim -> Dim

fromInteger :: Integer -> Dim

Ord Dim

Defined in Data.Massiv.Core.Index.Class

Methods

compare :: Dim -> Dim -> Ordering

(<) :: Dim -> Dim -> Bool

(<=) :: Dim -> Dim -> Bool

(>) :: Dim -> Dim -> Bool

(>=) :: Dim -> Dim -> Bool

max :: Dim -> Dim -> Dim

min :: Dim -> Dim -> Dim

Real Dim

Defined in Data.Massiv.Core.Index.Class

Methods

toRational :: Dim -> Rational

Show Dim

Defined in Data.Massiv.Core.Index.Class

Methods

showsPrec :: Int -> Dim -> ShowS

show :: Dim -> String

showList :: [Dim] -> ShowS

errorIx :: (Show ix, Show ix') => String -> ix -> ix' -> a

Helper function for throwing out of bounds errors

errorSizeMismatch :: (Show ix, Show ix') => String -> ix -> ix' -> a

Helper function for throwing error when sizes do not match

data Stride ix

Stride provides a way to ignore elements of an array if an index is divisible by a corresponding value in a stride. So, for a Stride (i :. j) only elements with indices will be kept around:

( 0 :. 0) ( 0 :. j) ( 0 :. 2j) ( 0 :. 3j) ...
( i :. 0) ( i :. j) ( i :. 2j) ( i :. 3j) ...
(2i :. 0) (2i :. j) (2i :. 2j) (2i :. 3j) ...
...

Only positive strides make sense, so Stride pattern synonym constructor will prevent a user from creating a stride with negative or zero values, thus promoting safety of the library.

Examples:

• Default and minimal stride of Stride (pureIndex 1) will have no affect and all elements will kept.
• If stride is Stride 2, then every 2nd element (i.e. with index 1, 3, 5, ..) will be skipped and only elemnts with indices divisible by 2 will be kept around.
• In case of two dimensions, if what you want is to keep all rows divisible by 5, but keep every column intact then you'd use Stride (5 :. 1).

Instances

Eq ix => Eq (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

(==) :: Stride ix -> Stride ix -> Bool

(/=) :: Stride ix -> Stride ix -> Bool

Ord ix => Ord (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

compare :: Stride ix -> Stride ix -> Ordering

(<) :: Stride ix -> Stride ix -> Bool

(<=) :: Stride ix -> Stride ix -> Bool

(>) :: Stride ix -> Stride ix -> Bool

(>=) :: Stride ix -> Stride ix -> Bool

max :: Stride ix -> Stride ix -> Stride ix

min :: Stride ix -> Stride ix -> Stride ix

Index ix => Show (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

showsPrec :: Int -> Stride ix -> ShowS

show :: Stride ix -> String

showList :: [Stride ix] -> ShowS

NFData ix => NFData (Stride ix)

Defined in Data.Massiv.Core.Index.Stride

Methods

rnf :: Stride ix -> ()

pattern Stride :: Index ix => ix -> Stride ix

A safe bidirectional pattern synonym for Stride construction that will make sure stride elements are always positive.

unStride :: Stride ix -> ix

Just a helper function for unwrapping Stride.

strideStart :: Index ix => Stride ix -> ix -> ix

Adjust strating index according to the stride

strideSize :: Index ix => Stride ix -> ix -> ix

Adjust size according to the stride.

toLinearIndexStride

Arguments

:: Index ix

=> Stride ix

Stride

-> ix

Size

-> ix

Index

-> Int

Compute an index with stride using the original size and index

oneStride :: Index ix => Stride ix

A default stride of 1, where all elements are kept

type family Ix (n :: Nat) = r | r -> n where ...

Defines n-dimensional index by relating a general IxN with few base cases.

Equations

Ix 0 = Ix0

Ix 1 = Ix1

Ix 2 = Ix2

Ix n = IxN n

data IxN (n :: Nat)

n-dimensional index. Needs a base case, which is the Ix2.

Constructors

(:>) !Int !(Ix (n - 1)) infixr 5

Instances

Bounded Ix3

Defined in Data.Massiv.Core.Index.Ix

Methods

minBound :: Ix3

maxBound :: Ix3

Num Ix3

Defined in Data.Massiv.Core.Index.Ix

Methods

(+) :: Ix3 -> Ix3 -> Ix3

(-) :: Ix3 -> Ix3 -> Ix3

(*) :: Ix3 -> Ix3 -> Ix3

negate :: Ix3 -> Ix3

abs :: Ix3 -> Ix3

signum :: Ix3 -> Ix3

fromInteger :: Integer -> Ix3

(3 <= n, Unbox (Ix (n - 1))) => Vector Vector (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (IxN n) -> m (Vector (IxN n))

basicUnsafeThaw :: PrimMonad m => Vector (IxN n) -> m (Mutable Vector (PrimState m) (IxN n))

basicLength :: Vector (IxN n) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (IxN n) -> Vector (IxN n)

basicUnsafeIndexM :: Monad m => Vector (IxN n) -> Int -> m (IxN n)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (IxN n) -> Vector (IxN n) -> m ()

elemseq :: Vector (IxN n) -> IxN n -> b -> b

(3 <= n, Unbox (Ix (n - 1))) => MVector MVector (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

basicLength :: MVector s (IxN n) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (IxN n) -> MVector s (IxN n)

basicOverlaps :: MVector s (IxN n) -> MVector s (IxN n) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (IxN n))

basicInitialize :: PrimMonad m => MVector (PrimState m) (IxN n) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> IxN n -> m (MVector (PrimState m) (IxN n))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (IxN n) -> Int -> m (IxN n)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (IxN n) -> Int -> IxN n -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (IxN n) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (IxN n) -> IxN n -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (IxN n) -> MVector (PrimState m) (IxN n) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (IxN n) -> MVector (PrimState m) (IxN n) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (IxN n) -> Int -> m (MVector (PrimState m) (IxN n))

(4 <= n, KnownNat n, Index (Ix (n - 1)), IxN (n - 1) ~ Ix (n - 1)) => Bounded (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

minBound :: IxN n

maxBound :: IxN n

Eq (Ix (n - 1)) => Eq (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

(==) :: IxN n -> IxN n -> Bool

(/=) :: IxN n -> IxN n -> Bool

(4 <= n, KnownNat n, Index (Ix (n - 1)), IxN (n - 1) ~ Ix (n - 1)) => Num (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

(+) :: IxN n -> IxN n -> IxN n

(-) :: IxN n -> IxN n -> IxN n

(*) :: IxN n -> IxN n -> IxN n

negate :: IxN n -> IxN n

abs :: IxN n -> IxN n

signum :: IxN n -> IxN n

fromInteger :: Integer -> IxN n

Ord (Ix (n - 1)) => Ord (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

compare :: IxN n -> IxN n -> Ordering

(<) :: IxN n -> IxN n -> Bool

(<=) :: IxN n -> IxN n -> Bool

(>) :: IxN n -> IxN n -> Bool

(>=) :: IxN n -> IxN n -> Bool

max :: IxN n -> IxN n -> IxN n

min :: IxN n -> IxN n -> IxN n

Show (Ix (n - 1)) => Show (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

showsPrec :: Int -> IxN n -> ShowS

show :: IxN n -> String

showList :: [IxN n] -> ShowS

NFData (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Methods

rnf :: IxN n -> ()

(3 <= n, Unbox (Ix (n - 1))) => Unbox (IxN n)

Unboxing of a IxN.

Defined in Data.Massiv.Core.Index.Ix

(4 <= n, KnownNat n, Index (Ix (n - 1)), IxN (n - 1) ~ Ix (n - 1)) => Index (IxN n)

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions (IxN n) :: Nat

Methods

dimensions :: IxN n -> Dim

totalElem :: IxN n -> Int

consDim :: Int -> Lower (IxN n) -> IxN n

unconsDim :: IxN n -> (Int, Lower (IxN n))

snocDim :: Lower (IxN n) -> Int -> IxN n

unsnocDim :: IxN n -> (Lower (IxN n), Int)

dropDim :: IxN n -> Dim -> Maybe (Lower (IxN n))

getIndex :: IxN n -> Dim -> Maybe Int

setIndex :: IxN n -> Dim -> Int -> Maybe (IxN n)

pureIndex :: Int -> IxN n

liftIndex2 :: (Int -> Int -> Int) -> IxN n -> IxN n -> IxN n

liftIndex :: (Int -> Int) -> IxN n -> IxN n

foldlIndex :: (a -> Int -> a) -> a -> IxN n -> a

isSafeIndex :: IxN n -> IxN n -> Bool

toLinearIndex :: IxN n -> IxN n -> Int

toLinearIndexAcc :: Int -> IxN n -> IxN n -> Int

fromLinearIndex :: IxN n -> Int -> IxN n

fromLinearIndexAcc :: IxN n -> Int -> (Int, IxN n)

repairIndex :: IxN n -> IxN n -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> IxN n

iter :: IxN n -> IxN n -> IxN n -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> a) -> a

iterM :: Monad m => IxN n -> IxN n -> IxN n -> (Int -> Int -> Bool) -> a -> (IxN n -> a -> m a) -> m a

iterM_ :: Monad m => IxN n -> IxN n -> IxN n -> (Int -> Int -> Bool) -> (IxN n -> m a) -> m ()

Index (IxN 3)

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions (IxN 3) :: Nat

Methods

dimensions :: IxN 3 -> Dim

totalElem :: IxN 3 -> Int

consDim :: Int -> Lower (IxN 3) -> IxN 3

unconsDim :: IxN 3 -> (Int, Lower (IxN 3))

snocDim :: Lower (IxN 3) -> Int -> IxN 3

unsnocDim :: IxN 3 -> (Lower (IxN 3), Int)

dropDim :: IxN 3 -> Dim -> Maybe (Lower (IxN 3))

getIndex :: IxN 3 -> Dim -> Maybe Int

setIndex :: IxN 3 -> Dim -> Int -> Maybe (IxN 3)

pureIndex :: Int -> IxN 3

liftIndex2 :: (Int -> Int -> Int) -> IxN 3 -> IxN 3 -> IxN 3

liftIndex :: (Int -> Int) -> IxN 3 -> IxN 3

foldlIndex :: (a -> Int -> a) -> a -> IxN 3 -> a

isSafeIndex :: IxN 3 -> IxN 3 -> Bool

toLinearIndex :: IxN 3 -> IxN 3 -> Int

toLinearIndexAcc :: Int -> IxN 3 -> IxN 3 -> Int

fromLinearIndex :: IxN 3 -> Int -> IxN 3

fromLinearIndexAcc :: IxN 3 -> Int -> (Int, IxN 3)

repairIndex :: IxN 3 -> IxN 3 -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> IxN 3

iter :: IxN 3 -> IxN 3 -> IxN 3 -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> a) -> a

iterM :: Monad m => IxN 3 -> IxN 3 -> IxN 3 -> (Int -> Int -> Bool) -> a -> (IxN 3 -> a -> m a) -> m a

iterM_ :: Monad m => IxN 3 -> IxN 3 -> IxN 3 -> (Int -> Int -> Bool) -> (IxN 3 -> m a) -> m ()

type Dimensions Ix3

Defined in Data.Massiv.Core.Index.Ix

type Dimensions Ix3 = 3

data MVector s (IxN n)

Defined in Data.Massiv.Core.Index.Ix

data MVector s (IxN n) = MV_IxN (MVector s Int, MVector s (Ix (n - 1)))

data Vector (IxN n)

Defined in Data.Massiv.Core.Index.Ix

data Vector (IxN n) = V_IxN (Vector Int, Vector (Ix (n - 1)))

type Dimensions (IxN n)

Defined in Data.Massiv.Core.Index.Ix

type Dimensions (IxN n) = n

type Lower (IxN n)

Defined in Data.Massiv.Core.Index.Ix

type Lower (IxN n) = Ix (n - 1)

type Ix5 = IxN 5

5-dimensional type synonym.

type Ix4 = IxN 4

4-dimensional type synonym.

type Ix3 = IxN 3

3-dimensional type synonym. Useful as a alternative to enabling DataKinds and using type level Nats.

data Ix2

2-dimensional index. This also a base index for higher dimensions.

Constructors

(:.) !Int !Int infixr 5

Instances

Bounded Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

minBound :: Ix2

maxBound :: Ix2

Eq Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

(==) :: Ix2 -> Ix2 -> Bool

(/=) :: Ix2 -> Ix2 -> Bool

Num Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

(+) :: Ix2 -> Ix2 -> Ix2

(-) :: Ix2 -> Ix2 -> Ix2

(*) :: Ix2 -> Ix2 -> Ix2

negate :: Ix2 -> Ix2

abs :: Ix2 -> Ix2

signum :: Ix2 -> Ix2

fromInteger :: Integer -> Ix2

Ord Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

compare :: Ix2 -> Ix2 -> Ordering

(<) :: Ix2 -> Ix2 -> Bool

(<=) :: Ix2 -> Ix2 -> Bool

(>) :: Ix2 -> Ix2 -> Bool

(>=) :: Ix2 -> Ix2 -> Bool

max :: Ix2 -> Ix2 -> Ix2

min :: Ix2 -> Ix2 -> Ix2

Show Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

showsPrec :: Int -> Ix2 -> ShowS

show :: Ix2 -> String

showList :: [Ix2] -> ShowS

NFData Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

rnf :: Ix2 -> ()

Unbox Ix2

Unboxing of a Ix2.

Defined in Data.Massiv.Core.Index.Ix

Index Ix2

Defined in Data.Massiv.Core.Index.Ix

Associated Types

type Dimensions Ix2 :: Nat

Methods

dimensions :: Ix2 -> Dim

totalElem :: Ix2 -> Int

consDim :: Int -> Lower Ix2 -> Ix2

unconsDim :: Ix2 -> (Int, Lower Ix2)

snocDim :: Lower Ix2 -> Int -> Ix2

unsnocDim :: Ix2 -> (Lower Ix2, Int)

dropDim :: Ix2 -> Dim -> Maybe (Lower Ix2)

getIndex :: Ix2 -> Dim -> Maybe Int

setIndex :: Ix2 -> Dim -> Int -> Maybe Ix2

pureIndex :: Int -> Ix2

liftIndex2 :: (Int -> Int -> Int) -> Ix2 -> Ix2 -> Ix2

liftIndex :: (Int -> Int) -> Ix2 -> Ix2

foldlIndex :: (a -> Int -> a) -> a -> Ix2 -> a

isSafeIndex :: Ix2 -> Ix2 -> Bool

toLinearIndex :: Ix2 -> Ix2 -> Int

toLinearIndexAcc :: Int -> Ix2 -> Ix2 -> Int

fromLinearIndex :: Ix2 -> Int -> Ix2

fromLinearIndexAcc :: Ix2 -> Int -> (Int, Ix2)

repairIndex :: Ix2 -> Ix2 -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix2

iter :: Ix2 -> Ix2 -> Ix2 -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> a) -> a

iterM :: Monad m => Ix2 -> Ix2 -> Ix2 -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> m a) -> m a

iterM_ :: Monad m => Ix2 -> Ix2 -> Ix2 -> (Int -> Int -> Bool) -> (Ix2 -> m a) -> m ()

Vector Vector Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Ix2 -> m (Vector Ix2)

basicUnsafeThaw :: PrimMonad m => Vector Ix2 -> m (Mutable Vector (PrimState m) Ix2)

basicLength :: Vector Ix2 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Ix2 -> Vector Ix2

basicUnsafeIndexM :: Monad m => Vector Ix2 -> Int -> m Ix2

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Ix2 -> Vector Ix2 -> m ()

elemseq :: Vector Ix2 -> Ix2 -> b -> b

MVector MVector Ix2

Defined in Data.Massiv.Core.Index.Ix

Methods

basicLength :: MVector s Ix2 -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Ix2 -> MVector s Ix2

basicOverlaps :: MVector s Ix2 -> MVector s Ix2 -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Ix2)

basicInitialize :: PrimMonad m => MVector (PrimState m) Ix2 -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Ix2 -> m (MVector (PrimState m) Ix2)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Ix2 -> Int -> m Ix2

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Ix2 -> Int -> Ix2 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Ix2 -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Ix2 -> Ix2 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Ix2 -> MVector (PrimState m) Ix2 -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Ix2 -> MVector (PrimState m) Ix2 -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Ix2 -> Int -> m (MVector (PrimState m) Ix2)

Load DW Ix2 e

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

loadS :: Monad m => Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array DW Ix2 e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

loadArrayWithStride :: Monad m => Int -> (m () -> m ()) -> Stride Ix2 -> Ix2 -> Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadArray :: Monad m => Int -> (m () -> m ()) -> Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

data Vector Ix2

Defined in Data.Massiv.Core.Index.Ix

data Vector Ix2 = V_Ix2 (Vector Ix2T)

type Dimensions Ix2

Defined in Data.Massiv.Core.Index.Ix

type Dimensions Ix2 = 2

type Lower Ix2

Defined in Data.Massiv.Core.Index.Ix

type Lower Ix2 = Ix1

data MVector s Ix2

Defined in Data.Massiv.Core.Index.Ix

data MVector s Ix2 = MV_Ix2 (MVector s Ix2T)

type Ix1 = Int

Another type synonym for 1-dimensional index, i.e. Int and Ix1T. Provided here purely for consistency.

pattern Ix5 :: Int -> Int -> Int -> Int -> Int -> Ix5

5-dimensional index constructor. (Ix5 i j k l m) = (i :> j :> k :> l :. m).

pattern Ix4 :: Int -> Int -> Int -> Int -> Ix4

4-dimensional index constructor. (Ix4 i j k l) == (i :> j :> k :. l).

pattern Ix3 :: Int -> Int -> Int -> Ix3

3-dimensional index constructor. (Ix3 i j k) == (i :> j :. k).

pattern Ix2 :: Int -> Int -> Ix2

2-dimensional index constructor. Useful when TypeOperators extension isn't enabled, or simply infix notation is inconvenient. (Ix2 i j) == (i :. j).

pattern Ix1 :: Int -> Ix1

This is a very handy pattern synonym to indicate that any arbitrary whole number is an Int, i.e. a 1-dimensional index: (Ix1 i) == (i :: Int)

toIx2 :: Ix2T -> Ix2

Convert a Int tuple to Ix2

fromIx2 :: Ix2 -> Ix2T

Convert an Ix2 to Int tuple

toIx3 :: Ix3T -> Ix3

Convert a Int 3-tuple to Ix3

fromIx3 :: Ix3 -> Ix3T

Convert an Ix3 to Int 3-tuple

toIx4 :: Ix4T -> Ix4

Convert a Int 4-tuple to Ix4

fromIx4 :: Ix4 -> Ix4T

Convert an Ix4 to Int 4-tuple

toIx5 :: Ix5T -> Ix5

Convert a Int 5-tuple to Ix5

fromIx5 :: Ix5 -> Ix5T

Convert an Ix5 to Int 5-tuple

data Border e

Approach to be used near the borders during various transformations. Whenever a function needs information not only about an element of interest, but also about it's neighbors, it will go out of bounds near the array edges, hence is this set of approaches that specify how to handle such situation.

Constructors

Fill e

Fill in a constant element.

           outside |  Array  | outside
(Fill 0) : 0 0 0 0 | 1 2 3 4 | 0 0 0 0

Wrap

Wrap around from the opposite border of the array.

           outside |  Array  | outside
Wrap :     1 2 3 4 | 1 2 3 4 | 1 2 3 4

Edge

Replicate the element at the edge.

           outside |  Array  | outside
Edge :     1 1 1 1 | 1 2 3 4 | 4 4 4 4

Reflect

Mirror like reflection.

           outside |  Array  | outside
Reflect :  4 3 2 1 | 1 2 3 4 | 4 3 2 1

Continue

Also mirror like reflection, but without repeating the edge element.

           outside |  Array  | outside
Continue : 1 4 3 2 | 1 2 3 4 | 3 2 1 4

Instances

Eq e => Eq (Border e)

Defined in Data.Massiv.Core.Index

Methods

(==) :: Border e -> Border e -> Bool

(/=) :: Border e -> Border e -> Bool

Show e => Show (Border e)

Defined in Data.Massiv.Core.Index

Methods

showsPrec :: Int -> Border e -> ShowS

show :: Border e -> String

showList :: [Border e] -> ShowS

NFData e => NFData (Border e)

Defined in Data.Massiv.Core.Index

Methods

rnf :: Border e -> ()

handleBorderIndex

Arguments

:: Index ix

=> Border e

Broder resolution technique

-> ix

Size

-> (ix -> e)

Index function that produces an element

-> ix

Index

-> e

Apply a border resolution technique to an index

zeroIndex :: Index ix => ix

Index with all zeros

isSafeSize :: Index ix => ix -> Bool

Checks whether the size is valid.

isNonEmpty :: Index ix => ix -> Bool

Checks whether array with this size can hold at least one element.

headDim :: Index ix => ix -> Int

tailDim :: Index ix => ix -> Lower ix

lastDim :: Index ix => ix -> Int

initDim :: Index ix => ix -> Lower ix

iterLinearM

Arguments

:: (Index ix, Monad m)

=> ix

Size

-> Int

Linear start

-> Int

Linear end

-> Int

Increment

-> (Int -> Int -> Bool)

Continuation condition (continue if True)

-> a

Accumulator

-> (Int -> ix -> a -> m a)

-> m a

Iterate over N-dimensional space lenarly from start to end in row-major fashion with an accumulator

iterLinearM_

Arguments

:: (Index ix, Monad m)

=> ix

Size

-> Int

Start

-> Int

End

-> Int

Increment

-> (Int -> Int -> Bool)

Continuation condition

-> (Int -> ix -> m ())

Monadic action that takes index in both forms

-> m ()

Same as iterLinearM, except without an accumulator.

class Construct r ix e => Ragged r ix e where

Minimal complete definition

empty, isNull, cons, uncons, unsafeGenerateM, edgeSize, flatten, loadRagged, raggedFormat

Methods

empty :: Comp -> Array r ix e

isNull :: Array r ix e -> Bool

cons :: Elt r ix e -> Array r ix e -> Array r ix e

uncons :: Array r ix e -> Maybe (Elt r ix e, Array r ix e)

edgeSize :: Array r ix e -> ix

flatten :: Array r ix e -> Array r Ix1 e

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower ix -> Array r ix e -> IO ()

raggedFormat :: (e -> String) -> String -> Array r ix e -> String

Instances

(Index ix, Index (Lower ix), Ragged L (Lower ix) e, Elt L ix e ~ Array L (Lower ix) e, Elt LN ix e ~ Array LN (Lower ix) e, Coercible (Elt LN ix e) [Elt LN (Lower ix) e]) => Ragged L ix e

Defined in Data.Massiv.Core.List

Methods

empty :: Comp -> Array L ix e

isNull :: Array L ix e -> Bool

cons :: Elt L ix e -> Array L ix e -> Array L ix e

uncons :: Array L ix e -> Maybe (Elt L ix e, Array L ix e)

unsafeGenerateM :: Monad m => Comp -> ix -> (ix -> m e) -> m (Array L ix e)

edgeSize :: Array L ix e -> ix

flatten :: Array L ix e -> Array L Ix1 e

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower ix -> Array L ix e -> IO ()

raggedFormat :: (e -> String) -> String -> Array L ix e -> String

Ragged L Ix1 e

Defined in Data.Massiv.Core.List

Methods

empty :: Comp -> Array L Ix1 e

isNull :: Array L Ix1 e -> Bool

cons :: Elt L Ix1 e -> Array L Ix1 e -> Array L Ix1 e

uncons :: Array L Ix1 e -> Maybe (Elt L Ix1 e, Array L Ix1 e)

unsafeGenerateM :: Monad m => Comp -> Ix1 -> (Ix1 -> m e) -> m (Array L Ix1 e)

edgeSize :: Array L Ix1 e -> Ix1

flatten :: Array L Ix1 e -> Array L Ix1 e

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower Ix1 -> Array L Ix1 e -> IO ()

raggedFormat :: (e -> String) -> String -> Array L Ix1 e -> String

class Nested r ix e where

Minimal complete definition

fromNested, toNested

Methods

fromNested :: NestedStruct r ix e -> Array r ix e

toNested :: Array r ix e -> NestedStruct r ix e

Instances

Nested L ix e

Defined in Data.Massiv.Core.List

Methods

fromNested :: NestedStruct L ix e -> Array L ix e

toNested :: Array L ix e -> NestedStruct L ix e

(Elt LN ix e ~ Array LN (Lower ix) e, ListItem ix e ~ [ListItem (Lower ix) e], Coercible (Elt LN ix e) (ListItem ix e)) => Nested LN ix e

Defined in Data.Massiv.Core.List

Methods

fromNested :: NestedStruct LN ix e -> Array LN ix e

toNested :: Array LN ix e -> NestedStruct LN ix e

Nested LN Ix1 e

Defined in Data.Massiv.Core.List

Methods

fromNested :: NestedStruct LN Ix1 e -> Array LN Ix1 e

toNested :: Array LN Ix1 e -> NestedStruct LN Ix1 e

class Manifest r ix e => Mutable r ix e

Minimal complete definition

msize, unsafeThaw, unsafeFreeze, unsafeNew, unsafeNewZero, unsafeLinearRead, unsafeLinearWrite

Instances

(Unbox e, Index ix) => Mutable U ix e

Defined in Data.Massiv.Array.Manifest.Unboxed

Associated Types

data MArray s U ix e :: *

Methods

msize :: MArray s U ix e -> ix

unsafeThaw :: PrimMonad m => Array U ix e -> m (MArray (PrimState m) U ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) U ix e -> m (Array U ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld U ix e)

unsafeThawA :: Applicative m => Array U ix e -> WorldState -> m (WorldState, MArray RealWorld U ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld U ix e -> WorldState -> m (WorldState, Array U ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld U ix e -> Int -> e -> WorldState -> m WorldState

(Index ix, Storable e) => Mutable S ix e

Defined in Data.Massiv.Array.Manifest.Storable

Associated Types

data MArray s S ix e :: *

Methods

msize :: MArray s S ix e -> ix

unsafeThaw :: PrimMonad m => Array S ix e -> m (MArray (PrimState m) S ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) S ix e -> m (Array S ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld S ix e)

unsafeThawA :: Applicative m => Array S ix e -> WorldState -> m (WorldState, MArray RealWorld S ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld S ix e -> WorldState -> m (WorldState, Array S ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld S ix e -> Int -> e -> WorldState -> m WorldState

(Index ix, Prim e) => Mutable P ix e

Defined in Data.Massiv.Array.Manifest.Primitive

Associated Types

data MArray s P ix e :: *

Methods

msize :: MArray s P ix e -> ix

unsafeThaw :: PrimMonad m => Array P ix e -> m (MArray (PrimState m) P ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) P ix e -> m (Array P ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld P ix e)

unsafeThawA :: Applicative m => Array P ix e -> WorldState -> m (WorldState, MArray RealWorld P ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld P ix e -> WorldState -> m (WorldState, Array P ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld P ix e -> Int -> e -> WorldState -> m WorldState

(Index ix, NFData e) => Mutable N ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Associated Types

data MArray s N ix e :: *

Methods

msize :: MArray s N ix e -> ix

unsafeThaw :: PrimMonad m => Array N ix e -> m (MArray (PrimState m) N ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) N ix e -> m (Array N ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld N ix e)

unsafeThawA :: Applicative m => Array N ix e -> WorldState -> m (WorldState, MArray RealWorld N ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld N ix e -> WorldState -> m (WorldState, Array N ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld N ix e -> Int -> e -> WorldState -> m WorldState

Index ix => Mutable B ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Associated Types

data MArray s B ix e :: *

Methods

msize :: MArray s B ix e -> ix

unsafeThaw :: PrimMonad m => Array B ix e -> m (MArray (PrimState m) B ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) B ix e -> m (Array B ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld B ix e)

unsafeThawA :: Applicative m => Array B ix e -> WorldState -> m (WorldState, MArray RealWorld B ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld B ix e -> WorldState -> m (WorldState, Array B ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld B ix e -> Int -> e -> WorldState -> m WorldState

class Source r ix e => Manifest r ix e

Manifest arrays are backed by actual memory and values are looked up versus computed as it is with delayed arrays. Because of this fact indexing functions (!), (!?), etc. are constrained to manifest arrays only.

Minimal complete definition

unsafeLinearIndexM

Instances

Index ix => Manifest M ix e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

unsafeLinearIndexM :: Array M ix e -> Int -> e

(Unbox e, Index ix) => Manifest U ix e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

unsafeLinearIndexM :: Array U ix e -> Int -> e

(Index ix, Storable e) => Manifest S ix e

Defined in Data.Massiv.Array.Manifest.Storable

Methods

unsafeLinearIndexM :: Array S ix e -> Int -> e

(Index ix, Prim e) => Manifest P ix e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

unsafeLinearIndexM :: Array P ix e -> Int -> e

(Index ix, NFData e) => Manifest N ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

unsafeLinearIndexM :: Array N ix e -> Int -> e

Index ix => Manifest B ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

unsafeLinearIndexM :: Array B ix e -> Int -> e

class Size r ix e => Slice r ix e

Minimal complete definition

unsafeSlice

Instances

(Index ix, Index (Lower ix), Elt D ix e ~ Array D (Lower ix) e) => Slice D ix e

Defined in Data.Massiv.Array.Delayed.Internal

Methods

unsafeSlice :: Array D ix e -> ix -> ix -> Dim -> Maybe (Elt D ix e)

(Index ix, Index (Lower ix), Elt M ix e ~ Array M (Lower ix) e) => Slice M ix e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

unsafeSlice :: Array M ix e -> ix -> ix -> Dim -> Maybe (Elt M ix e)

Slice M Ix1 e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

unsafeSlice :: Array M Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt M Ix1 e)

(Unbox e, Index ix, Index (Lower ix), Elt U ix e ~ Elt M ix e, Elt M ix e ~ Array M (Lower ix) e) => Slice U ix e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

unsafeSlice :: Array U ix e -> ix -> ix -> Dim -> Maybe (Elt U ix e)

Unbox e => Slice U Ix1 e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

unsafeSlice :: Array U Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt U Ix1 e)

(Prim e, Index ix, Index (Lower ix), Elt P ix e ~ Elt M ix e, Elt M ix e ~ Array M (Lower ix) e) => Slice P ix e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

unsafeSlice :: Array P ix e -> ix -> ix -> Dim -> Maybe (Elt P ix e)

Prim e => Slice P Ix1 e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

unsafeSlice :: Array P Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt P Ix1 e)

class Size r ix e => InnerSlice r ix e

Minimal complete definition

unsafeInnerSlice

Instances

(Elt D ix e ~ Array D (Lower ix) e, Index ix) => InnerSlice D ix e

Defined in Data.Massiv.Array.Delayed.Internal

Methods

unsafeInnerSlice :: Array D ix e -> (Lower ix, Int) -> Int -> Elt D ix e

(Elt M ix e ~ Array M (Lower ix) e, Index ix, Index (Lower ix)) => InnerSlice M ix e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

unsafeInnerSlice :: Array M ix e -> (Lower ix, Int) -> Int -> Elt M ix e

InnerSlice M Ix1 e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

unsafeInnerSlice :: Array M Ix1 e -> (Lower Ix1, Int) -> Int -> Elt M Ix1 e

(Unbox e, Index ix, Index (Lower ix), Elt U ix e ~ Elt M ix e, Elt M ix e ~ Array M (Lower ix) e) => InnerSlice U ix e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

unsafeInnerSlice :: Array U ix e -> (Lower ix, Int) -> Int -> Elt U ix e

Unbox e => InnerSlice U Ix1 e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

unsafeInnerSlice :: Array U Ix1 e -> (Lower Ix1, Int) -> Int -> Elt U Ix1 e

(Storable e, Index ix, Index (Lower ix), Elt M ix e ~ Array M (Lower ix) e, Elt S ix e ~ Array M (Lower ix) e) => InnerSlice S ix e

Defined in Data.Massiv.Array.Manifest.Storable

Methods

unsafeInnerSlice :: Array S ix e -> (Lower ix, Int) -> Int -> Elt S ix e

(Prim e, Index ix, Index (Lower ix), Elt M ix e ~ Array M (Lower ix) e, Elt P ix e ~ Array M (Lower ix) e) => InnerSlice P ix e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

unsafeInnerSlice :: Array P ix e -> (Lower ix, Int) -> Int -> Elt P ix e

Prim e => InnerSlice P Ix1 e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

unsafeInnerSlice :: Array P Ix1 e -> (Lower Ix1, Int) -> Int -> Elt P Ix1 e

(NFData e, Index ix, Index (Lower ix), Elt M ix e ~ Array M (Lower ix) e, Elt N ix e ~ Array M (Lower ix) e) => InnerSlice N ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

unsafeInnerSlice :: Array N ix e -> (Lower ix, Int) -> Int -> Elt N ix e

(NFData e, Index ix, Index (Lower ix), Elt M ix e ~ Array M (Lower ix) e, Elt B ix e ~ Array M (Lower ix) e) => InnerSlice B ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

unsafeInnerSlice :: Array B ix e -> (Lower ix, Int) -> Int -> Elt B ix e

class OuterSlice r ix e where

Minimal complete definition

unsafeOuterSlice

Methods

outerLength :: Array r ix e -> Int

outerLength :: Size r ix e => Array r ix e -> Int

Instances

Ragged L ix e => OuterSlice L ix e

Defined in Data.Massiv.Core.List

Methods

unsafeOuterSlice :: Array L ix e -> Int -> Elt L ix e

outerLength :: Array L ix e -> Int

OuterSlice L Ix1 e

Defined in Data.Massiv.Core.List

Methods

unsafeOuterSlice :: Array L Ix1 e -> Int -> Elt L Ix1 e

outerLength :: Array L Ix1 e -> Int

(Elt D ix e ~ Array D (Lower ix) e, Index ix) => OuterSlice D ix e

Defined in Data.Massiv.Array.Delayed.Internal

Methods

unsafeOuterSlice :: Array D ix e -> Int -> Elt D ix e

outerLength :: Array D ix e -> Int

(Elt M ix e ~ Array M (Lower ix) e, Index ix, Index (Lower ix)) => OuterSlice M ix e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

unsafeOuterSlice :: Array M ix e -> Int -> Elt M ix e

outerLength :: Array M ix e -> Int

OuterSlice M Ix1 e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

unsafeOuterSlice :: Array M Ix1 e -> Int -> Elt M Ix1 e

outerLength :: Array M Ix1 e -> Int

(Unbox e, Index ix, Index (Lower ix), Elt U ix e ~ Elt M ix e, Elt M ix e ~ Array M (Lower ix) e) => OuterSlice U ix e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

unsafeOuterSlice :: Array U ix e -> Int -> Elt U ix e

outerLength :: Array U ix e -> Int

Unbox e => OuterSlice U Ix1 e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

unsafeOuterSlice :: Array U Ix1 e -> Int -> Elt U Ix1 e

outerLength :: Array U Ix1 e -> Int

(Storable e, Index ix, Index (Lower ix), Elt M ix e ~ Array M (Lower ix) e, Elt S ix e ~ Array M (Lower ix) e) => OuterSlice S ix e

Defined in Data.Massiv.Array.Manifest.Storable

Methods

unsafeOuterSlice :: Array S ix e -> Int -> Elt S ix e

outerLength :: Array S ix e -> Int

(Prim e, Index ix, Index (Lower ix), Elt M ix e ~ Array M (Lower ix) e, Elt P ix e ~ Array M (Lower ix) e) => OuterSlice P ix e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

unsafeOuterSlice :: Array P ix e -> Int -> Elt P ix e

outerLength :: Array P ix e -> Int

Prim e => OuterSlice P Ix1 e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

unsafeOuterSlice :: Array P Ix1 e -> Int -> Elt P Ix1 e

outerLength :: Array P Ix1 e -> Int

(NFData e, Index ix, Index (Lower ix), Elt M ix e ~ Array M (Lower ix) e, Elt N ix e ~ Array M (Lower ix) e) => OuterSlice N ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

unsafeOuterSlice :: Array N ix e -> Int -> Elt N ix e

outerLength :: Array N ix e -> Int

(NFData e, Index ix, Index (Lower ix), Elt M ix e ~ Array M (Lower ix) e, Elt B ix e ~ Array M (Lower ix) e) => OuterSlice B ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

unsafeOuterSlice :: Array B ix e -> Int -> Elt B ix e

outerLength :: Array B ix e -> Int

class Size r ix e => Load r ix e where

Any array that can be computed

Methods

loadS

Arguments

:: Monad m

=> Array r ix e

Array that is being loaded

-> (Int -> m e)

Function that reads an element from target array

-> (Int -> e -> m ())

Function that writes an element into target array

-> m ()

Load an array into memory sequentially

loadP

Arguments

:: [Int]

List of capabilities to run workers on, as described in forkOn. Empty list will imply all capabilities, i.e. run on all cores available through +RTS -N.

-> Array r ix e

Array that is being loaded

-> (Int -> IO e)

Function that reads an element from target array

-> (Int -> e -> IO ())

Function that writes an element into target array

-> IO ()

Load an array into memory in parallel

loadArrayWithStride

Arguments

:: Monad m

=> Int

Total number of workers (for Seq it's always 1)

-> (m () -> m ())

A monadic action that will schedule work for the workers (for Seq it's always id)

-> Stride ix

Stride to use

-> ix

Size of the target array affected by the stride.

-> Array r ix e

Array that is being loaded

-> (Int -> m e)

Function that reads an element from target array

-> (Int -> e -> m ())

Function that writes an element into target array

-> m ()

Load an array into memory with stride. Default implementation can only handle the sequential case and only if there is an instance of Source.

loadArrayWithStride

Arguments

:: (Source r ix e, Monad m)

=> Int

Total number of workers (for Seq it's always 1)

-> (m () -> m ())

A monadic action that will schedule work for the workers (for Seq it's always id)

-> Stride ix

Stride to use

-> ix

Size of the target array affected by the stride.

-> Array r ix e

Array that is being loaded

-> (Int -> m e)

Function that reads an element from target array

-> (Int -> e -> m ())

Function that writes an element into target array

-> m ()

Load an array into memory with stride. Default implementation can only handle the sequential case and only if there is an instance of Source.

loadArray

Arguments

:: Monad m

=> Int

Total number of workers (for Seq it's always 1)

-> (m () -> m ())

A monadic action that will schedule work for the workers (for Seq it's always id)

-> Array r ix e

Array that is being loaded

-> (Int -> m e)

Function that reads an element from target array

-> (Int -> e -> m ())

Function that writes an element into target array

-> m ()

Load an array into memory. Default implementation will respect the scheduler and use Source instance to do loading in row-major fashion in parallel as well as sequentially.

loadArray

Arguments

:: (Source r ix e, Monad m)

=> Int

Total number of workers (for Seq it's always 1)

-> (m () -> m ())

A monadic action that will schedule work for the workers (for Seq it's always id)

-> Array r ix e

Array that is being loaded

-> (Int -> m e)

Function that reads an element from target array

-> (Int -> e -> m ())

Function that writes an element into target array

-> m ()

Load an array into memory. Default implementation will respect the scheduler and use Source instance to do loading in row-major fashion in parallel as well as sequentially.

Instances

Index ix => Load D ix e

Defined in Data.Massiv.Array.Delayed.Internal

Methods

loadS :: Monad m => Array D ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array D ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

loadArrayWithStride :: Monad m => Int -> (m () -> m ()) -> Stride ix -> ix -> Array D ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadArray :: Monad m => Int -> (m () -> m ()) -> Array D ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

Index ix => Load M ix e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

loadS :: Monad m => Array M ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array M ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

loadArrayWithStride :: Monad m => Int -> (m () -> m ()) -> Stride ix -> ix -> Array M ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadArray :: Monad m => Int -> (m () -> m ()) -> Array M ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

(Index ix, Load DW (Lower ix) e) => Load DW ix e

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

loadS :: Monad m => Array DW ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array DW ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

loadArrayWithStride :: Monad m => Int -> (m () -> m ()) -> Stride ix -> ix -> Array DW ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadArray :: Monad m => Int -> (m () -> m ()) -> Array DW ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

Load DW Ix2T e

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

loadS :: Monad m => Array DW Ix2T e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array DW Ix2T e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

loadArrayWithStride :: Monad m => Int -> (m () -> m ()) -> Stride Ix2T -> Ix2T -> Array DW Ix2T e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadArray :: Monad m => Int -> (m () -> m ()) -> Array DW Ix2T e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

Load DW Ix2 e

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

loadS :: Monad m => Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array DW Ix2 e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

loadArrayWithStride :: Monad m => Int -> (m () -> m ()) -> Stride Ix2 -> Ix2 -> Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadArray :: Monad m => Int -> (m () -> m ()) -> Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

Load DW Ix1 e

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

loadS :: Monad m => Array DW Ix1 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array DW Ix1 e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

loadArrayWithStride :: Monad m => Int -> (m () -> m ()) -> Stride Ix1 -> Ix1 -> Array DW Ix1 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadArray :: Monad m => Int -> (m () -> m ()) -> Array DW Ix1 e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

Index ix => Load DI ix e

Defined in Data.Massiv.Array.Delayed.Interleaved

Methods

loadS :: Monad m => Array DI ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array DI ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

loadArrayWithStride :: Monad m => Int -> (m () -> m ()) -> Stride ix -> ix -> Array DI ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadArray :: Monad m => Int -> (m () -> m ()) -> Array DI ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

class Size r ix e => Source r ix e

Arrays that can be used as source to practically any manipulation function.

Instances

Index ix => Source D ix e

Defined in Data.Massiv.Array.Delayed.Internal

Methods

unsafeIndex :: Array D ix e -> ix -> e

unsafeLinearIndex :: Array D ix e -> Int -> e

Index ix => Source M ix e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

unsafeIndex :: Array M ix e -> ix -> e

unsafeLinearIndex :: Array M ix e -> Int -> e

(Unbox e, Index ix) => Source U ix e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

unsafeIndex :: Array U ix e -> ix -> e

unsafeLinearIndex :: Array U ix e -> Int -> e

(Storable e, Index ix) => Source S ix e

Defined in Data.Massiv.Array.Manifest.Storable

Methods

unsafeIndex :: Array S ix e -> ix -> e

unsafeLinearIndex :: Array S ix e -> Int -> e

(Prim e, Index ix) => Source P ix e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

unsafeIndex :: Array P ix e -> ix -> e

unsafeLinearIndex :: Array P ix e -> Int -> e

(Index ix, NFData e) => Source N ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

unsafeIndex :: Array N ix e -> ix -> e

unsafeLinearIndex :: Array N ix e -> Int -> e

Index ix => Source B ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

unsafeIndex :: Array B ix e -> ix -> e

unsafeLinearIndex :: Array B ix e -> Int -> e

class Construct r ix e => Size r ix e

An array that contains size information. They can be resized and new arrays extracted from it in constant time.

Minimal complete definition

size, unsafeResize, unsafeExtract

Instances

Index ix => Size D ix e

Defined in Data.Massiv.Array.Delayed.Internal

Methods

size :: Array D ix e -> ix

unsafeResize :: Index ix' => ix' -> Array D ix e -> Array D ix' e

unsafeExtract :: ix -> ix -> Array D ix e -> Array (EltRepr D ix) ix e

Index ix => Size M ix e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

size :: Array M ix e -> ix

unsafeResize :: Index ix' => ix' -> Array M ix e -> Array M ix' e

unsafeExtract :: ix -> ix -> Array M ix e -> Array (EltRepr M ix) ix e

(Unbox e, Index ix) => Size U ix e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

size :: Array U ix e -> ix

unsafeResize :: Index ix' => ix' -> Array U ix e -> Array U ix' e

unsafeExtract :: ix -> ix -> Array U ix e -> Array (EltRepr U ix) ix e

(Storable e, Index ix) => Size S ix e

Defined in Data.Massiv.Array.Manifest.Storable

Methods

size :: Array S ix e -> ix

unsafeResize :: Index ix' => ix' -> Array S ix e -> Array S ix' e

unsafeExtract :: ix -> ix -> Array S ix e -> Array (EltRepr S ix) ix e

(Prim e, Index ix) => Size P ix e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

size :: Array P ix e -> ix

unsafeResize :: Index ix' => ix' -> Array P ix e -> Array P ix' e

unsafeExtract :: ix -> ix -> Array P ix e -> Array (EltRepr P ix) ix e

(Index ix, NFData e) => Size N ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

size :: Array N ix e -> ix

unsafeResize :: Index ix' => ix' -> Array N ix e -> Array N ix' e

unsafeExtract :: ix -> ix -> Array N ix e -> Array (EltRepr N ix) ix e

Index ix => Size B ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

size :: Array B ix e -> ix

unsafeResize :: Index ix' => ix' -> Array B ix e -> Array B ix' e

unsafeExtract :: ix -> ix -> Array B ix e -> Array (EltRepr B ix) ix e

Index ix => Size DW ix e

Any resize or extract on Windowed Array will loose the interior window and all other optimizations, thus hurting the performance a lot.

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

size :: Array DW ix e -> ix

unsafeResize :: Index ix' => ix' -> Array DW ix e -> Array DW ix' e

unsafeExtract :: ix -> ix -> Array DW ix e -> Array (EltRepr DW ix) ix e

Index ix => Size DI ix e

Defined in Data.Massiv.Array.Delayed.Interleaved

Methods

size :: Array DI ix e -> ix

unsafeResize :: Index ix' => ix' -> Array DI ix e -> Array DI ix' e

unsafeExtract :: ix -> ix -> Array DI ix e -> Array (EltRepr DI ix) ix e

class (Typeable r, Index ix) => Construct r ix e

Array types that can be constructed.

Minimal complete definition

getComp, setComp, unsafeMakeArray

Instances

(Index ix, Ragged L ix e, Ragged L (Lower ix) e, Elt L ix e ~ Array L (Lower ix) e) => Construct L ix e

Defined in Data.Massiv.Core.List

Methods

getComp :: Array L ix e -> Comp

setComp :: Comp -> Array L ix e -> Array L ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array L ix e

Construct L Ix1 e

Defined in Data.Massiv.Core.List

Methods

getComp :: Array L Ix1 e -> Comp

setComp :: Comp -> Array L Ix1 e -> Array L Ix1 e

unsafeMakeArray :: Comp -> Ix1 -> (Ix1 -> e) -> Array L Ix1 e

Index ix => Construct D ix e

Defined in Data.Massiv.Array.Delayed.Internal

Methods

getComp :: Array D ix e -> Comp

setComp :: Comp -> Array D ix e -> Array D ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array D ix e

Index ix => Construct M ix e

Defined in Data.Massiv.Array.Manifest.Internal

Methods

getComp :: Array M ix e -> Comp

setComp :: Comp -> Array M ix e -> Array M ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array M ix e

(Unbox e, Index ix) => Construct U ix e

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

getComp :: Array U ix e -> Comp

setComp :: Comp -> Array U ix e -> Array U ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array U ix e

(Storable e, Index ix) => Construct S ix e

Defined in Data.Massiv.Array.Manifest.Storable

Methods

getComp :: Array S ix e -> Comp

setComp :: Comp -> Array S ix e -> Array S ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array S ix e

(Prim e, Index ix) => Construct P ix e

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

getComp :: Array P ix e -> Comp

setComp :: Comp -> Array P ix e -> Array P ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array P ix e

(Index ix, NFData e) => Construct N ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

getComp :: Array N ix e -> Comp

setComp :: Comp -> Array N ix e -> Array N ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array N ix e

Index ix => Construct B ix e

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

getComp :: Array B ix e -> Comp

setComp :: Comp -> Array B ix e -> Array B ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array B ix e

Index ix => Construct DW ix e

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

getComp :: Array DW ix e -> Comp

setComp :: Comp -> Array DW ix e -> Array DW ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array DW ix e

Index ix => Construct DI ix e

Defined in Data.Massiv.Array.Delayed.Interleaved

Methods

getComp :: Array DI ix e -> Comp

setComp :: Comp -> Array DI ix e -> Array DI ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array DI ix e

type family NestedStruct r ix e :: *

Instances

type NestedStruct L ix e

Defined in Data.Massiv.Core.List

type NestedStruct L ix e = Array LN ix e

type NestedStruct LN ix e

Defined in Data.Massiv.Core.List

type NestedStruct LN ix e = [ListItem ix e]

type family Elt r ix e :: * where ...

Equations

Elt r Ix1 e = e

Elt r ix e = Array (EltRepr r ix) (Lower ix) e

type family EltRepr r ix :: *

Instances

type EltRepr L ix

Defined in Data.Massiv.Core.List

type EltRepr L ix = L

type EltRepr LN ix

Defined in Data.Massiv.Core.List

type EltRepr LN ix = LN

type EltRepr D ix

Defined in Data.Massiv.Array.Delayed.Internal

type EltRepr D ix = D

type EltRepr M ix

Defined in Data.Massiv.Array.Manifest.Internal

type EltRepr M ix = M

type EltRepr U ix

Defined in Data.Massiv.Array.Manifest.Unboxed

type EltRepr U ix = M

type EltRepr S ix

Defined in Data.Massiv.Array.Manifest.Storable

type EltRepr S ix = M

type EltRepr P ix

Defined in Data.Massiv.Array.Manifest.Primitive

type EltRepr P ix = M

type EltRepr N ix

Defined in Data.Massiv.Array.Manifest.Boxed

type EltRepr N ix = M

type EltRepr B ix

Defined in Data.Massiv.Array.Manifest.Boxed

type EltRepr B ix = M

type EltRepr DW ix

Defined in Data.Massiv.Array.Delayed.Windowed

type EltRepr DW ix = D

type EltRepr DI ix

Defined in Data.Massiv.Array.Delayed.Interleaved

type EltRepr DI ix = DI

data family Array r ix e :: *

The array family. Representations r describes how data is arranged or computed. All arrays have a common property that each index ix always maps to the same unique element, even if that element does not exist in memory and has to be computed upon lookup. Data is always arranged in a nested fasion, depth of which is controlled by Rank ix.

Instances

Functor (Array D ix)

Defined in Data.Massiv.Array.Delayed.Internal

Methods

fmap :: (a -> b) -> Array D ix a -> Array D ix b

(<$) :: a -> Array D ix b -> Array D ix a

Functor (Array DW ix)

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

fmap :: (a -> b) -> Array DW ix a -> Array DW ix b

(<$) :: a -> Array DW ix b -> Array DW ix a

Functor (Array DI ix)

Defined in Data.Massiv.Array.Delayed.Interleaved

Methods

fmap :: (a -> b) -> Array DI ix a -> Array DI ix b

(<$) :: a -> Array DI ix b -> Array DI ix a

Index ix => Applicative (Array D ix)

Defined in Data.Massiv.Array.Delayed.Internal

Methods

pure :: a -> Array D ix a

(<*>) :: Array D ix (a -> b) -> Array D ix a -> Array D ix b

liftA2 :: (a -> b -> c) -> Array D ix a -> Array D ix b -> Array D ix c

(*>) :: Array D ix a -> Array D ix b -> Array D ix b

(<*) :: Array D ix a -> Array D ix b -> Array D ix a

Index ix => Foldable (Array D ix)

Row-major sequential folding over a Delayed array.

Defined in Data.Massiv.Array.Delayed.Internal

Methods

fold :: Monoid m => Array D ix m -> m

foldMap :: Monoid m => (a -> m) -> Array D ix a -> m

foldr :: (a -> b -> b) -> b -> Array D ix a -> b

foldr' :: (a -> b -> b) -> b -> Array D ix a -> b

foldl :: (b -> a -> b) -> b -> Array D ix a -> b

foldl' :: (b -> a -> b) -> b -> Array D ix a -> b

foldr1 :: (a -> a -> a) -> Array D ix a -> a

foldl1 :: (a -> a -> a) -> Array D ix a -> a

toList :: Array D ix a -> [a]

null :: Array D ix a -> Bool

length :: Array D ix a -> Int

elem :: Eq a => a -> Array D ix a -> Bool

maximum :: Ord a => Array D ix a -> a

minimum :: Ord a => Array D ix a -> a

sum :: Num a => Array D ix a -> a

product :: Num a => Array D ix a -> a

Index ix => Foldable (Array M ix)

Row-major sequential folding over a Manifest array.

Defined in Data.Massiv.Array.Manifest.Internal

Methods

fold :: Monoid m => Array M ix m -> m

foldMap :: Monoid m => (a -> m) -> Array M ix a -> m

foldr :: (a -> b -> b) -> b -> Array M ix a -> b

foldr' :: (a -> b -> b) -> b -> Array M ix a -> b

foldl :: (b -> a -> b) -> b -> Array M ix a -> b

foldl' :: (b -> a -> b) -> b -> Array M ix a -> b

foldr1 :: (a -> a -> a) -> Array M ix a -> a

foldl1 :: (a -> a -> a) -> Array M ix a -> a

toList :: Array M ix a -> [a]

null :: Array M ix a -> Bool

length :: Array M ix a -> Int

elem :: Eq a => a -> Array M ix a -> Bool

maximum :: Ord a => Array M ix a -> a

minimum :: Ord a => Array M ix a -> a

sum :: Num a => Array M ix a -> a

product :: Num a => Array M ix a -> a

Index ix => Foldable (Array B ix)

Row-major sequential folding over a Boxed array.

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

fold :: Monoid m => Array B ix m -> m

foldMap :: Monoid m => (a -> m) -> Array B ix a -> m

foldr :: (a -> b -> b) -> b -> Array B ix a -> b

foldr' :: (a -> b -> b) -> b -> Array B ix a -> b

foldl :: (b -> a -> b) -> b -> Array B ix a -> b

foldl' :: (b -> a -> b) -> b -> Array B ix a -> b

foldr1 :: (a -> a -> a) -> Array B ix a -> a

foldl1 :: (a -> a -> a) -> Array B ix a -> a

toList :: Array B ix a -> [a]

null :: Array B ix a -> Bool

length :: Array B ix a -> Int

elem :: Eq a => a -> Array B ix a -> Bool

maximum :: Ord a => Array B ix a -> a

minimum :: Ord a => Array B ix a -> a

sum :: Num a => Array B ix a -> a

product :: Num a => Array B ix a -> a

Nested LN ix e => IsList (Array L ix e)

Defined in Data.Massiv.Core.List

Associated Types

type Item (Array L ix e) :: *

Methods

fromList :: [Item (Array L ix e)] -> Array L ix e

fromListN :: Int -> [Item (Array L ix e)] -> Array L ix e

toList :: Array L ix e -> [Item (Array L ix e)]

Nested LN ix e => IsList (Array LN ix e)

Defined in Data.Massiv.Core.List

Associated Types

type Item (Array LN ix e) :: *

Methods

fromList :: [Item (Array LN ix e)] -> Array LN ix e

fromListN :: Int -> [Item (Array LN ix e)] -> Array LN ix e

toList :: Array LN ix e -> [Item (Array LN ix e)]

(Unbox e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array U ix e)

Defined in Data.Massiv.Array.Manifest.Unboxed

Associated Types

type Item (Array U ix e) :: *

Methods

fromList :: [Item (Array U ix e)] -> Array U ix e

fromListN :: Int -> [Item (Array U ix e)] -> Array U ix e

toList :: Array U ix e -> [Item (Array U ix e)]

(Storable e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array S ix e)

Defined in Data.Massiv.Array.Manifest.Storable

Associated Types

type Item (Array S ix e) :: *

Methods

fromList :: [Item (Array S ix e)] -> Array S ix e

fromListN :: Int -> [Item (Array S ix e)] -> Array S ix e

toList :: Array S ix e -> [Item (Array S ix e)]

(Prim e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array P ix e)

Defined in Data.Massiv.Array.Manifest.Primitive

Associated Types

type Item (Array P ix e) :: *

Methods

fromList :: [Item (Array P ix e)] -> Array P ix e

fromListN :: Int -> [Item (Array P ix e)] -> Array P ix e

toList :: Array P ix e -> [Item (Array P ix e)]

(NFData e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array N ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

Associated Types

type Item (Array N ix e) :: *

Methods

fromList :: [Item (Array N ix e)] -> Array N ix e

fromListN :: Int -> [Item (Array N ix e)] -> Array N ix e

toList :: Array N ix e -> [Item (Array N ix e)]

(IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array B ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

Associated Types

type Item (Array B ix e) :: *

Methods

fromList :: [Item (Array B ix e)] -> Array B ix e

fromListN :: Int -> [Item (Array B ix e)] -> Array B ix e

toList :: Array B ix e -> [Item (Array B ix e)]

(Eq e, Index ix) => Eq (Array D ix e)

Defined in Data.Massiv.Array.Delayed.Internal

Methods

(==) :: Array D ix e -> Array D ix e -> Bool

(/=) :: Array D ix e -> Array D ix e -> Bool

(Eq e, Index ix) => Eq (Array M ix e)

Defined in Data.Massiv.Array.Manifest.Internal

Methods

(==) :: Array M ix e -> Array M ix e -> Bool

(/=) :: Array M ix e -> Array M ix e -> Bool

(Unbox e, Eq e, Index ix) => Eq (Array U ix e)

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

(==) :: Array U ix e -> Array U ix e -> Bool

(/=) :: Array U ix e -> Array U ix e -> Bool

(Storable e, Eq e, Index ix) => Eq (Array S ix e)

Defined in Data.Massiv.Array.Manifest.Storable

Methods

(==) :: Array S ix e -> Array S ix e -> Bool

(/=) :: Array S ix e -> Array S ix e -> Bool

(Prim e, Eq e, Index ix) => Eq (Array P ix e)

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

(==) :: Array P ix e -> Array P ix e -> Bool

(/=) :: Array P ix e -> Array P ix e -> Bool

(Index ix, NFData e, Eq e) => Eq (Array N ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

(==) :: Array N ix e -> Array N ix e -> Bool

(/=) :: Array N ix e -> Array N ix e -> Bool

(Index ix, Eq e) => Eq (Array B ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

(==) :: Array B ix e -> Array B ix e -> Bool

(/=) :: Array B ix e -> Array B ix e -> Bool

(Index ix, Floating e) => Floating (Array D ix e)

Defined in Data.Massiv.Array.Delayed.Internal

Methods

pi :: Array D ix e

exp :: Array D ix e -> Array D ix e

log :: Array D ix e -> Array D ix e

sqrt :: Array D ix e -> Array D ix e

(**) :: Array D ix e -> Array D ix e -> Array D ix e

logBase :: Array D ix e -> Array D ix e -> Array D ix e

sin :: Array D ix e -> Array D ix e

cos :: Array D ix e -> Array D ix e

tan :: Array D ix e -> Array D ix e

asin :: Array D ix e -> Array D ix e

acos :: Array D ix e -> Array D ix e

atan :: Array D ix e -> Array D ix e

sinh :: Array D ix e -> Array D ix e

cosh :: Array D ix e -> Array D ix e

tanh :: Array D ix e -> Array D ix e

asinh :: Array D ix e -> Array D ix e

acosh :: Array D ix e -> Array D ix e

atanh :: Array D ix e -> Array D ix e

log1p :: Array D ix e -> Array D ix e

expm1 :: Array D ix e -> Array D ix e

log1pexp :: Array D ix e -> Array D ix e

log1mexp :: Array D ix e -> Array D ix e

(Index ix, Fractional e) => Fractional (Array D ix e)

Defined in Data.Massiv.Array.Delayed.Internal

Methods

(/) :: Array D ix e -> Array D ix e -> Array D ix e

recip :: Array D ix e -> Array D ix e

fromRational :: Rational -> Array D ix e

(Index ix, Num e) => Num (Array D ix e)

Defined in Data.Massiv.Array.Delayed.Internal

Methods

(+) :: Array D ix e -> Array D ix e -> Array D ix e

(-) :: Array D ix e -> Array D ix e -> Array D ix e

(*) :: Array D ix e -> Array D ix e -> Array D ix e

negate :: Array D ix e -> Array D ix e

abs :: Array D ix e -> Array D ix e

signum :: Array D ix e -> Array D ix e

fromInteger :: Integer -> Array D ix e

(Ord e, Index ix) => Ord (Array D ix e)

Defined in Data.Massiv.Array.Delayed.Internal

Methods

compare :: Array D ix e -> Array D ix e -> Ordering

(<) :: Array D ix e -> Array D ix e -> Bool

(<=) :: Array D ix e -> Array D ix e -> Bool

(>) :: Array D ix e -> Array D ix e -> Bool

(>=) :: Array D ix e -> Array D ix e -> Bool

max :: Array D ix e -> Array D ix e -> Array D ix e

min :: Array D ix e -> Array D ix e -> Array D ix e

(Ord e, Index ix) => Ord (Array M ix e)

Defined in Data.Massiv.Array.Manifest.Internal

Methods

compare :: Array M ix e -> Array M ix e -> Ordering

(<) :: Array M ix e -> Array M ix e -> Bool

(<=) :: Array M ix e -> Array M ix e -> Bool

(>) :: Array M ix e -> Array M ix e -> Bool

(>=) :: Array M ix e -> Array M ix e -> Bool

max :: Array M ix e -> Array M ix e -> Array M ix e

min :: Array M ix e -> Array M ix e -> Array M ix e

(Unbox e, Ord e, Index ix) => Ord (Array U ix e)

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

compare :: Array U ix e -> Array U ix e -> Ordering

(<) :: Array U ix e -> Array U ix e -> Bool

(<=) :: Array U ix e -> Array U ix e -> Bool

(>) :: Array U ix e -> Array U ix e -> Bool

(>=) :: Array U ix e -> Array U ix e -> Bool

max :: Array U ix e -> Array U ix e -> Array U ix e

min :: Array U ix e -> Array U ix e -> Array U ix e

(Storable e, Ord e, Index ix) => Ord (Array S ix e)

Defined in Data.Massiv.Array.Manifest.Storable

Methods

compare :: Array S ix e -> Array S ix e -> Ordering

(<) :: Array S ix e -> Array S ix e -> Bool

(<=) :: Array S ix e -> Array S ix e -> Bool

(>) :: Array S ix e -> Array S ix e -> Bool

(>=) :: Array S ix e -> Array S ix e -> Bool

max :: Array S ix e -> Array S ix e -> Array S ix e

min :: Array S ix e -> Array S ix e -> Array S ix e

(Prim e, Ord e, Index ix) => Ord (Array P ix e)

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

compare :: Array P ix e -> Array P ix e -> Ordering

(<) :: Array P ix e -> Array P ix e -> Bool

(<=) :: Array P ix e -> Array P ix e -> Bool

(>) :: Array P ix e -> Array P ix e -> Bool

(>=) :: Array P ix e -> Array P ix e -> Bool

max :: Array P ix e -> Array P ix e -> Array P ix e

min :: Array P ix e -> Array P ix e -> Array P ix e

(Index ix, NFData e, Ord e) => Ord (Array N ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

compare :: Array N ix e -> Array N ix e -> Ordering

(<) :: Array N ix e -> Array N ix e -> Bool

(<=) :: Array N ix e -> Array N ix e -> Bool

(>) :: Array N ix e -> Array N ix e -> Bool

(>=) :: Array N ix e -> Array N ix e -> Bool

max :: Array N ix e -> Array N ix e -> Array N ix e

min :: Array N ix e -> Array N ix e -> Array N ix e

(Index ix, Ord e) => Ord (Array B ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

compare :: Array B ix e -> Array B ix e -> Ordering

(<) :: Array B ix e -> Array B ix e -> Bool

(<=) :: Array B ix e -> Array B ix e -> Bool

(>) :: Array B ix e -> Array B ix e -> Bool

(>=) :: Array B ix e -> Array B ix e -> Bool

max :: Array B ix e -> Array B ix e -> Array B ix e

min :: Array B ix e -> Array B ix e -> Array B ix e

(Ragged L ix e, Source r ix e, Show e) => Show (Array r ix e)

Defined in Data.Massiv.Core.List

Methods

showsPrec :: Int -> Array r ix e -> ShowS

show :: Array r ix e -> String

showList :: [Array r ix e] -> ShowS

(Ragged L ix e, Show e) => Show (Array L ix e)

Defined in Data.Massiv.Core.List

Methods

showsPrec :: Int -> Array L ix e -> ShowS

show :: Array L ix e -> String

showList :: [Array L ix e] -> ShowS

(Ragged L ix e, Show e) => Show (Array LN ix e)

Defined in Data.Massiv.Core.List

Methods

showsPrec :: Int -> Array LN ix e -> ShowS

show :: Array LN ix e -> String

showList :: [Array LN ix e] -> ShowS

(Show e, Ragged L ix e, Load DW ix e) => Show (Array DW ix e)

Defined in Data.Massiv.Array.Delayed.Windowed

Methods

showsPrec :: Int -> Array DW ix e -> ShowS

show :: Array DW ix e -> String

showList :: [Array DW ix e] -> ShowS

(Index ix, NFData e) => NFData (Array U ix e)

Defined in Data.Massiv.Array.Manifest.Unboxed

Methods

rnf :: Array U ix e -> ()

Index ix => NFData (Array S ix e)

Defined in Data.Massiv.Array.Manifest.Storable

Methods

rnf :: Array S ix e -> ()

Index ix => NFData (Array P ix e)

Defined in Data.Massiv.Array.Manifest.Primitive

Methods

rnf :: Array P ix e -> ()

(Index ix, NFData e) => NFData (Array N ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

rnf :: Array N ix e -> ()

(Index ix, NFData e) => NFData (Array B ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

Methods

rnf :: Array B ix e -> ()

data Array L ix e

Defined in Data.Massiv.Core.List

data Array L ix e = LArray {

• lComp :: Comp
• lData :: !(Array LN ix e)

}

data Array LN ix e

Defined in Data.Massiv.Core.List

data Array LN ix e = List {

• unList :: [Elt LN ix e]

}

data Array D ix e

Defined in Data.Massiv.Array.Delayed.Internal

data Array D ix e = DArray {

• dComp :: !Comp
• dSize :: !ix
• dIndex :: ix -> e

}

data Array M ix e

Defined in Data.Massiv.Array.Manifest.Internal

data Array M ix e = MArray {

• mComp :: !Comp
• mSize :: !ix
• mLinearIndex :: Int -> e

}

data Array U ix e

Defined in Data.Massiv.Array.Manifest.Unboxed

data Array U ix e = UArray {

• uComp :: !Comp
• uSize :: !ix
• uData :: !(Vector e)

}

data Array S ix e

Defined in Data.Massiv.Array.Manifest.Storable

data Array S ix e = SArray {

• sComp :: !Comp
• sSize :: !ix
• sData :: !(Vector e)

}

data Array P ix e

Defined in Data.Massiv.Array.Manifest.Primitive

data Array P ix e = PArray {

• pComp :: !Comp
• pSize :: !ix
• pData :: !ByteArray

}

data Array N ix e

Defined in Data.Massiv.Array.Manifest.Boxed

data Array N ix e = NArray {

• bArray :: Array B ix e

}

data Array B ix e

Defined in Data.Massiv.Array.Manifest.Boxed

data Array B ix e = BArray {

• bComp :: !Comp
• bSize :: !ix
• bData :: !(Array e)

}

data Array DW ix e

Defined in Data.Massiv.Array.Delayed.Windowed

data Array DW ix e = DWArray {

• dwArray :: !(Array D ix e)
• dwStencilSize :: !(Maybe ix)
• dwWindow :: !(Maybe (Window ix e))

}

data Array DI ix e

Defined in Data.Massiv.Array.Delayed.Interleaved

data Array DI ix e = DIArray {

• diArray :: Array D ix e

}

type Item (Array L ix e)

Defined in Data.Massiv.Core.List

type Item (Array L ix e) = ListItem ix e

type Item (Array LN ix e)

Defined in Data.Massiv.Core.List

type Item (Array LN ix e) = ListItem ix e

type Item (Array U ix e)

Defined in Data.Massiv.Array.Manifest.Unboxed

type Item (Array U ix e) = Item (Array L ix e)

type Item (Array S ix e)

Defined in Data.Massiv.Array.Manifest.Storable

type Item (Array S ix e) = Item (Array L ix e)

type Item (Array P ix e)

Defined in Data.Massiv.Array.Manifest.Primitive

type Item (Array P ix e) = Item (Array L ix e)

type Item (Array N ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

type Item (Array N ix e) = Item (Array L ix e)

type Item (Array B ix e)

Defined in Data.Massiv.Array.Manifest.Boxed

type Item (Array B ix e) = Item (Array L ix e)

data L

Constructors

L

Instances

(Index ix, Index (Lower ix), Ragged L (Lower ix) e, Elt L ix e ~ Array L (Lower ix) e, Elt LN ix e ~ Array LN (Lower ix) e, Coercible (Elt LN ix e) [Elt LN (Lower ix) e]) => Ragged L ix e

Defined in Data.Massiv.Core.List

Methods

empty :: Comp -> Array L ix e

isNull :: Array L ix e -> Bool

cons :: Elt L ix e -> Array L ix e -> Array L ix e

uncons :: Array L ix e -> Maybe (Elt L ix e, Array L ix e)

unsafeGenerateM :: Monad m => Comp -> ix -> (ix -> m e) -> m (Array L ix e)

edgeSize :: Array L ix e -> ix

flatten :: Array L ix e -> Array L Ix1 e

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower ix -> Array L ix e -> IO ()

raggedFormat :: (e -> String) -> String -> Array L ix e -> String

Ragged L Ix1 e

Defined in Data.Massiv.Core.List

Methods

empty :: Comp -> Array L Ix1 e

isNull :: Array L Ix1 e -> Bool

cons :: Elt L Ix1 e -> Array L Ix1 e -> Array L Ix1 e

uncons :: Array L Ix1 e -> Maybe (Elt L Ix1 e, Array L Ix1 e)

unsafeGenerateM :: Monad m => Comp -> Ix1 -> (Ix1 -> m e) -> m (Array L Ix1 e)

edgeSize :: Array L Ix1 e -> Ix1

flatten :: Array L Ix1 e -> Array L Ix1 e

loadRagged :: (IO () -> IO ()) -> (Int -> e -> IO a) -> Int -> Int -> Lower Ix1 -> Array L Ix1 e -> IO ()

raggedFormat :: (e -> String) -> String -> Array L Ix1 e -> String

Nested L ix e

Defined in Data.Massiv.Core.List

Methods

fromNested :: NestedStruct L ix e -> Array L ix e

toNested :: Array L ix e -> NestedStruct L ix e

Ragged L ix e => OuterSlice L ix e

Defined in Data.Massiv.Core.List

Methods

unsafeOuterSlice :: Array L ix e -> Int -> Elt L ix e

outerLength :: Array L ix e -> Int

OuterSlice L Ix1 e

Defined in Data.Massiv.Core.List

Methods

unsafeOuterSlice :: Array L Ix1 e -> Int -> Elt L Ix1 e

outerLength :: Array L Ix1 e -> Int

(Index ix, Ragged L ix e, Ragged L (Lower ix) e, Elt L ix e ~ Array L (Lower ix) e) => Construct L ix e

Defined in Data.Massiv.Core.List

Methods

getComp :: Array L ix e -> Comp

setComp :: Comp -> Array L ix e -> Array L ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array L ix e

Construct L Ix1 e

Defined in Data.Massiv.Core.List

Methods

getComp :: Array L Ix1 e -> Comp

setComp :: Comp -> Array L Ix1 e -> Array L Ix1 e

unsafeMakeArray :: Comp -> Ix1 -> (Ix1 -> e) -> Array L Ix1 e

Nested LN ix e => IsList (Array L ix e)

Defined in Data.Massiv.Core.List

Associated Types

type Item (Array L ix e) :: *

Methods

fromList :: [Item (Array L ix e)] -> Array L ix e

fromListN :: Int -> [Item (Array L ix e)] -> Array L ix e

toList :: Array L ix e -> [Item (Array L ix e)]

(Ragged L ix e, Show e) => Show (Array L ix e)

Defined in Data.Massiv.Core.List

Methods

showsPrec :: Int -> Array L ix e -> ShowS

show :: Array L ix e -> String

showList :: [Array L ix e] -> ShowS

data Array L ix e

Defined in Data.Massiv.Core.List

data Array L ix e = LArray {

• lComp :: Comp
• lData :: !(Array LN ix e)

}

type EltRepr L ix

Defined in Data.Massiv.Core.List

type EltRepr L ix = L

type NestedStruct L ix e

Defined in Data.Massiv.Core.List

type NestedStruct L ix e = Array LN ix e

type Item (Array L ix e)

Defined in Data.Massiv.Core.List

type Item (Array L ix e) = ListItem ix e

type family ListItem ix e :: * where ...

Equations

ListItem Ix1 e = e

ListItem ix e = [ListItem (Lower ix) e]

data LN

Instances

(Elt LN ix e ~ Array LN (Lower ix) e, ListItem ix e ~ [ListItem (Lower ix) e], Coercible (Elt LN ix e) (ListItem ix e)) => Nested LN ix e

Defined in Data.Massiv.Core.List

Methods

fromNested :: NestedStruct LN ix e -> Array LN ix e

toNested :: Array LN ix e -> NestedStruct LN ix e

Nested LN Ix1 e

Defined in Data.Massiv.Core.List

Methods

fromNested :: NestedStruct LN Ix1 e -> Array LN Ix1 e

toNested :: Array LN Ix1 e -> NestedStruct LN Ix1 e

Nested LN ix e => IsList (Array LN ix e)

Defined in Data.Massiv.Core.List

Associated Types

type Item (Array LN ix e) :: *

Methods

fromList :: [Item (Array LN ix e)] -> Array LN ix e

fromListN :: Int -> [Item (Array LN ix e)] -> Array LN ix e

toList :: Array LN ix e -> [Item (Array LN ix e)]

(Ragged L ix e, Show e) => Show (Array LN ix e)

Defined in Data.Massiv.Core.List

Methods

showsPrec :: Int -> Array LN ix e -> ShowS

show :: Array LN ix e -> String

showList :: [Array LN ix e] -> ShowS

data Array LN ix e

Defined in Data.Massiv.Core.List

data Array LN ix e = List {

• unList :: [Elt LN ix e]

}

type EltRepr LN ix

Defined in Data.Massiv.Core.List

type EltRepr LN ix = LN

type NestedStruct LN ix e

Defined in Data.Massiv.Core.List

type NestedStruct LN ix e = [ListItem ix e]

type Item (Array LN ix e)

Defined in Data.Massiv.Core.List

type Item (Array LN ix e) = ListItem ix e

Representations

module Data.Massiv.Array.Delayed

module Data.Massiv.Array.Manifest

Stencil

module Data.Massiv.Array.Stencil

module Data.Massiv.Array.Numeric