Copyright	(c) Edward Kmett 2010-2014
License	BSD3
Maintainer	ekmett@gmail.com
Stability	experimental
Portability	GHC only
Safe Haskell	None
Language	Haskell2010

Numeric.AD.Mode.Forward

Contents

Gradient
Jacobian
Transposed Jacobian
Hessian Product
Derivatives
Directional Derivatives

Description

Forward mode automatic differentiation

Synopsis

Documentation

data AD s a Source

Instances

Bounded a => Bounded (AD s a)
Enum a => Enum (AD s a)
Eq a => Eq (AD s a)
Floating a => Floating (AD s a)
Fractional a => Fractional (AD s a)
Num a => Num (AD s a)
Ord a => Ord (AD s a)
Read a => Read (AD s a)
Real a => Real (AD s a)
RealFloat a => RealFloat (AD s a)
RealFrac a => RealFrac (AD s a)
Show a => Show (AD s a)
Erf a => Erf (AD s a)
InvErf a => InvErf (AD s a)
Mode a => Mode (AD s a)
Typeable (* -> * -> *) AD
type Scalar (AD s a) = Scalar a

data Forward a Source

Forward mode AD

Instances

(Num a, Bounded a) => Bounded (Forward a)
(Num a, Enum a) => Enum (Forward a)
(Num a, Eq a) => Eq (Forward a)
Floating a => Floating (Forward a)
Fractional a => Fractional (Forward a)
Data a => Data (Forward a)
Num a => Num (Forward a)
(Num a, Ord a) => Ord (Forward a)
Real a => Real (Forward a)
RealFloat a => RealFloat (Forward a)
RealFrac a => RealFrac (Forward a)
Show a => Show (Forward a)
Erf a => Erf (Forward a)
InvErf a => InvErf (Forward a)
Num a => Mode (Forward a)
Num a => Jacobian (Forward a)
Typeable (* -> *) Forward
type Scalar (Forward a) = a
type D (Forward a) = Id a

auto :: Mode t => Scalar t -> t Source

Embed a constant

Gradient

grad :: (Traversable f, Num a) => (forall s. f (AD s (Forward a)) -> AD s (Forward a)) -> f a -> f a Source

Compute the gradient of a function using forward mode AD.

Note, this performs O(n) worse than grad for n inputs, in exchange for better space utilization.

grad' :: (Traversable f, Num a) => (forall s. f (AD s (Forward a)) -> AD s (Forward a)) -> f a -> (a, f a) Source

Compute the gradient and answer to a function using forward mode AD.

Note, this performs O(n) worse than grad' for n inputs, in exchange for better space utilization.

gradWith :: (Traversable f, Num a) => (a -> a -> b) -> (forall s. f (AD s (Forward a)) -> AD s (Forward a)) -> f a -> f b Source

Compute the gradient of a function using forward mode AD and combine the result with the input using a user-specified function.

Note, this performs O(n) worse than gradWith for n inputs, in exchange for better space utilization.

gradWith' :: (Traversable f, Num a) => (a -> a -> b) -> (forall s. f (AD s (Forward a)) -> AD s (Forward a)) -> f a -> (a, f b) Source

Compute the gradient of a function using forward mode AD and the answer, and combine the result with the input using a user-specified function.

Note, this performs O(n) worse than gradWith' for n inputs, in exchange for better space utilization.

>>> gradWith' (,) sum [0..4]
(10,[(0,1),(1,1),(2,1),(3,1),(4,1)])

Jacobian

jacobian :: (Traversable f, Traversable g, Num a) => (forall s. f (AD s (Forward a)) -> g (AD s (Forward a))) -> f a -> g (f a) Source

Compute the Jacobian using Forward mode AD. This must transpose the result, so jacobianT is faster and allows more result types.

>>> jacobian (\[x,y] -> [y,x,x+y,x*y,exp x * sin y]) [pi,1]
[[0.0,1.0],[1.0,0.0],[1.0,1.0],[1.0,3.141592653589793],[19.472221418841606,12.502969588876512]]

jacobian' :: (Traversable f, Traversable g, Num a) => (forall s. f (AD s (Forward a)) -> g (AD s (Forward a))) -> f a -> g (a, f a) Source

