Data.Vector.Unboxed.Mutable.Sized

This module re-exports the functionality in Sized specialized to Mutable

Functions returning a vector determine the size from the type context unless they have a ' suffix in which case they take an explicit Proxy argument.

Functions where the resultant vector size is not know until compile time are not exported.

Documentation

type MVector = MVector MVector

Vector specialized to use Mutable

Accessors

Length information

length :: forall n s a. KnownNat n => MVector n s a -> Int

O(1) Yield the length of the mutable vector as an Int.

length' :: forall n s a. MVector n s a -> Proxy n

O(1) Yield the length of the mutable vector as a Proxy.

null :: forall n s a. KnownNat n => MVector n s a -> Bool

O(1) Check whether the mutable vector is empty

Extracting subvectors

slice

Arguments

:: (KnownNat i, KnownNat n, Unbox a)

=> p i

starting index

-> MVector ((i + n) + k) s a

-> MVector n s a

O(1) Yield a slice of the mutable vector without copying it with an inferred length argument.

slice'

Arguments

:: (KnownNat i, KnownNat n, Unbox a)

=> p i

starting index

-> p n

length

-> MVector ((i + n) + k) s a

-> MVector n s a

O(1) Yield a slice of the mutable vector without copying it with an explicit length argument.

init :: forall n s a. Unbox a => MVector (n + 1) s a -> MVector n s a

O(1) Yield all but the last element of a non-empty mutable vector without copying.

tail :: forall n s a. Unbox a => MVector (1 + n) s a -> MVector n s a

O(1) Yield all but the first element of a non-empty mutable vector without copying.

take :: forall n k s a. (KnownNat n, Unbox a) => MVector (n + k) s a -> MVector n s a

O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is inferred from the type.

take' :: forall n k s a p. (KnownNat n, Unbox a) => p n -> MVector (n + k) s a -> MVector n s a

O(1) Yield the first n elements. The resultant vector always contains this many elements. The length of the resultant vector is given explicitly as a Proxy argument.

drop :: forall n k s a. (KnownNat n, Unbox a) => MVector (n + k) s a -> MVector k s a

O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.

drop' :: forall n k s a p. (KnownNat n, Unbox a) => p n -> MVector (n + k) s a -> MVector k s a

O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is givel explicitly as a Proxy argument.

splitAt :: forall n m s a. (KnownNat n, Unbox a) => MVector (n + m) s a -> (MVector n s a, MVector m s a)

O(1) Yield the first n elements paired with the remainder without copying. The lengths of the resultant vector are inferred from the type.

splitAt' :: forall n m s a p. (KnownNat n, Unbox a) => p n -> MVector (n + m) s a -> (MVector n s a, MVector m s a)

O(1) Yield the first n elements paired with the remainder without copying. The length of the first resultant vector is passed explicitly as a Proxy argument.

Overlaps

overlaps :: forall n k s a. Unbox a => MVector n s a -> MVector k s a -> Bool

O(1) Yield all but the the first n elements. The given vector must contain at least this many elements The length of the resultant vector is inferred from the type.

Construction

Initialisation

new :: forall n m a. (KnownNat n, PrimMonad m, Unbox a) => m (MVector n (PrimState m) a)

Create a mutable vector where the length is inferred from the type.

unsafeNew :: forall n m a. (KnownNat n, PrimMonad m, Unbox a) => m (MVector n (PrimState m) a)

Create a mutable vector where the length is inferred from the type. The memory is not initialized.

replicate :: forall n m a. (KnownNat n, PrimMonad m, Unbox a) => a -> m (MVector n (PrimState m) a)

Create a mutable vector where the length is inferred from the type and fill it with an initial value.

replicate' :: forall n m a p. (KnownNat n, PrimMonad m, Unbox a) => p n -> a -> m (MVector n (PrimState m) a)

Create a mutable vector where the length is given explicitly as a Proxy argument and fill it with an initial value.

replicateM :: forall n m a. (KnownNat n, PrimMonad m, Unbox a) => m a -> m (MVector n (PrimState m) a)

Create a mutable vector where the length is inferred from the type and fill it with values produced by repeatedly executing the monadic action.

replicateM' :: forall n m a p. (KnownNat n, PrimMonad m, Unbox a) => p n -> m a -> m (MVector n (PrimState m) a)

