O(1) Indexing

O(1) First element

O(1) Last element

O(1) Indexing in a monad.

The monad allows operations to be strict in the vector when necessary. Suppose vector copying is implemented like this:

copy mv v = ... write mv i (v ! i) ...

For lazy vectors, v ! i would not be evaluated which means that mv would unnecessarily retain a reference to v in each element written.

With indexM, copying can be implemented like this instead:

copy mv v = ... do
                  x <- indexM v i
                  write mv i x

Here, no references to v are retained because indexing (but not the elements) is evaluated eagerly.

O(1) First element of a vector in a monad. See indexM for an explanation of why this is useful.

O(1) Last element of a vector in a monad. See indexM for an explanation of why this is useful.

O(1) Yield all but the last element without copying. The vector may not be empty.

O(1) Yield all but the first element without copying. The vector may not be empty.

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>

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>

O(m+min(n1,n2)) 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>

The function update provides the same functionality and is usually more convenient.

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

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

Examples

>>> import qualified Data.Vector.Unboxed as VU
>>> VU.accum (+) (VU.fromList [1000.0,2000.0,3000.0]) [(2,4),(1,6),(0,3),(1,10)]
[1003.0,2016.0,3004.0]

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.

Examples

>>> import qualified Data.Vector.Unboxed as VU
>>> VU.accumulate (+) (VU.fromList [1000.0,2000.0,3000.0]) (VU.fromList [(2,4),(1,6),(0,3),(1,10)])
[1003.0,2016.0,3004.0]

O(m+min(n1,n2)) 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>

The function accumulate provides the same functionality and is usually more convenient.

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

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>

O(n) Left fold on non-empty vectors

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

O(n) Right fold on non-empty vectors

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

O(n) Yield the maximum element of the vector. The vector may not be empty.

Examples

>>> import qualified Data.Vector.Unboxed as VU
>>> VU.maximum $ VU.fromList [2.0, 1.0]
2.0

O(n) Yield the maximum element of the vector according to the given comparison function. The vector may not be empty.

O(n) Yield the minimum element of the vector. The vector may not be empty.

Examples

>>> import qualified Data.Vector.Unboxed as VU
>>> VU.minimum $ VU.fromList [2.0, 1.0]
1.0

O(n) Yield the minimum element of the vector according to the given comparison function. The vector may not be empty.

O(n) Yield the index of the minimum element of the vector. The vector may not be empty.

O(n) Yield the index of the minimum element of the vector according to the given comparison function. The vector may not be empty.

O(n) Yield the index of the maximum element of the vector. The vector may not be empty.

O(n) Yield the index of the maximum element of the vector according to the given comparison function. The vector may not be empty.

O(n) Monadic fold over non-empty vectors

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

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

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

O(n) Scan over a non-empty vector

scanl f <x1,...,xn> = <y1,...,yn>
  where y1 = x1
        yi = f y(i-1) xi

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

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

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