ad 0.27 → 0.28

raw patch · 13 files changed

+309/−138 lines, 13 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Numeric/AD/Internal.hs +5/−1
• Numeric/AD/Internal/Classes.hs +1/−1
• Numeric/AD/Internal/Comonad.hs +29/−0
• Numeric/AD/Internal/Composition.hs +1/−1
• Numeric/AD/Internal/Forward.hs +1/−1
• Numeric/AD/Internal/Iterated.hs +141/−0
• Numeric/AD/Internal/Reverse.hs +1/−1
• Numeric/AD/Internal/Stream.hs +27/−107
• Numeric/AD/Internal/Tensors.hs +62/−0
• Numeric/AD/Internal/Tower.hs +1/−1
• Numeric/AD/Stream.hs +0/−22
• Numeric/AD/Tensors.hs +32/−0
• ad.cabal +8/−3

@@ -1,5 +1,5 @@ {-# LANGUAGE Rank2Types, GeneralizedNewtypeDeriving, TemplateHaskell, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, DeriveFunctor, DeriveFoldable, DeriveTraversable #-}-{-# OPTIONS_HADDOCK hide, prune #-}+-- {-# OPTIONS_HADDOCK hide, prune #-} ----------------------------------------------------------------------------- -- | -- Module      :  Numeric.AD.Internal@@ -32,9 +32,13 @@ 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

@@ -1,5 +1,5 @@ {-# LANGUAGE Rank2Types, TypeFamilies, FlexibleInstances, MultiParamTypeClasses, FlexibleContexts, FunctionalDependencies, UndecidableInstances, GeneralizedNewtypeDeriving, TemplateHaskell #-}-{-# OPTIONS_HADDOCK hide #-}+-- {-# OPTIONS_HADDOCK hide #-} ----------------------------------------------------------------------------- -- | -- Module      :  Numeric.AD.Internal.Classes

@@ -0,0 +1,29 @@+{-# LANGUAGE TypeOperators, TemplateHaskell, ScopedTypeVariables #-}+-- {-# OPTIONS_HADDOCK hide #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.AD.Internal.Comonad+-- Copyright   :  (c) Edward Kmett 2010+-- License     :  BSD3+-- Maintainer  :  ekmett@gmail.com+-- Stability   :  experimental+-- Portability :  GHC only+--+-----------------------------------------------------------------------------++-- TODO: separate a \"comonads\" package from \"category-extras\"++module Numeric.AD.Internal.Comonad+    ( Copointed(..)+    , Comonad(..)+    ) where++class Functor f => Copointed f where+    extract :: f a -> a++class Copointed f => Comonad f where+    duplicate :: f a -> f (f a)+    extend :: (f a -> b) -> f a -> f b++    duplicate = extend id+    extend f = fmap f . duplicate

@@ -1,5 +1,5 @@ {-# LANGUAGE Rank2Types, TypeFamilies, MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, FlexibleContexts, TemplateHaskell, UndecidableInstances, TypeOperators #-}-{-# OPTIONS_HADDOCK hide, prune #-}+-- {-# OPTIONS_HADDOCK hide, prune #-} ----------------------------------------------------------------------------- -- | -- Module      :  Numeric.AD.Internal.Composition

@@ -1,5 +1,5 @@ {-# LANGUAGE Rank2Types, TypeFamilies, DeriveDataTypeable, TemplateHaskell, UndecidableInstances, BangPatterns #-}-{-# OPTIONS_HADDOCK hide, prune #-}+-- {-# OPTIONS_HADDOCK hide, prune #-} ----------------------------------------------------------------------------- -- | -- Module      :  Numeric.AD.Internal.Forward

@@ -0,0 +1,141 @@+{-# LANGUAGE TemplateHaskell, ScopedTypeVariables, DeriveDataTypeable, FlexibleContexts, UndecidableInstances #-}+-- {-# OPTIONS_HADDOCK hide #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.AD.Internal.Iterated+-- Copyright   :  (c) Edward Kmett 2010+-- License     :  BSD3+-- Maintainer  :  ekmett@gmail.com+-- Stability   :  experimental+-- Portability :  GHC only+--+-----------------------------------------------------------------------------++module Numeric.AD.Internal.Iterated+    ( Iterated(..)+    , tailI+    , unfoldI+    ) where++import Control.Applicative+import Data.Monoid+import Data.Foldable+import Data.Traversable+-- import Data.Data+-- import Data.Typeable+import Numeric.AD.Internal+import Numeric.AD.Internal.Comonad+import Language.Haskell.TH++infixl 3 :|++data Iterated f a = a :| f (Iterated f a)+--    deriving (Data, Typeable)++instance Functor f => Functor (Iterated f) where+    fmap f (a :| as) = f a :| fmap f <$> as++instance Functor f => Copointed (Iterated f) where+    extract (a :| _) = a++instance Functor f => Comonad (Iterated f) where+    duplicate aas@(_ :| as) = aas :| duplicate <$> as+    extend f aas@(_ :| as) = f aas :| extend f <$> as++instance Foldable f => Foldable (Iterated f) where+    foldMap f (a :| as) = f a `mappend` foldMap (foldMap f) as++instance Traversable f => Traversable (Iterated f) where+    traverse f (a :| as) = (:|) <$> f a <*> traverse (traverse f) as++-- tails of the f-branching stream comonad/cofree comonad+tailI :: (Iterated f a) -> f (Iterated f a)+tailI (_ :| as) = as++unfoldI :: Functor f => (a -> (b, f a)) -> a -> Iterated f b+unfoldI f a = h :| unfoldI f <$> t+    where+        (h, t) = f a++instance Primal (Iterated f) where+    primal (a :| _) = a++instance Mode f => Mode (Iterated f) where+    lift a = as+        where as = a :| lift as+    (a :| as) <+> (b :| bs) = (a + b) :| (as <+> bs)+    a *^ (b :| bs) = (a * b) :| (lift a *^ bs)+    (a :| as) ^* b = (a * b) :| (as ^* lift b)+    (a :| as) ^/ b = (a / b) :| (as ^/ lift b)++instance Mode f => Lifted (Iterated f) where+    showsPrec1 n (a :| _) = showsPrec n a+    (==!) = (==) `on` primal+    compare1 = compare `on` primal+    fromInteger1 a = fromInteger a :| fromInteger1 a+    (a :| as) +! (b :| bs) = (a + b) :| (as +! bs)+    (a :| as) -! (b :| bs) = (a - b) :| (as -! bs)+    (a :| as) *! (b :| bs) = (a * b) :| (as *! bs)+    negate1 (a :| as) = negate a :| negate1 as+    abs1 (a :| as) = abs a :| abs1 as+    signum1 (a :| as) = signum a :| signum1 as+    (a :| as) /! (b :| bs) = (a / b) :| (as /! bs)+    recip1 (a :| as) = recip a :| recip1 as+    fromRational1 n = fromRational n :| fromRational1 n+    toRational1 = toRational . primal+    pi1 = pi :| pi1+    exp1 (a :| as) = exp a :| exp1 as+    log1 (a :| as) = log a :| log1 as+    sqrt1 (a :| as) = sqrt a :| sqrt1 as+    (a :| as) **! (b :| bs) = (a ** b) :| (as **! bs)+    logBase1 (a :| as) (b :| bs) = logBase a b :| logBase1 as bs+    sin1 (a :| as) = sin a :| sin1 as+    cos1 (a :| as) = cos a :| cos1 as+    tan1 (a :| as) = tan a :| tan1 as+    asin1 (a :| as) = asin a :| asin1 as+    acos1 (a :| as) = acos a :| acos1 as+    atan1 (a :| as) = atan a :| atan1 as+    sinh1 (a :| as) = sinh a :| sinh1 as+    cosh1 (a :| as) = cosh a :| cosh1 as+    tanh1 (a :| as) = tanh a :| tanh1 as+    asinh1 (a :| as) = asinh a :| asinh1 as+    acosh1 (a :| as) = acosh a :| acosh1 as+    atanh1 (a :| as) = atanh a :| atanh1 as+    properFraction1 (a :| as) = (b, c :| cs)+        where+            (b, c) = properFraction a+            (_ :: Int, cs) = properFraction1 as+    truncate1 = truncate . primal+    round1 = round . primal+    ceiling1 = ceiling . primal+    floor1  = floor . primal+    floatRadix1 = floatRadix . primal+    floatDigits1 = floatDigits . primal+    floatRange1 = floatRange . primal+    decodeFloat1 = decodeFloat . primal+    encodeFloat1 m e = encodeFloat m e :| encodeFloat1 m e+    exponent1 = exponent . primal+    significand1 (a :| as) = significand a :| significand1 as+    scaleFloat1 n (a :| as) = scaleFloat n a :| scaleFloat1 n as+    isNaN1 = isNaN . primal+    isInfinite1 = isInfinite . primal+    isDenormalized1 = isDenormalized . primal+    isNegativeZero1 = isNegativeZero . primal+    isIEEE1 = isIEEE . primal+    atan21 (a :| as) (b :| bs) = atan2 a b :| atan21 as bs+    succ1 (a :| as) = succ a :| succ1 as+    pred1 (a :| as) = pred a :| pred1 as+    toEnum1 n = toEnum n :| toEnum1 n+    fromEnum1 = fromEnum . primal+    enumFrom1 = error "TODO"+    enumFromThen1 = error "TODO"+    enumFromTo1 = error "TODO"+    enumFromThenTo1 = error "TODO"+    minBound1 = minBound :| minBound1+    maxBound1 = maxBound :| maxBound1+    -- TODO:++-- instance (Mode f, Foo a) => Foo (Iterated f) ...+deriveNumeric+    (classP (mkName "Mode") [varT $ mkName "f"]:)+    (conT (mkName "Iterated") `appT` varT (mkName "f"))

@@ -1,5 +1,5 @@ {-# LANGUAGE Rank2Types, TypeFamilies, MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, FlexibleContexts, TemplateHaskell, UndecidableInstances #-}-{-# OPTIONS_HADDOCK hide, prune #-}+-- {-# OPTIONS_HADDOCK hide, prune #-} ----------------------------------------------------------------------------- -- | -- Module      :  Numeric.AD.Internal.Reverse

@@ -1,5 +1,5 @@-{-# LANGUAGE TypeOperators, TemplateHaskell, ScopedTypeVariables #-}-{-# OPTIONS_HADDOCK hide #-}+{-# LANGUAGE StandaloneDeriving, FlexibleContexts, UndecidableInstances #-}+-- {-# OPTIONS_HADDOCK hide #-} ----------------------------------------------------------------------------- -- | -- Module      :  Numeric.AD.Internal.Stream@@ -9,136 +9,56 @@ -- Stability   :  experimental -- Portability :  GHC only ----- A cofree comonad/f-branching stream  for use in returning towers of gradients. --- -----------------------------------------------------------------------------  module Numeric.AD.Internal.Stream -    ( (:>)(..)-    , Comonad(..)-    , unfold-    , tails+    ( Stream(..)+    , unfoldS+    , headS+    , tailS     ) where  import Control.Applicative import Data.Monoid import Data.Foldable import Data.Traversable-import Numeric.AD.Internal-import Language.Haskell.TH+-- import Data.Data+-- import Data.Typeable+import Numeric.AD.Internal.Comonad -infixl 3 :<, :>+infixl 3 :< -class Functor f => Comonad f where-    extract :: (f :> a) -> a-    duplicate :: (f :> a) -> (f :> (f :> a))-    extend :: ((f :> a) -> b) -> (f :> a) -> (f :> b)+data Stream f a = a :< f (Stream f a) -data (f :> a) = a :< f (f :> a)+deriving instance (Show a, Show (f (Stream f a))) => Show (Stream f a) -instance Functor f => Functor ((:>)f) where+-- TODO: Data, Typeable++instance Functor f => Functor (Stream f) where     fmap f (a :< as) = f a :< fmap f <$> as -instance Functor f => Comonad ((:>) f) where+instance Functor f => Copointed (Stream f) where     extract (a :< _) = a++instance Functor f => Comonad (Stream f) where     duplicate aas@(_ :< as) = aas :< duplicate <$> as     extend f aas@(_ :< as) = f aas :< extend f <$> as -instance Foldable f => Foldable ((:>) f) where+instance Foldable f => Foldable (Stream f) where     foldMap f (a :< as) = f a `mappend` foldMap (foldMap f) as -instance Traversable f => Traversable ((:>) f) where+instance Traversable f => Traversable (Stream f) where     traverse f (a :< as) = (:<) <$> f a <*> traverse (traverse f) as +headS :: Stream f a -> a+headS (a :< _) = a+ -- tails of the f-branching stream comonad/cofree comonad-tails :: (f :> a) -> f (f :> a)-tails (_ :< as) = as+tailS :: Stream f a -> f (Stream f a)+tailS (_ :< as) = as -unfold :: Functor f => (a -> (b, f a)) -> a -> (f :> b)-unfold f a = h :< unfold f <$> t +unfoldS :: Functor f => (a -> (b, f a)) -> a -> Stream f b+unfoldS f a = h :< unfoldS f <$> t      where         (h, t) = f a -instance Primal ((:>) f) where-    primal (a :< _) = a--instance Mode f => Mode ((:>) f) where-    lift a = as-        where as = a :< lift as-    (a :< as) <+> (b :< bs) = (a + b) :< (as <+> bs)-    a *^ (b :< bs) = (a * b) :< (lift a *^ bs)-    (a :< as) ^* b = (a * b) :< (as ^* lift b)-    (a :< as) ^/ b = (a / b) :< (as ^/ lift b)--instance Mode f => Lifted ((:>) f) where-    showsPrec1 n (a :< _) = showsPrec n a-    (==!) = (==) `on` primal-    compare1 = compare `on` primal-    fromInteger1 a = fromInteger a :< fromInteger1 a-    (a :< as) +! (b :< bs) = (a + b) :< (as +! bs)-    (a :< as) -! (b :< bs) = (a - b) :< (as -! bs)-    (a :< as) *! (b :< bs) = (a * b) :< (as *! bs)-    negate1 (a :< as) = negate a :< negate1 as-    abs1 (a :< as) = abs a :< abs1 as-    signum1 (a :< as) = signum a :< signum1 as-    (a :< as) /! (b :< bs) = (a / b) :< (as /! bs)-    recip1 (a :< as) = recip a :< recip1 as-    fromRational1 n = fromRational n :< fromRational1 n-    toRational1 = toRational . primal-    pi1 = pi :< pi1-    exp1 (a :< as) = exp a :< exp1 as-    log1 (a :< as) = log a :< log1 as-    sqrt1 (a :< as) = sqrt a :< sqrt1 as-    (a :< as) **! (b :< bs) = (a ** b) :< (as **! bs)-    logBase1 (a :< as) (b :< bs) = logBase a b :< logBase1 as bs-    sin1 (a :< as) = sin a :< sin1 as-    cos1 (a :< as) = cos a :< cos1 as-    tan1 (a :< as) = tan a :< tan1 as-    asin1 (a :< as) = asin a :< asin1 as-    acos1 (a :< as) = acos a :< acos1 as-    atan1 (a :< as) = atan a :< atan1 as-    sinh1 (a :< as) = sinh a :< sinh1 as-    cosh1 (a :< as) = cosh a :< cosh1 as-    tanh1 (a :< as) = tanh a :< tanh1 as-    asinh1 (a :< as) = asinh a :< asinh1 as-    acosh1 (a :< as) = acosh a :< acosh1 as-    atanh1 (a :< as) = atanh a :< atanh1 as-    properFraction1 (a :< as) = (b, c :< cs) -        where-            (b, c) = properFraction a-            (_ :: Int, cs) = properFraction1 as-    truncate1 = truncate . primal-    round1 = round . primal-    ceiling1 = ceiling . primal -    floor1  = floor . primal -    floatRadix1 = floatRadix . primal-    floatDigits1 = floatDigits . primal-    floatRange1 = floatRange . primal-    decodeFloat1 = decodeFloat . primal-    encodeFloat1 m e = encodeFloat m e :< encodeFloat1 m e-    exponent1 = exponent . primal -    significand1 (a :< as) = significand a :< significand1 as-    scaleFloat1 n (a :< as) = scaleFloat n a :< scaleFloat1 n as-    isNaN1 = isNaN . primal -    isInfinite1 = isInfinite . primal-    isDenormalized1 = isDenormalized . primal -    isNegativeZero1 = isNegativeZero . primal -    isIEEE1 = isIEEE . primal -    atan21 (a :< as) (b :< bs) = atan2 a b :< atan21 as bs-    succ1 (a :< as) = succ a :< succ1 as-    pred1 (a :< as) = pred a :< pred1 as-    toEnum1 n = toEnum n :< toEnum1 n-    fromEnum1 = fromEnum . primal-    enumFrom1 = error "TODO"-    enumFromThen1 = error "TODO"-    enumFromTo1 = error "TODO"-    enumFromThenTo1 = error "TODO"-    minBound1 = minBound :< minBound1-    maxBound1 = maxBound :< maxBound1-    -- TODO:----- instance (Mode f, Foo a) => Foo ((:>) f) ...-deriveNumeric -    (classP (mkName "Mode") [varT $ mkName "f"]:) -    (conT (mkName ":>") `appT` varT (mkName "f")) 

@@ -0,0 +1,62 @@+{-# LANGUAGE TypeOperators, TemplateHaskell, ScopedTypeVariables #-}+-- {-# OPTIONS_HADDOCK hide #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.AD.Internal.Tensors+-- Copyright   :  (c) Edward Kmett 2010+-- License     :  BSD3+-- Maintainer  :  ekmett@gmail.com+-- Stability   :  experimental+-- Portability :  GHC only+--+-----------------------------------------------------------------------------++module Numeric.AD.Internal.Tensors+    ( Tensors(..)+    , headT+    , tailT+    , tensors+    ) where++import Control.Applicative+import Data.Foldable+import Data.Traversable+import Data.Monoid+--import Data.Data+--import Data.Typeable+import Numeric.AD.Internal.Comonad+import Numeric.AD.Internal.Stream++infixl 3 :-++data Tensors f a = a :- Tensors f (f a)+-- TODO: deriving (Data, Typeable)++instance Functor f => Functor (Tensors f) where+    fmap f (a :- as) = f a :- fmap (fmap f) as++instance Foldable f => Foldable (Tensors f) where+    foldMap f (a :- as) = f a `mappend` foldMap (foldMap f) as++instance Traversable f => Traversable (Tensors f) where+    traverse f (a :- as) = (:-) <$> f a <*> traverse (traverse f) as++-- | While we can not be a 'Comonad' without a 'fzip'-like operation, you can use the+-- comonad for @'Stream' f a@ to manipulate a structure comonadically that you can turn +-- into 'Tensors'.+instance Functor f => Copointed (Tensors f) where+    extract (a :- _) = a++tailT :: Tensors f a -> Tensors f (f a)+tailT (_ :- as) = as+{-# INLINE tailT #-}++headT :: Tensors f a -> a+headT (a :- _) = a+{-# INLINE headT #-}++tensors :: Functor f => Stream f a -> Tensors f a+tensors (a :< as) = a :- distribute (tensors <$> as)+    where+        distribute :: Functor f => f (Tensors f a) -> Tensors f (f a)+        distribute x = (headT <$> x) :- distribute (tailT <$> x)

@@ -1,5 +1,5 @@ {-# LANGUAGE Rank2Types, TypeFamilies, FlexibleContexts, UndecidableInstances, TemplateHaskell #-}-{-# OPTIONS_HADDOCK hide, prune #-}+-- {-# OPTIONS_HADDOCK hide, prune #-} ----------------------------------------------------------------------------- -- | -- Module      : Numeric.AD.Tower.Internal

@@ -1,22 +0,0 @@-{-# LANGUAGE TypeOperators, TemplateHaskell, ScopedTypeVariables #-}--------------------------------------------------------------------------------- |--- Module      :  Numeric.AD.Stream--- Copyright   :  (c) Edward Kmett 2010--- License     :  BSD3--- Maintainer  :  ekmett@gmail.com--- Stability   :  experimental--- Portability :  GHC only------ A cofree comonad/f-branching stream  for use in returning towers of gradients. -----------------------------------------------------------------------------------module Numeric.AD.Stream -    ( (:>)(..)-    , Comonad(..)-    , unfold-    , tails-    ) where--import Numeric.AD.Internal.Stream

@@ -0,0 +1,32 @@+{-# LANGUAGE TypeOperators, TemplateHaskell, ScopedTypeVariables #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.AD.Tensors+-- Copyright   :  (c) Edward Kmett 2010+-- License     :  BSD3+-- Maintainer  :  ekmett@gmail.com+-- Stability   :  experimental+-- Portability :  GHC only+--+-----------------------------------------------------------------------------++module Numeric.AD.Tensors+    ( +    -- * Tensors+      Tensors(..)+    , headT+    , tailT+    , tensors+    -- * f-Branching Streams+    , Stream(..)+    , headS+    , tailS+    , unfoldS+    -- * Comonads+    , Copointed(..)+    , Comonad(..)+    ) where++import Numeric.AD.Internal.Comonad+import Numeric.AD.Internal.Stream+import Numeric.AD.Internal.Tensors

@@ -1,5 +1,5 @@ Name:         ad-Version:      0.27+Version:      0.28 License:      BSD3 License-File: LICENSE Copyright:    (c) Edward Kmett 2010,@@ -31,14 +31,19 @@     Numeric.AD.Tower     Numeric.AD.Directed     Numeric.AD.Newton-    Numeric.AD.Stream+    Numeric.AD.Tensors+     Numeric.AD.Internal     Numeric.AD.Internal.Classes+    Numeric.AD.Internal.Comonad+    Numeric.AD.Internal.Stream+    Numeric.AD.Internal.Tensors+     Numeric.AD.Internal.Composition     Numeric.AD.Internal.Forward     Numeric.AD.Internal.Reverse     Numeric.AD.Internal.Tower-    Numeric.AD.Internal.Stream+    Numeric.AD.Internal.Iterated  Extra-Source-Files: TODO GHC-Options: -Wall