ad 0.28 → 0.30.0

raw patch · 10 files changed

+231/−167 lines, 10 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Numeric/AD.hs +2/−1
• Numeric/AD/Internal.hs +2/−162
• Numeric/AD/Internal/Classes.hs +9/−0
• Numeric/AD/Internal/Combinators.hs +27/−0
• Numeric/AD/Internal/Forward.hs +1/−0
• Numeric/AD/Internal/Identity.hs +135/−0
• Numeric/AD/Internal/Iterated.hs +1/−0
• Numeric/AD/Internal/Reverse.hs +1/−0
• Numeric/AD/Internal/Types.hs +42/−0
• ad.cabal +11/−4

@@ -100,7 +100,8 @@ import Data.Traversable (Traversable) import Data.Foldable (Foldable, foldr') import Control.Applicative-import Numeric.AD.Internal (AD(..), probed, unprobe, UU, UF, FU, FF)+import Numeric.AD.Internal (AD(..), UU, UF, FU, FF)+import Numeric.AD.Internal.Identity (probed, unprobe) import Numeric.AD.Internal.Classes  (Mode(..)) 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, dus, dus0, dusF, dus0F)

@@ -1,4 +1,3 @@-{-# LANGUAGE Rank2Types, GeneralizedNewtypeDeriving, TemplateHaskell, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, DeriveFunctor, DeriveFoldable, DeriveTraversable #-} -- {-# OPTIONS_HADDOCK hide, prune #-} ----------------------------------------------------------------------------- -- |@@ -12,168 +11,9 @@ ----------------------------------------------------------------------------- module Numeric.AD.Internal     ( module Numeric.AD.Internal.Classes-    , UU, UF, FU, FF-    , zipWithT-    , zipWithDefaultT-    , on-    , AD(..)-    , Id(..)-    , probe-    , unprobe-    , probed-    , unprobed-    , Pair(..)+    , module Numeric.AD.Internal.Types     ) where -import Control.Applicative-import Language.Haskell.TH import Numeric.AD.Internal.Classes-import Data.Monoid-import Data.Traversable (Traversable, mapAccumL)-import Data.Foldable (Foldable, toList)---- | A scalar-to-scalar automatically-differentiable function.-type UU a = forall s. Mode s => AD s a -> AD s a--- | A scalar-to-non-scalar automatically-differentiable function.-type UF f a = forall s. Mode s => AD s a -> f (AD s a)--- | A non-scalar-to-scalar automatically-differentiable function.-type FU f a = forall s. Mode s => f (AD s a) -> AD s a--- | A non-scalar-to-non-scalar automatically-differentiable function.-type FF f g a = forall s. Mode s => f (AD s a) -> g (AD s a)--on :: (a -> a -> b) -> (c -> a) -> c -> c -> b-on f g a b = f (g a) (g b)--data Pair a b = Pair a b deriving (Eq, Ord, Show, Read, Functor, Foldable, Traversable)--zipWithT :: (Foldable f, Traversable g) => (a -> b -> c) -> f a -> g b -> g c-zipWithT f as = snd . mapAccumL (\(a:as') b -> (as', f a b)) (toList as)--zipWithDefaultT :: (Foldable f, Traversable g) => a -> (a -> b -> c) -> f a -> g b -> g c-zipWithDefaultT z f as = zipWithT f (toList as ++ repeat z)--class Iso a b where-    iso :: f a -> f b-    osi :: f b -> f a--instance Iso a a where-    iso = id-    osi = id---- | 'AD' serves as a common wrapper for different 'Mode' instances, exposing a traditional--- numerical tower. Universal quantification is used to limit the actions in user code to--- machinery that will return the same answers under all AD modes, allowing us to use modes--- interchangeably as both the type level \"brand\" and dictionary, providing a common API.-newtype AD f a = AD { runAD :: f a } deriving (Iso (f a), Lifted, Mode, Primal)----- > instance (Lifted f, Num a) => Num (AD f a)--- etc.-let f = varT (mkName "f") in -    deriveNumeric -        (classP ''Lifted [f]:) -        (conT ''AD `appT` f)--newtype Id a = Id a deriving-    (Iso a, Eq, Ord, Show, Enum, Bounded, Num, Real, Fractional, Floating, RealFrac, RealFloat, Monoid)--probe :: a -> AD Id a-probe a = AD (Id a)--unprobe :: AD Id a -> a-unprobe (AD (Id a)) = a--pid :: f a -> f (Id a)-pid = iso--unpid :: f (Id a) -> f a-unpid = osi--probed :: f a -> f (AD Id a)-probed = iso . pid--unprobed :: f (AD Id a) -> f a-unprobed = unpid . osi--instance Functor Id where-    fmap f (Id a) = Id (f a)--instance Applicative Id where-    pure = Id-    Id f <*> Id a = Id (f a)--instance Monad Id where-    return = Id-    Id a >>= f = f a--instance Lifted Id where-    (==!) = (==)-    compare1 = compare-    showsPrec1 = showsPrec-    fromInteger1 = fromInteger-    (+!) = (+)-    (-!) = (-)-    (*!) = (*)-    negate1 = negate-    abs1 = abs-    signum1 = signum-    (/!) = (/)-    recip1 = recip-    fromRational1 = fromRational-    toRational1 = toRational-    pi1 = pi-    exp1 = exp-    log1 = log-    sqrt1 = sqrt-    (**!) = (**)-    logBase1 = logBase-    sin1 = sin-    cos1 = cos-    tan1 = tan-    asin1 = asin-    acos1 = acos-    atan1 = atan-    sinh1 = sinh-    cosh1 = cosh-    tanh1 = tanh-    asinh1 = asinh-    acosh1 = acosh-    atanh1 = atanh-    properFraction1 = properFraction-    truncate1 = truncate-    round1 = round-    ceiling1 = ceiling-    floor1 = floor-    floatRadix1 = floatRadix-    floatDigits1 = floatDigits-    floatRange1 = floatRange-    decodeFloat1 = decodeFloat-    encodeFloat1 = encodeFloat-    exponent1 = exponent-    significand1 = significand-    scaleFloat1 = scaleFloat-    isNaN1 = isNaN-    isInfinite1 = isInfinite-    isDenormalized1 = isDenormalized-    isNegativeZero1 = isNegativeZero-    isIEEE1 = isIEEE-    atan21 = atan2-    succ1 = succ-    pred1 = pred-    toEnum1 = toEnum-    fromEnum1 = fromEnum-    enumFrom1 = enumFrom-    enumFromThen1 = enumFromThen-    enumFromTo1 = enumFromTo-    enumFromThenTo1 = enumFromThenTo-    minBound1 = minBound-    maxBound1 = maxBound--instance Mode Id where-    lift = Id-    Id a ^* b = Id (a * b)-    a *^ Id b = Id (a * b)-    Id a <+> Id b = Id (a + b)+import Numeric.AD.Internal.Types -instance Primal Id where-    primal (Id a) = a

@@ -22,6 +22,7 @@     , deriveLifted     , deriveNumeric     , Lifted(..)+    , Iso(..)     ) where  import Control.Applicative@@ -32,6 +33,14 @@ infixl 7 *!, /!, ^*, *^, ^/ infixl 6 +!, -!, <+> infix 4 ==!++class Iso a b where+    iso :: f a -> f b+    osi :: f b -> f a++instance Iso a a where+    iso = id+    osi = id  class Lifted t where     showsPrec1          :: Show a => Int -> t a -> ShowS

@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.AD.Internal.Combinators+-- Copyright   :  (c) Edward Kmett 2010+-- License     :  BSD3+-- Maintainer  :  ekmett@gmail.com+-- Stability   :  experimental+-- Portability :  GHC only+--+-----------------------------------------------------------------------------+module Numeric.AD.Internal.Combinators+    ( zipWithT+    , zipWithDefaultT+    , on+    ) where++import Data.Traversable (Traversable, mapAccumL)+import Data.Foldable (Foldable, toList)++on :: (a -> a -> b) -> (c -> a) -> c -> c -> b+on f g a b = f (g a) (g b)++zipWithT :: (Foldable f, Traversable g) => (a -> b -> c) -> f a -> g b -> g c+zipWithT f as = snd . mapAccumL (\(a:as') b -> (as', f a b)) (toList as)++zipWithDefaultT :: (Foldable f, Traversable g) => a -> (a -> b -> c) -> f a -> g b -> g c+zipWithDefaultT z f as = zipWithT f (toList as ++ repeat z)

@@ -34,6 +34,7 @@ import Data.Data import Control.Applicative import Numeric.AD.Internal+import Numeric.AD.Internal.Identity  data Forward a = Forward a a deriving (Show, Data, Typeable) 

@@ -0,0 +1,135 @@+{-# LANGUAGE GeneralizedNewtypeDeriving, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.AD.Internal.Identity+-- Copyright   :  (c) Edward Kmett 2010+-- License     :  BSD3+-- Maintainer  :  ekmett@gmail.com+-- Stability   :  experimental+-- Portability :  GHC only+--+-----------------------------------------------------------------------------+module Numeric.AD.Internal.Identity+    ( Id(..)+    , probe+    , unprobe+    , probed+    , unprobed+    ) where++import Control.Applicative+import Numeric.AD.Internal.Classes+import Numeric.AD.Internal.Types+import Data.Monoid+import Data.Traversable (Traversable, traverse)+import Data.Foldable (Foldable, foldMap)++newtype Id a = Id a deriving+    (Iso a, Eq, Ord, Show, Enum, Bounded, Num, Real, Fractional, Floating, RealFrac, RealFloat, Monoid)++probe :: a -> AD Id a+probe a = AD (Id a)++unprobe :: AD Id a -> a+unprobe (AD (Id a)) = a++pid :: f a -> f (Id a)+pid = iso++unpid :: f (Id a) -> f a+unpid = osi++probed :: f a -> f (AD Id a)+probed = iso . pid++unprobed :: f (AD Id a) -> f a+unprobed = unpid . osi++instance Functor Id where+    fmap f (Id a) = Id (f a)++instance Foldable Id where+    foldMap f (Id a) = f a++instance Traversable Id where+    traverse f (Id a) = Id <$> f a++instance Applicative Id where+    pure = Id+    Id f <*> Id a = Id (f a)++instance Monad Id where+    return = Id+    Id a >>= f = f a++instance Lifted Id where+    (==!) = (==)+    compare1 = compare+    showsPrec1 = showsPrec+    fromInteger1 = fromInteger+    (+!) = (+)+    (-!) = (-)+    (*!) = (*)+    negate1 = negate+    abs1 = abs+    signum1 = signum+    (/!) = (/)+    recip1 = recip+    fromRational1 = fromRational+    toRational1 = toRational+    pi1 = pi+    exp1 = exp+    log1 = log+    sqrt1 = sqrt+    (**!) = (**)+    logBase1 = logBase+    sin1 = sin+    cos1 = cos+    tan1 = tan+    asin1 = asin+    acos1 = acos+    atan1 = atan+    sinh1 = sinh+    cosh1 = cosh+    tanh1 = tanh+    asinh1 = asinh+    acosh1 = acosh+    atanh1 = atanh+    properFraction1 = properFraction+    truncate1 = truncate+    round1 = round+    ceiling1 = ceiling+    floor1 = floor+    floatRadix1 = floatRadix+    floatDigits1 = floatDigits+    floatRange1 = floatRange+    decodeFloat1 = decodeFloat+    encodeFloat1 = encodeFloat+    exponent1 = exponent+    significand1 = significand+    scaleFloat1 = scaleFloat+    isNaN1 = isNaN+    isInfinite1 = isInfinite+    isDenormalized1 = isDenormalized+    isNegativeZero1 = isNegativeZero+    isIEEE1 = isIEEE+    atan21 = atan2+    succ1 = succ+    pred1 = pred+    toEnum1 = toEnum+    fromEnum1 = fromEnum+    enumFrom1 = enumFrom+    enumFromThen1 = enumFromThen+    enumFromTo1 = enumFromTo+    enumFromThenTo1 = enumFromThenTo+    minBound1 = minBound+    maxBound1 = maxBound++instance Mode Id where+    lift = Id+    Id a ^* b = Id (a * b)+    a *^ Id b = Id (a * b)+    Id a <+> Id b = Id (a + b)++instance Primal Id where+    primal (Id a) = a

@@ -25,6 +25,7 @@ -- import Data.Typeable import Numeric.AD.Internal import Numeric.AD.Internal.Comonad+import Numeric.AD.Internal.Combinators (on) import Language.Haskell.TH  infixl 3 :|

@@ -49,6 +49,7 @@ import System.IO.Unsafe (unsafePerformIO) import Language.Haskell.TH import Numeric.AD.Internal+import Numeric.AD.Internal.Identity  -- | A @Tape@ records the information needed back propagate from the output to each input during 'Reverse' 'Mode' AD. data Tape a t

@@ -0,0 +1,42 @@+{-# LANGUAGE Rank2Types, GeneralizedNewtypeDeriving, TemplateHaskell, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, DeriveFunctor, DeriveFoldable, DeriveTraversable #-}+-- {-# OPTIONS_HADDOCK hide, prune #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.AD.Internal.Types+-- Copyright   :  (c) Edward Kmett 2010+-- License     :  BSD3+-- Maintainer  :  ekmett@gmail.com+-- Stability   :  experimental+-- Portability :  GHC only+--+-----------------------------------------------------------------------------+module Numeric.AD.Internal.Types+    ( AD(..)+    , UU, UF, FU, FF+    ) where++import Language.Haskell.TH+import Numeric.AD.Internal.Classes++-- | 'AD' serves as a common wrapper for different 'Mode' instances, exposing a traditional+-- numerical tower. Universal quantification is used to limit the actions in user code to+-- machinery that will return the same answers under all AD modes, allowing us to use modes+-- interchangeably as both the type level \"brand\" and dictionary, providing a common API.+newtype AD f a = AD { runAD :: f a } deriving (Iso (f a), Lifted, Mode, Primal)++-- > instance (Lifted f, Num a) => Num (AD f a)+-- etc.+let f = varT (mkName "f") in +    deriveNumeric +        (classP ''Lifted [f]:) +        (conT ''AD `appT` f)++-- | A scalar-to-scalar automatically-differentiable function.+type UU a = forall s. Mode s => AD s a -> AD s a+-- | A scalar-to-non-scalar automatically-differentiable function.+type UF f a = forall s. Mode s => AD s a -> f (AD s a)+-- | A non-scalar-to-scalar automatically-differentiable function.+type FU f a = forall s. Mode s => f (AD s a) -> AD s a+-- | A non-scalar-to-non-scalar automatically-differentiable function.+type FF f g a = forall s. Mode s => f (AD s a) -> g (AD s a)+

@@ -1,5 +1,5 @@ Name:         ad-Version:      0.28+Version:      0.30.0 License:      BSD3 License-File: LICENSE Copyright:    (c) Edward Kmett 2010,@@ -11,9 +11,13 @@ Homepage:     http://comonad.com/reader/ Synopsis:     Automatic Differentiation Description:  -    Forward, reverse, and higher-order automatic differentiation combinators with a common API.+    Forward-, reverse- and mixed- mode automatic differentiation combinators with a common API.     . -    Type-level \"branding\" is used to prevent the end user from confusing infinitesimals.+    Type-level \"branding\" is used to both prevent the end user from confusing infinitesimals +    and to limit unsafe access to the implementation details of each Mode.+    .+    The combinators in "Numeric.AD" choose from a variety of automatic differentiation modes,+    based on the arity of their inputs and outputs.  Build-Type:   Simple Build-Depends:       @@ -35,6 +39,8 @@      Numeric.AD.Internal     Numeric.AD.Internal.Classes+    Numeric.AD.Internal.Types+    Numeric.AD.Internal.Combinators     Numeric.AD.Internal.Comonad     Numeric.AD.Internal.Stream     Numeric.AD.Internal.Tensors@@ -43,7 +49,8 @@     Numeric.AD.Internal.Forward     Numeric.AD.Internal.Reverse     Numeric.AD.Internal.Tower+    Numeric.AD.Internal.Identity     Numeric.AD.Internal.Iterated  Extra-Source-Files: TODO-GHC-Options: -Wall+GHC-Options: -Wall -fspec-constr -O2