Data.Vector.Storable.Sized

This module re-exports the functionality in Sized specialized to Storable

Functions returning a vector determine the size from the type context unless they have a ' suffix in which case they take an explicit Proxy argument.

Functions where the resultant vector size is not know until compile time are not exported.

Documentation

type Vector = Vector Vector

Vector specialized to use Storable

Accessors

Length information

length :: forall n a. KnownNat n => Vector n a -> Int

O(1) Yield the length of the vector as an Int.

length' :: forall n a. KnownNat n => Vector n a -> Proxy n

O(1) Yield the length of the vector as a Proxy.

Indexing

index :: forall n a. (KnownNat n, Storable a) => Vector n a -> Finite n -> a

O(1) Safe indexing using a Finite.

index' :: forall n m a. (KnownNat n, KnownNat m, Storable a) => Vector ((n + m) + 1) a -> Proxy n -> a

O(1) Safe indexing using a Proxy.

unsafeIndex :: forall n a. (KnownNat n, Storable a) => Vector n a -> Int -> a

O(1) Indexing using an Int without bounds checking.

head :: forall n a. Storable a => Vector (n + 1) a -> a

O(1) Yield the first element of a non-empty vector.

last :: forall n a. Storable a => Vector (n + 1) a -> a

O(1) Yield the last element of a non-empty vector.

Monadic indexing

indexM :: forall n a m. (KnownNat n, Storable a, Monad m) => Vector n a -> Finite n -> m a

O(1) Safe indexing in a monad. See the documentation for indexM for an explanation of why this is useful.

indexM' :: forall n k a m. (KnownNat n, KnownNat k, Storable a, Monad m) => Vector (n + k) a -> Proxy n -> m a

O(1) Safe indexing in a monad using a Proxy. See the documentation for indexM for an explanation of why this is useful.

unsafeIndexM :: forall n a m. (KnownNat n, Storable a, Monad m) => Vector n a -> Int -> m a

O(1) Indexing using an Int without bounds checking. See the documentation for indexM for an explanation of why this is useful.

headM :: forall n a m. (KnownNat n, Storable a, Monad m) => Vector (n + 1) a -> m a

O(1) Yield the first element of a non-empty vector in a monad. See the documentation for indexM for an explanation of why this is useful.

lastM :: forall n a m. (KnownNat n, Storable a, Monad m) => Vector (n + 1) a -> m a

O(1) Yield the last element of a non-empty vector in a monad. See the documentation for indexM for an explanation of why this is useful.

Extracting subvectors (slicing)

slice

Arguments

:: (KnownNat i, KnownNat n, Storable a)

=> Proxy i

starting index

-> Vector (i + n) a

-> Vector n a

O(1) Yield a slice of the vector without copying it with an inferred length argument.

slice'

Arguments

:: (KnownNat i, KnownNat n, Storable a)

=> Proxy i

starting index

-> Proxy n

length

-> Vector (i + n) a

-> Vector n a

O(1) Yield a slice of the vector without copying it with an explicit length argument.

init :: forall n a. Storable a => Vector (n + 1) a -> Vector n a

O(1) Yield all but the last element of a non-empty vector without copying.

tail :: forall n a. Storable a => Vector (n + 1) a -> Vector n a

O(1) Yield all but the first element of a non-empty vector without copying.

take :: forall n m a. (KnownNat n, KnownNat m, Storable a) => Vector (m + n) a -> Vector n a

O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is inferred from the type.

take' :: forall n m a. (KnownNat n, KnownNat m, Storable a) => Proxy n -> Vector (m + n) a -> Vector n a

O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is given explicitly as a Proxy argument.

drop :: forall n m a. (KnownNat n, KnownNat m, Storable a) => Vector (m + n) a -> Vector m a

O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.

drop' :: forall n m a. (KnownNat n, KnownNat m, Storable a) => Proxy n -> Vector (m + n) a -> Vector m a

O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is givel explicitly as a Proxy argument.

