Data.Vector.Unboxed

Unboxed vectors based on Unbox.

Documentation

data Vector a

Unboxed vectors

Instances

Unbox a => IVector Vector a

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

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

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

Length information

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

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

Construction

empty :: Unbox a => Vector a

Empty vector

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

Vector with exaclty one element

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

Prepend an element

snoc :: Unbox a => Vector a -> a -> Vector a

Append an element

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

Vector of the given length with the given value in each position

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

Concatenate two vectors

copy :: Unbox a => Vector a -> Vector a

Create a copy of a vector. Useful when dealing with slices.

Accessing individual elements

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

Indexing

head :: Unbox a => Vector a -> a

First element

last :: Unbox a => Vector a -> a

Last element

Subvectors

slice

Arguments

:: Unbox a

=> Vector a

-> Int

starting index

-> Int

length

-> Vector a

Yield a part of the vector without copying it. Safer version of unsafeSlice.

init :: Unbox a => Vector a -> Vector a

Yield all but the last element without copying.

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

All but the first element (without copying).

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

Yield the first n elements without copying.

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

Yield all but the first n elements without copying.

Permutations

accum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a

(//) :: Unbox a => Vector a -> [(Int, a)] -> Vector a

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

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

Mapping

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

Map a function over a vector

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

Zipping and unzipping

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

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.

Filtering

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

Drop elements which do not satisfy the predicate

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

Yield the longest prefix of elements satisfying the predicate.

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

Drop the longest prefix of elements that satisfy the predicate.

Searching

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

Check whether the vector contains an element

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

Inverse of elem

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

Yield Just the first element matching the predicate or Nothing if no such element exists.

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

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

Folding

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

Left fold

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

Lefgt fold on non-empty vectors

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

Left fold with strict accumulator

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

Left fold on non-empty vectors with strict accumulator

foldr :: Unbox a => (a -> b -> b) -> b -> Vector a -> b

Right fold

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

Right fold on non-empty vectors

Specialised folds

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

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

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

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

Unfolding

unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a

Scans

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

Prefix scan

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

Prefix scan with strict accumulator

Enumeration

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

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

Conversion to/from lists

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

Convert a vector to a list

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

Convert a list to a vector