module Data.Vector.Storable (
Vector, MVector(..), Storable,
length, null,
empty, singleton, cons, snoc, replicate, (++), copy,
(!), head, last,
slice, init, tail, take, drop,
accum, (//), backpermute, reverse,
map, concatMap,
zipWith, zipWith3,
filter, takeWhile, dropWhile,
elem, notElem, find, findIndex,
foldl, foldl1, foldl', foldl1', foldr, foldr1,
and, or, sum, product, maximum, minimum,
unfoldr,
prescanl, prescanl',
postscanl, postscanl',
scanl, scanl', scanl1, scanl1',
enumFromTo, enumFromThenTo,
toList, fromList
) where
import qualified Data.Vector.Generic as G
import Data.Vector.Storable.Mutable ( MVector(..) )
import Data.Vector.Storable.Internal
import Foreign.Storable
import Foreign.ForeignPtr
import System.IO.Unsafe ( unsafePerformIO )
import Prelude hiding ( length, null,
replicate, (++),
head, last,
init, tail, take, drop, reverse,
map, concatMap,
zipWith, zipWith3, zip, zip3, unzip, unzip3,
filter, takeWhile, dropWhile,
elem, notElem,
foldl, foldl1, foldr, foldr1,
and, or, sum, product, minimum, maximum,
scanl, scanl1,
enumFromTo, enumFromThenTo )
import qualified Prelude
data Vector a = Vector !Int
!Int
!(ForeignPtr a)
instance (Show a, Storable a) => Show (Vector a) where
show = (Prelude.++ " :: Data.Vector.Storable.Vector")
. ("fromList " Prelude.++)
. show
. toList
instance Storable a => G.Vector Vector a where
vnew init = unsafePerformIO (do
MVector i n p <- init
return (Vector i n p))
vlength (Vector _ n _) = n
unsafeSlice (Vector i _ p) j n = Vector (i+j) n p
unsafeIndexM (Vector i _ p) j = return
. inlinePerformIO
$ withForeignPtr p (`peekElemOff` (i+j))
instance (Storable a, Eq a) => Eq (Vector a) where
(==) = G.eq
instance (Storable a, Ord a) => Ord (Vector a) where
compare = G.cmp
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
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.++)
copy :: Storable a => Vector a -> Vector a
copy = G.copy
(!) :: 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
slice :: Storable a => Vector a -> Int
-> Int
-> 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
accum :: Storable a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
accum = G.accum
(//) :: Storable a => Vector a -> [(Int, a)] -> Vector a
(//) = (G.//)
backpermute :: Storable a => Vector a -> Vector Int -> Vector a
backpermute = G.backpermute
reverse :: Storable a => Vector a -> Vector a
reverse = G.reverse
map :: (Storable a, Storable b) => (a -> b) -> Vector a -> Vector b
map = G.map
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
filter :: Storable a => (a -> Bool) -> Vector a -> Vector a
filter = G.filter
takeWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
takeWhile = G.takeWhile
dropWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
dropWhile = G.dropWhile
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
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
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
minimum :: (Storable a, Ord a) => Vector a -> a
minimum = G.minimum
unfoldr :: Storable a => (b -> Maybe (a, b)) -> b -> Vector a
unfoldr = G.unfoldr
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'
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