splitAt :: forall n m a. (KnownNat n, KnownNat m, Storable a) => Vector (n + m) a -> (Vector n a, Vector m a)

O(1) Yield the first n elements paired with the remainder without copying. The lengths of the resultant vector are inferred from the type.

splitAt' :: forall n m a. (KnownNat n, KnownNat m, Storable a) => Proxy n -> Vector (n + m) a -> (Vector n a, Vector m a)

O(1) Yield the first n elements paired with the remainder without copying. The length of the first resultant vector is passed explicitly as a Proxy argument.

Construction

Initialization

empty :: forall a. Storable a => Vector 0 a

O(1) Empty vector.

singleton :: forall a. Storable a => a -> Vector 1 a

O(1) Vector with exactly one element.

replicate :: forall n a. (KnownNat n, Storable a) => a -> Vector n a

O(n) Construct a vector with the same element in each position where the length is inferred from the type.

replicate' :: forall n a. (KnownNat n, Storable a) => Proxy n -> a -> Vector n a

O(n) Construct a vector with the same element in each position where the length is given explicitly as a Proxy argument.

generate :: forall n a. (KnownNat n, Storable a) => (Int -> a) -> Vector n a

O(n) construct a vector of the given length by applying the function to each index where the length is inferred from the type.

generate' :: forall n a. (KnownNat n, Storable a) => Proxy n -> (Int -> a) -> Vector n a

O(n) construct a vector of the given length by applying the function to each index where the length is given explicitly as a Proxy argument.

generate_ :: forall n a. (KnownNat n, Storable a) => (Finite n -> a) -> Vector n a

O(n) construct a vector of the given length by applying the function to each index where the length is inferred from the type.

The function can expect a Finite n, meaning that its input will always be between 0 and n - 1.

iterateN :: forall n a. (KnownNat n, Storable a) => (a -> a) -> a -> Vector n a

O(n) Apply function n times to value. Zeroth element is original value. The length is inferred from the type.

iterateN' :: forall n a. (KnownNat n, Storable a) => Proxy n -> (a -> a) -> a -> Vector n a

O(n) Apply function n times to value. Zeroth element is original value. The length is given explicitly as a Proxy argument.

Monadic initialization

replicateM :: forall n m a. (KnownNat n, Storable a, Monad m) => m a -> m (Vector n a)

O(n) Execute the monadic action n times and store the results in a vector where n is inferred from the type.

replicateM' :: forall n m a. (KnownNat n, Storable a, Monad m) => Proxy n -> m a -> m (Vector n a)

O(n) Execute the monadic action n times and store the results in a vector where n is given explicitly as a Proxy argument.

generateM :: forall n m a. (KnownNat n, Storable a, Monad m) => (Int -> m a) -> m (Vector n a)

O(n) Construct a vector of length n by applying the monadic action to each index where n is inferred from the type.

generateM' :: forall n m a. (KnownNat n, Storable a, Monad m) => Proxy n -> (Int -> m a) -> m (Vector n a)

O(n) Construct a vector of length n by applying the monadic action to each index where n is given explicitly as a Proxy argument.

generateM_ :: forall n m a. (KnownNat n, Storable a, Monad m) => (Finite n -> m a) -> m (Vector n a)

O(n) Construct a vector of length n by applying the monadic action to each index where n is inferred from the type.

The function can expect a Finite n, meaning that its input will always be between 0 and n - 1.

Unfolding

unfoldrN :: forall n a b. (KnownNat n, Storable a) => (b -> (a, b)) -> b -> Vector n a

O(n) Construct a vector with exactly n elements by repeatedly applying the generator function to the a seed. The length, n, is inferred from the type.

unfoldrN' :: forall n a b. (KnownNat n, Storable a) => Proxy n -> (b -> (a, b)) -> b -> Vector n a

O(n) Construct a vector with exactly n elements by repeatedly applying the generator function to the a seed. The length, n, is given explicitly as a Proxy argument.

Enumeration

enumFromN :: forall n a. (KnownNat n, Storable a, Num a) => a -> Vector n a

