dph-prim-seq-0.5.1.1: Sequential Primitives for Data-Parallel Haskell.

Data.Array.Parallel.Unlifted.Sequential.Vector

Description

Wrappers for primitives defined in `Data.Vector`

Synopsis

# Array classes

class (Vector Vector a, MVector MVector a) => Unbox a

Instances

 Unbox Bool Unbox Char Unbox Double Unbox Float Unbox Int Unbox Int8 Unbox Int16 Unbox Int32 Unbox Int64 Unbox Word Unbox Word8 Unbox Word16 Unbox Word32 Unbox Word64 Unbox () (RealFloat a, Unbox a) => Unbox (Complex a) (Unbox a, Unbox b) => Unbox (a, b) (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c) (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d) (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e) (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f)

# Array types

data family Vector a

data family MVector s a

# Streaming

stream :: Vector v a => v a -> Stream a

O(1) Convert a vector to a `Stream`

unstream :: Vector v a => Stream a -> v a

O(n) Construct a vector from a `Stream`

# Basic operations

length :: Unbox a => Vector a -> Int

O(1) Yield the length of the vector.

null :: Unbox a => Vector a -> Bool

O(1) Test whether a vector if empty

empty :: Unbox a => Vector a

O(1) Empty vector

singleton :: Unbox a => a -> Vector a

O(1) Vector with exactly one element

cons :: Unbox a => a -> Vector a -> Vector a

O(n) Prepend an element

Yield an array of units

replicate :: Unbox a => Int -> a -> Vector a

O(n) Vector of the given length with the same value in each position

(!) :: Unbox a => Vector a -> Int -> a

O(1) Indexing

(++) :: Unbox a => Vector a -> Vector a -> Vector a

O(m+n) Concatenate two vectors

interleave :: Unbox e => Vector e -> Vector e -> Vector eSource

Interleave the elements of two arrays

indexed :: Unbox a => Vector a -> Vector (Int, a)

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

repeat :: Unbox e => Int -> Vector e -> Vector eSource

Repeat an array `n` times

repeatS :: Unbox e => Int -> Vector e -> Stream eSource

# Subarrays

slice :: Unbox a => Vector a -> Int -> Int -> Vector aSource

extract :: Unbox a => Vector a -> Int -> Int -> Vector aSource

tail :: Unbox a => Vector a -> Vector a

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

take :: Unbox a => Int -> Vector a -> Vector a

O(1) Yield at the first `n` elements without copying. The vector may contain less than `n` elements in which case it is returned unchanged.

drop :: Unbox a => Int -> Vector a -> Vector a

O(1) Yield all but the first `n` elements without copying. The vector may contain less than `n` elements in which case an empty vector is returned.

splitAt :: Unbox a => Int -> Vector a -> (Vector a, Vector a)

O(1) Yield the first `n` elements paired with the remainder without copying.

Note that `splitAt n v` is equivalent to `(take n v, drop n v)` but slightly more efficient.

# Permutations

mbpermute :: (Unbox e, Unbox d) => (e -> d) -> Vector e -> Vector Int -> Vector dSource

Arguments

 :: Unbox e => Int length of result array -> (Int -> e) initialiser function -> Vector (Int, e) index-value pairs -> Vector e

Default back permute

• The values of the index-value pairs are written into the position in the result array that is indicated by the corresponding index.
• All positions not covered by the index-value pairs will have the value determined by the initialiser function for that index position.

reverse :: Unbox a => Vector a -> Vector a

O(n) Reverse a vector

update

Arguments

 :: Unbox a => Vector a initial vector (of length `m`) -> Vector (Int, a) vector of index/value pairs (of length `n`) -> Vector 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>
