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 |
Mutable adaptive unboxed vectors
- data family MVector s a
- type IOVector = MVector RealWorld
- type STVector s = MVector s
- class (Vector Vector a, MVector MVector a) => Unbox a
- length :: Unbox a => MVector s a -> Int
- null :: Unbox a => MVector s a -> Bool
- slice :: Unbox a => Int -> Int -> MVector s a -> MVector s a
- init :: Unbox a => MVector s a -> MVector s a
- tail :: Unbox a => MVector s a -> MVector s a
- take :: Unbox a => Int -> MVector s a -> MVector s a
- drop :: Unbox a => Int -> MVector s a -> MVector s a
- splitAt :: Unbox a => Int -> MVector s a -> (MVector s a, MVector s a)
- unsafeSlice :: Unbox a => Int -> Int -> MVector s a -> MVector s a
- unsafeInit :: Unbox a => MVector s a -> MVector s a
- unsafeTail :: Unbox a => MVector s a -> MVector s a
- unsafeTake :: Unbox a => Int -> MVector s a -> MVector s a
- unsafeDrop :: Unbox a => Int -> MVector s a -> MVector s a
- overlaps :: Unbox a => MVector s a -> MVector s a -> Bool
- new :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)
- unsafeNew :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)
- replicate :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)
- replicateM :: (PrimMonad m, Unbox a) => Int -> m a -> m (MVector (PrimState m) a)
- clone :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> m (MVector (PrimState m) a)
- grow :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- unsafeGrow :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
- clear :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> m ()
- zip :: (Unbox a, Unbox b) => MVector s a -> MVector s b -> MVector s (a, b)
- zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a -> MVector s b -> MVector s c -> MVector s (a, b, c)
- zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s (a, b, c, d)
- zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s (a, b, c, d, e)
- zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s f -> MVector s (a, b, c, d, e, f)
- unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a, MVector s b)
- unzip3 :: (Unbox a, Unbox b, Unbox c) => MVector s (a, b, c) -> (MVector s a, MVector s b, MVector s c)
- unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s (a, b, c, d) -> (MVector s a, MVector s b, MVector s c, MVector s d)
- unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e)
- unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e, MVector s f)
- read :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a
- write :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()
- modify :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- swap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()
- unsafeRead :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a
- unsafeWrite :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()
- unsafeModify :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
- unsafeSwap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()
- nextPermutation :: (PrimMonad m, Ord e, Unbox e) => MVector (PrimState m) e -> m Bool
- set :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> a -> m ()
- copy :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- move :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeCopy :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
- unsafeMove :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
Mutable vectors of primitive types
class (Vector Vector a, MVector MVector a) => Unbox a #
Unbox Bool # | |
Unbox Char # | |
Unbox Double # | |
Unbox Float # | |
Unbox Int # | |
Unbox Int8 # | |
Unbox Int16 # | |
Unbox Int32 # | |
Unbox Int64 # | |
Unbox Word # | |
Unbox Word8 # | |
Unbox Word16 # | |
Unbox Word32 # | |
Unbox Word64 # | |
Unbox () # | |
Unbox a => Unbox (Complex a) # | |
(Unbox a, Unbox b) => Unbox (a, b) # | |
(Unbox a, Unbox b, Unbox c) => Unbox (a, b, c) # | |
(Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d) # | |
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e) # | |
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f) # | |
Accessors
Length information
Extracting subvectors
slice :: Unbox a => Int -> Int -> MVector s a -> MVector s a #
Yield a part of the mutable vector without copying it.
Yield a part of the mutable vector without copying it. No bounds checks are performed.
unsafeInit :: Unbox a => MVector s a -> MVector s a #
unsafeTail :: Unbox a => MVector s a -> MVector s a #
Overlapping
Construction
Initialisation
new :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a) #
Create a mutable vector of the given length.
unsafeNew :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a) #
Create a mutable vector of the given length. The memory is not initialized.
replicate :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a) #
Create a mutable vector of the given length (0 if the length is negative) and fill it with an initial value.
replicateM :: (PrimMonad m, Unbox a) => Int -> m a -> m (MVector (PrimState m) a) #
Create a mutable vector of the given length (0 if the length is negative) and fill it with values produced by repeatedly executing the monadic action.
clone :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> m (MVector (PrimState m) a) #
Create a copy of a mutable vector.
Growing
grow :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) #
Grow a vector by the given number of elements. The number must be positive.
unsafeGrow :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a) #
Grow a vector by the given number of elements. The number must be positive but this is not checked.
Restricting memory usage
clear :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> m () #
Reset all elements of the vector to some undefined value, clearing all references to external objects. This is usually a noop for unboxed vectors.
Zipping and unzipping
zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a -> MVector s b -> MVector s c -> MVector s (a, b, c) #
O(1) Zip 3 vectors
zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s (a, b, c, d) #
O(1) Zip 4 vectors
zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s (a, b, c, d, e) #
O(1) Zip 5 vectors
zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s f -> MVector s (a, b, c, d, e, f) #
O(1) Zip 6 vectors
unzip3 :: (Unbox a, Unbox b, Unbox c) => MVector s (a, b, c) -> (MVector s a, MVector s b, MVector s c) #
O(1) Unzip 3 vectors
unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s (a, b, c, d) -> (MVector s a, MVector s b, MVector s c, MVector s d) #
O(1) Unzip 4 vectors
unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e) #
O(1) Unzip 5 vectors
unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a, MVector s b, MVector s c, MVector s d, MVector s e, MVector s f) #
O(1) Unzip 6 vectors
Accessing individual elements
read :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a #
Yield the element at the given position.
write :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m () #
Replace the element at the given position.
modify :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () #
Modify the element at the given position.
swap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m () #
Swap the elements at the given positions.
unsafeRead :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a #
Yield the element at the given position. No bounds checks are performed.
unsafeWrite :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m () #
Replace the element at the given position. No bounds checks are performed.
unsafeModify :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> (a -> a) -> Int -> m () #
Modify the element at the given position. No bounds checks are performed.
unsafeSwap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m () #
Swap the elements at the given positions. No bounds checks are performed.
Modifying vectors
nextPermutation :: (PrimMonad m, Ord e, Unbox e) => MVector (PrimState m) e -> m Bool #
Compute the next (lexicographically) permutation of given vector in-place. Returns False when input is the last permtuation
Filling and copying
set :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> a -> m () #
Set all elements of the vector to the given value.
Copy a vector. The two vectors must have the same length and may not overlap.
move :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m () #
Move the contents of a vector. The two vectors must have the same length.
If the vectors do not overlap, then this is equivalent to copy
.
Otherwise, the copying is performed as if the source vector were
copied to a temporary vector and then the temporary vector was copied
to the target vector.
Copy a vector. The two vectors must have the same length and may not overlap. This is not checked.
Move the contents of a vector. The two vectors must have the same length, but this is not checked.
If the vectors do not overlap, then this is equivalent to unsafeCopy
.
Otherwise, the copying is performed as if the source vector were
copied to a temporary vector and then the temporary vector was copied
to the target vector.