O(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is inferred from the type.

enumFromN' :: forall n a. (KnownNat n, Storable a, Num a) => a -> Proxy n -> Vector n a

O(n) Yield a vector of length n containing the values x, x+1 etc. The length, n, is given explicitly as a Proxy argument.

enumFromStepN :: forall n a. (KnownNat n, Storable a, Num a) => a -> a -> Vector n a

O(n) Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is inferred from the type.

enumFromStepN' :: forall n a. (KnownNat n, Storable a, Num a) => a -> a -> Proxy n -> Vector n a

O(n) Yield a vector of the given length containing the values x, x+y, x+y+y etc. The length, n, is given explicitly as a Proxy argument.

Concatenation

cons :: forall n a. Storable a => a -> Vector n a -> Vector (n + 1) a

O(n) Prepend an element.

snoc :: forall n a. Storable a => Vector n a -> a -> Vector (n + 1) a

O(n) Append an element.

(++) :: forall n m a. Storable a => Vector n a -> Vector m a -> Vector (n + m) a

O(m+n) Concatenate two vectors.

Restricting memory usage

force :: Storable a => Vector n a -> Vector n a

O(n) Yield the argument but force it not to retain any extra memory, possibly by copying it.

This is especially useful when dealing with slices. For example:

force (slice 0 2 <huge vector>)

Here, the slice retains a reference to the huge vector. Forcing it creates a copy of just the elements that belong to the slice and allows the huge vector to be garbage collected.

Modifying vectors

Bulk updates

(//)

Arguments

:: Storable a

=> Vector m a

initial vector (of length m)

-> [(Int, a)]

list of index/value pairs (of length n)

-> Vector m a

O(m+n) For each pair (i,a) from the list, replace the vector element at position i by a.

<5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>

update

Arguments

:: (Storable a, Storable (Int, a))

=> Vector m a

initial vector (of length m)

-> Vector n (Int, a)

vector of index/value pairs (of length n)

-> Vector m a

O(m+n) For each pair (i,a) from the vector of index/value pairs, replace the vector element at position i by a.

update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>

update_

Arguments

:: Storable a

=> Vector m a

initial vector (of length m)

-> Vector n Int

index vector (of length n)

-> Vector n a

value vector (of length n)

-> Vector m a

O(m+n) For each index i from the index vector and the corresponding value a from the value vector, replace the element of the initial vector at position i by a.

update_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>

This function is useful for instances of Vector that cannot store pairs. Otherwise, update is probably more convenient.

update_ xs is ys = update xs (zip is ys)

unsafeUpd

Arguments

:: Storable a

=> Vector m a

initial vector (of length m)

-> [(Int, a)]

list of index/value pairs (of length n)

-> Vector m a

Same as (//) but without bounds checking.

unsafeUpdate

Arguments

:: (Storable a, Storable (Int, a))

=> Vector m a

initial vector (of length m)

-> Vector n (Int, a)

vector of index/value pairs (of length n)

-> Vector m a

Same as update but without bounds checking.

unsafeUpdate_

Arguments

:: Storable a

=> Vector m a

initial vector (of length m)

-> Vector n Int

index vector (of length n)

-> Vector n a

value vector (of length n)

-> Vector m a

Same as update_ but without bounds checking.

Accumulations

accum

Arguments

:: Storable a

=> (a -> b -> a)

accumulating function f

-> Vector m a

initial vector (of length m)

-> [(Int, b)]

list of index/value pairs (of length n)

-> Vector m a

O(m+n) For each pair (i,b) from the list, replace the vector element a at position i by f a b.

accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>

accumulate

Arguments

:: (Storable a, Storable (Int, b))

=> (a -> b -> a)

accumulating function f

-> Vector m a

initial vector (of length m)

-> Vector n (Int, b)

vector of index/value pairs (of length n)

-> Vector m a

O(m+n) For each pair (i,b) from the vector of pairs, replace the vector element a at position i by f a b.

accumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>

accumulate_

Arguments

:: (Storable a, Storable b)

=> (a -> b -> a)

accumulating function f

-> Vector m a

initial vector (of length m)

-> Vector n Int

index vector (of length n)

-> Vector n b

value vector (of length n)

-> Vector m a

O(m+n) For each index i from the index vector and the corresponding value b from the the value vector, replace the element of the initial vector at position i by f a b.

accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>

This function is useful for instances of Vector that cannot store pairs. Otherwise, accumulate is probably more convenient:

accumulate_ f as is bs = accumulate f as (zip is bs)

unsafeAccum

Arguments

:: Storable a

=> (a -> b -> a)

accumulating function f

-> Vector m a

initial vector (of length m)

-> [(Int, b)]

list of index/value pairs (of length n)

-> Vector m a

Same as accum but without bounds checking.

unsafeAccumulate

Arguments

:: (Storable a, Storable (Int, b))

=> (a -> b -> a)

accumulating function f

-> Vector m a

initial vector (of length m)

-> Vector n (Int, b)

vector of index/value pairs (of length n)

-> Vector m a

Same as accumulate but without bounds checking.

unsafeAccumulate_

Arguments

:: (Storable a, Storable b)

=> (a -> b -> a)

accumulating function f

-> Vector m a

initial vector (of length m)

-> Vector n Int

index vector (of length n)

-> Vector n b

value vector (of length n)

-> Vector m a

Same as accumulate_ but without bounds checking.

Permutations

reverse :: Storable a => Vector n a -> Vector n a

O(n) Reverse a vector

backpermute

Arguments

:: Storable a

=> Vector m a

xs value vector

-> Vector n Int

is index vector (of length n)

-> Vector n a

O(n) Yield the vector obtained by replacing each element i of the index vector by xs!i. This is equivalent to map (xs!) is but is often much more efficient.

backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>

unsafeBackpermute

Arguments

:: Storable a

=> Vector m a

xs value vector

-> Vector n Int

is index vector (of length n)

-> Vector n a

Same as backpermute but without bounds checking.

Elementwise operations

Indexing

indexed :: (Storable a, Storable (Int, a)) => Vector n a -> Vector n (Int, a)

O(n) Pair each element in a vector with its index

Mapping

map :: (Storable a, Storable b) => (a -> b) -> Vector n a -> Vector n b

O(n) Map a function over a vector

imap :: (Storable a, Storable b) => (Int -> a -> b) -> Vector n a -> Vector n b

O(n) Apply a function to every element of a vector and its index

concatMap :: (Storable a, Storable b) => (a -> Vector m b) -> Vector n a -> Vector (n * m) b

O(n*m) Map a function over a vector and concatenate the results. The function is required to always return the same length vector.

Monadic mapping

mapM :: (Monad m, Storable a, Storable b) => (a -> m b) -> Vector n a -> m (Vector n b)

O(n) Apply the monadic action to all elements of the vector, yielding a vector of results

imapM :: (Monad m, Storable a, Storable b) => (Int -> a -> m b) -> Vector n a -> m (Vector n b)

O(n) Apply the monadic action to every element of a vector and its index, yielding a vector of results

mapM_ :: (Monad m, Storable a) => (a -> m b) -> Vector n a -> m ()

O(n) Apply the monadic action to all elements of a vector and ignore the results

imapM_ :: (Monad m, Storable a) => (Int -> a -> m b) -> Vector n a -> m ()

O(n) Apply the monadic action to every element of a vector and its index, ignoring the results

forM :: (Monad m, Storable a, Storable b) => Vector n a -> (a -> m b) -> m (Vector n b)

O(n) Apply the monadic action to all elements of the vector, yielding a vector of results. Equvalent to flip mapM.

forM_ :: (Monad m, Storable a) => Vector n a -> (a -> m b) -> m ()

O(n) Apply the monadic action to all elements of a vector and ignore the results. Equivalent to flip mapM_.

Zipping

zipWith :: (Storable a, Storable b, Storable c) => (a -> b -> c) -> Vector n a -> Vector n b -> Vector n c

O(n) Zip two vectors of the same length with the given function.

zipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d

Zip three vectors with the given function.

zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e

zipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f

zipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

izipWith :: (Storable a, Storable b, Storable c) => (Int -> a -> b -> c) -> Vector n a -> Vector n b -> Vector n c

O(n) Zip two vectors of the same length with a function that also takes the elements' indices).

izipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (Int -> a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d

izipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (Int -> a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e

izipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (Int -> a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f

izipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

zip :: (Storable a, Storable b, Storable (a, b)) => Vector n a -> Vector n b -> Vector n (a, b)

O(n) Zip two vectors of the same length

zip3 :: (Storable a, Storable b, Storable c, Storable (a, b, c)) => Vector n a -> Vector n b -> Vector n c -> Vector n (a, b, c)

zip4 :: (Storable a, Storable b, Storable c, Storable d, Storable (a, b, c, d)) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n (a, b, c, d)

zip5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable (a, b, c, d, e)) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n (a, b, c, d, e)

zip6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable (a, b, c, d, e, f)) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n (a, b, c, d, e, f)

Monadic zipping

zipWithM :: (Monad m, Storable a, Storable b, Storable c) => (a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

O(n) Zip the two vectors of the same length with the monadic action and yield a vector of results

izipWithM :: (Monad m, Storable a, Storable b, Storable c) => (Int -> a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

O(n) Zip the two vectors with a monadic action that also takes the element index and yield a vector of results

zipWithM_ :: (Monad m, Storable a, Storable b) => (a -> b -> m c) -> Vector n a -> Vector n b -> m ()

O(n) Zip the two vectors with the monadic action and ignore the results

izipWithM_ :: (Monad m, Storable a, Storable b) => (Int -> a -> b -> m c) -> Vector n a -> Vector n b -> m ()

O(n) Zip the two vectors with a monadic action that also takes the element index and ignore the results

Unzipping

unzip :: (Storable a, Storable b, Storable (a, b)) => Vector n (a, b) -> (Vector n a, Vector n b)

O(min(m,n)) Unzip a vector of pairs.

unzip3 :: (Storable a, Storable b, Storable c, Storable (a, b, c)) => Vector n (a, b, c) -> (Vector n a, Vector n b, Vector n c)

unzip4 :: (Storable a, Storable b, Storable c, Storable d, Storable (a, b, c, d)) => Vector n (a, b, c, d) -> (Vector n a, Vector n b, Vector n c, Vector n d)

unzip5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable (a, b, c, d, e)) => Vector n (a, b, c, d, e) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e)

unzip6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable (a, b, c, d, e, f)) => Vector n (a, b, c, d, e, f) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e, Vector n f)

Working with predicates

Searching

elem :: (Storable a, Eq a) => a -> Vector n a -> Bool infix 4

O(n) Check if the vector contains an element

notElem :: (Storable a, Eq a) => a -> Vector n a -> Bool infix 4

O(n) Check if the vector does not contain an element (inverse of elem)

find :: Storable a => (a -> Bool) -> Vector n a -> Maybe a

O(n) Yield Just the first element matching the predicate or Nothing if no such element exists.

findIndex :: Storable a => (a -> Bool) -> Vector n a -> Maybe Int

O(n) Yield Just the index of the first element matching the predicate or Nothing if no such element exists.

elemIndex :: (Storable a, Eq a) => a -> Vector n a -> Maybe Int

O(n) Yield Just the index of the first occurence of the given element or Nothing if the vector does not contain the element. This is a specialised version of findIndex.

Folding

foldl :: Storable b => (a -> b -> a) -> a -> Vector n b -> a

O(n) Left fold

foldl1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n + 1) a -> a

O(n) Left fold on non-empty vectors

foldl' :: Storable b => (a -> b -> a) -> a -> Vector n b -> a

O(n) Left fold with strict accumulator

foldl1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n + 1) a -> a

