Safe Haskell | Safe-Inferred |
---|

The `Dif`

module contains a data type, `Dif`

, that allows for
automatic forward differentiation.

All the ideas are from Jerzy Karczmarczuk's work, see http://users.info.unicaen.fr/~karczma/arpap/diffalg.pdf.

A simple example, if we define

foo x = x*x

then the function

foo' = deriv foo

will behave as if its body was 2*x.

# Documentation

The `Dif`

type is the type of differentiable numbers.
It's an instance of all the usual numeric classes.
The computed derivative of a function is is correct
except where the function is discontinuous, at these points
the derivative should be a Dirac pulse, but it isn't.

The `Dif`

numbers are printed with a trailing ~~ to
indicate that there is a "tail" of derivatives.

Eq a => Eq (Dif a) | |

(Fractional (Dif a), Floating a, Eq a) => Floating (Dif a) | |

(Num (Dif a), Fractional a, Eq a) => Fractional (Dif a) | |

(Num a, Eq a) => Num (Dif a) | |

(Eq (Dif a), Ord a) => Ord (Dif a) | |

Read a => Read (Dif a) | |

(Num (Dif a), Ord (Dif a), Real a) => Real (Dif a) | |

(RealFrac (Dif a), Floating (Dif a), RealFloat a) => RealFloat (Dif a) | |

(Real (Dif a), Fractional (Dif a), RealFrac a) => RealFrac (Dif a) | |

Show a => Show (Dif a) |

dVar :: (Num a, Eq a) => a -> Dif aSource

The `dVar`

function turns a number into a variable
number. This is the number with with respect to which
the derivaticve is computed.