Types that can be converted to and from our canonical 'Vector d r' type

Class for representing d dimensional vectors.

Specifies that we have an appropriate constraint for the vector implementation

Generate a vector from a given function.

Convert a list of exactly d elements into a vector with dimension d.

>>> vectorFromList [10,2,3] :: Maybe (Vector 3 Int)
Just (Vector3 10 2 3)
>>> vectorFromList [10,2,3,5] :: Maybe (Vector 3 Int)
Nothing
>>> vectorFromList [10,2] :: Maybe (Vector 3 Int)
Nothing

Lens to access te i^t component.

>>> myVec3 ^. component @0
1
>>> myVec3 ^. component @1
2
>>> myVec3 & component @1 %~ (*5)
Vector3 1 10 3
>>> myVec2 & component @1 %~ (*5)
Vector2 10 100

Shorthand for accessing the x-component

>>> Vector3 1 2 3 ^. xComponent
1
>>> Vector2 1 2 & xComponent .~ 10
Vector2 10 2

Shorthand for accessing the y-component

>>> Vector3 1 2 3 ^. yComponent
2
>>> Vector2 1 2 & yComponent .~ 10
Vector2 1 10

Shorthand for accessing the z-component

>>> Vector3 1 2 3 ^. zComponent
3
>>> Vector3 1 2 3 & zComponent .~ 10
Vector3 1 2 10

Shorthand for accessing the w-component

>>> Vector4 1 2 3 4 ^. wComponent
4
>>> Vector4 1 2 3 4 & wComponent .~ 10
Vector4 1 2 3 10

Take a prefix of length i of the vector

>>> prefix myVec3 :: Vector 2 Int
Vector2 1 2

Take a suffix of length i of the vector

>>> suffix @_ @_ @_ @(Vector 2 Int) myVec3
Vector2 2 3

Add an element to the front of the vector

>>> cons 5 myVec2 :: Vector 3 Int
Vector3 5 10 20

Add an element to the back of the vector.

>>> snoc myVec2 5 :: Vector 3 Int
Vector3 10 20 5

Extract the first element from the vector

>>> uncons myVec3 :: (Int, Vector 2 Int)
(1,Vector2 2 3)

Extract the last element from the vector

>>> unsnoc myVec3  :: (Vector 2 Int, Int)
(Vector2 1 2,3)

Class that supports additive opreations on vectors

zero vector

Apply a function to the components of two vectors.

Linearly interpolate between the two vectors

add two vectors

subtract vectors

negate v

left scalar multiplication

right scalar multiplication

scalar division

sum a collection of vectors.

Produce a default basis for a vector space. If the dimensionality of the vector space is not statically known, see basisFor.

unit vector

"zip through the two vectors", folding over the result.

as an example, we can implement the dot product of two vectors u and v using:

>>> let myDot u v = getSum $ foldMapZip (\x x' -> Sum $ x * x') u v
>>> myDot (Vector3 1 2 3) (Vector3 10 20 30)
140

The equivalent class of Linear.Metric

Note that we do not define a distance itself, and that norm and signorm have a Radical constraint rather than Floating.