ad 0.22 → 0.23

raw patch · 4 files changed

+99/−13 lines, 4 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Numeric/AD.hs +12/−1
• Numeric/AD/Internal/Tower.hs +30/−1
• Numeric/AD/Tower.hs +56/−10
• ad.cabal +1/−1

@@ -66,6 +66,10 @@     , du'     , duF     , duF'+    , dus+    , dus0+    , dusF+    , dus0F      -- * Taylor Series (Tower)     , taylor@@ -96,7 +100,7 @@ import Numeric.AD.Classes  (Mode(..)) import Numeric.AD.Internal (AD(..), probed, unprobe) import Numeric.AD.Forward  (diff, diff', diffF, diffF', du, du', duF, duF', diffM, diffM', jacobianT, jacobianWithT) -import Numeric.AD.Tower    (diffsF, diffs0F , diffs, diffs0, taylor, taylor0, maclaurin, maclaurin0)+import Numeric.AD.Tower    (diffsF, diffs0F , diffs, diffs0, taylor, taylor0, maclaurin, maclaurin0, dus, dus0, dusF, dus0F) import Numeric.AD.Reverse  (grad, grad', gradWith, gradWith', gradM, gradM', gradWithM, gradWithM', gradF, gradF', gradWithF, gradWithF') import Numeric.AD.Internal.Composition @@ -178,3 +182,10 @@ -- | Compute the order 3 Hessian tensor on a non-scalar-to-non-scalar function via the forward-mode Jacobian of the mixed-mode Jacobian of the function. hessianTensor :: (Traversable f, Traversable g, Num a) => (forall s. Mode s => f (AD s a) -> g (AD s a)) -> f a -> g (f (f a)) hessianTensor f = decomposeFunctor . Forward.jacobian (ComposeFunctor . jacobian (fmap decomposeMode . f . fmap composeMode))++-- the cofree comonad of f+-- data f :> a = (f :> a) :> a++-- gradients :: (Traversable f, Num a) => (forall s. Mode s => f (AD s a) -> AD s a) -> f a -> (f :> a) ++-- jacobians :: (Traversable f, Traversable g, Num a) => (forall s. Mode s => f (AD s a) -> g (AD s a)) -> f a -> g (f :> a) 

@@ -13,17 +13,24 @@ module Numeric.AD.Internal.Tower     ( Tower(..)     , zeroPad+    , zeroPadF+    , transposePadF     , d     , d'+    , withD     , tangents     , bundle     , apply     , getADTower+    , tower     ) where +import Prelude hiding (all)+import Control.Applicative+import Data.Foldable+import Language.Haskell.TH import Numeric.AD.Classes import Numeric.AD.Internal-import Language.Haskell.TH  -- | @Tower@ is an AD 'Mode' that calculates a tangent tower by forward AD, and provides fast 'diffsUU', 'diffsUF' newtype Tower a = Tower { getTower :: [a] } deriving (Show)@@ -34,6 +41,21 @@ zeroPad xs = xs ++ repeat 0 {-# INLINE zeroPad #-} +zeroPadF :: (Functor f, Num a) => [f a] -> [f a]+zeroPadF fxs@(fx:_) = fxs ++ repeat (const 0 <$> fx)+zeroPadF _ = error "zeroPadF :: empty list"+{-# INLINE zeroPadF #-}++transposePadF :: (Foldable f, Functor f) => a -> f [a] -> [f a]+transposePadF pad fx+    | all null fx = []+    | otherwise = fmap headPad fx : transposePadF pad (drop1 <$> fx)+    where+        headPad [] = pad+        headPad (x:_) = x+        drop1 (_:xs) = xs+        drop1 xs = xs+ d :: Num a => [a] -> a d (_:da:_) = da d _ = 0@@ -54,6 +76,10 @@ bundle a (Tower as) = Tower (a:as) {-# INLINE bundle #-} +withD :: (a, a) -> AD Tower a+withD (a, da) = AD (Tower [a,da])+{-# INLINE withD #-}+ apply :: Num a => (AD Tower a -> b) -> a -> b apply f a = f (AD (Tower [a,1])) {-# INLINE apply #-}@@ -61,6 +87,9 @@ getADTower :: AD Tower a -> [a] getADTower (AD t) = getTower t {-# INLINE getADTower #-}++tower :: [a] -> AD Tower a+tower as = AD (Tower as)  instance Primal Tower where     primal (Tower (x:_)) = x

@@ -21,15 +21,24 @@     , maclaurin     , maclaurin0     -- * Derivatives-    , diff-    , diff'-    , diffs-    , diffs0-    , diffsF-    , diffs0F+    , 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)     -- * Monadic Combinators-    , diffsM-    , diffs0M+    , diffsM  -- answer and all derivatives of the monadic action (a -> m a)+    , diffs0M -- answer and all zero padded derivatives of (a -> m a)     -- * Exposed Types     , Mode(..)     , AD(..)@@ -84,10 +93,47 @@ {-# INLINE maclaurin0 #-}  diff :: Num a => (forall s. Mode s => AD s a -> AD s a) -> a -> a-diff f a = d $ diffs f a+diff f = d . diffs f {-# INLINE diff #-}  diff' :: Num a => (forall s. Mode s => AD s a -> AD s a) -> a -> (a, a)-diff' f a = d' $ diffs f a+diff' f = d' . diffs f {-# INLINE diff' #-} +du :: (Functor f, Num a) => (forall s. f (AD s a) -> AD s a) -> f (a, a) -> a+du f = d . getADTower . f . fmap withD+{-# INLINE du #-}++du' :: (Functor f, Num a) => (forall s. f (AD s a) -> AD s a) -> f (a, a) -> (a, a)+du' f = d' . getADTower . f . fmap withD+{-# INLINE du' #-}++duF :: (Functor f, Functor g, Num a) => (forall s. f (AD s a) -> g (AD s a)) -> f (a, a) -> g a+duF f = fmap (d . getADTower) . f . fmap withD+{-# INLINE duF #-}++duF' :: (Functor f, Functor g, Num a) => (forall s. f (AD s a) -> g (AD s a)) -> f (a, a) -> g (a, a)+duF' f = fmap (d' . getADTower) . f . fmap withD+{-# INLINE duF' #-}++dus :: (Functor f, Num a) => (forall s. f (AD s a) -> AD s a) -> f [a] -> [a]+dus f = getADTower . f . fmap tower+{-# INLINE dus #-}++dus0 :: (Functor f, Num a) => (forall s. f (AD s a) -> AD s a) -> f [a] -> [a]+dus0 f = zeroPad . getADTower . f . fmap tower+{-# INLINE dus0 #-}++dusF :: (Functor f, Functor g, Num a) => (forall s. f (AD s a) -> g (AD s a)) -> f [a] -> g [a]+dusF f = fmap getADTower . f . fmap tower+{-# INLINE dusF #-}++dus0F :: (Functor f, Functor g, Num a) => (forall s. f (AD s a) -> g (AD s a)) -> f [a] -> g [a]+dus0F f = fmap getADTower . f . fmap tower+{-# INLINE dus0F #-}++-- TODO: higher order gradients+-- data f :> a = a :< f (f :> a) +-- gradients  :: (Traversable f, Num a) => (forall s. Mode s => f (AD s a) -> AD s a) -> f a -> f :> a+-- gradientsF, jacobians :: (Traversable f, Functor g, Num a) => (forall s. Mode s => f (AD s a) -> g (AD s a)) -> f a -> g (f :> a)+-- gradientsM :: (Traversable f, Monad m, Num a) => (forall s. Mode s => f (AD s a) -> m (AD s a)) -> f a -> m (f :> a)

@@ -1,5 +1,5 @@ Name:         ad-Version:      0.22+Version:      0.23 License:      BSD3 License-File: LICENSE Copyright:    Edward Kmett 2010