Stability | experimental |
---|---|

Maintainer | conal@conal.net |

Linear maps

- type :-* u v = MSum (Basis u :->: v)
- linear :: (HasBasis u, HasTrie (Basis u)) => (u -> v) -> u :-* v
- lapply :: (VectorSpace v, Scalar u ~ Scalar v, HasBasis u, HasTrie (Basis u)) => (u :-* v) -> u -> v
- atBasis :: (HasTrie a, AdditiveGroup b) => MSum (a :->: b) -> a -> b
- idL :: (HasBasis u, HasTrie (Basis u)) => u :-* u
- (*.*) :: (HasBasis u, HasTrie (Basis u), HasBasis v, HasTrie (Basis v), VectorSpace w, Scalar v ~ Scalar w) => (v :-* w) -> (u :-* v) -> u :-* w
- liftMS :: AdditiveGroup a => (a -> b) -> MSum a -> MSum b
- liftMS2 :: (AdditiveGroup a, AdditiveGroup b) => (a -> b -> c) -> MSum a -> MSum b -> MSum c
- liftMS3 :: (AdditiveGroup a, AdditiveGroup b, AdditiveGroup c) => (a -> b -> c -> d) -> MSum a -> MSum b -> MSum c -> MSum d
- liftL :: (Functor f, AdditiveGroup (f a)) => (a -> b) -> MSum (f a) -> MSum (f b)
- liftL2 :: (Applicative f, AdditiveGroup (f a), AdditiveGroup (f b)) => (a -> b -> c) -> MSum (f a) -> MSum (f b) -> MSum (f c)
- liftL3 :: (Applicative f, AdditiveGroup (f a), AdditiveGroup (f b), AdditiveGroup (f c)) => (a -> b -> c -> d) -> MSum (f a) -> MSum (f b) -> MSum (f c) -> MSum (f d)

# Documentation

type :-* u v = MSum (Basis u :->: v)Source

Linear map, represented as an optional memo-trie from basis to
values, where `Nothing`

means the zero map (an optimization).

linear :: (HasBasis u, HasTrie (Basis u)) => (u -> v) -> u :-* vSource

Function (assumed linear) as linear map.

lapply :: (VectorSpace v, Scalar u ~ Scalar v, HasBasis u, HasTrie (Basis u)) => (u :-* v) -> u -> vSource

Apply a linear map to a vector.

atBasis :: (HasTrie a, AdditiveGroup b) => MSum (a :->: b) -> a -> bSource

Evaluate a linear map on a basis element. I've loosened the type to
work around a typing problem in `derivAtBasis`

.
atBasis :: (AdditiveGroup v, HasTrie (Basis u)) =>
(u :-* v) -> Basis u -> v

(*.*) :: (HasBasis u, HasTrie (Basis u), HasBasis v, HasTrie (Basis v), VectorSpace w, Scalar v ~ Scalar w) => (v :-* w) -> (u :-* v) -> u :-* wSource

Compose linear maps

liftMS :: AdditiveGroup a => (a -> b) -> MSum a -> MSum bSource

liftMS2 :: (AdditiveGroup a, AdditiveGroup b) => (a -> b -> c) -> MSum a -> MSum b -> MSum cSource

liftMS3 :: (AdditiveGroup a, AdditiveGroup b, AdditiveGroup c) => (a -> b -> c -> d) -> MSum a -> MSum b -> MSum c -> MSum dSource

liftL :: (Functor f, AdditiveGroup (f a)) => (a -> b) -> MSum (f a) -> MSum (f b)Source

Apply a linear function to each element of a linear map.
`liftL f l == linear f *.* l`

, but works more efficiently.

liftL2 :: (Applicative f, AdditiveGroup (f a), AdditiveGroup (f b)) => (a -> b -> c) -> MSum (f a) -> MSum (f b) -> MSum (f c)Source

Apply a linear binary function (not to be confused with a bilinear function) to each element of a linear map.

liftL3 :: (Applicative f, AdditiveGroup (f a), AdditiveGroup (f b), AdditiveGroup (f c)) => (a -> b -> c -> d) -> MSum (f a) -> MSum (f b) -> MSum (f c) -> MSum (f d)Source

Apply a linear ternary function (not to be confused with a trilinear function) to each element of a linear map.