Modulevector-space-0.19Haskell2010

Data.Maclaurin

Infinite derivative towers via linear maps, using the Maclaurin representation. See blog posts http://conal.net/blog/tag/derivative/.

2 types
18 values

Packagevector-space-0.19
Exports20
LanguageHaskell2010
LicenceBSD-3-Clause
SourceMaclaurin.hs

datadata (:>) a b

Tower of derivatives.

Constructors

Dinfixr 9
- powVal :: b
- derivative :: a :-* (a :> b)

Instances19Eq, Floating, Fractional, Num, Ord, Show, …

(VectorSpace s, HasBasis s, HasTrie (Basis s), Basis s ~ ()) => HasNormal (Two (One s :> s))Defined in vector-space-0.19 · Data.Cross
(VectorSpace s, HasBasis s, HasTrie (Basis s), HasNormal (Two s :> Three s)) => HasNormal (Three (Two s :> s))Defined in vector-space-0.19 · Data.Cross
Eq (a :> b)Defined in vector-space-0.19 · Data.Maclaurin
(HasBasis a, s ~ Scalar a, HasTrie (Basis a), Floating s, VectorSpace s, Scalar s ~ s) => Floating (a :> s)Defined in vector-space-0.19 · Data.Maclaurin
(HasBasis a, s ~ Scalar a, HasTrie (Basis a), Fractional s, VectorSpace s, Scalar s ~ s) => Fractional (a :> s)Defined in vector-space-0.19 · Data.Maclaurin
(HasBasis a, s ~ Scalar a, HasTrie (Basis a), Num s, VectorSpace s, Scalar s ~ s) => Num (a :> s)Defined in vector-space-0.19 · Data.Maclaurin
(AdditiveGroup b, HasBasis a, HasTrie (Basis a), OrdB b, IfB b, Ord b) => Ord (a :> b)Defined in vector-space-0.19 · Data.Maclaurin
Show b => Show (a :> b)Defined in vector-space-0.19 · Data.Maclaurin
(AdditiveGroup v, HasBasis u, HasTrie (Basis u), IfB v) => IfB (u :> v)Defined in vector-space-0.19 · Data.Maclaurin
OrdB v => OrdB (u :> v)Defined in vector-space-0.19 · Data.Maclaurin
(HasBasis a, HasTrie (Basis a), AdditiveGroup u) => AdditiveGroup (a :> u)Defined in vector-space-0.19 · Data.Maclaurin
(InnerSpace u, s ~ Scalar u, AdditiveGroup s, HasBasis a, HasTrie (Basis a)) => InnerSpace (a :> u)Defined in vector-space-0.19 · Data.Maclaurin
(HasBasis a, HasTrie (Basis a), VectorSpace u) => VectorSpace (a :> u)Defined in vector-space-0.19 · Data.Maclaurin
(HasTrie (Basis a), HasCross2 v) => HasCross2 (a :> v)Defined in vector-space-0.19 · Data.Cross
(HasBasis a, HasTrie (Basis a), VectorSpace v, HasCross3 v) => HasCross3 (a :> v)Defined in vector-space-0.19 · Data.Cross
(Num s, HasTrie (Basis (s, s)), HasBasis s, Basis s ~ ()) => HasNormal (Two s :> Three s)Defined in vector-space-0.19 · Data.Cross
(HasBasis s, HasTrie (Basis s), Basis s ~ ()) => HasNormal (One s :> Two s)Defined in vector-space-0.19 · Data.Cross
type BooleanOf (a :> b) = BooleanOf bDefined in vector-space-0.19 · Data.Maclaurin
type Scalar (a :> u) = a :> Scalar uDefined in vector-space-0.19 · Data.Maclaurin

valuepowVal :: a :> b -> b

valuederivative :: a :> b -> a :-* (a :> b)

valuederivAtBasis

:: (HasTrie (Basis a), HasBasis a, AdditiveGroup b)
=> a :> b
-> Basis a
-> a :> b

Sample the derivative at a basis element. Optimized for partial application to save work for non-scalar derivatives.

typetype (:~>) a b = a -> a :> b

Infinitely differentiable functions

valuepureD :: (AdditiveGroup b, HasBasis a, HasTrie (Basis a)) => b -> a :> b

Constant derivative tower.

valuefmapD :: HasTrie (Basis a) => (b -> c) -> a :> b -> a :> c

Map a linear function over a derivative tower.

value(<$>>) :: HasTrie (Basis a) => (b -> c) -> a :> b -> a :> c

Map a linear function over a derivative tower.

valueliftD2

:: (HasBasis a, HasTrie (Basis a), AdditiveGroup b, AdditiveGroup c)
=> b -> c -> d
-> a :> b
-> a :> c
-> a :> d

Apply a linear binary function over derivative towers.

valueliftD3

:: (HasBasis a, HasTrie (Basis a), AdditiveGroup b, AdditiveGroup c, AdditiveGroup d)
=> b -> c -> d -> e
-> a :> b
-> a :> c
-> a :> d
-> a :> e

Apply a linear ternary function over derivative towers.

valueidD :: (VectorSpace u, HasBasis u, HasTrie (Basis u)) => u :~> u

Differentiable identity function. Sometimes called "the derivation variable" or similar, but it's not really a variable.

valuefstD :: (HasBasis a, HasTrie (Basis a), HasBasis b, HasTrie (Basis b), Scalar a ~ Scalar b) => (a, b) :~> a

Differentiable version of fst

valuesndD :: (HasBasis a, HasTrie (Basis a), HasBasis b, HasTrie (Basis b), Scalar a ~ Scalar b) => (a, b) :~> b

Differentiable version of snd

valuelinearD

:: (HasBasis u, HasTrie (Basis u), AdditiveGroup v)
=> u -> v
-> u :~> v

Every linear function has a constant derivative equal to the function itself (as a linear map).

valuedistrib

:: (HasBasis a, HasTrie (Basis a), AdditiveGroup u)
=> b -> c -> u
-> a :> b
-> a :> c
-> a :> u

Derivative tower for applying a binary function that distributes over addition, such as multiplication. A bit weaker assumption than bilinearity. Is bilinearity necessary for correctness here?

value(>-<)

:: (HasBasis a, HasTrie (Basis a), VectorSpace u)
=> u -> u
-> a :> u -> a :> Scalar u
-> a :> u
-> a :> u

Specialized chain rule. See also (\@.)

Misc

4 declarations

valuepairD

:: (HasBasis a, HasTrie (Basis a), VectorSpace b, VectorSpace c)
=> (a :> b, a :> c)
-> a :> (b, c)

valueunpairD :: HasTrie (Basis a) => a :> (b, c) -> (a :> b, a :> c)

valuetripleD

:: (HasBasis a, HasTrie (Basis a), VectorSpace b, VectorSpace c, VectorSpace d)
=> (a :> b, a :> c, a :> d)
-> a :> (b, c, d)

valueuntripleD :: HasTrie (Basis a) => a :> (b, c, d) -> (a :> b, a :> c, a :> d)