```

# Higher-order operations

map :: (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b

O(n) Map a function over a vector

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

O(min(m,n)) Zip two vectors with the given function.

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

Zip three vectors with the given function.

filter :: Unbox a => (a -> Bool) -> Vector a -> Vector a

O(n) Drop elements that do not satisfy the predicate

pack :: Unbox e => Vector e -> Vector Bool -> Vector eSource

Extract all elements from an array according to a given flag array

foldl :: Unbox a => (b -> a -> b) -> b -> Vector a -> bSource

Array reduction proceeding from the left

foldl1 :: Unbox a => (a -> a -> a) -> Vector a -> aSource

Array reduction proceeding from the left for non-empty arrays

foldl1Maybe :: Unbox a => (a -> a -> a) -> Vector a -> Maybe aSource

fold :: Unbox a => (a -> a -> a) -> a -> Vector a -> aSource

Array reduction that requires an associative combination function with its unit

fold1 :: Unbox a => (a -> a -> a) -> Vector a -> aSource

Reduction of a non-empty array which requires an associative combination function

fold1Maybe :: Unbox a => (a -> a -> a) -> Vector a -> Maybe aSource

scanl :: (Unbox a, Unbox b) => (b -> a -> b) -> b -> Vector a -> Vector bSource

Prefix scan proceedings from left to right

scanl1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector aSource

Prefix scan of a non-empty array proceeding from left to right

scan :: Unbox a => (a -> a -> a) -> a -> Vector a -> Vector aSource

Prefix scan proceeding from left to right that needs an associative combination function with its unit

scan1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector aSource

Prefix scan of a non-empty array proceeding from left to right that needs an associative combination function

scanRes :: Unbox a => (a -> a -> a) -> a -> Vector a -> (Vector a, a)Source

# Searching

elem :: (Unbox a, Eq a) => a -> Vector a -> Bool

O(n) Check if the vector contains an element

notElem :: (Unbox a, Eq a) => a -> Vector a -> Bool

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

# Logical operations

O(n) Check if all elements are `True`

or :: Vector Bool -> Bool

O(n) Check if any element is `True`

any :: Unbox a => (a -> Bool) -> Vector a -> Bool

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

all :: Unbox a => (a -> Bool) -> Vector a -> Bool

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

# Arithmetic operations

sum :: (Unbox a, Num a) => Vector a -> a

O(n) Compute the sum of the elements

product :: (Unbox a, Num a) => Vector a -> a

O(n) Compute the produce of the elements

maximum :: (Unbox a, Ord a) => Vector a -> a

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

minimum :: (Unbox a, Ord a) => Vector a -> a

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

maximumBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> a

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

minimumBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> a

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

maxIndex :: (Unbox a, Ord a) => Vector a -> Int

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

minIndex :: (Unbox a, Ord a) => Vector a -> Int

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

maxIndexBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> Int

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

minIndexBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> Int

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

# Arrays of pairs

zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)Source

unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a, Vector b)Source

fsts :: (Unbox a, Unbox b) => Vector (a, b) -> Vector aSource

snds :: (Unbox a, Unbox b) => Vector (a, b) -> Vector bSource

# Enumerations

enumFromTo :: (Unbox a, Enum a) => a -> a -> Vector a

O(n) Enumerate values from `x` to `y`.

WARNING: This operation can be very inefficient. If at all possible, use `enumFromN` instead.

enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a

O(n) Enumerate values from `x` to `y` with a specific step `z`.

WARNING: This operation can be very inefficient. If at all possible, use `enumFromStepN` instead.

# Searching

find :: Unbox a => (a -> Bool) -> Vector a -> Maybe a

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

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

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

# Conversions to/from lists

toList :: Unbox a => Vector a -> [a]

O(n) Convert a vector to a list

fromList :: Unbox a => [a] -> Vector a

O(n) Convert a list to a vector

# Random arrays

random :: (Unbox a, Random a, RandomGen g) => Int -> g -> Vector aSource

randomR :: (Unbox a, Random a, RandomGen g) => Int -> (a, a) -> g -> Vector aSource

# Mutating operations

new :: Unbox a => Int -> (forall s. MVector s a -> ST s ()) -> Vector aSource

copy :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()

O(n) Copy an immutable vector into a mutable one. The two vectors must have the same length.

# Mutable vectors

newM :: Unbox a => Int -> ST s (MVector s a)Source

unsafeFreeze :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a)

O(1) Unsafe convert a mutable vector to an immutable one without copying. The mutable vector may not be used after this operation.

write :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()

Replace the element at the given position.

read :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a

Yield the element at the given position.

mpermute :: Unbox e => MVector s e -> Vector e -> Vector Int -> ST s ()Source

mupdate :: Unbox e => MVector s e -> Vector (Int, e) -> ST s ()Source

mdrop :: Unbox a => Int -> MVector s a -> MVector s aSource

mslice :: Unbox a => Int -> Int -> MVector s a -> MVector s aSource

# I/O

class Unbox a => UIO a whereSource

Methods

hPut :: Handle -> Vector a -> IO ()Source

hGet :: Handle -> IO (Vector a)Source

Instances

 UIO Double UIO Int (UIO a, UIO b) => UIO (a, b)