vector-0.4.1: Efficient Arrays Source code Contents Index

Data.Vector.Primitive Portability non-portable Stability experimental Maintainer Roman Leshchinskiy <rl@cse.unsw.edu.au>

Contents Length information Construction Accessing individual elements Subvectors Permutations Mapping Zipping and unzipping Filtering Searching Folding Specialised folds Unfolding Scans Enumeration Conversion to/from lists

Description

Unboxed vectors of primitive types.

Synopsis

data Vector a data MVector m a = MVector !Int !Int !(MutableByteArray m) Prim (sizeOf#, alignment#, indexByteArray#, readByteArray#, writeByteArray#, indexOffAddr#, readOffAddr#, writeOffAddr#) length :: Prim a => Vector a -> Int null :: Prim a => Vector a -> Bool empty :: Prim a => Vector a singleton :: Prim a => a -> Vector a cons :: Prim a => a -> Vector a -> Vector a snoc :: Prim a => Vector a -> a -> Vector a replicate :: Prim a => Int -> a -> Vector a (++) :: Prim a => Vector a -> Vector a -> Vector a copy :: Prim a => Vector a -> Vector a (!) :: Prim a => Vector a -> Int -> a head :: Prim a => Vector a -> a last :: Prim a => Vector a -> a slice :: Prim a => Vector a -> Int -> Int -> Vector a init :: Prim a => Vector a -> Vector a tail :: Prim a => Vector a -> Vector a take :: Prim a => Int -> Vector a -> Vector a drop :: Prim a => Int -> Vector a -> Vector a accum :: Prim a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a (//) :: Prim a => Vector a -> [(Int, a)] -> Vector a backpermute :: Prim a => Vector a -> Vector Int -> Vector a reverse :: Prim a => Vector a -> Vector a map :: (Prim a, Prim b) => (a -> b) -> Vector a -> Vector b concatMap :: (Prim a, Prim b) => (a -> Vector b) -> Vector a -> Vector b zipWith :: (Prim a, Prim b, Prim c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c zipWith3 :: (Prim a, Prim b, Prim c, Prim d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d filter :: Prim a => (a -> Bool) -> Vector a -> Vector a takeWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a dropWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a elem :: (Prim a, Eq a) => a -> Vector a -> Bool notElem :: (Prim a, Eq a) => a -> Vector a -> Bool find :: Prim a => (a -> Bool) -> Vector a -> Maybe a findIndex :: Prim a => (a -> Bool) -> Vector a -> Maybe Int foldl :: Prim b => (a -> b -> a) -> a -> Vector b -> a foldl1 :: Prim a => (a -> a -> a) -> Vector a -> a foldl' :: Prim b => (a -> b -> a) -> a -> Vector b -> a foldl1' :: Prim a => (a -> a -> a) -> Vector a -> a foldr :: Prim a => (a -> b -> b) -> b -> Vector a -> b foldr1 :: Prim a => (a -> a -> a) -> Vector a -> a sum :: (Prim a, Num a) => Vector a -> a product :: (Prim a, Num a) => Vector a -> a maximum :: (Prim a, Ord a) => Vector a -> a minimum :: (Prim a, Ord a) => Vector a -> a unfoldr :: Prim a => (b -> Maybe (a, b)) -> b -> Vector a prescanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a prescanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a postscanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a postscanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a scanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a scanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a scanl1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a scanl1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a enumFromTo :: (Prim a, Enum a) => a -> a -> Vector a enumFromThenTo :: (Prim a, Enum a) => a -> a -> a -> Vector a toList :: Prim a => Vector a -> [a] fromList :: Prim a => [a] -> Vector a

Documentation

data Vector a Source

Unboxed vectors of primitive types Instances Prim a => Vector Vector a (Prim a, Eq a) => Eq (Vector a) (Prim a, Ord a) => Ord (Vector a) (Show a, Prim a) => Show (Vector a)

data MVector m a Source

Mutable unboxed vectors. They live in the ST monad. Constructors MVector !Int !Int !(MutableByteArray m) Instances Prim a => MVectorPure (MVector m) a (Prim a, PrimMonad m) => MVector (MVector m) m a

Prim (sizeOf#, alignment#, indexByteArray#, readByteArray#, writeByteArray#, indexOffAddr#, readOffAddr#, writeOffAddr#)

Length information

length :: Prim a => Vector a -> Int Source

null :: Prim a => Vector a -> Bool Source

Construction

empty :: Prim a => Vector a Source

Empty vector

singleton :: Prim a => a -> Vector a Source

Vector with exaclty one element

cons :: Prim a => a -> Vector a -> Vector a Source

Prepend an element

snoc :: Prim a => Vector a -> a -> Vector a Source

Append an element

replicate :: Prim a => Int -> a -> Vector a Source

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

(++) :: Prim a => Vector a -> Vector a -> Vector a Source

Concatenate two vectors

copy :: Prim a => Vector a -> Vector a Source

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

Accessing individual elements

(!) :: Prim a => Vector a -> Int -> a Source

Indexing

head :: Prim a => Vector a -> a Source

First element

last :: Prim a => Vector a -> a Source

Last element

Subvectors

slice Source

:: Prim a => Vector a -> Int starting index -> Int length -> Vector a Yield a part of the vector without copying it. Safer version of unsafeSlice.

init :: Prim a => Vector a -> Vector a Source

Yield all but the last element without copying.

tail :: Prim a => Vector a -> Vector a Source

All but the first element (without copying).

take :: Prim a => Int -> Vector a -> Vector a Source

Yield the first n elements without copying.

drop :: Prim a => Int -> Vector a -> Vector a Source

Yield all but the first n elements without copying.

Permutations

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

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

backpermute :: Prim a => Vector a -> Vector Int -> Vector a Source

reverse :: Prim a => Vector a -> Vector a Source

Mapping

map :: (Prim a, Prim b) => (a -> b) -> Vector a -> Vector b Source

Map a function over a vector

concatMap :: (Prim a, Prim b) => (a -> Vector b) -> Vector a -> Vector b Source

Zipping and unzipping

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

Zip two vectors with the given function.

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

Zip three vectors with the given function.

Filtering

filter :: Prim a => (a -> Bool) -> Vector a -> Vector a Source

Drop elements which do not satisfy the predicate

takeWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a Source

Yield the longest prefix of elements satisfying the predicate.

dropWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a Source

Drop the longest prefix of elements that satisfy the predicate.

Searching

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

Check whether the vector contains an element

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

Inverse of elem

find :: Prim a => (a -> Bool) -> Vector a -> Maybe a Source

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

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

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

Folding

foldl :: Prim b => (a -> b -> a) -> a -> Vector b -> a Source

Left fold

foldl1 :: Prim a => (a -> a -> a) -> Vector a -> a Source

Lefgt fold on non-empty vectors

foldl' :: Prim b => (a -> b -> a) -> a -> Vector b -> a Source

Left fold with strict accumulator

foldl1' :: Prim a => (a -> a -> a) -> Vector a -> a Source

Left fold on non-empty vectors with strict accumulator

foldr :: Prim a => (a -> b -> b) -> b -> Vector a -> b Source

Right fold

foldr1 :: Prim a => (a -> a -> a) -> Vector a -> a Source

Right fold on non-empty vectors

Specialised folds

sum :: (Prim a, Num a) => Vector a -> a Source

product :: (Prim a, Num a) => Vector a -> a Source

maximum :: (Prim a, Ord a) => Vector a -> a Source

minimum :: (Prim a, Ord a) => Vector a -> a Source

Unfolding

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

Scans

prescanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a Source

Prefix scan

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

Prefix scan with strict accumulator

postscanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a Source

Suffix scan

postscanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a Source

Suffix scan with strict accumulator

scanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a Source

Haskell-style scan

scanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a Source

Haskell-style scan with strict accumulator

scanl1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a Source

Scan over a non-empty Vector

scanl1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a Source

Scan over a non-empty Vector with a strict accumulator

Enumeration

enumFromTo :: (Prim a, Enum a) => a -> a -> Vector a Source

enumFromThenTo :: (Prim a, Enum a) => a -> a -> a -> Vector a Source

Conversion to/from lists

toList :: Prim a => Vector a -> [a] Source

Convert a vector to a list

fromList :: Prim a => [a] -> Vector a Source

Convert a list to a vector

Produced by Haddock version 2.4.2