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

Numeric.AD.Rank1.Forward

Contents

Gradient
Jacobian
Transposed Jacobian
Hessian Product
Derivatives
Directional Derivatives

Description

Forward mode automatic differentiation

Synopsis

Documentation

data Forward a Source #

Forward mode AD

Instances

(Num a, Bounded a) => Bounded (Forward a) #
Methods minBound :: Forward a # maxBound :: Forward a #
(Num a, Enum a) => Enum (Forward a) #
Methods succ :: Forward a -> Forward a # pred :: Forward a -> Forward a # toEnum :: Int -> Forward a # fromEnum :: Forward a -> Int # enumFrom :: Forward a -> [Forward a] # enumFromThen :: Forward a -> Forward a -> [Forward a] # enumFromTo :: Forward a -> Forward a -> [Forward a] # enumFromThenTo :: Forward a -> Forward a -> Forward a -> [Forward a] #
(Num a, Eq a) => Eq (Forward a) #
Methods (==) :: Forward a -> Forward a -> Bool # (/=) :: Forward a -> Forward a -> Bool #
Floating a => Floating (Forward a) #
Methods pi :: Forward a # exp :: Forward a -> Forward a # log :: Forward a -> Forward a # sqrt :: Forward a -> Forward a # (**) :: Forward a -> Forward a -> Forward a # logBase :: Forward a -> Forward a -> Forward a # sin :: Forward a -> Forward a # cos :: Forward a -> Forward a # tan :: Forward a -> Forward a # asin :: Forward a -> Forward a # acos :: Forward a -> Forward a # atan :: Forward a -> Forward a # sinh :: Forward a -> Forward a # cosh :: Forward a -> Forward a # tanh :: Forward a -> Forward a # asinh :: Forward a -> Forward a # acosh :: Forward a -> Forward a # atanh :: Forward a -> Forward a # log1p :: Forward a -> Forward a # expm1 :: Forward a -> Forward a # log1pexp :: Forward a -> Forward a # log1mexp :: Forward a -> Forward a #
Fractional a => Fractional (Forward a) #
Methods (/) :: Forward a -> Forward a -> Forward a # recip :: Forward a -> Forward a # fromRational :: Rational -> Forward a #
Data a => Data (Forward a) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Forward a -> c (Forward a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Forward a) # toConstr :: Forward a -> Constr # dataTypeOf :: Forward a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Forward a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Forward a)) # gmapT :: (forall b. Data b => b -> b) -> Forward a -> Forward a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Forward a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Forward a -> r # gmapQ :: (forall d. Data d => d -> u) -> Forward a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Forward a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Forward a -> m (Forward a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Forward a -> m (Forward a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Forward a -> m (Forward a) #
Num a => Num (Forward a) #
Methods (+) :: Forward a -> Forward a -> Forward a # (-) :: Forward a -> Forward a -> Forward a # (*) :: Forward a -> Forward a -> Forward a # negate :: Forward a -> Forward a # abs :: Forward a -> Forward a # signum :: Forward a -> Forward a # fromInteger :: Integer -> Forward a #
(Num a, Ord a) => Ord (Forward a) #
Methods compare :: Forward a -> Forward a -> Ordering # (<) :: Forward a -> Forward a -> Bool # (<=) :: Forward a -> Forward a -> Bool # (>) :: Forward a -> Forward a -> Bool # (>=) :: Forward a -> Forward a -> Bool # max :: Forward a -> Forward a -> Forward a # min :: Forward a -> Forward a -> Forward a #
Real a => Real (Forward a) #
Methods toRational :: Forward a -> Rational #
RealFloat a => RealFloat (Forward a) #
Methods floatRadix :: Forward a -> Integer # floatDigits :: Forward a -> Int # floatRange :: Forward a -> (Int, Int) # decodeFloat :: Forward a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Forward a # exponent :: Forward a -> Int # significand :: Forward a -> Forward a # scaleFloat :: Int -> Forward a -> Forward a # isNaN :: Forward a -> Bool # isInfinite :: Forward a -> Bool # isDenormalized :: Forward a -> Bool # isNegativeZero :: Forward a -> Bool # isIEEE :: Forward a -> Bool # atan2 :: Forward a -> Forward a -> Forward a #
RealFrac a => RealFrac (Forward a) #
Methods properFraction :: Integral b => Forward a -> (b, Forward a) # truncate :: Integral b => Forward a -> b # round :: Integral b => Forward a -> b # ceiling :: Integral b => Forward a -> b # floor :: Integral b => Forward a -> b #
Show a => Show (Forward a) Source #
Methods showsPrec :: Int -> Forward a -> ShowS # show :: Forward a -> String # showList :: [Forward a] -> ShowS #
Erf a => Erf (Forward a) #
Methods erf :: Forward a -> Forward a # erfc :: Forward a -> Forward a # erfcx :: Forward a -> Forward a # normcdf :: Forward a -> Forward a #
InvErf a => InvErf (Forward a) #
Methods inverf :: Forward a -> Forward a # inverfc :: Forward a -> Forward a # invnormcdf :: Forward a -> Forward a #
Num a => Mode (Forward a) Source #
Associated Types type Scalar (Forward a) :: * Source # Methods isKnownConstant :: Forward a -> Bool Source # isKnownZero :: Forward a -> Bool Source # auto :: Scalar (Forward a) -> Forward a Source # (^) :: Scalar (Forward a) -> Forward a -> Forward a Source # (^) :: Forward a -> Scalar (Forward a) -> Forward a Source # (^/) :: Forward a -> Scalar (Forward a) -> Forward a Source # zero :: Forward a Source #
Num a => Jacobian (Forward a) Source #
Associated Types type D (Forward a) :: * Source # Methods unary :: (Scalar (Forward a) -> Scalar (Forward a)) -> D (Forward a) -> Forward a -> Forward a Source # lift1 :: (Scalar (Forward a) -> Scalar (Forward a)) -> (D (Forward a) -> D (Forward a)) -> Forward a -> Forward a Source # lift1_ :: (Scalar (Forward a) -> Scalar (Forward a)) -> (D (Forward a) -> D (Forward a) -> D (Forward a)) -> Forward a -> Forward a Source # binary :: (Scalar (Forward a) -> Scalar (Forward a) -> Scalar (Forward a)) -> D (Forward a) -> D (Forward a) -> Forward a -> Forward a -> Forward a Source # lift2 :: (Scalar (Forward a) -> Scalar (Forward a) -> Scalar (Forward a)) -> (D (Forward a) -> D (Forward a) -> (D (Forward a), D (Forward a))) -> Forward a -> Forward a -> Forward a Source # lift2_ :: (Scalar (Forward a) -> Scalar (Forward a) -> Scalar (Forward a)) -> (D (Forward a) -> D (Forward a) -> D (Forward a) -> (D (Forward a), D (Forward a))) -> Forward a -> Forward a -> Forward a Source #
type Scalar (Forward a) Source #
type Scalar (Forward a) = a
type D (Forward a) Source #
type D (Forward a) = Id a

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

Embed a constant

Gradient

grad :: (Traversable f, Num a) => (f (Forward a) -> 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) => (f (Forward a) -> 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) -> (f (Forward a) -> 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) -> (f (Forward a) -> 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) => (f (Forward a) -> g (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) => (f (Forward a) -> g (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) -> (f (Forward a) -> g (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) -> (f (Forward a) -> g (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) => (f (Forward a) -> g (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) -> (f (Forward a) -> g (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) => (f (On (Forward (Forward a))) -> 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) => (f (On (Forward (Forward a))) -> 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 => (Forward a -> 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 => (Forward a -> 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) => (Forward a -> f (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) => (Forward a -> f (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) => (f (Forward a) -> 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) => (f (Forward a) -> 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) => (f (Forward a) -> g (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) => (f (Forward a) -> g (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.