O(n) Left fold on non-empty vectors with strict accumulator

foldr :: Storable a => (a -> b -> b) -> b -> Vector n a -> b

O(n) Right fold

foldr1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n + 1) a -> a

O(n) Right fold on non-empty vectors

foldr' :: Storable a => (a -> b -> b) -> b -> Vector n a -> b

O(n) Right fold with a strict accumulator

foldr1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n + 1) a -> a

O(n) Right fold on non-empty vectors with strict accumulator

ifoldl :: Storable b => (a -> Int -> b -> a) -> a -> Vector n b -> a

O(n) Left fold (function applied to each element and its index)

ifoldl' :: Storable b => (a -> Int -> b -> a) -> a -> Vector n b -> a

O(n) Left fold with strict accumulator (function applied to each element and its index)

ifoldr :: Storable a => (Int -> a -> b -> b) -> b -> Vector n a -> b

O(n) Right fold (function applied to each element and its index)

ifoldr' :: Storable a => (Int -> a -> b -> b) -> b -> Vector n a -> b

O(n) Right fold with strict accumulator (function applied to each element and its index)

Specialised folds

all :: Storable a => (a -> Bool) -> Vector n a -> Bool

O(n) Check if all elements satisfy the predicate.

any :: Storable a => (a -> Bool) -> Vector n a -> Bool

