Copyright | (c) Roman Leshchinskiy 2009-2010 |
---|---|
License | BSD-style |
Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au> |
Stability | experimental |
Portability | non-portable |
Safe Haskell | None |
Language | Haskell2010 |
Adaptive unboxed vectors. The implementation is based on type families and picks an efficient, specialised representation for every element type. In particular, unboxed vectors of pairs are represented as pairs of unboxed vectors.
Implementing unboxed vectors for new data types can be very easy. Here is
how the library does this for
Complex
by simply wrapping vectors of
pairs.
newtype instanceMVector
s (Complex
a) = MV_Complex (MVector
s (a,a)) newtype instanceVector
(Complex
a) = V_Complex (Vector
(a,a)) instance (RealFloat
a,Unbox
a) =>MVector
MVector
(Complex
a) where {-# INLINE basicLength #-} basicLength (MV_Complex v) =basicLength
v ... instance (RealFloat
a,Unbox
a) => Data.Vector.Generic.VectorVector
(Complex
a) where {-# INLINE basicLength #-} basicLength (V_Complex v) = Data.Vector.Generic.basicLength v ... instance (RealFloat
a,Unbox
a) =>Unbox
(Complex
a)
Synopsis
- data family Vector a
- data family MVector s a
- class ( Vector Vector a, MVector MVector a) => Unbox a
- length :: Unbox a => Vector a -> Int
- null :: Unbox a => Vector a -> Bool
- (!) :: Unbox a => Vector a -> Int -> a
- (!?) :: Unbox a => Vector a -> Int -> Maybe a
- head :: Unbox a => Vector a -> a
- last :: Unbox a => Vector a -> a
- unsafeIndex :: Unbox a => Vector a -> Int -> a
- unsafeHead :: Unbox a => Vector a -> a
- unsafeLast :: Unbox a => Vector a -> a
- indexM :: ( Unbox a, Monad m) => Vector a -> Int -> m a
- headM :: ( Unbox a, Monad m) => Vector a -> m a
- lastM :: ( Unbox a, Monad m) => Vector a -> m a
- unsafeIndexM :: ( Unbox a, Monad m) => Vector a -> Int -> m a
- unsafeHeadM :: ( Unbox a, Monad m) => Vector a -> m a
- unsafeLastM :: ( Unbox a, Monad m) => Vector a -> m a
- slice :: Unbox a => Int -> Int -> Vector a -> Vector a
- init :: Unbox a => Vector a -> Vector a
- tail :: Unbox a => Vector a -> Vector a
- take :: Unbox a => Int -> Vector a -> Vector a
- drop :: Unbox a => Int -> Vector a -> Vector a
- splitAt :: Unbox a => Int -> Vector a -> ( Vector a, Vector a)
- uncons :: Unbox a => Vector a -> Maybe (a, Vector a)
- unsnoc :: Unbox a => Vector a -> Maybe ( Vector a, a)
- unsafeSlice :: Unbox a => Int -> Int -> Vector a -> Vector a
- unsafeInit :: Unbox a => Vector a -> Vector a
- unsafeTail :: Unbox a => Vector a -> Vector a
- unsafeTake :: Unbox a => Int -> Vector a -> Vector a
- unsafeDrop :: Unbox a => Int -> Vector a -> Vector a
- empty :: Unbox a => Vector a
- singleton :: Unbox a => a -> Vector a
- replicate :: Unbox a => Int -> a -> Vector a
- generate :: Unbox a => Int -> ( Int -> a) -> Vector a
- iterateN :: Unbox a => Int -> (a -> a) -> a -> Vector a
- replicateM :: ( Monad m, Unbox a) => Int -> m a -> m ( Vector a)
- generateM :: ( Monad m, Unbox a) => Int -> ( Int -> m a) -> m ( Vector a)
- iterateNM :: ( Monad m, Unbox a) => Int -> (a -> m a) -> a -> m ( Vector a)
- create :: Unbox a => ( forall s. ST s ( MVector s a)) -> Vector a
- createT :: ( Traversable f, Unbox a) => ( forall s. ST s (f ( MVector s a))) -> f ( Vector a)
- unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a
- unfoldrN :: Unbox a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
- unfoldrExactN :: Unbox a => Int -> (b -> (a, b)) -> b -> Vector a
- unfoldrM :: ( Monad m, Unbox a) => (b -> m ( Maybe (a, b))) -> b -> m ( Vector a)
- unfoldrNM :: ( Monad m, Unbox a) => Int -> (b -> m ( Maybe (a, b))) -> b -> m ( Vector a)
- unfoldrExactNM :: ( Monad m, Unbox a) => Int -> (b -> m (a, b)) -> b -> m ( Vector a)
- constructN :: Unbox a => Int -> ( Vector a -> a) -> Vector a
- constructrN :: Unbox a => Int -> ( Vector a -> a) -> Vector a
- enumFromN :: ( Unbox a, Num a) => a -> Int -> Vector a
- enumFromStepN :: ( Unbox a, Num a) => a -> a -> Int -> Vector a
- enumFromTo :: ( Unbox a, Enum a) => a -> a -> Vector a
- enumFromThenTo :: ( Unbox a, Enum a) => a -> a -> a -> Vector a
- cons :: Unbox a => a -> Vector a -> Vector a
- snoc :: Unbox a => Vector a -> a -> Vector a
- (++) :: Unbox a => Vector a -> Vector a -> Vector a
- concat :: Unbox a => [ Vector a] -> Vector a
- force :: Unbox a => Vector a -> Vector a
- (//) :: Unbox a => Vector a -> [( Int , a)] -> Vector a
- update :: Unbox a => Vector a -> Vector ( Int , a) -> Vector a
- update_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
- unsafeUpd :: Unbox a => Vector a -> [( Int , a)] -> Vector a
- unsafeUpdate :: Unbox a => Vector a -> Vector ( Int , a) -> Vector a
- unsafeUpdate_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
- accum :: Unbox a => (a -> b -> a) -> Vector a -> [( Int , b)] -> Vector a
- accumulate :: ( Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector ( Int , b) -> Vector a
- accumulate_ :: ( Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
- unsafeAccum :: Unbox a => (a -> b -> a) -> Vector a -> [( Int , b)] -> Vector a
- unsafeAccumulate :: ( Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector ( Int , b) -> Vector a
- unsafeAccumulate_ :: ( Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
- reverse :: Unbox a => Vector a -> Vector a
- backpermute :: Unbox a => Vector a -> Vector Int -> Vector a
- unsafeBackpermute :: Unbox a => Vector a -> Vector Int -> Vector a
- modify :: Unbox a => ( forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
- indexed :: Unbox a => Vector a -> Vector ( Int , a)
- map :: ( Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
- imap :: ( Unbox a, Unbox b) => ( Int -> a -> b) -> Vector a -> Vector b
- concatMap :: ( Unbox a, Unbox b) => (a -> Vector b) -> Vector a -> Vector b
- mapM :: ( Monad m, Unbox a, Unbox b) => (a -> m b) -> Vector a -> m ( Vector b)
- imapM :: ( Monad m, Unbox a, Unbox b) => ( Int -> a -> m b) -> Vector a -> m ( Vector b)
- mapM_ :: ( Monad m, Unbox a) => (a -> m b) -> Vector a -> m ()
- imapM_ :: ( Monad m, Unbox a) => ( Int -> a -> m b) -> Vector a -> m ()
- forM :: ( Monad m, Unbox a, Unbox b) => Vector a -> (a -> m b) -> m ( Vector b)
- forM_ :: ( Monad m, Unbox a) => Vector a -> (a -> m b) -> m ()
- iforM :: ( Monad m, Unbox a, Unbox b) => Vector a -> ( Int -> a -> m b) -> m ( Vector b)
- iforM_ :: ( Monad m, Unbox a) => Vector a -> ( Int -> a -> m b) -> m ()
- zipWith :: ( Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c
- zipWith3 :: ( Unbox a, Unbox b, Unbox c, Unbox d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
- zipWith4 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
- zipWith5 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
- zipWith6 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
- izipWith :: ( Unbox a, Unbox b, Unbox c) => ( Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
- izipWith3 :: ( Unbox a, Unbox b, Unbox c, Unbox d) => ( Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
- izipWith4 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => ( Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
- izipWith5 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => ( Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
- izipWith6 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => ( Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
- zip :: ( Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
- zip3 :: ( Unbox a, Unbox b, Unbox c) => Vector a -> Vector b -> Vector c -> Vector (a, b, c)
- zip4 :: ( Unbox a, Unbox b, Unbox c, Unbox d) => Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
- zip5 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)
- zip6 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f)
- zipWithM :: ( Monad m, Unbox a, Unbox b, Unbox c) => (a -> b -> m c) -> Vector a -> Vector b -> m ( Vector c)
- izipWithM :: ( Monad m, Unbox a, Unbox b, Unbox c) => ( Int -> a -> b -> m c) -> Vector a -> Vector b -> m ( Vector c)
- zipWithM_ :: ( Monad m, Unbox a, Unbox b) => (a -> b -> m c) -> Vector a -> Vector b -> m ()
- izipWithM_ :: ( Monad m, Unbox a, Unbox b) => ( Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
- unzip :: ( Unbox a, Unbox b) => Vector (a, b) -> ( Vector a, Vector b)
- unzip3 :: ( Unbox a, Unbox b, Unbox c) => Vector (a, b, c) -> ( Vector a, Vector b, Vector c)
- unzip4 :: ( Unbox a, Unbox b, Unbox c, Unbox d) => Vector (a, b, c, d) -> ( Vector a, Vector b, Vector c, Vector d)
- unzip5 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector (a, b, c, d, e) -> ( Vector a, Vector b, Vector c, Vector d, Vector e)
- unzip6 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector (a, b, c, d, e, f) -> ( Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
- filter :: Unbox a => (a -> Bool ) -> Vector a -> Vector a
- ifilter :: Unbox a => ( Int -> a -> Bool ) -> Vector a -> Vector a
- filterM :: ( Monad m, Unbox a) => (a -> m Bool ) -> Vector a -> m ( Vector a)
- uniq :: ( Unbox a, Eq a) => Vector a -> Vector a
- mapMaybe :: ( Unbox a, Unbox b) => (a -> Maybe b) -> Vector a -> Vector b
- imapMaybe :: ( Unbox a, Unbox b) => ( Int -> a -> Maybe b) -> Vector a -> Vector b
- mapMaybeM :: ( Monad m, Unbox a, Unbox b) => (a -> m ( Maybe b)) -> Vector a -> m ( Vector b)
- imapMaybeM :: ( Monad m, Unbox a, Unbox b) => ( Int -> a -> m ( Maybe b)) -> Vector a -> m ( Vector b)
- takeWhile :: Unbox a => (a -> Bool ) -> Vector a -> Vector a
- dropWhile :: Unbox a => (a -> Bool ) -> Vector a -> Vector a
- partition :: Unbox a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
- unstablePartition :: Unbox a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
- partitionWith :: ( Unbox a, Unbox b, Unbox c) => (a -> Either b c) -> Vector a -> ( Vector b, Vector c)
- span :: Unbox a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
- break :: Unbox a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
- elem :: ( Unbox a, Eq a) => a -> Vector a -> Bool
- notElem :: ( Unbox a, Eq a) => a -> Vector a -> Bool
- find :: Unbox a => (a -> Bool ) -> Vector a -> Maybe a
- findIndex :: Unbox a => (a -> Bool ) -> Vector a -> Maybe Int
- findIndices :: Unbox a => (a -> Bool ) -> Vector a -> Vector Int
- elemIndex :: ( Unbox a, Eq a) => a -> Vector a -> Maybe Int
- elemIndices :: ( Unbox a, Eq a) => a -> Vector a -> Vector Int
- foldl :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
- foldl1 :: Unbox a => (a -> a -> a) -> Vector a -> a
- foldl' :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
- foldl1' :: Unbox a => (a -> a -> a) -> Vector a -> a
- foldr :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
- foldr1 :: Unbox a => (a -> a -> a) -> Vector a -> a
- foldr' :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
- foldr1' :: Unbox a => (a -> a -> a) -> Vector a -> a
- ifoldl :: Unbox b => (a -> Int -> b -> a) -> a -> Vector b -> a
- ifoldl' :: Unbox b => (a -> Int -> b -> a) -> a -> Vector b -> a
- ifoldr :: Unbox a => ( Int -> a -> b -> b) -> b -> Vector a -> b
- ifoldr' :: Unbox a => ( Int -> a -> b -> b) -> b -> Vector a -> b
- foldMap :: ( Monoid m, Unbox a) => (a -> m) -> Vector a -> m
- foldMap' :: ( Monoid m, Unbox a) => (a -> m) -> Vector a -> m
- all :: Unbox a => (a -> Bool ) -> Vector a -> Bool
- any :: Unbox a => (a -> Bool ) -> Vector a -> Bool
- and :: Vector Bool -> Bool
- or :: Vector Bool -> Bool
- sum :: ( Unbox a, Num a) => Vector a -> a
- product :: ( Unbox a, Num a) => Vector a -> a
- maximum :: ( Unbox a, Ord a) => Vector a -> a
- maximumBy :: Unbox a => (a -> a -> Ordering ) -> Vector a -> a
- minimum :: ( Unbox a, Ord a) => Vector a -> a
- minimumBy :: Unbox a => (a -> a -> Ordering ) -> Vector a -> a
- minIndex :: ( Unbox a, Ord a) => Vector a -> Int
- minIndexBy :: Unbox a => (a -> a -> Ordering ) -> Vector a -> Int
- maxIndex :: ( Unbox a, Ord a) => Vector a -> Int
- maxIndexBy :: Unbox a => (a -> a -> Ordering ) -> Vector a -> Int
- foldM :: ( Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
- ifoldM :: ( Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
- foldM' :: ( Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
- ifoldM' :: ( Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
- fold1M :: ( Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m a
- fold1M' :: ( Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m a
- foldM_ :: ( Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m ()
- ifoldM_ :: ( Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
- foldM'_ :: ( Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m ()
- ifoldM'_ :: ( Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
- fold1M_ :: ( Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m ()
- fold1M'_ :: ( Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m ()
- prescanl :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- prescanl' :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- postscanl :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- postscanl' :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- scanl :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- scanl' :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- scanl1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
- scanl1' :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
- iscanl :: ( Unbox a, Unbox b) => ( Int -> a -> b -> a) -> a -> Vector b -> Vector a
- iscanl' :: ( Unbox a, Unbox b) => ( Int -> a -> b -> a) -> a -> Vector b -> Vector a
- prescanr :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- prescanr' :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- postscanr :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- postscanr' :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- scanr :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- scanr' :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- scanr1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
- scanr1' :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
- iscanr :: ( Unbox a, Unbox b) => ( Int -> a -> b -> b) -> b -> Vector a -> Vector b
- iscanr' :: ( Unbox a, Unbox b) => ( Int -> a -> b -> b) -> b -> Vector a -> Vector b
- eqBy :: ( Unbox a, Unbox b) => (a -> b -> Bool ) -> Vector a -> Vector b -> Bool
- cmpBy :: ( Unbox a, Unbox b) => (a -> b -> Ordering ) -> Vector a -> Vector b -> Ordering
- toList :: Unbox a => Vector a -> [a]
- fromList :: Unbox a => [a] -> Vector a
- fromListN :: Unbox a => Int -> [a] -> Vector a
- convert :: ( Vector v a, Vector w a) => v a -> w a
- freeze :: ( Unbox a, PrimMonad m) => MVector ( PrimState m) a -> m ( Vector a)
- thaw :: ( Unbox a, PrimMonad m) => Vector a -> m ( MVector ( PrimState m) a)
- copy :: ( Unbox a, PrimMonad m) => MVector ( PrimState m) a -> Vector a -> m ()
- unsafeFreeze :: ( Unbox a, PrimMonad m) => MVector ( PrimState m) a -> m ( Vector a)
- unsafeThaw :: ( Unbox a, PrimMonad m) => Vector a -> m ( MVector ( PrimState m) a)
- unsafeCopy :: ( Unbox a, PrimMonad m) => MVector ( PrimState m) a -> Vector a -> m ()
Unboxed vectors
Instances
data family MVector s a Source #