Data.Vector.Storable

Storable-based vectors.

Documentation

data Vector a

Storable-based vectors

Instances

Storable a => Vector Vector a

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

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

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

data MVector s a

Mutable Storable-based vectors

Constructors

MVector !Int !Int !(ForeignPtr a)

Instances

Storable a => MVector MVector a

class Storable a

The member functions of this class facilitate writing values of primitive types to raw memory (which may have been allocated with the above mentioned routines) and reading values from blocks of raw memory. The class, furthermore, includes support for computing the storage requirements and alignment restrictions of storable types.

Memory addresses are represented as values of type Ptr a, for some a which is an instance of class Storable. The type argument to Ptr helps provide some valuable type safety in FFI code (you can't mix pointers of different types without an explicit cast), while helping the Haskell type system figure out which marshalling method is needed for a given pointer.

All marshalling between Haskell and a foreign language ultimately boils down to translating Haskell data structures into the binary representation of a corresponding data structure of the foreign language and vice versa. To code this marshalling in Haskell, it is necessary to manipulate primitive data types stored in unstructured memory blocks. The class Storable facilitates this manipulation on all types for which it is instantiated, which are the standard basic types of Haskell, the fixed size Int types (Int8, Int16, Int32, Int64), the fixed size Word types (Word8, Word16, Word32, Word64), StablePtr, all types from Foreign.C.Types, as well as Ptr.

Minimal complete definition: sizeOf, alignment, one of peek, peekElemOff and peekByteOff, and one of poke, pokeElemOff and pokeByteOff.

Instances

Storable Bool

Storable Char

Storable Double

Storable Float

Storable Int

Storable Int8

Storable Int16

Storable Int32

Storable Int64

Storable Word

Storable Word8

Storable Word16

Storable Word32

Storable Word64

Storable WordPtr

Storable IntPtr

Storable (StablePtr a)

Storable (Ptr a)

Storable (FunPtr a)

Length information

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

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

Construction

empty :: Storable a => Vector a

Empty vector

singleton :: Storable a => a -> Vector a

Vector with exaclty one element

cons :: Storable a => a -> Vector a -> Vector a

Prepend an element

snoc :: Storable a => Vector a -> a -> Vector a

Append an element

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

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

generate :: Storable a => Int -> (Int -> a) -> Vector a

Generate a vector of the given length by applying the function to each index

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

Concatenate two vectors

copy :: Storable a => Vector a -> Vector a

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

Accessing individual elements

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

Indexing

head :: Storable a => Vector a -> a

First element

last :: Storable a => Vector a -> a

Last element

indexM :: (Storable a, Monad m) => Vector a -> Int -> m a

Monadic indexing which can be strict in the vector while remaining lazy in the element

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

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

unsafeIndex :: Storable a => Vector a -> Int -> a

Unsafe indexing without bounds checking

unsafeHead :: Storable a => Vector a -> a

Yield the first element of a vector without checking if the vector is empty

unsafeLast :: Storable a => Vector a -> a

Yield the last element of a vector without checking if the vector is empty

unsafeIndexM :: (Storable a, Monad m) => Vector a -> Int -> m a

Unsafe monadic indexing without bounds checks

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

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

Subvectors

slice

Arguments

:: Storable a

=> Int

starting index

-> Int

length

-> Vector a

-> Vector a

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

init :: Storable a => Vector a -> Vector a

Yield all but the last element without copying.

tail :: Storable a => Vector a -> Vector a

All but the first element (without copying).

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

Yield the first n elements without copying.

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

Yield all but the first n elements without copying.

unsafeSlice

Arguments

:: Storable a

=> Int

starting index

-> Int

length

-> Vector a

-> Vector a

Unsafely yield a part of the vector without copying it and without performing bounds checks.

unsafeInit :: Storable a => Vector a -> Vector a

unsafeTail :: Storable a => Vector a -> Vector a

unsafeTake :: Storable a => Int -> Vector a -> Vector a

unsafeDrop :: Storable a => Int -> Vector a -> Vector a

Permutations

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

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

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

update_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a

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

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

unsafeAccum :: Storable a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a

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

unsafeUpd :: Storable a => Vector a -> [(Int, a)] -> Vector a

unsafeUpdate_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a

unsafeBackpermute :: Storable a => Vector a -> Vector Int -> Vector a

Mapping

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

Map a function over a vector

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

Apply a function to every index/value pair

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

Zipping and unzipping

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

Zip two vectors with the given function.

zipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector 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 a -> Vector b -> Vector c -> Vector d -> Vector e

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

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

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

Zip two vectors and their indices with the given function.

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

Zip three vectors and their indices with the given function.

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

izipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector 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 a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g

Filtering

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

Drop elements which do not satisfy the predicate

ifilter :: Storable a => (Int -> a -> Bool) -> Vector a -> Vector a

Drop elements that do not satisfy the predicate (applied to values and their indices)

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

Yield the longest prefix of elements satisfying the predicate.

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

Drop the longest prefix of elements that satisfy the predicate.

partition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

Split the vector in two parts, the first one containing those elements that satisfy the predicate and the second one those that don't. The relative order of the elements is preserved at the cost of a (sometimes) reduced performance compared to unstablePartition.

unstablePartition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

Split the vector in two parts, the first one containing those elements that satisfy the predicate and the second one those that don't. The order of the elements is not preserved.

span :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

Split the vector into the longest prefix of elements that satisfy the predicate and the rest.

break :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

Split the vector into the longest prefix of elements that do not satisfy the predicate and the rest.

Searching

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

Check whether the vector contains an element

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

Inverse of elem

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

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

findIndex :: Storable 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.

findIndices :: Storable a => (a -> Bool) -> Vector a -> Vector Int

Yield the indices of elements satisfying the predicate

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

Yield Just the index of the first occurence of the given element or Nothing if the vector does not contain the element

elemIndices :: (Storable a, Eq a) => a -> Vector a -> Vector Int

Yield the indices of all occurences of the given element

Folding

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

Left fold

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

Lefgt fold on non-empty vectors

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

Left fold with strict accumulator

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

Left fold on non-empty vectors with strict accumulator

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

Right fold

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

Right fold on non-empty vectors

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

Right fold with a strict accumulator

foldr1' :: Storable a => (a -> a -> a) -> Vector a -> a

Right fold on non-empty vectors with strict accumulator

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

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

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

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

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

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

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

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

Specialised folds

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

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

and :: Vector Bool -> Bool

or :: Vector Bool -> Bool

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

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

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

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

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

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

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

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

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

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

Unfolding

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

Scans

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

Prefix scan

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

Prefix scan with strict accumulator

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

Suffix scan

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

Suffix scan with strict accumulator

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

Haskell-style scan

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

Haskell-style scan with strict accumulator

scanl1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a

Scan over a non-empty Vector

scanl1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a

Scan over a non-empty Vector with a strict accumulator

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

Prefix right-to-left scan

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

Prefix right-to-left scan with strict accumulator

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

Suffix right-to-left scan

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

Suffix right-to-left scan with strict accumulator

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

Haskell-style right-to-left scan

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

Haskell-style right-to-left scan with strict accumulator

scanr1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a

Right-to-left scan over a non-empty vector

scanr1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a

Right-to-left scan over a non-empty vector with a strict accumulator

Enumeration

enumFromN :: (Storable a, Num a) => a -> Int -> Vector a

Yield a vector of the given length containing the values x, x+1 etc. This operation is usually more efficient than enumFromTo.

enumFromStepN :: (Storable a, Num a) => a -> a -> Int -> Vector a

Yield a vector of the given length containing the values x, x+y, x+y+y etc. This operations is usually more efficient than enumFromThenTo.

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

Enumerate values from x to y.

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

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

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.

Conversion to/from lists

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

Convert a vector to a list

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

Convert a list to a vector

Accessing the underlying memory

unsafeFromForeignPtr

Arguments

:: ForeignPtr a

pointer

-> Int

offset

-> Int

length

-> Vector a

Create a vector from a ForeignPtr with an offset and a length. The data may not be modified through the ForeignPtr afterwards.

unsafeToForeignPtr :: Vector a -> (ForeignPtr a, Int, Int)

Yield the underlying ForeignPtr together with the offset to the data and its length. The data may not be modified through the ForeignPtr.

unsafeWith :: Storable a => Vector a -> (Ptr a -> IO b) -> IO b

Pass a pointer to the vector's data to the IO action. The data may not be modified through the 'Ptr.