Safe Haskell	None
Language	Haskell98

Data.Vector.Fixed.Primitive

Contents

Immutable
Mutable
Type classes

Description

Unboxed vectors with fixed length. Vectors from Data.Vector.Fixed.Unboxed provide more flexibility at no performeance cost.

Synopsis

Immutable

data Vec n a Source #

Unboxed vector with fixed length

Instances

(Arity n, Prim a) => VectorN Vec n a Source #

(Arity n, Prim a) => Vector (Vec n) a Source #
Methods construct :: Fun (Dim (Vec n)) a (Vec n a) Source # inspect :: Vec n a -> Fun (Dim (Vec n)) a b -> b Source # basicIndex :: Vec n a -> Int -> a Source #
(Arity n, Prim a) => IVector (Vec n) a Source #
Methods unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) a -> m (Vec n a) Source # unsafeThaw :: PrimMonad m => Vec n a -> m (Mutable (Vec n) (PrimState m) a) Source # unsafeIndex :: Vec n a -> Int -> a Source #
(Arity n, Prim a, Eq a) => Eq (Vec n a) Source #
Methods (==) :: Vec n a -> Vec n a -> Bool # (/=) :: Vec n a -> Vec n a -> Bool #
(Typeable * n, Arity n, Prim a, Data a) => Data (Vec n a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vec n a -> c (Vec n a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vec n a) # toConstr :: Vec n a -> Constr # dataTypeOf :: Vec n a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Vec n a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vec n a)) # gmapT :: (forall b. Data b => b -> b) -> Vec n a -> Vec n a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vec n a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vec n a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vec n a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vec n a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vec n a -> m (Vec n a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vec n a -> m (Vec n a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vec n a -> m (Vec n a) #
(Arity n, Prim a, Ord a) => Ord (Vec n a) Source #
Methods compare :: Vec n a -> Vec n a -> Ordering # (<) :: Vec n a -> Vec n a -> Bool # (<=) :: Vec n a -> Vec n a -> Bool # (>) :: Vec n a -> Vec n a -> Bool # (>=) :: Vec n a -> Vec n a -> Bool # max :: Vec n a -> Vec n a -> Vec n a # min :: Vec n a -> Vec n a -> Vec n a #
(Arity n, Prim a, Show a) => Show (Vec n a) Source #
Methods showsPrec :: Int -> Vec n a -> ShowS # show :: Vec n a -> String # showList :: [Vec n a] -> ShowS #
(Arity n, Prim a, Monoid a) => Monoid (Vec n a) Source #
Methods mempty :: Vec n a # mappend :: Vec n a -> Vec n a -> Vec n a # mconcat :: [Vec n a] -> Vec n a #
(Storable a, Prim a, Arity n) => Storable (Vec n a) Source #
Methods sizeOf :: Vec n a -> Int # alignment :: Vec n a -> Int # peekElemOff :: Ptr (Vec n a) -> Int -> IO (Vec n a) # pokeElemOff :: Ptr (Vec n a) -> Int -> Vec n a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Vec n a) # pokeByteOff :: Ptr b -> Int -> Vec n a -> IO () # peek :: Ptr (Vec n a) -> IO (Vec n a) # poke :: Ptr (Vec n a) -> Vec n a -> IO () #
(Arity n, Prim a, NFData a) => NFData (Vec n a) Source #
Methods rnf :: Vec n a -> () #
type Dim (Vec n) Source #
type Dim (Vec n) = n
type Mutable (Vec n) Source #
type Mutable (Vec n) = MVec n

type Vec1 = Vec (S Z) Source #

type Vec2 = Vec (S (S Z)) Source #

type Vec3 = Vec (S (S (S Z))) Source #

type Vec4 = Vec (S (S (S (S Z)))) Source #

type Vec5 = Vec (S (S (S (S (S Z))))) Source #

Mutable

data MVec n s a Source #

Mutable unboxed vector with fixed length

Instances

(Arity n, Prim a) => MVector (MVec n) a Source #
Methods overlaps :: MVec n s a -> MVec n s a -> Bool Source # copy :: PrimMonad m => MVec n (PrimState m) a -> MVec n (PrimState m) a -> m () Source # move :: PrimMonad m => MVec n (PrimState m) a -> MVec n (PrimState m) a -> m () Source # new :: PrimMonad m => m (MVec n (PrimState m) a) Source # unsafeRead :: PrimMonad m => MVec n (PrimState m) a -> Int -> m a Source # unsafeWrite :: PrimMonad m => MVec n (PrimState m) a -> Int -> a -> m () Source #
type DimM (MVec n) Source #
type DimM (MVec n) = n

Type classes

class Prim a #

Class of types supporting primitive array operations

Minimal complete definition

sizeOf#, alignment#, indexByteArray#, readByteArray#, writeByteArray#, setByteArray#, indexOffAddr#, readOffAddr#, writeOffAddr#, setOffAddr#

Instances

Prim Char
Methods sizeOf# :: Char -> Int# # alignment# :: Char -> Int# # indexByteArray# :: ByteArray# -> Int# -> Char # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Char#) # writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Char # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Char#) # writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s #
Prim Double
Methods sizeOf# :: Double -> Int# # alignment# :: Double -> Int# # indexByteArray# :: ByteArray# -> Int# -> Double # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Double#) # writeByteArray# :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Double -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Double # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Double#) # writeOffAddr# :: Addr# -> Int# -> Double -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Double -> State# s -> State# s #
Prim Float
Methods sizeOf# :: Float -> Int# # alignment# :: Float -> Int# # indexByteArray# :: ByteArray# -> Int# -> Float # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Float#) # writeByteArray# :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Float -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Float # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Float#) # writeOffAddr# :: Addr# -> Int# -> Float -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Float -> State# s -> State# s #
Prim Int
Methods sizeOf# :: Int -> Int# # alignment# :: Int -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int#) # writeOffAddr# :: Addr# -> Int# -> Int -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int -> State# s -> State# s #
Prim Int8
Methods sizeOf# :: Int8 -> Int# # alignment# :: Int8 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int8 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int8#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int8 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int8 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int8 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int8#) # writeOffAddr# :: Addr# -> Int# -> Int8 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int8 -> State# s -> State# s #
Prim Int16
Methods sizeOf# :: Int16 -> Int# # alignment# :: Int16 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int16 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int16#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int16 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int16 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int16#) # writeOffAddr# :: Addr# -> Int# -> Int16 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int16 -> State# s -> State# s #
Prim Int32
Methods sizeOf# :: Int32 -> Int# # alignment# :: Int32 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int32 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int32#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int32 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int32#) # writeOffAddr# :: Addr# -> Int# -> Int32 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int32 -> State# s -> State# s #
Prim Int64
Methods sizeOf# :: Int64 -> Int# # alignment# :: Int64 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Int64 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int64#) # writeByteArray# :: MutableByteArray# s -> Int# -> Int64 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Int64 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Int64#) # writeOffAddr# :: Addr# -> Int# -> Int64 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Int64 -> State# s -> State# s #
Prim Word
Methods sizeOf# :: Word -> Int# # alignment# :: Word -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word#) # writeOffAddr# :: Addr# -> Int# -> Word -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word -> State# s -> State# s #
Prim Word8
Methods sizeOf# :: Word8 -> Int# # alignment# :: Word8 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word8 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word8#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word8 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word8#) # writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s #
Prim Word16
Methods sizeOf# :: Word16 -> Int# # alignment# :: Word16 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word16 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word16#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word16 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word16 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word16#) # writeOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word16 -> State# s -> State# s #
Prim Word32
Methods sizeOf# :: Word32 -> Int# # alignment# :: Word32 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word32 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word32#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word32 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word32#) # writeOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word32 -> State# s -> State# s #
Prim Word64
Methods sizeOf# :: Word64 -> Int# # alignment# :: Word64 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word64 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word64#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word64 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word64 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word64#) # writeOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word64 -> State# s -> State# s #
Prim Addr
Methods sizeOf# :: Addr -> Int# # alignment# :: Addr -> Int# # indexByteArray# :: ByteArray# -> Int# -> Addr # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Addr#) # writeByteArray# :: MutableByteArray# s -> Int# -> Addr -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Addr -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Addr # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Addr#) # writeOffAddr# :: Addr# -> Int# -> Addr -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Addr -> State# s -> State# s #