O(n) Check if any element satisfies the predicate.

and :: Vector n Bool -> Bool

O(n) Check if all elements are True

or :: Vector n Bool -> Bool

O(n) Check if any element is True

sum :: (Storable a, Num a) => Vector n a -> a

O(n) Compute the sum of the elements

product :: (Storable a, Num a) => Vector n a -> a

O(n) Compute the produce of the elements

maximum :: (Storable a, Ord a, KnownNat n) => Vector (n + 1) a -> a

O(n) Yield the maximum element of the non-empty vector.

maximumBy :: (Storable a, KnownNat n) => (a -> a -> Ordering) -> Vector (n + 1) a -> a

O(n) Yield the maximum element of the non-empty vector according to the given comparison function.

minimum :: (Storable a, Ord a, KnownNat n) => Vector (n + 1) a -> a

O(n) Yield the minimum element of the non-empty vector.

minimumBy :: (Storable a, KnownNat n) => (a -> a -> Ordering) -> Vector (n + 1) a -> a

O(n) Yield the minimum element of the non-empty vector according to the given comparison function.

maxIndex :: (Storable a, Ord a, KnownNat n) => Vector (n + 1) a -> Int

O(n) Yield the index of the maximum element of the non-empty vector.

maxIndexBy :: (Storable a, KnownNat n) => (a -> a -> Ordering) -> Vector (n + 1) a -> Int

