{-# LANGUAGE CPP #-} {-# LANGUAGE Rank2Types #-} {-# LANGUAGE BangPatterns #-} ----------------------------------------------------------------------------- -- | -- Copyright : (c) Edward Kmett 2010-2015 -- License : BSD3 -- Maintainer : ekmett@gmail.com -- Stability : experimental -- Portability : GHC only -- -- Higher order derivatives via a \"dual number tower\". -- ----------------------------------------------------------------------------- module Numeric.AD.Rank1.Tower ( Tower , auto -- * Taylor Series , taylor , taylor0 -- * Maclaurin Series , maclaurin , maclaurin0 -- * Derivatives , diff -- first derivative of (a -> a) , diff' -- answer and first derivative of (a -> a) , diffs -- answer and all derivatives of (a -> a) , diffs0 -- zero padded derivatives of (a -> a) , diffsF -- answer and all derivatives of (a -> f a) , diffs0F -- zero padded derivatives of (a -> f a) -- * Directional Derivatives , du -- directional derivative of (f a -> a) , du' -- answer and directional derivative of (f a -> a) , dus -- answer and all directional derivatives of (f a -> a) , dus0 -- answer and all zero padded directional derivatives of (f a -> a) , duF -- directional derivative of (f a -> g a) , duF' -- answer and directional derivative of (f a -> g a) , dusF -- answer and all directional derivatives of (f a -> g a) , dus0F -- answer and all zero padded directional derivatives of (f a -> g a) ) where #if __GLASGOW_HASKELL__ < 710 import Data.Functor ((<$>)) #endif import Numeric.AD.Internal.Tower import Numeric.AD.Mode -- | Compute the answer and all derivatives of a function @(a -> a)@ diffs :: Num a => (Tower a -> Tower a) -> a -> [a] diffs f a = getADTower $ apply f a {-# INLINE diffs #-} -- | Compute the zero-padded derivatives of a function @(a -> a)@ diffs0 :: Num a => (Tower a -> Tower a) -> a -> [a] diffs0 f a = zeroPad (diffs f a) {-# INLINE diffs0 #-} -- | Compute the answer and all derivatives of a function @(a -> f a)@ diffsF :: (Functor f, Num a) => (Tower a -> f (Tower a)) -> a -> f [a] diffsF f a = getADTower <$> apply f a {-# INLINE diffsF #-} -- | Compute the zero-padded derivatives of a function @(a -> f a)@ diffs0F :: (Functor f, Num a) => (Tower a -> f (Tower a)) -> a -> f [a] diffs0F f a = (zeroPad . getADTower) <$> apply f a {-# INLINE diffs0F #-} -- | @taylor f x@ compute the Taylor series of @f@ around @x@. taylor :: Fractional a => (Tower a -> Tower a) -> a -> a -> [a] taylor f x dx = go 1 1 (diffs f x) where go !n !acc (a:as) = a * acc : go (n + 1) (acc * dx / n) as go _ _ [] = [] -- | @taylor0 f x@ compute the Taylor series of @f@ around @x@, zero-padded. taylor0 :: Fractional a => (Tower a -> Tower a) -> a -> a -> [a] taylor0 f x dx = zeroPad (taylor f x dx) {-# INLINE taylor0 #-} -- | @maclaurin f@ compute the Maclaurin series of @f@ maclaurin :: Fractional a => (Tower a -> Tower a) -> a -> [a] maclaurin f = taylor f 0 {-# INLINE maclaurin #-} -- | @maclaurin f@ compute the Maclaurin series of @f@, zero-padded maclaurin0 :: Fractional a => (Tower a -> Tower a) -> a -> [a] maclaurin0 f = taylor0 f 0 {-# INLINE maclaurin0 #-} -- | Compute the first derivative of a function @(a -> a)@ diff :: Num a => (Tower a -> Tower a) -> a -> a diff f = d . diffs f {-# INLINE diff #-} -- | Compute the answer and first derivative of a function @(a -> a)@ diff' :: Num a => (Tower a -> Tower a) -> a -> (a, a) diff' f = d' . diffs f {-# INLINE diff' #-} -- | Compute a directional derivative of a function @(f a -> a)@ du :: (Functor f, Num a) => (f (Tower a) -> Tower a) -> f (a, a) -> a du f = d . getADTower . f . fmap withD {-# INLINE du #-} -- | Compute the answer and a directional derivative of a function @(f a -> a)@ du' :: (Functor f, Num a) => (f (Tower a) -> Tower a) -> f (a, a) -> (a, a) du' f = d' . getADTower . f . fmap withD {-# INLINE du' #-} -- | Compute a directional derivative of a function @(f a -> g a)@ duF :: (Functor f, Functor g, Num a) => (f (Tower a) -> g (Tower a)) -> f (a, a) -> g a duF f = fmap (d . getADTower) . f . fmap withD {-# INLINE duF #-} -- | Compute the answer and a directional derivative of a function @(f a -> g a)@ duF' :: (Functor f, Functor g, Num a) => (f (Tower a) -> g (Tower a)) -> f (a, a) -> g (a, a) duF' f = fmap (d' . getADTower) . f . fmap withD {-# INLINE duF' #-} -- | Given a function @(f a -> a)@, and a tower of derivatives, compute the corresponding directional derivatives. dus :: (Functor f, Num a) => (f (Tower a) -> Tower a) -> f [a] -> [a] dus f = getADTower . f . fmap tower {-# INLINE dus #-} -- | Given a function @(f a -> a)@, and a tower of derivatives, compute the corresponding directional derivatives, zero-padded dus0 :: (Functor f, Num a) => (f (Tower a) -> Tower a) -> f [a] -> [a] dus0 f = zeroPad . getADTower . f . fmap tower {-# INLINE dus0 #-} -- | Given a function @(f a -> g a)@, and a tower of derivatives, compute the corresponding directional derivatives dusF :: (Functor f, Functor g, Num a) => (f (Tower a) -> g (Tower a)) -> f [a] -> g [a] dusF f = fmap getADTower . f . fmap tower {-# INLINE dusF #-} -- | Given a function @(f a -> g a)@, and a tower of derivatives, compute the corresponding directional derivatives, zero-padded dus0F :: (Functor f, Functor g, Num a) => (f (Tower a) -> g (Tower a)) -> f [a] -> g [a] dus0F f = fmap getADTower . f . fmap tower {-# INLINE dus0F #-}