ad-0.28: Automatic Differentiation

PortabilityGHC only






type UU a = forall s. Mode s => AD s a -> AD s aSource

A scalar-to-scalar automatically-differentiable function.

type UF f a = forall s. Mode s => AD s a -> f (AD s a)Source

A scalar-to-non-scalar automatically-differentiable function.

type FU f a = forall s. Mode s => f (AD s a) -> AD s aSource

A non-scalar-to-scalar automatically-differentiable function.

type FF f g a = forall s. Mode s => f (AD s a) -> g (AD s a)Source

A non-scalar-to-non-scalar automatically-differentiable function.

zipWithT :: (Foldable f, Traversable g) => (a -> b -> c) -> f a -> g b -> g cSource

zipWithDefaultT :: (Foldable f, Traversable g) => a -> (a -> b -> c) -> f a -> g b -> g cSource

on :: (a -> a -> b) -> (c -> a) -> c -> c -> bSource

newtype AD f a Source

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.




runAD :: f a


Primal f => Primal (AD f) 
Mode f => Mode (AD f) 
Lifted f => Lifted (AD f) 
Var (AD Reverse) 
Iso (f a) (AD f a) 
(Num a, Lifted f, Bounded a) => Bounded (AD f a) 
(Num a, Lifted f, Enum a) => Enum (AD f a) 
(Num a, Lifted f, Eq a) => Eq (AD f a) 
(Lifted f, Floating a) => Floating (AD f a) 
(Lifted f, Fractional a) => Fractional (AD f a) 
(Lifted f, Num a) => Num (AD f a) 
(Num a, Lifted f, Ord a) => Ord (AD f a) 
(Lifted f, Real a) => Real (AD f a) 
(Lifted f, RealFloat a) => RealFloat (AD f a) 
(Lifted f, RealFrac a) => RealFrac (AD f a) 
(Lifted f, Show a) => Show (AD f a) 

newtype Id a Source


Id a 


Monad Id 
Functor Id 
Applicative Id 
Primal Id 
Mode Id 
Lifted Id 
Iso a (Id a) 
Bounded a => Bounded (Id a) 
Enum a => Enum (Id a) 
Eq a => Eq (Id a) 
Floating a => Floating (Id a) 
Fractional a => Fractional (Id a) 
Num a => Num (Id a) 
Ord a => Ord (Id a) 
Real a => Real (Id a) 
RealFloat a => RealFloat (Id a) 
RealFrac a => RealFrac (Id a) 
Show a => Show (Id a) 
Monoid a => Monoid (Id a) 

probe :: a -> AD Id aSource

unprobe :: AD Id a -> aSource

probed :: f a -> f (AD Id a)Source

unprobed :: f (AD Id a) -> f aSource

data Pair a b Source


Pair a b 


Functor (Pair a) 
Foldable (Pair a) 
Traversable (Pair a) 
(Eq a, Eq b) => Eq (Pair a b) 
(Ord a, Ord b) => Ord (Pair a b) 
(Read a, Read b) => Read (Pair a b) 
(Show a, Show b) => Show (Pair a b)