Linear.Vector

Operations on free vector spaces.

Documentation

class Functor f => Additive f where

A vector is an additive group with additional structure.

Methods

zero :: Num a => f a

The zero vector

(^+^) :: Num a => f a -> f a -> f a

Compute the sum of two vectors

>>> V2 1 2 ^+^ V2 3 4
V2 4 6

(^-^) :: Num a => f a -> f a -> f a

Compute the difference between two vectors

>>> V2 4 5 - V2 3 1
V2 1 4

lerp :: Num a => a -> f a -> f a -> f a

Linearly interpolate between two vectors.

liftU2 :: (a -> a -> a) -> f a -> f a -> f a

Apply a function to merge the 'non-zero' components of two vectors, unioning the rest of the values.

• For a dense vector this is equivalent to liftA2.
• For a sparse vector this is equivalent to unionWith.

liftI2 :: (a -> b -> c) -> f a -> f b -> f c

Apply a function to the components of two vectors.

• For a dense vector this is equivalent to liftA2.
• For a sparse vector this is equivalent to intersectionWith.

Instances

Additive []

Additive Complex

Additive ZipList

Additive Maybe

Additive IntMap

Additive Identity

Additive Vector

Additive V0

Additive V2

Additive V3

Additive V4

Additive Plucker

Additive Quaternion

Additive ((->) b)

Ord k => Additive (Map k)

(Eq k, Hashable k) => Additive (HashMap k)

Dim k n => Additive (V k n)

negated :: (Functor f, Num a) => f a -> f a

Compute the negation of a vector

>>> negated (V2 2 4)
V2 (-2) (-4)

(^*) :: (Functor f, Num a) => f a -> a -> f a

Compute the right scalar product

>>> V2 3 4 ^* 2
V2 6 8

(*^) :: (Functor f, Num a) => a -> f a -> f a

Compute the left scalar product

>>> 2 *^ V2 3 4
V2 6 8

(^/) :: (Functor f, Fractional a) => f a -> a -> f a

Compute division by a scalar on the right.

basis :: (Applicative t, Traversable t, Num a) => [t a]

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

basisFor :: (Traversable t, Enum a, Num a) => t a -> [t a]

Produce a default basis for a vector space from which the argument is drawn.

kronecker :: (Applicative t, Num a, Traversable t) => t a -> t (t a)

Produce a diagonal matrix from a vector.