Size of vector expressed as type-level natural.

Type level zero

Successor of n

Type class for vectors with fixed length.

Vector parametrized by length. In ideal world it should be:

 forall n. (Arity n, Vector (v n) a, Dim (v n) ~ n) => VectorN v a

Alas polymorphic constraints aren't allowed in haskell.

Type class for handling n-ary functions.

Newtype wrapper which is used to make Fn injective.

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

Change continuation type.

Generic function for construction of arbitrary vectors. It represents partially constructed vector where n is number of uninitialized elements, v is type of vector and a element type.

Uninitialized vector could be obtained from con and vector elements could be added from left to right using |> operator. Finally it could be converted to vector using vec function.

Construction of complex number which could be seen as 2-element vector:

>>> import Data.Complex
>>> vec $ con |> 1 |> 3 :: Complex Double
1.0 :+ 3.0

Convert fully applied constructor to vector

Seed constructor

Apply another element to vector

Replicate value n times.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec2)
>>> replicate 1 :: Vec2 Int     -- Two element vector
fromList [1,1]

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> replicate 2 :: Vec3 Double  -- Three element vector
fromList [2.0,2.0,2.0]

>>> import Data.Vector.Fixed.Boxed (Vec)
>>> replicate "foo" :: Vec N5 String
fromList ["foo","foo","foo","foo","foo"]

Execute monadic action for every element of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec2,Vec3)
>>> replicateM (Just 3) :: Maybe (Vec3 Int)
Just fromList [3,3,3]
>>> replicateM (putStrLn "Hi!") :: IO (Vec2 ())
Hi!
Hi!
fromList [(),()]

Unit vector along Nth axis,

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> basis 0 :: Vec3 Int
fromList [1,0,0]
>>> basis 1 :: Vec3 Int
fromList [0,1,0]
>>> basis 2 :: Vec3 Int
fromList [0,0,1]

Generate vector from function which maps element's index to its value.

Examples:

>>> import Data.Vector.Fixed.Unboxed (Vec)
>>> generate (^2) :: Vec N4 Int
fromList [0,1,4,9]

Monadic generation

First element of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = vec $ con |> 1 |> 2 |> 3 :: Vec3 Int
>>> head x
1

Tail of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec2, Vec3)
>>> let x = vec $ con |> 1 |> 2 |> 3 :: Vec3 Int
>>> tail x :: Vec2 Int
fromList [2,3]

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.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = vec $ con |> 1 |> 2 |> 3 :: Vec3 Int
>>> tailWith sum x
5

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

Test two vectors for equality.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec2)
>>> let v0 = basis 0 :: Vec2 Int
>>> let v1 = basis 1 :: Vec2 Int
>>> v0 `eq` v0
True
>>> v0 `eq` v1
False

Map over vector

Monadic map over vector.

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

Apply function to every element of the vector and its index.

Apply monadic function to every element of the vector and its index.

Apply monadic function to every element of the vector and its index and discard result.

Evaluate every action in the vector from left to right.

Evaluate every action in the vector from left to right and ignore result

Left fold over vector

Left fold over vector

Monadic fold over vector.

Left fold over vector. Function is applied to each element and its index.

Left monadic fold over vector. Function is applied to each element and its index.

Sum all elements in the vector

Maximum element of vector

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = vec $ con |> 1 |> 2 |> 3 :: Vec3 Int
>>> maximum x
3

Minimum element of vector

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = vec $ con |> 1 |> 2 |> 3 :: Vec3 Int
>>> minimum x
1

Zip two vector together using function.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let b0 = basis 0 :: Vec3 Int
>>> let b1 = basis 1 :: Vec3 Int
>>> let b2 = basis 2 :: Vec3 Int
>>> let vplus x y = zipWith (+) x y
>>> vplus b0 b1
fromList [1,1,0]
>>> vplus b0 b2
fromList [1,0,1]
>>> vplus b1 b2
fromList [0,1,1]

Zip two vector together using monadic function.

Zip two vector together using function which takes element index as well.

Zip two vector together using monadic function which takes element index as well..

Convert between different vector types

Convert vector to the list

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

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