module Data.Vector.Unboxed (
Vector,
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,
sum, product, maximum, minimum,
unfoldr,
prescanl, prescanl',
enumFromTo, enumFromThenTo,
toList, fromList
) where
import Data.Vector.IVector ( IVector(..) )
import qualified Data.Vector.IVector as IV
import qualified Data.Vector.Unboxed.Mutable.ST as Mut
import Data.Vector.Unboxed.Unbox
import Control.Monad.ST ( runST )
import GHC.ST ( ST(..) )
import GHC.Prim ( ByteArray#, unsafeFreezeByteArray#, (+#) )
import GHC.Base ( Int(..) )
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,
enumFromTo, enumFromThenTo )
import qualified Prelude
data Vector a = Vector !Int
!Int
ByteArray#
instance (Show a, Unbox a) => Show (Vector a) where
show = (Prelude.++ " :: Data.Vector.Unboxed.Vector") . ("fromList " Prelude.++) . show . toList
instance Unbox a => IVector Vector a where
vnew init = runST (do
Mut.Vector i n marr# <- init
ST (\s# -> case unsafeFreezeByteArray# marr# s# of
(# s2#, arr# #) -> (# s2#, Vector i n arr# #)))
vlength (Vector _ n _) = n
unsafeSlice (Vector i _ arr#) j n = Vector (i+j) n arr#
unsafeIndexM (Vector (I# i#) _ arr#) (I# j#) = return (at# arr# (i# +# j#))
instance (Unbox a, Eq a) => Eq (Vector a) where
(==) = IV.eq
instance (Unbox a, Ord a) => Ord (Vector a) where
compare = IV.cmp
length :: Unbox a => Vector a -> Int
length = IV.length
null :: Unbox a => Vector a -> Bool
null = IV.null
empty :: Unbox a => Vector a
empty = IV.empty
singleton :: Unbox a => a -> Vector a
singleton = IV.singleton
replicate :: Unbox a => Int -> a -> Vector a
replicate = IV.replicate
cons :: Unbox a => a -> Vector a -> Vector a
cons = IV.cons
snoc :: Unbox a => Vector a -> a -> Vector a
snoc = IV.snoc
infixr 5 ++
(++) :: Unbox a => Vector a -> Vector a -> Vector a
(++) = (IV.++)
copy :: Unbox a => Vector a -> Vector a
copy = IV.copy
(!) :: Unbox a => Vector a -> Int -> a
(!) = (IV.!)
head :: Unbox a => Vector a -> a
head = IV.head
last :: Unbox a => Vector a -> a
last = IV.last
slice :: Unbox a => Vector a -> Int
-> Int
-> Vector a
slice = IV.slice
init :: Unbox a => Vector a -> Vector a
init = IV.init
tail :: Unbox a => Vector a -> Vector a
tail = IV.tail
take :: Unbox a => Int -> Vector a -> Vector a
take = IV.take
drop :: Unbox a => Int -> Vector a -> Vector a
drop = IV.drop
accum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
accum = IV.accum
(//) :: Unbox a => Vector a -> [(Int, a)] -> Vector a
(//) = (IV.//)
backpermute :: Unbox a => Vector a -> Vector Int -> Vector a
backpermute = IV.backpermute
reverse :: Unbox a => Vector a -> Vector a
reverse = IV.reverse
map :: (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
map = IV.map
concatMap :: (Unbox a, Unbox b) => (a -> Vector b) -> Vector a -> Vector b
concatMap = IV.concatMap
zipWith :: (Unbox a, Unbox b, Unbox c)
=> (a -> b -> c) -> Vector a -> Vector b -> Vector c
zipWith = IV.zipWith
zipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d)
=> (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
zipWith3 = IV.zipWith3
filter :: Unbox a => (a -> Bool) -> Vector a -> Vector a
filter = IV.filter
takeWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
takeWhile = IV.takeWhile
dropWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
dropWhile = IV.dropWhile
infix 4 `elem`
elem :: (Unbox a, Eq a) => a -> Vector a -> Bool
elem = IV.elem
infix 4 `notElem`
notElem :: (Unbox a, Eq a) => a -> Vector a -> Bool
notElem = IV.notElem
find :: Unbox a => (a -> Bool) -> Vector a -> Maybe a
find = IV.find
findIndex :: Unbox a => (a -> Bool) -> Vector a -> Maybe Int
findIndex = IV.findIndex
foldl :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
foldl = IV.foldl
foldl1 :: Unbox a => (a -> a -> a) -> Vector a -> a
foldl1 = IV.foldl1
foldl' :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
foldl' = IV.foldl'
foldl1' :: Unbox a => (a -> a -> a) -> Vector a -> a
foldl1' = IV.foldl1'
foldr :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
foldr = IV.foldr
foldr1 :: Unbox a => (a -> a -> a) -> Vector a -> a
foldr1 = IV.foldr1
sum :: (Unbox a, Num a) => Vector a -> a
sum = IV.sum
product :: (Unbox a, Num a) => Vector a -> a
product = IV.product
maximum :: (Unbox a, Ord a) => Vector a -> a
maximum = IV.maximum
minimum :: (Unbox a, Ord a) => Vector a -> a
minimum = IV.minimum
unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a
unfoldr = IV.unfoldr
prescanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
prescanl = IV.prescanl
prescanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
prescanl' = IV.prescanl'
enumFromTo :: (Unbox a, Enum a) => a -> a -> Vector a
enumFromTo = IV.enumFromTo
enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a
enumFromThenTo = IV.enumFromThenTo
toList :: Unbox a => Vector a -> [a]
toList = IV.toList
fromList :: Unbox a => [a] -> Vector a
fromList = IV.fromList