module Data.Vector.Storable (
Vector, MVector(..), Storable,
length, null,
empty, singleton, cons, snoc, replicate, generate, (++), force,
(!), head, last, indexM, headM, lastM,
unsafeIndex, unsafeHead, unsafeLast,
unsafeIndexM, unsafeHeadM, unsafeLastM,
slice, init, tail, take, drop,
unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
accum, accumulate_, (//), update_, backpermute, reverse,
unsafeAccum, unsafeAccumulate_,
unsafeUpd, unsafeUpdate_,
unsafeBackpermute,
map, imap, concatMap,
zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
filter, ifilter, takeWhile, dropWhile,
partition, unstablePartition, span, break,
elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
ifoldl, ifoldl', ifoldr, ifoldr',
all, any, and, or,
sum, product,
maximum, maximumBy, minimum, minimumBy,
minIndex, minIndexBy, maxIndex, maxIndexBy,
unfoldr, unfoldrN,
prescanl, prescanl',
postscanl, postscanl',
scanl, scanl', scanl1, scanl1',
prescanr, prescanr',
postscanr, postscanr',
scanr, scanr', scanr1, scanr1',
enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
toList, fromList, fromListN,
replicateM, mapM, mapM_, forM, forM_, zipWithM, zipWithM_, filterM,
foldM, foldM', fold1M, fold1M',
create, modify, copy, unsafeCopy,
unsafeFromForeignPtr, unsafeToForeignPtr, unsafeWith
) where
import qualified Data.Vector.Generic as G
import Data.Vector.Storable.Mutable ( MVector(..) )
import Data.Vector.Storable.Internal
import qualified Data.Vector.Fusion.Stream as Stream
import Foreign.Storable
import Foreign.ForeignPtr
import Foreign.Ptr
import Foreign.Marshal.Array ( advancePtr, copyArray )
import Control.Monad.ST ( ST )
import Control.Monad.Primitive
import Prelude hiding ( length, null,
replicate, (++),
head, last,
init, tail, take, drop, reverse,
map, concatMap,
zipWith, zipWith3, zip, zip3, unzip, unzip3,
filter, takeWhile, dropWhile, span, break,
elem, notElem,
foldl, foldl1, foldr, foldr1,
all, any, and, or, sum, product, minimum, maximum,
scanl, scanl1, scanr, scanr1,
enumFromTo, enumFromThenTo,
mapM, mapM_ )
import qualified Prelude
import Data.Typeable ( Typeable )
import Data.Data ( Data(..) )
#include "vector.h"
data Vector a = Vector !(Ptr a)
!Int
!(ForeignPtr a)
deriving ( Typeable )
instance (Show a, Storable a) => Show (Vector a) where
show = (Prelude.++ " :: Data.Vector.Storable.Vector")
. ("fromList " Prelude.++)
. show
. toList
instance (Data a, Storable a) => Data (Vector a) where
gfoldl = G.gfoldl
toConstr _ = error "toConstr"
gunfold _ _ = error "gunfold"
dataTypeOf _ = G.mkType "Data.Vector.Storable.Vector"
dataCast1 = G.dataCast
type instance G.Mutable Vector = MVector
instance Storable a => G.Vector Vector a where
unsafeFreeze (MVector p n fp) = return $ Vector p n fp
basicLength (Vector _ n _) = n
basicUnsafeSlice i n (Vector p _ fp) = Vector (p `advancePtr` i) n fp
basicUnsafeIndexM (Vector p _ fp) i = return
. unsafeInlineIO
$ withForeignPtr fp $ \_ ->
peekElemOff p i
basicUnsafeCopy (MVector p n fp) (Vector q _ fq)
= unsafePrimToPrim
$ withForeignPtr fp $ \_ ->
withForeignPtr fq $ \_ ->
copyArray p q n
elemseq _ = seq
instance (Storable a, Eq a) => Eq (Vector a) where
xs == ys = Stream.eq (G.stream xs) (G.stream ys)
xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys))
instance (Storable a, Ord a) => Ord (Vector a) where
compare xs ys = Stream.cmp (G.stream xs) (G.stream ys)
xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT
xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT
xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT
xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
length :: Storable a => Vector a -> Int
length = G.length
null :: Storable a => Vector a -> Bool
null = G.null
empty :: Storable a => Vector a
empty = G.empty
singleton :: Storable a => a -> Vector a
singleton = G.singleton
replicate :: Storable a => Int -> a -> Vector a
replicate = G.replicate
generate :: Storable a => Int -> (Int -> a) -> Vector a
generate = G.generate
cons :: Storable a => a -> Vector a -> Vector a
cons = G.cons
snoc :: Storable a => Vector a -> a -> Vector a
snoc = G.snoc
infixr 5 ++
(++) :: Storable a => Vector a -> Vector a -> Vector a
(++) = (G.++)
force :: Storable a => Vector a -> Vector a
force = G.force
(!) :: Storable a => Vector a -> Int -> a
(!) = (G.!)
head :: Storable a => Vector a -> a
head = G.head
last :: Storable a => Vector a -> a
last = G.last
unsafeIndex :: Storable a => Vector a -> Int -> a
unsafeIndex = G.unsafeIndex
unsafeHead :: Storable a => Vector a -> a
unsafeHead = G.unsafeHead
unsafeLast :: Storable a => Vector a -> a
unsafeLast = G.unsafeLast
indexM :: (Storable a, Monad m) => Vector a -> Int -> m a
indexM = G.indexM
headM :: (Storable a, Monad m) => Vector a -> m a
headM = G.headM
lastM :: (Storable a, Monad m) => Vector a -> m a
lastM = G.lastM
unsafeIndexM :: (Storable a, Monad m) => Vector a -> Int -> m a
unsafeIndexM = G.unsafeIndexM
unsafeHeadM :: (Storable a, Monad m) => Vector a -> m a
unsafeHeadM = G.unsafeHeadM
unsafeLastM :: (Storable a, Monad m) => Vector a -> m a
unsafeLastM = G.unsafeLastM
slice :: Storable a => Int
-> Int
-> Vector a
-> Vector a
slice = G.slice
init :: Storable a => Vector a -> Vector a
init = G.init
tail :: Storable a => Vector a -> Vector a
tail = G.tail
take :: Storable a => Int -> Vector a -> Vector a
take = G.take
drop :: Storable a => Int -> Vector a -> Vector a
drop = G.drop
unsafeSlice :: Storable a => Int
-> Int
-> Vector a
-> Vector a
unsafeSlice = G.unsafeSlice
unsafeInit :: Storable a => Vector a -> Vector a
unsafeInit = G.unsafeInit
unsafeTail :: Storable a => Vector a -> Vector a
unsafeTail = G.unsafeTail
unsafeTake :: Storable a => Int -> Vector a -> Vector a
unsafeTake = G.unsafeTake
unsafeDrop :: Storable a => Int -> Vector a -> Vector a
unsafeDrop = G.unsafeDrop
unsafeAccum :: Storable a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
unsafeAccum = G.unsafeAccum
unsafeAccumulate_ :: (Storable a, Storable b) =>
(a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
unsafeAccumulate_ = G.unsafeAccumulate_
accum :: Storable a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
accum = G.accum
accumulate_ :: (Storable a, Storable b) =>
(a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
accumulate_ = G.accumulate_
unsafeUpd :: Storable a => Vector a -> [(Int, a)] -> Vector a
unsafeUpd = G.unsafeUpd
unsafeUpdate_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a
unsafeUpdate_ = G.unsafeUpdate_
(//) :: Storable a => Vector a -> [(Int, a)] -> Vector a
(//) = (G.//)
update_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a
update_ = G.update_
backpermute :: Storable a => Vector a -> Vector Int -> Vector a
backpermute = G.backpermute
unsafeBackpermute :: Storable a => Vector a -> Vector Int -> Vector a
unsafeBackpermute = G.unsafeBackpermute
reverse :: Storable a => Vector a -> Vector a
reverse = G.reverse
map :: (Storable a, Storable b) => (a -> b) -> Vector a -> Vector b
map = G.map
imap :: (Storable a, Storable b) => (Int -> a -> b) -> Vector a -> Vector b
imap = G.imap
concatMap :: (Storable a, Storable b) => (a -> Vector b) -> Vector a -> Vector b
concatMap = G.concatMap
zipWith :: (Storable a, Storable b, Storable c)
=> (a -> b -> c) -> Vector a -> Vector b -> Vector c
zipWith = G.zipWith
zipWith3 :: (Storable a, Storable b, Storable c, Storable d)
=> (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
zipWith3 = G.zipWith3
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
zipWith4 = G.zipWith4
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
zipWith5 = G.zipWith5
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
zipWith6 = G.zipWith6
izipWith :: (Storable a, Storable b, Storable c)
=> (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
izipWith = G.izipWith
izipWith3 :: (Storable a, Storable b, Storable c, Storable d)
=> (Int -> a -> b -> c -> d)
-> Vector a -> Vector b -> Vector c -> Vector d
izipWith3 = G.izipWith3
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
izipWith4 = G.izipWith4
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
izipWith5 = G.izipWith5
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
izipWith6 = G.izipWith6
filter :: Storable a => (a -> Bool) -> Vector a -> Vector a
filter = G.filter
ifilter :: Storable a => (Int -> a -> Bool) -> Vector a -> Vector a
ifilter = G.ifilter
takeWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
takeWhile = G.takeWhile
dropWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
dropWhile = G.dropWhile
partition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
partition = G.partition
unstablePartition
:: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
unstablePartition = G.unstablePartition
span :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
span = G.span
break :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
break = G.break
infix 4 `elem`
elem :: (Storable a, Eq a) => a -> Vector a -> Bool
elem = G.elem
infix 4 `notElem`
notElem :: (Storable a, Eq a) => a -> Vector a -> Bool
notElem = G.notElem
find :: Storable a => (a -> Bool) -> Vector a -> Maybe a
find = G.find
findIndex :: Storable a => (a -> Bool) -> Vector a -> Maybe Int
findIndex = G.findIndex
findIndices :: Storable a => (a -> Bool) -> Vector a -> Vector Int
findIndices = G.findIndices
elemIndex :: (Storable a, Eq a) => a -> Vector a -> Maybe Int
elemIndex = G.elemIndex
elemIndices :: (Storable a, Eq a) => a -> Vector a -> Vector Int
elemIndices = G.elemIndices
foldl :: Storable b => (a -> b -> a) -> a -> Vector b -> a
foldl = G.foldl
foldl1 :: Storable a => (a -> a -> a) -> Vector a -> a
foldl1 = G.foldl1
foldl' :: Storable b => (a -> b -> a) -> a -> Vector b -> a
foldl' = G.foldl'
foldl1' :: Storable a => (a -> a -> a) -> Vector a -> a
foldl1' = G.foldl1'
foldr :: Storable a => (a -> b -> b) -> b -> Vector a -> b
foldr = G.foldr
foldr1 :: Storable a => (a -> a -> a) -> Vector a -> a
foldr1 = G.foldr1
foldr' :: Storable a => (a -> b -> b) -> b -> Vector a -> b
foldr' = G.foldr'
foldr1' :: Storable a => (a -> a -> a) -> Vector a -> a
foldr1' = G.foldr1'
ifoldl :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a
ifoldl = G.ifoldl
ifoldl' :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a
ifoldl' = G.ifoldl'
ifoldr :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b
ifoldr = G.ifoldr
ifoldr' :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b
ifoldr' = G.ifoldr'
all :: Storable a => (a -> Bool) -> Vector a -> Bool
all = G.all
any :: Storable a => (a -> Bool) -> Vector a -> Bool
any = G.any
and :: Vector Bool -> Bool
and = G.and
or :: Vector Bool -> Bool
or = G.or
sum :: (Storable a, Num a) => Vector a -> a
sum = G.sum
product :: (Storable a, Num a) => Vector a -> a
product = G.product
maximum :: (Storable a, Ord a) => Vector a -> a
maximum = G.maximum
maximumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a
maximumBy = G.maximumBy
minimum :: (Storable a, Ord a) => Vector a -> a
minimum = G.minimum
minimumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a
minimumBy = G.minimumBy
maxIndex :: (Storable a, Ord a) => Vector a -> Int
maxIndex = G.maxIndex
maxIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int
maxIndexBy = G.maxIndexBy
minIndex :: (Storable a, Ord a) => Vector a -> Int
minIndex = G.minIndex
minIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int
minIndexBy = G.minIndexBy
unfoldr :: Storable a => (b -> Maybe (a, b)) -> b -> Vector a
unfoldr = G.unfoldr
unfoldrN :: Storable a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
unfoldrN = G.unfoldrN
prescanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
prescanl = G.prescanl
prescanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
prescanl' = G.prescanl'
postscanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
postscanl = G.postscanl
postscanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
postscanl' = G.postscanl'
scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl = G.scanl
scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl' = G.scanl'
scanl1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a
scanl1 = G.scanl1
scanl1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a
scanl1' = G.scanl1'
prescanr
:: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
prescanr = G.prescanr
prescanr'
:: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
prescanr' = G.prescanr'
postscanr
:: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
postscanr = G.postscanr
postscanr'
:: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
postscanr' = G.postscanr'
scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr = G.scanr
scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr' = G.scanr'
scanr1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a
scanr1 = G.scanr1
scanr1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a
scanr1' = G.scanr1'
enumFromN :: (Storable a, Num a) => a -> Int -> Vector a
enumFromN = G.enumFromN
enumFromStepN :: (Storable a, Num a) => a -> a -> Int -> Vector a
enumFromStepN = G.enumFromStepN
enumFromTo :: (Storable a, Enum a) => a -> a -> Vector a
enumFromTo = G.enumFromTo
enumFromThenTo :: (Storable a, Enum a) => a -> a -> a -> Vector a
enumFromThenTo = G.enumFromThenTo
toList :: Storable a => Vector a -> [a]
toList = G.toList
fromList :: Storable a => [a] -> Vector a
fromList = G.fromList
fromListN :: Storable a => Int -> [a] -> Vector a
fromListN = G.fromListN
replicateM :: (Monad m, Storable a) => Int -> m a -> m (Vector a)
replicateM = G.replicateM
mapM :: (Monad m, Storable a, Storable b) => (a -> m b) -> Vector a -> m (Vector b)
mapM = G.mapM
mapM_ :: (Monad m, Storable a) => (a -> m b) -> Vector a -> m ()
mapM_ = G.mapM_
forM :: (Monad m, Storable a, Storable b) => Vector a -> (a -> m b) -> m (Vector b)
forM = G.forM
forM_ :: (Monad m, Storable a) => Vector a -> (a -> m b) -> m ()
forM_ = G.forM_
zipWithM :: (Monad m, Storable a, Storable b, Storable c)
=> (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
zipWithM = G.zipWithM
zipWithM_ :: (Monad m, Storable a, Storable b)
=> (a -> b -> m c) -> Vector a -> Vector b -> m ()
zipWithM_ = G.zipWithM_
filterM :: (Monad m, Storable a) => (a -> m Bool) -> Vector a -> m (Vector a)
filterM = G.filterM
foldM :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
foldM = G.foldM
fold1M :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
fold1M = G.fold1M
foldM' :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
foldM' = G.foldM'
fold1M' :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
fold1M' = G.fold1M'
create :: Storable a => (forall s. ST s (MVector s a)) -> Vector a
create = G.create
modify
:: Storable a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
modify = G.modify
unsafeCopy
:: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
unsafeCopy = G.unsafeCopy
copy :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
copy = G.copy
unsafeFromForeignPtr :: Storable a
=> ForeignPtr a
-> Int
-> Int
-> Vector a
unsafeFromForeignPtr fp i n = Vector (offsetToPtr fp i) n fp
unsafeToForeignPtr :: Storable a => Vector a -> (ForeignPtr a, Int, Int)
unsafeToForeignPtr (Vector p n fp) = (fp, ptrToOffset fp p, n)
unsafeWith :: Storable a => Vector a -> (Ptr a -> IO b) -> IO b
unsafeWith (Vector p n fp) m = withForeignPtr fp $ \_ -> m p