Compute the Jacobian using Forward mode AD along with the actual answer.

jacobianWith :: (Traversable f, Traversable g, Num a) => (a -> a -> b) -> (forall s. f (AD s (Forward a)) -> g (AD s (Forward a))) -> f a -> g (f b) Source

Compute the Jacobian using Forward mode AD and combine the output with the input. This must transpose the result, so jacobianWithT is faster, and allows more result types.

jacobianWith' :: (Traversable f, Traversable g, Num a) => (a -> a -> b) -> (forall s. f (AD s (Forward a)) -> g (AD s (Forward a))) -> f a -> g (a, f b) Source

Compute the Jacobian using Forward mode AD combined with the input using a user specified function, along with the actual answer.

Transposed Jacobian

jacobianT :: (Traversable f, Functor g, Num a) => (forall s. f (AD s (Forward a)) -> g (AD s (Forward a))) -> f a -> f (g a) Source

A fast, simple, transposed Jacobian computed with forward-mode AD.

jacobianWithT :: (Traversable f, Functor g, Num a) => (a -> a -> b) -> (forall s. f (AD s (Forward a)) -> g (AD s (Forward a))) -> f a -> f (g b) Source

A fast, simple, transposed Jacobian computed with Forward mode AD that combines the output with the input.

Hessian Product

hessianProduct :: (Traversable f, Num a) => (forall s. f (AD s (On (Forward (Forward a)))) -> AD s (On (Forward (Forward a)))) -> f (a, a) -> f a Source

Compute the product of a vector with the Hessian using forward-on-forward-mode AD.

hessianProduct' :: (Traversable f, Num a) => (forall s. f (AD s (On (Forward (Forward a)))) -> AD s (On (Forward (Forward a)))) -> f (a, a) -> f (a, a) Source

Compute the gradient and hessian product using forward-on-forward-mode AD.

Derivatives

diff :: Num a => (forall s. AD s (Forward a) -> AD s (Forward a)) -> a -> a Source

The diff function calculates the first derivative of a scalar-to-scalar function by forward-mode AD

>>> diff sin 0
1.0

diff' :: Num a => (forall s. AD s (Forward a) -> AD s (Forward a)) -> a -> (a, a) Source

The diff' function calculates the result and first derivative of scalar-to-scalar function by Forward mode AD

diff' sin == sin &&& cos
diff' f = f &&& d f

>>> diff' sin 0
(0.0,1.0)

>>> diff' exp 0
(1.0,1.0)

diffF :: (Functor f, Num a) => (forall s. AD s (Forward a) -> f (AD s (Forward a))) -> a -> f a Source

The diffF function calculates the first derivatives of scalar-to-nonscalar function by Forward mode AD

>>> diffF (\a -> [sin a, cos a]) 0
[1.0,-0.0]

diffF' :: (Functor f, Num a) => (forall s. AD s (Forward a) -> f (AD s (Forward a))) -> a -> f (a, a) Source

The diffF' function calculates the result and first derivatives of a scalar-to-non-scalar function by Forward mode AD

>>> diffF' (\a -> [sin a, cos a]) 0
[(0.0,1.0),(1.0,-0.0)]

Directional Derivatives

du :: (Functor f, Num a) => (forall s. f (AD s (Forward a)) -> AD s (Forward a)) -> f (a, a) -> a Source

Compute the directional derivative of a function given a zipped up Functor of the input values and their derivatives

du' :: (Functor f, Num a) => (forall s. f (AD s (Forward a)) -> AD s (Forward a)) -> f (a, a) -> (a, a) Source

Compute the answer and directional derivative of a function given a zipped up Functor of the input values and their derivatives

duF :: (Functor f, Functor g, Num a) => (forall s. f (AD s (Forward a)) -> g (AD s (Forward a))) -> f (a, a) -> g a Source

Compute a vector of directional derivatives for a function given a zipped up Functor of the input values and their derivatives.

duF' :: (Functor f, Functor g, Num a) => (forall s. f (AD s (Forward a)) -> g (AD s (Forward a))) -> f (a, a) -> g (a, a) Source

Compute a vector of answers and directional derivatives for a function given a zipped up Functor of the input values and their derivatives.