vector-0.10.0.1: Efficient Arrays

Portability | non-portable
Stability | experimental
Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au>
Safe Haskell | None

Data.Vector.Unboxed.Mutable

Contents

- Mutable vectors of primitive types
- Accessors
  - Length information
  - Extracting subvectors
  - Overlapping
- Construction
  - Initialisation
  - Growing
  - Restricting memory usage
- Zipping and unzipping
- Accessing individual elements
- Modifying vectors
  - Filling and copying

Description

Mutable adaptive unboxed vectors

Synopsis

- 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 ()
- 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 ()
- unsafeSwap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()
- 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

data family MVector s a Source

type IOVector = MVector RealWorld Source

type STVector s = MVector sSource

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

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 () |
(RealFloat a, 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

length :: Unbox a => MVector s a -> Int Source

Length of the mutable vector.

null :: Unbox a => MVector s a -> Bool Source

Check whether the vector is empty

## Extracting subvectors

slice :: Unbox a => Int -> Int -> MVector s a -> MVector s aSource

Yield a part of the mutable vector without copying it.

init :: Unbox a => MVector s a -> MVector s aSource

tail :: Unbox a => MVector s a -> MVector s aSource

take :: Unbox a => Int -> MVector s a -> MVector s aSource

drop :: Unbox a => Int -> MVector s a -> MVector s aSource

splitAt :: Unbox a => Int -> MVector s a -> (MVector s a, MVector s a)Source

unsafeSlice Source

Arguments

:: Unbox a |
=> Int | starting index
-> Int | length of the slice
-> MVector s a |
-> MVector s a |

Yield a part of the mutable vector without copying it. No bounds checks are performed.

unsafeInit :: Unbox a => MVector s a -> MVector s aSource

unsafeTail :: Unbox a => MVector s a -> MVector s aSource

unsafeTake :: Unbox a => Int -> MVector s a -> MVector s aSource

unsafeDrop :: Unbox a => Int -> MVector s a -> MVector s aSource

## Overlapping

overlaps :: Unbox a => MVector s a -> MVector s a -> Bool Source

# Construction

## Initialisation

new :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)Source

Create a mutable vector of the given length.

unsafeNew :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)Source

Create a mutable vector of the given length. The length is not checked.

replicate :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)Source

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)Source

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)Source

Create a copy of a mutable vector.

## Growing

grow :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)Source

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)Source

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 ()Source

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

zip :: (Unbox a, Unbox b) => MVector s a -> MVector s b -> MVector s (a, b)Source

O(1) Zip 2 vectors

zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a -> MVector s b -> MVector s c -> MVector s (a, b, c)Source

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)Source

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)Source

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)Source

O(1) Zip 6 vectors

unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a, MVector s b)Source

O(1) Unzip 2 vectors

unzip3 :: (Unbox a, Unbox b, Unbox c) => MVector s (a, b, c) -> (MVector s a, MVector s b, MVector s c)Source

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)Source

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)Source

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)Source

O(1) Unzip 6 vectors

# Accessing individual elements

read :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m aSource

Yield the element at the given position.

write :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()Source

Replace the element at the given position.

swap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()Source

Swap the elements at the given positions.

unsafeRead :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m aSource

Yield the element at the given position. No bounds checks are performed.

unsafeWrite :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()Source

Replace the element at the given position. No bounds checks are performed.

unsafeSwap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()Source

Swap the elements at the given positions. No bounds checks are performed.

# Modifying vectors

## Filling and copying

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

Set all elements of the vector to the given value.

copy :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()Source

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 ()Source

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.

unsafeCopy Source

Arguments

:: (PrimMonad m, Unbox a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

Copy a vector. The two vectors must have the same length and may not overlap. This is not checked.

unsafeMove Source

Arguments

:: (PrimMonad m, Unbox a) |
=> MVector (PrimState m) a | target
-> MVector (PrimState m) a | source
-> m () |

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.