{-# LANGUAGE Rank2Types #-} ----------------------------------------------------------------------------- -- | -- Copyright : (c) Edward Kmett 2010-2014 -- License : BSD3 -- Maintainer : ekmett@gmail.com -- Stability : experimental -- Portability : GHC only -- -- Higher order derivatives via a \"dual number tower\". -- ----------------------------------------------------------------------------- module Numeric.AD.Mode.Tower ( AD , 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 (a -> a) , du' -- answer and directional derivative of (a -> a) , dus -- answer and all directional derivatives of (a -> a) , dus0 -- answer and all zero padded directional derivatives of (a -> a) , duF -- directional derivative of (a -> f a) , duF' -- answer and directional derivative of (a -> f a) , dusF -- answer and all directional derivatives of (a -> f a) , dus0F -- answer and all zero padded directional derivatives of (a -> a) ) where import qualified Numeric.AD.Rank1.Tower as Rank1 import Numeric.AD.Internal.Tower (Tower) import Numeric.AD.Internal.Type (AD(..)) import Numeric.AD.Mode diffs :: Num a => (forall s. AD s (Tower a) -> AD s (Tower a)) -> a -> [a] diffs f = Rank1.diffs (runAD.f.AD) {-# INLINE diffs #-} diffs0 :: Num a => (forall s. AD s (Tower a) -> AD s (Tower a)) -> a -> [a] diffs0 f = Rank1.diffs0 (runAD.f.AD) {-# INLINE diffs0 #-} diffsF :: (Functor f, Num a) => (forall s. AD s (Tower a) -> f (AD s (Tower a))) -> a -> f [a] diffsF f = Rank1.diffsF (fmap runAD.f.AD) {-# INLINE diffsF #-} diffs0F :: (Functor f, Num a) => (forall s. AD s (Tower a) -> f (AD s (Tower a))) -> a -> f [a] diffs0F f = Rank1.diffs0F (fmap runAD.f.AD) {-# INLINE diffs0F #-} taylor :: Fractional a => (forall s. AD s (Tower a) -> AD s (Tower a)) -> a -> a -> [a] taylor f = Rank1.taylor (runAD.f.AD) taylor0 :: Fractional a => (forall s. AD s (Tower a) -> AD s (Tower a)) -> a -> a -> [a] taylor0 f = Rank1.taylor0 (runAD.f.AD) {-# INLINE taylor0 #-} maclaurin :: Fractional a => (forall s. AD s (Tower a) -> AD s (Tower a)) -> a -> [a] maclaurin f = Rank1.maclaurin (runAD.f.AD) {-# INLINE maclaurin #-} maclaurin0 :: Fractional a => (forall s. AD s (Tower a) -> AD s (Tower a)) -> a -> [a] maclaurin0 f = Rank1.maclaurin0 (runAD.f.AD) {-# INLINE maclaurin0 #-} diff :: Num a => (forall s. AD s (Tower a) -> AD s (Tower a)) -> a -> a diff f = Rank1.diff (runAD.f.AD) {-# INLINE diff #-} diff' :: Num a => (forall s. AD s (Tower a) -> AD s (Tower a)) -> a -> (a, a) diff' f = Rank1.diff' (runAD.f.AD) {-# INLINE diff' #-} du :: (Functor f, Num a) => (forall s. f (AD s (Tower a)) -> AD s (Tower a)) -> f (a, a) -> a du f = Rank1.du (runAD.f. fmap AD) {-# INLINE du #-} du' :: (Functor f, Num a) => (forall s. f (AD s (Tower a)) -> AD s (Tower a)) -> f (a, a) -> (a, a) du' f = Rank1.du' (runAD.f.fmap AD) {-# INLINE du' #-} duF :: (Functor f, Functor g, Num a) => (forall s. f (AD s (Tower a)) -> g (AD s (Tower a))) -> f (a, a) -> g a duF f = Rank1.duF (fmap runAD.f.fmap AD) {-# INLINE duF #-} duF' :: (Functor f, Functor g, Num a) => (forall s. f (AD s (Tower a)) -> g (AD s (Tower a))) -> f (a, a) -> g (a, a) duF' f = Rank1.duF' (fmap runAD.f.fmap AD) {-# INLINE duF' #-} dus :: (Functor f, Num a) => (forall s. f (AD s (Tower a)) -> AD s (Tower a)) -> f [a] -> [a] dus f = Rank1.dus (runAD.f.fmap AD) {-# INLINE dus #-} dus0 :: (Functor f, Num a) => (forall s. f (AD s (Tower a)) -> AD s (Tower a)) -> f [a] -> [a] dus0 f = Rank1.dus0 (runAD.f.fmap AD) {-# INLINE dus0 #-} dusF :: (Functor f, Functor g, Num a) => (forall s. f (AD s (Tower a)) -> g (AD s (Tower a))) -> f [a] -> g [a] dusF f = Rank1.dusF (fmap runAD.f.fmap AD) {-# INLINE dusF #-} dus0F :: (Functor f, Functor g, Num a) => (forall s. f (AD s (Tower a)) -> g (AD s (Tower a))) -> f [a] -> g [a] dus0F f = Rank1.dus0F (fmap runAD.f.fmap AD) {-# INLINE dus0F #-}