Size of vector expressed as type-level natural.

Type level zero

Successor of n

Type class for vectors with fixed length. Instance should provide two functions: one to create vector and another for vector deconstruction. They must obey following law:

 inspect v construct = v

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.

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
fromList [1,1]

>>> replicate 2 :: (Double,Double,Double)
(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 [(),()]

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]

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

Unfold vector.

Unit vector along Nth axis. If index is larger than vector dimensions returns zero vector.

Examples:

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

First element of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = mk3 1 2 3 :: Vec3 Int
>>> head x
1

Tail of vector.

Examples:

>>> import Data.Complex
>>> tail (1,2,3) :: Complex Double
2.0 :+ 3.0

Retrieve vector's element at index. Generic implementation is O(n) but more efficient one is used when possible.

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

Analog of sequenceA from Traversable.

Analog of traverse from Traversable.

Left fold over vector

Right fold over vector

Left fold over vector

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

Left fold over vector

Monadic fold over vector.

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

Sum all elements in the vector.

Maximal element of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = mk3 1 2 3 :: Vec3 Int
>>> maximum x
3

Minimal element of vector.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec3)
>>> let x = mk3 1 2 3 :: Vec3 Int
>>> minimum x
1

Conjunction of all elements of a vector.

Disjunction of all elements of a vector.

Determines whether all elements of vector satisfy predicate.

Determines whether any of element of vector satisfy predicate.

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. Will throw error if list is shorter than resulting vector.

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