Portability | GHC only |
---|---|

Stability | experimental |

Maintainer | ekmett@gmail.com |

Safe Haskell | None |

This module provides reverse-mode Automatic Differentiation implementation using linear time topological sorting after the fact.

For this form of reverse-mode AD we use `StableName`

to recover
sharing information from the tape to avoid combinatorial explosion, and thus
run asymptotically faster than it could without such sharing information, but the use
of side-effects contained herein is benign.

- newtype Kahn a = Kahn (Tape a (Kahn a))
- data Tape a t
- partials :: forall a. Num a => AD Kahn a -> [(Int, a)]
- partialArray :: Num a => (Int, Int) -> AD Kahn a -> Array Int a
- partialMap :: Num a => AD Kahn a -> IntMap a
- derivative :: Num a => AD Kahn a -> a
- derivative' :: Num a => AD Kahn a -> (a, a)
- vgrad :: Grad i o o' a => i -> o
- vgrad' :: Grad i o o' a => i -> o'
- class Num a => Grad i o o' a | i -> a o o', o -> a i o', o' -> a i o where

# Documentation

`Kahn`

is a `Mode`

using reverse-mode automatic differentiation that provides fast `diffFU`

, `diff2FU`

, `grad`

, `grad2`

and a fast `jacobian`

when you have a significantly smaller number of outputs than inputs.

A `Tape`

records the information needed back propagate from the output to each input during reverse `Mode`

AD.

partials :: forall a. Num a => AD Kahn a -> [(Int, a)]Source

This returns a list of contributions to the partials.
The variable ids returned in the list are likely *not* unique!

derivative :: Num a => AD Kahn a -> aSource

derivative' :: Num a => AD Kahn a -> (a, a)Source