Portability | portable |
---|---|

Stability | provisional |

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

Safe Haskell | Trustworthy |

Operations on free vector spaces.

- class Functor f => Additive f where
- 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 :: (Applicative t, Traversable t, Num a) => [t a]
- basisFor :: (Traversable t, Enum a, Num a) => t a -> [t a]
- kronecker :: (Applicative t, Num a, Traversable t) => t a -> t (t a)
- outer :: (Functor f, Functor g, Num a) => f a -> g a -> f (g a)

# Documentation

class Functor f => Additive f whereSource

A vector is an additive group with additional structure.

The zero vector

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

Compute the sum of two vectors

`>>>`

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

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

Compute the difference between two vectors

`>>>`

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

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

Linearly interpolate between two vectors.

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

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 cSource

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`

.

Additive [] | |

Additive Complex | |

Additive ZipList | |

Additive Maybe | |

Additive Identity | |

Additive IntMap | |

Additive Vector | |

Additive V0 | |

Additive V1 | |

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 n => Additive (V n) | |

Additive f => Additive (Point f) |

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

Compute the negation of a vector

`>>>`

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

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

Compute the right scalar product

`>>>`

V2 6 8`V2 3 4 ^* 2`

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

Compute the left scalar product

`>>>`

V2 6 8`2 *^ V2 3 4`

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

Compute division by a scalar on the right.

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

Sum over multiple vectors

`>>>`

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

basis :: (Applicative 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, Enum a, Num a) => t a -> [t a]Source

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)Source

Produce a diagonal matrix from a vector.