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 Maybe

Additive Complex

Additive ZipList

Additive Identity

Additive IntMap

Additive Vector

Additive V0

Additive V1

Additive V2

Additive V3

Additive V4

Additive Plucker

Additive Quaternion

Additive ((->) b)

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

Ord k => Additive (Map k)

Dim n => Additive (V n)

Additive f => Additive (Point f)

newtype E t

Basis element

Constructors

E

Fields

el :: forall x. Lens' (t x) x

Instances

(Num r, TrivialConjugate r) => Coalgebra r (E Quaternion)

Num r => Coalgebra r (E Complex)

Num r => Coalgebra r (E V4)

Num r => Coalgebra r (E V3)

Num r => Coalgebra r (E V2)

Num r => Coalgebra r (E V1)

Num r => Coalgebra r (E V0)

(Num r, TrivialConjugate r) => Algebra r (E Quaternion)

Num r => Algebra r (E Complex)

Num r => Algebra r (E V1)

Num r => Algebra r (E V0)

FunctorWithIndex (E V0) V0

FunctorWithIndex (E V1) V1

FunctorWithIndex (E V2) V2

FunctorWithIndex (E V3) V3

FunctorWithIndex (E V4) V4

FunctorWithIndex (E Plucker) Plucker

FunctorWithIndex (E Quaternion) Quaternion

FoldableWithIndex (E V0) V0

FoldableWithIndex (E V1) V1

FoldableWithIndex (E V2) V2

FoldableWithIndex (E V3) V3

FoldableWithIndex (E V4) V4

FoldableWithIndex (E Plucker) Plucker

FoldableWithIndex (E Quaternion) Quaternion

TraversableWithIndex (E V0) V0

TraversableWithIndex (E V1) V1

TraversableWithIndex (E V2) V2

TraversableWithIndex (E V3) V3

TraversableWithIndex (E V4) V4

TraversableWithIndex (E Plucker) Plucker

TraversableWithIndex (E Quaternion) Quaternion

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.

sumV :: (Foldable f, Additive v, Num a) => f (v a) -> v a

Sum over multiple vectors

>>> sumV [V2 1 1, V2 3 4]
V2 4 5

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, Num a) => t b -> [t a]

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

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

Produce a diagonal matrix from a vector.

outer :: (Functor f, Functor g, Num a) => f a -> g a -> f (g a)

Outer (tensor) product of two vectors

unit :: (Applicative t, Num a) => Lens' (t a) a -> t a

Create a unit vector.

>>> unit _x :: V2 Int
V2 1 0