Copyright | (c) Roman Leshchinskiy 2008-2010 |
---|---|
License | BSD-style |
Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au> |
Stability | experimental |
Portability | non-portable |
Safe Haskell | None |
Language | Haskell2010 |
Data.Vector.Primitive
Description
Unboxed vectors of primitive types. The use of this module is not recommended except in very special cases. Adaptive unboxed vectors defined in Data.Vector.Unboxed are significantly more flexible at no performance cost.
Synopsis
- data Vector a = Vector ! Int ! Int ! ByteArray
- data MVector s a = MVector ! Int ! Int !( MutableByteArray s)
- class Prim a
- length :: Prim a => Vector a -> Int
- null :: Prim a => Vector a -> Bool
- (!) :: Prim a => Vector a -> Int -> a
- (!?) :: Prim a => Vector a -> Int -> Maybe a
- head :: Prim a => Vector a -> a
- last :: Prim a => Vector a -> a
- unsafeIndex :: Prim a => Vector a -> Int -> a
- unsafeHead :: Prim a => Vector a -> a
- unsafeLast :: Prim a => Vector a -> a
- indexM :: ( Prim a, Monad m) => Vector a -> Int -> m a
- headM :: ( Prim a, Monad m) => Vector a -> m a
- lastM :: ( Prim a, Monad m) => Vector a -> m a
- unsafeIndexM :: ( Prim a, Monad m) => Vector a -> Int -> m a
- unsafeHeadM :: ( Prim a, Monad m) => Vector a -> m a
- unsafeLastM :: ( Prim a, Monad m) => Vector a -> m a
- slice :: Prim a => Int -> Int -> Vector a -> Vector a
- init :: Prim a => Vector a -> Vector a
- tail :: Prim a => Vector a -> Vector a
- take :: Prim a => Int -> Vector a -> Vector a
- drop :: Prim a => Int -> Vector a -> Vector a
- splitAt :: Prim a => Int -> Vector a -> ( Vector a, Vector a)
- uncons :: Prim a => Vector a -> Maybe (a, Vector a)
- unsnoc :: Prim a => Vector a -> Maybe ( Vector a, a)
- unsafeSlice :: Prim a => Int -> Int -> Vector a -> Vector a
- unsafeInit :: Prim a => Vector a -> Vector a
- unsafeTail :: Prim a => Vector a -> Vector a
- unsafeTake :: Prim a => Int -> Vector a -> Vector a
- unsafeDrop :: Prim a => Int -> Vector a -> Vector a
- empty :: Prim a => Vector a
- singleton :: Prim a => a -> Vector a
- replicate :: Prim a => Int -> a -> Vector a
- generate :: Prim a => Int -> ( Int -> a) -> Vector a
- iterateN :: Prim a => Int -> (a -> a) -> a -> Vector a
- replicateM :: ( Monad m, Prim a) => Int -> m a -> m ( Vector a)
- generateM :: ( Monad m, Prim a) => Int -> ( Int -> m a) -> m ( Vector a)
- iterateNM :: ( Monad m, Prim a) => Int -> (a -> m a) -> a -> m ( Vector a)
- create :: Prim a => ( forall s. ST s ( MVector s a)) -> Vector a
- createT :: ( Traversable f, Prim a) => ( forall s. ST s (f ( MVector s a))) -> f ( Vector a)
- unfoldr :: Prim a => (b -> Maybe (a, b)) -> b -> Vector a
- unfoldrN :: Prim a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
- unfoldrExactN :: Prim a => Int -> (b -> (a, b)) -> b -> Vector a
- unfoldrM :: ( Monad m, Prim a) => (b -> m ( Maybe (a, b))) -> b -> m ( Vector a)
- unfoldrNM :: ( Monad m, Prim a) => Int -> (b -> m ( Maybe (a, b))) -> b -> m ( Vector a)
- unfoldrExactNM :: ( Monad m, Prim a) => Int -> (b -> m (a, b)) -> b -> m ( Vector a)
- constructN :: Prim a => Int -> ( Vector a -> a) -> Vector a
- constructrN :: Prim a => Int -> ( Vector a -> a) -> Vector a
- enumFromN :: ( Prim a, Num a) => a -> Int -> Vector a
- enumFromStepN :: ( Prim a, Num a) => a -> a -> Int -> Vector a
- enumFromTo :: ( Prim a, Enum a) => a -> a -> Vector a
- enumFromThenTo :: ( Prim a, Enum a) => a -> a -> a -> Vector a
- cons :: Prim a => a -> Vector a -> Vector a
- snoc :: Prim a => Vector a -> a -> Vector a
- (++) :: Prim a => Vector a -> Vector a -> Vector a
- concat :: Prim a => [ Vector a] -> Vector a
- force :: Prim a => Vector a -> Vector a
- (//) :: Prim a => Vector a -> [( Int , a)] -> Vector a
- update_ :: Prim a => Vector a -> Vector Int -> Vector a -> Vector a
- unsafeUpd :: Prim a => Vector a -> [( Int , a)] -> Vector a
- unsafeUpdate_ :: Prim a => Vector a -> Vector Int -> Vector a -> Vector a
- accum :: Prim a => (a -> b -> a) -> Vector a -> [( Int , b)] -> Vector a
- accumulate_ :: ( Prim a, Prim b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
- unsafeAccum :: Prim a => (a -> b -> a) -> Vector a -> [( Int , b)] -> Vector a
- unsafeAccumulate_ :: ( Prim a, Prim b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
- reverse :: Prim a => Vector a -> Vector a
- backpermute :: Prim a => Vector a -> Vector Int -> Vector a
- unsafeBackpermute :: Prim a => Vector a -> Vector Int -> Vector a
- modify :: Prim a => ( forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
- map :: ( Prim a, Prim b) => (a -> b) -> Vector a -> Vector b
- imap :: ( Prim a, Prim b) => ( Int -> a -> b) -> Vector a -> Vector b
- concatMap :: ( Prim a, Prim b) => (a -> Vector b) -> Vector a -> Vector b
- mapM :: ( Monad m, Prim a, Prim b) => (a -> m b) -> Vector a -> m ( Vector b)
- imapM :: ( Monad m, Prim a, Prim b) => ( Int -> a -> m b) -> Vector a -> m ( Vector b)
- mapM_ :: ( Monad m, Prim a) => (a -> m b) -> Vector a -> m ()
- imapM_ :: ( Monad m, Prim a) => ( Int -> a -> m b) -> Vector a -> m ()
- forM :: ( Monad m, Prim a, Prim b) => Vector a -> (a -> m b) -> m ( Vector b)
- forM_ :: ( Monad m, Prim a) => Vector a -> (a -> m b) -> m ()
- iforM :: ( Monad m, Prim a, Prim b) => Vector a -> ( Int -> a -> m b) -> m ( Vector b)
- iforM_ :: ( Monad m, Prim a) => Vector a -> ( Int -> a -> m b) -> m ()
- zipWith :: ( Prim a, Prim b, Prim c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c
- zipWith3 :: ( Prim a, Prim b, Prim c, Prim d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
- zipWith4 :: ( Prim a, Prim b, Prim c, Prim d, Prim e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
- zipWith5 :: ( Prim a, Prim b, Prim c, Prim d, Prim e, Prim f) => (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
- zipWith6 :: ( Prim a, Prim b, Prim c, Prim d, Prim e, Prim f, Prim g) => (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
- izipWith :: ( Prim a, Prim b, Prim c) => ( Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
- izipWith3 :: ( Prim a, Prim b, Prim c, Prim d) => ( Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
- izipWith4 :: ( Prim a, Prim b, Prim c, Prim d, Prim e) => ( Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
- izipWith5 :: ( Prim a, Prim b, Prim c, Prim d, Prim e, Prim f) => ( Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
- izipWith6 :: ( Prim a, Prim b, Prim c, Prim d, Prim e, Prim f, Prim g) => ( Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
- zipWithM :: ( Monad m, Prim a, Prim b, Prim c) => (a -> b -> m c) -> Vector a -> Vector b -> m ( Vector c)
- izipWithM :: ( Monad m, Prim a, Prim b, Prim c) => ( Int -> a -> b -> m c) -> Vector a -> Vector b -> m ( Vector c)
- zipWithM_ :: ( Monad m, Prim a, Prim b) => (a -> b -> m c) -> Vector a -> Vector b -> m ()
- izipWithM_ :: ( Monad m, Prim a, Prim b) => ( Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
- filter :: Prim a => (a -> Bool ) -> Vector a -> Vector a
- ifilter :: Prim a => ( Int -> a -> Bool ) -> Vector a -> Vector a
- filterM :: ( Monad m, Prim a) => (a -> m Bool ) -> Vector a -> m ( Vector a)
- uniq :: ( Prim a, Eq a) => Vector a -> Vector a
- mapMaybe :: ( Prim a, Prim b) => (a -> Maybe b) -> Vector a -> Vector b
- imapMaybe :: ( Prim a, Prim b) => ( Int -> a -> Maybe b) -> Vector a -> Vector b
- mapMaybeM :: ( Monad m, Prim a, Prim b) => (a -> m ( Maybe b)) -> Vector a -> m ( Vector b)
- imapMaybeM :: ( Monad m, Prim a, Prim b) => ( Int -> a -> m ( Maybe b)) -> Vector a -> m ( Vector b)
- takeWhile :: Prim a => (a -> Bool ) -> Vector a -> Vector a
- dropWhile :: Prim a => (a -> Bool ) -> Vector a -> Vector a
- partition :: Prim a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
- unstablePartition :: Prim a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
- partitionWith :: ( Prim a, Prim b, Prim c) => (a -> Either b c) -> Vector a -> ( Vector b, Vector c)
- span :: Prim a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
- break :: Prim a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
- elem :: ( Prim a, Eq a) => a -> Vector a -> Bool
- notElem :: ( Prim a, Eq a) => a -> Vector a -> Bool
- find :: Prim a => (a -> Bool ) -> Vector a -> Maybe a
- findIndex :: Prim a => (a -> Bool ) -> Vector a -> Maybe Int
- findIndices :: Prim a => (a -> Bool ) -> Vector a -> Vector Int
- elemIndex :: ( Prim a, Eq a) => a -> Vector a -> Maybe Int
- elemIndices :: ( Prim a, Eq a) => a -> Vector a -> Vector Int
- foldl :: Prim b => (a -> b -> a) -> a -> Vector b -> a
- foldl1 :: Prim a => (a -> a -> a) -> Vector a -> a
- foldl' :: Prim b => (a -> b -> a) -> a -> Vector b -> a
- foldl1' :: Prim a => (a -> a -> a) -> Vector a -> a
- foldr :: Prim a => (a -> b -> b) -> b -> Vector a -> b
- foldr1 :: Prim a => (a -> a -> a) -> Vector a -> a
- foldr' :: Prim a => (a -> b -> b) -> b -> Vector a -> b
- foldr1' :: Prim a => (a -> a -> a) -> Vector a -> a
- ifoldl :: Prim b => (a -> Int -> b -> a) -> a -> Vector b -> a
- ifoldl' :: Prim b => (a -> Int -> b -> a) -> a -> Vector b -> a
- ifoldr :: Prim a => ( Int -> a -> b -> b) -> b -> Vector a -> b
- ifoldr' :: Prim a => ( Int -> a -> b -> b) -> b -> Vector a -> b
- foldMap :: ( Monoid m, Prim a) => (a -> m) -> Vector a -> m
- foldMap' :: ( Monoid m, Prim a) => (a -> m) -> Vector a -> m
- all :: Prim a => (a -> Bool ) -> Vector a -> Bool
- any :: Prim a => (a -> Bool ) -> Vector a -> Bool
- sum :: ( Prim a, Num a) => Vector a -> a
- product :: ( Prim a, Num a) => Vector a -> a
- maximum :: ( Prim a, Ord a) => Vector a -> a
- maximumBy :: Prim a => (a -> a -> Ordering ) -> Vector a -> a
- minimum :: ( Prim a, Ord a) => Vector a -> a
- minimumBy :: Prim a => (a -> a -> Ordering ) -> Vector a -> a
- minIndex :: ( Prim a, Ord a) => Vector a -> Int
- minIndexBy :: Prim a => (a -> a -> Ordering ) -> Vector a -> Int
- maxIndex :: ( Prim a, Ord a) => Vector a -> Int
- maxIndexBy :: Prim a => (a -> a -> Ordering ) -> Vector a -> Int
- foldM :: ( Monad m, Prim b) => (a -> b -> m a) -> a -> Vector b -> m a
- ifoldM :: ( Monad m, Prim b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
- foldM' :: ( Monad m, Prim b) => (a -> b -> m a) -> a -> Vector b -> m a
- ifoldM' :: ( Monad m, Prim b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
- fold1M :: ( Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m a
- fold1M' :: ( Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m a
- foldM_ :: ( Monad m, Prim b) => (a -> b -> m a) -> a -> Vector b -> m ()
- ifoldM_ :: ( Monad m, Prim b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
- foldM'_ :: ( Monad m, Prim b) => (a -> b -> m a) -> a -> Vector b -> m ()
- ifoldM'_ :: ( Monad m, Prim b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
- fold1M_ :: ( Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m ()
- fold1M'_ :: ( Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m ()
- prescanl :: ( Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
- prescanl' :: ( Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
- postscanl :: ( Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
- postscanl' :: ( Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
- scanl :: ( Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
- scanl' :: ( Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
- scanl1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a
- scanl1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a
- iscanl :: ( Prim a, Prim b) => ( Int -> a -> b -> a) -> a -> Vector b -> Vector a
- iscanl' :: ( Prim a, Prim b) => ( Int -> a -> b -> a) -> a -> Vector b -> Vector a
- prescanr :: ( Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
- prescanr' :: ( Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
- postscanr :: ( Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
- postscanr' :: ( Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
- scanr :: ( Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
- scanr' :: ( Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
- scanr1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a
- scanr1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a
- iscanr :: ( Prim a, Prim b) => ( Int -> a -> b -> b) -> b -> Vector a -> Vector b
- iscanr' :: ( Prim a, Prim b) => ( Int -> a -> b -> b) -> b -> Vector a -> Vector b
- eqBy :: ( Prim a, Prim b) => (a -> b -> Bool ) -> Vector a -> Vector b -> Bool
- cmpBy :: ( Prim a, Prim b) => (a -> b -> Ordering ) -> Vector a -> Vector b -> Ordering
- toList :: Prim a => Vector a -> [a]
- fromList :: Prim a => [a] -> Vector a
- fromListN :: Prim a => Int -> [a] -> Vector a
- convert :: ( Vector v a, Vector w a) => v a -> w a
- freeze :: ( Prim a, PrimMonad m) => MVector ( PrimState m) a -> m ( Vector a)
- thaw :: ( Prim a, PrimMonad m) => Vector a -> m ( MVector ( PrimState m) a)
- copy :: ( Prim a, PrimMonad m) => MVector ( PrimState m) a -> Vector a -> m ()
- unsafeFreeze :: ( Prim a, PrimMonad m) => MVector ( PrimState m) a -> m ( Vector a)
- unsafeThaw :: ( Prim a, PrimMonad m) => Vector a -> m ( MVector ( PrimState m) a)
- unsafeCopy :: ( Prim a, PrimMonad m) => MVector ( PrimState m) a -> Vector a -> m ()
Primitive vectors
Unboxed vectors of primitive types
Instances
NFData1 Vector Source # |
Since: 0.12.1.0 |
Defined in Data.Vector.Primitive |
|
Prim a => Vector Vector a Source # | |
Defined in Data.Vector.Primitive Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) a -> m ( Vector a) Source # basicUnsafeThaw :: PrimMonad m => Vector a -> m ( Mutable Vector ( PrimState m) a) Source # basicLength :: Vector a -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a Source # basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) a -> Vector a -> m () Source # |
|
Prim a => IsList ( Vector a) Source # | |
( Prim a, Eq a) => Eq ( Vector a) Source # | |
( Data a, Prim a) => Data ( Vector a) Source # | |
Defined in Data.Vector.Primitive Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Vector a -> c ( Vector a) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Vector a) Source # toConstr :: Vector a -> Constr Source # dataTypeOf :: Vector a -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Vector a)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Vector a)) Source # gmapT :: ( forall b. Data b => b -> b) -> Vector a -> Vector a Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Vector a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Vector a -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Vector a -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Vector a -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Vector a -> m ( Vector a) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Vector a -> m ( Vector a) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Vector a -> m ( Vector a) Source # |
|
( Prim a, Ord a) => Ord ( Vector a) Source # | |
Defined in Data.Vector.Primitive |
|
( Read a, Prim a) => Read ( Vector a) Source # | |
( Show a, Prim a) => Show ( Vector a) Source # | |
Prim a => Semigroup ( Vector a) Source # | |
Prim a => Monoid ( Vector a) Source # | |
NFData ( Vector a) Source # | |
Defined in Data.Vector.Primitive |
|
type Mutable Vector Source # | |
Defined in Data.Vector.Primitive |
|
type Item ( Vector a) Source # | |
Defined in Data.Vector.Primitive |
Mutable vectors of primitive types.
Constructors
MVector ! Int ! Int !( MutableByteArray s) |
offset, length, underlying mutable byte array |
Instances
Class of types supporting primitive array operations. This includes
interfacing with GC-managed memory (functions suffixed with
ByteArray#
)
and interfacing with unmanaged memory (functions suffixed with
Addr#
).
Endianness is platform-dependent.
Minimal complete definition
sizeOf# , alignment# , indexByteArray# , readByteArray# , writeByteArray# , setByteArray# , indexOffAddr# , readOffAddr# , writeOffAddr# , setOffAddr#