O(n) Yield the index of the maximum element of the non-empty vector according to the given comparison function.

minIndex :: (Storable a, Ord a, KnownNat n) => Vector (n + 1) a -> Int

O(n) Yield the index of the minimum element of the non-empty vector.

minIndexBy :: (Storable a, KnownNat n) => (a -> a -> Ordering) -> Vector (n + 1) a -> Int

O(n) Yield the index of the minimum element of the non-empty vector according to the given comparison function.

Monadic folds

foldM :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector n b -> m a

O(n) Monadic fold

ifoldM :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector n b -> m a

O(n) Monadic fold (action applied to each element and its index)

fold1M :: (Monad m, Storable a, KnownNat n) => (a -> a -> m a) -> Vector (n + 1) a -> m a

O(n) Monadic fold over non-empty vectors

foldM' :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector n b -> m a

O(n) Monadic fold with strict accumulator

ifoldM' :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector n b -> m a

O(n) Monadic fold with strict accumulator (action applied to each element and its index)

fold1M' :: (Monad m, Storable a, KnownNat n) => (a -> a -> m a) -> Vector (n + 1) a -> m a

O(n) Monadic fold over non-empty vectors with strict accumulator

foldM_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector n b -> m ()

O(n) Monadic fold that discards the result

