Data.Vector.Fixed

Generic API for vectors with fixed length.

For encoding of vector size library uses Peano naturals defined in the library. At come point in the future it would make sense to switch to new GHC type level numerals.

Vector type class

Vector size

type family Dim v

Size of vector expressed as type-level natural.

data Z

Type level zero

Instances

Arity Z

data S n

Successor of n

Instances

Arity n => Arity (S n)

Synonyms for small numerals

type N1 = S Z

type N2 = S N1

type N3 = S N2

type N4 = S N3

type N5 = S N4

type N6 = S N5

Type class

class Arity (Dim v) => Vector v a where

Type class for vectors with fixed length.

Methods

construct :: Fun (Dim v) a (v a)

N-ary function for creation of vectors.

inspect :: v a -> Fun (Dim v) a b -> b

Deconstruction of vector.

Instances

(Arity (Dim Complex), RealFloat a) => Vector Complex a

(Arity (Dim (VecList n)), Arity n) => Vector (VecList n) a

(Arity (Dim (Vec n)), Arity n) => Vector (Vec n) a

(Arity (Dim (Vec n)), Arity n, Prim a) => Vector (Vec n) a

(Arity (Dim (Vec n)), Unbox n a) => Vector (Vec n) a

(Arity (Dim (Vec n)), Arity n, Storable a) => Vector (Vec n) a

class Arity n

Type class for handling n-ary functions.

Instances

Arity Z

Arity n => Arity (S n)

newtype Fun n a b

Newtype wrapper which is used to make Fn injective.

Constructors

Fun (Fn n a b)

Instances

Arity n => Functor (Fun n a)

length :: forall v a. Arity (Dim v) => v a -> Int

Length of vector. Function doesn't evaluate its argument.

convertContinuation :: forall n a r. Arity n => (forall v. (Dim v ~ n, Vector v a) => v a -> r) -> Fun n a r

Change continuation type.

Generic functions

Literal vectors

data New n v a

Newtype wrapper for partially constructed vectors. n is number of uninitialized elements.

Example of use:

>>> vec $ con |> 1 |> 3 :: Complex Double
> 1 :+ 3

vec :: New Z v a -> v a

Convert fully applied constructor to vector

con :: Vector v a => New (Dim v) v a

Seed constructor

(|>) :: New (S n) v a -> a -> New n v a

Apply another element to vector

Construction

replicate :: Vector v a => a -> v a

Replicate value n times.

replicateM :: (Vector v a, Monad m) => m a -> m (v a)

Execute monadic action for every element of vector.

basis :: forall v a. (Vector v a, Num a) => Int -> v a

Unit vector along Nth axis,

generate :: forall v a. Vector v a => (Int -> a) -> v a

Generate vector.

generateM :: forall m v a. (Monad m, Vector v a) => (Int -> m a) -> m (v a)

Monadic generation

Element access

head :: (Vector v a, Dim v ~ S n) => v a -> a

First element of vector.

tail :: (Vector v a, Vector w a, Dim v ~ S (Dim w)) => v a -> w a

Tail of vector.

tailWith

Arguments

:: (Arity n, Vector v a, Dim v ~ S n)

=> (forall w. (Vector w a, Dim w ~ n) => w a -> r)

Continuation

-> v a

Vector

-> r

Continuation variant of tail. It should be used when tail of vector is immediately deconstructed with polymorphic function. For example sum . tail will fail with unhelpful error message because return value of tail is polymorphic. But tailWith sum works just fine.

(!) :: Vector v a => v a -> Int -> a

O(n) Get vector's element at index i.

Map

map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b

Map over vector

mapM :: (Vector v a, Vector v b, Monad m) => (a -> m b) -> v a -> m (v b)

Monadic map over vector.

mapM_ :: (Vector v a, Monad m) => (a -> m b) -> v a -> m ()

Apply monadic action to each element of vector and ignore result.

Folding

foldl :: Vector v a => (b -> a -> b) -> b -> v a -> b

Left fold over vector

foldl1 :: (Vector v a, Dim v ~ S n) => (a -> a -> a) -> v a -> a

Left fold over vector

foldM :: (Vector v a, Monad m) => (b -> a -> m b) -> b -> v a -> m b

Monadic fold over vector.

sum :: (Vector v a, Num a) => v a -> a

Sum all elements in the vector

maximum :: (Vector v a, Dim v ~ S n, Ord a) => v a -> a

Maximum element of vector

minimum :: (Vector v a, Dim v ~ S n, Ord a) => v a -> a

Minimum element of vector

Zips

zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> v a -> v b -> v c

Zip two vector together.

izipWith :: (Vector v a, Vector v b, Vector v c) => (Int -> a -> b -> c) -> v a -> v b -> v c

Zip two vector together.

Conversion

convert :: (Vector v a, Vector w a, Dim v ~ Dim w) => v a -> w a

Convert between different vector types

toList :: Vector v a => v a -> [a]

Convert vector to the list

fromList :: forall v a. Vector v a => [a] -> v a

Create vector form list. List must have same length as the vector.

Special types

newtype VecList n a

Vector based on the lists. Not very useful by itself but is necessary for implementation.

Constructors

VecList [a]

Instances

(Arity (Dim (VecList n)), Arity n) => Vector (VecList n) a

Eq a => Eq (VecList n a)

Show a => Show (VecList n a)