Copyright | (C) 2012-2015 Edward Kmett |
---|---|

License | BSD-style (see the file LICENSE) |

Maintainer | Edward Kmett <ekmett@gmail.com> |

Stability | provisional |

Portability | portable |

Safe Haskell | Trustworthy |

Language | Haskell2010 |

Operations on free vector spaces.

## Synopsis

- class Functor f => Additive f where
- newtype E t = E {}
- negated :: (Functor f, Num a) => f a -> f a
- (^*) :: (Functor f, Num a) => f a -> a -> f a
- (*^) :: (Functor f, Num a) => a -> f a -> f a
- (^/) :: (Functor f, Fractional a) => f a -> a -> f a
- sumV :: (Foldable f, Additive v, Num a) => f (v a) -> v a
- basis :: (Additive t, Traversable t, Num a) => [t a]
- basisFor :: (Traversable t, Num a) => t b -> [t a]
- scaled :: (Traversable t, Num a) => t a -> t (t a)
- outer :: (Functor f, Functor g, Num a) => f a -> g a -> f (g a)
- unit :: (Additive t, Num a) => ASetter' (t a) a -> t a

# Documentation

class Functor f => Additive f where Source #

A vector is an additive group with additional structure.

Nothing

The zero vector

zero :: (GAdditive (Rep1 f), Generic1 f, Num a) => f a Source #

The zero vector

(^+^) :: Num a => f a -> f a -> f a infixl 6 Source #

Compute the sum of two vectors

`>>>`

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

(^-^) :: Num a => f a -> f a -> f a infixl 6 Source #

Compute the difference between two vectors

`>>>`

V2 1 4`V2 4 5 ^-^ V2 3 1`

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

Linearly interpolate between two vectors.

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

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

liftU2 :: Applicative f => (a -> a -> a) -> f a -> f a -> f a Source #

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

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

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`

.

liftI2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c Source #

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

Basis element

## Instances

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

Compute the negation of a vector

`>>>`

V2 (-2) (-4)`negated (V2 2 4)`

(^*) :: (Functor f, Num a) => f a -> a -> f a infixl 7 Source #

Compute the right scalar product

`>>>`

V2 6 8`V2 3 4 ^* 2`

(*^) :: (Functor f, Num a) => a -> f a -> f a infixl 7 Source #

Compute the left scalar product

`>>>`

V2 6 8`2 *^ V2 3 4`

(^/) :: (Functor f, Fractional a) => f a -> a -> f a infixl 7 Source #

Compute division by a scalar on the right.

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

Sum over multiple vectors

`>>>`

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

basis :: (Additive t, Traversable t, Num a) => [t a] Source #

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] Source #

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

scaled :: (Traversable t, Num a) => t a -> t (t a) Source #

Produce a diagonal (scale) matrix from a vector.

`>>>`

V2 (V2 2 0) (V2 0 3)`scaled (V2 2 3)`