ifoldM_ :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector n b -> m ()

O(n) Monadic fold that discards the result (action applied to each element and its index)

fold1M_ :: (Monad m, Storable a, KnownNat n) => (a -> a -> m a) -> Vector (n + 1) a -> m ()

O(n) Monadic fold over non-empty vectors that discards the result

foldM'_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector n b -> m ()

O(n) Monadic fold with strict accumulator that discards the result

ifoldM'_ :: (Monad m, Storable b) => (a -> Int -> b -> m a) -> a -> Vector n b -> m ()

O(n) Monadic fold with strict accumulator that discards the result (action applied to each element and its index)

fold1M'_ :: (Monad m, Storable a, KnownNat n) => (a -> a -> m a) -> Vector (n + 1) a -> m ()

O(n) Monad fold over non-empty vectors with strict accumulator that discards the result

Monadic sequencing

sequence :: (Monad m, Storable a, Storable (m a)) => Vector n (m a) -> m (Vector n a)

Evaluate each action and collect the results

sequence_ :: (Monad m, Storable (m a)) => Vector n (m a) -> m ()

Evaluate each action and discard the results

Prefix sums (scans)

prescanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

O(n) Prescan

prescanl f z = init . scanl f z

Example: prescanl (+) 0 <1,2,3,4> = <0,1,3,6>

prescanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

O(n) Prescan with strict accumulator

postscanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

O(n) Scan

postscanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

O(n) Scan with strict accumulator

scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

O(n) Haskell-style scan

scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

O(n) Haskell-style scan with strict accumulator

scanl1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 1) a

O(n) Scan over a non-empty vector

scanl1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 1) a

O(n) Scan over a non-empty vector with a strict accumulator

prescanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

O(n) Right-to-left prescan

prescanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

O(n) Right-to-left prescan with strict accumulator

postscanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

O(n) Right-to-left scan

postscanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

O(n) Right-to-left scan with strict accumulator

scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

O(n) Right-to-left Haskell-style scan

scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

O(n) Right-to-left Haskell-style scan with strict accumulator

scanr1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 1) a

O(n) Right-to-left scan over a non-empty vector

scanr1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 1) a

O(n) Right-to-left scan over a non-empty vector with a strict accumulator

Conversions

Lists

toList :: Storable a => Vector n a -> [a]

O(n) Convert a vector to a list

fromList :: (Storable a, KnownNat n) => [a] -> Maybe (Vector n a)

O(n) Convert a list to a vector

fromListN :: forall n a. (Storable a, KnownNat n) => [a] -> Maybe (Vector n a)

O(n) Convert the first n elements of a list to a vector. The length of the resultant vector is inferred from the type.

fromListN' :: forall n a. (Storable a, KnownNat n) => Proxy n -> [a] -> Maybe (Vector n a)

O(n) Convert the first n elements of a list to a vector. The length of the resultant vector is given explicitly as a Proxy argument.

withSizedList :: forall a r. Storable a => [a] -> (forall n. KnownNat n => Vector n a -> r) -> r

O(n) Takes a list and returns a continuation providing a vector with a size parameter corresponding to the length of the list.

Essentially converts a list into a vector with the proper size parameter, determined at runtime.

See withSized

Unsized Vectors

toSized :: forall n a. (Storable a, KnownNat n) => Vector a -> Maybe (Vector n a)

Convert a Vector into a Vector if it has the correct size, otherwise return Nothing.

withSized :: forall a r. Storable a => Vector a -> (forall n. KnownNat n => Vector n a -> r) -> r

Takes a Vector and returns a continuation providing a Vector with a size parameter n that is determined at runtime based on the length of the input vector.

Essentially converts a Vector into a Vector with the correct size parameter n.

fromSized :: Vector n a -> Vector a

withVectorUnsafe :: forall a b n. (Storable a, Storable b) => (Vector a -> Vector b) -> Vector n a -> Vector n b

Apply a function on unsized vectors to a sized vector. The function must preserve the size of the vector, this is not checked.