Create a mutable vector where the length is given explicitly as a Proxy argument and fill it with values produced by repeatedly executing the monadic action.

clone :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> m (MVector n (PrimState m) a)

Create a copy of a mutable vector.

Growing

grow :: forall n k m a p. (KnownNat k, PrimMonad m, Unbox a) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

Grow a mutable vector by an amount given explicitly as a Proxy argument.

growFront :: forall n k m a p. (KnownNat k, PrimMonad m, Unbox a) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

Grow a mutable vector (from the front) by an amount given explicitly as a Proxy argument.

Restricting memory usage

clear :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> m ()

Reset all elements of the vector to some undefined value, clearing all references to external objects.

Accessing individual elements

read :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Finite n -> m a

O(1) Yield the element at a given type-safe position using Finite.

read' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> m a

O(1) Yield the element at a given type-safe position using Proxy.

write :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Finite n -> a -> m ()

O(1) Replace the element at a given type-safe position using Finite.

write' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m ()

O(1) Replace the element at a given type-safe position using Proxy.

modify :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()

O(1) Modify the element at a given type-safe position using Finite.

modify' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a) => MVector ((n + k) + 1) (PrimState m) a -> (a -> a) -> p k -> m ()

O(1) Modify the element at a given type-safe position using Proxy.

swap :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()

O(1) Swap the elements at a given type-safe position using Finites.

exchange :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Finite n -> a -> m a

O(1) Replace the element at a given type-safe position and return the old element, using Finite.

exchange' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m a

O(1) Replace the element at a given type-safe position and return the old element, using Finite.

unsafeRead :: forall n a m. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Int -> m a

O(1) Yield the element at a given Int position without bounds checking.

unsafeWrite :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Int -> a -> m ()

O(1) Replace the element at a given Int position without bounds checking.

unsafeModify :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> (a -> a) -> Int -> m ()

O(1) Modify the element at a given Int position without bounds checking.

unsafeSwap :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Int -> Int -> m ()

O(1) Swap the elements at a given Int position without bounds checking.

unsafeExchange :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Int -> a -> m a

O(1) Replace the element at a given Int position and return the old element. No bounds checks are performed.

Modifying vectors

nextPermutation :: forall n e m. (Ord e, PrimMonad m, Unbox e) => MVector n (PrimState m) e -> m Bool

Compute the next (lexicographically) permutation of a given vector in-place. Returns False when the input is the last permutation.

Filling and copying

set :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> a -> m ()

Set all elements of the vector to the given value.

copy

Arguments

:: (PrimMonad m, Unbox a)

=> MVector n (PrimState m) a

target

-> MVector n (PrimState m) a

source

-> m ()

Copy a vector. The two vectors may not overlap.

move

Arguments

:: (PrimMonad m, Unbox a)

=> MVector n (PrimState m) a

target

-> MVector n (PrimState m) a

source

-> m ()

Move the contents of a vector. If the two vectors do not overlap, 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.

unsafeCopy

Arguments

:: (PrimMonad m, Unbox a)

=> MVector n (PrimState m) a

target

-> MVector n (PrimState m) a

source

-> m ()

Copy a vector. The two vectors may not overlap. This is not checked.

Conversions

Unsized Mutable Vectors

toSized :: forall n a s. (KnownNat n, Unbox a) => MVector s a -> Maybe (MVector n s a)

Convert a MVector into a MVector if it has the correct size, otherwise return Nothing.

Note that this does no copying; the returned MVector is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given MVector.

withSized :: forall s a r. Unbox a => MVector s a -> (forall n. KnownNat n => MVector n s a -> r) -> r

Takes a MVector and returns a continuation providing a MVector with a size parameter n that is determined at runtime based on the length of the input vector.

Essentially converts a MVector into a MVector with the correct size parameter n.

Note that this does no copying; the returned MVector is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given MVector.

fromSized :: MVector n s a -> MVector s a

Convert a MVector into a MVector.

Note that this does no copying; the returned MVector is a reference to the exact same vector in memory as the given one, and any modifications to it are also reflected in the given MVector.

Unbox

class (Vector Vector a, MVector MVector a) => Unbox a

Instances

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)