Numeric.AD.Classes

AD modes

class Lifted t => Mode t where

Methods

lift :: Num a => a -> t a

Embed a constant

(<+>) :: Num a => t a -> t a -> t a

Vector sum

(*^) :: Num a => a -> t a -> t a

Scalar-vector multiplication

(^*) :: Num a => t a -> a -> t a

Vector-scalar multiplication

(^/) :: Fractional a => t a -> a -> t a

Scalar division

zero :: Num a => t a

 'zero' = 'lift' 0

Instances

Mode Id

Lifted Forward => Mode Forward

Lifted Reverse => Mode Reverse

Lifted Tower => Mode Tower

Mode f => Mode (AD f)

(Mode f, Mode g) => Mode (ComposeMode f g)

one :: (Mode t, Num a) => t a

 'one' = 'lift' 1

Automatically Deriving AD

class (Mode t, Mode (D t)) => Jacobian t where

Jacobian is used by deriveMode but is not exposed via Mode to prevent its abuse by end users via the AD data type.

Associated Types

type D t :: * -> *

Methods

unary :: Num a => (a -> a) -> D t a -> t a -> t a

lift1 :: Num a => (a -> a) -> (D t a -> D t a) -> t a -> t a

lift1_ :: Num a => (a -> a) -> (D t a -> D t a -> D t a) -> t a -> t a

binary :: Num a => (a -> a -> a) -> D t a -> D t a -> t a -> t a -> t a

lift2 :: Num a => (a -> a -> a) -> (D t a -> D t a -> (D t a, D t a)) -> t a -> t a -> t a

lift2_ :: Num a => (a -> a -> a) -> (D t a -> D t a -> D t a -> (D t a, D t a)) -> t a -> t a -> t a

Instances

Lifted Forward => Jacobian Forward

Lifted Reverse => Jacobian Reverse

Lifted Tower => Jacobian Tower

class Primal t where

Primal is used by deriveMode but is not exposed via the Mode class to prevent its abuse by end users via the AD data type.

It provides direct access to the result, stripped of its derivative information, but this is unsafe in general as (lift . primal) would discard derivative information. The end user is protected from accidentally using this function by the universal quantification on the various combinators we expose.

Methods

primal :: Num a => t a -> a

Instances

Primal Id

Primal Forward

Primal Reverse

Primal Tower

Primal f => Primal (AD f)

(Primal f, Mode g, Primal g) => Primal (ComposeMode f g)

deriveLifted :: Q Type -> Q [Dec]

deriveLifted t provides

 instance Lifted $t

given supplied instances for

 instance Lifted $t => Primal $t where ...
 instance Lifted $t => Jacobian $t where ...

The seemingly redundant Lifted $t constraints are caused by Template Haskell staging restrictions.

deriveNumeric :: Q Type -> Q Type -> Q [Dec]

deriveNumeric f g provides the following instances:

 instance ('Lifted' $f, 'Num' a, 'Enum' a) => 'Enum' ($g a)
 instance ('Lifted' $f, 'Num' a, 'Eq' a) => 'Eq' ($g a)
 instance ('Lifted' $f, 'Num' a, 'Ord' a) => 'Ord' ($g a)
 instance ('Lifted' $f, 'Num a, 'Bounded' a) => 'Bounded' ($g a)
 instance ('Lifted' $f, 'Show' a) => 'Show' ($g a)
 instance ('Lifted' $f, 'Num' a) => 'Num' ($g a)
 instance ('Lifted' $f, 'Fractional' a) => 'Fractional' ($g a)
 instance ('Lifted' $f, 'Floating' a) => 'Floating' ($g a)
 instance ('Lifted' $f, 'RealFloat' a) => 'RealFloat' ($g a)
 instance ('Lifted' $f, 'RealFrac' a) => 'RealFrac' ($g a)
 instance ('Lifted' $f, 'Real' a) => 'Real' ($g a)

class Lifted t where

Higher-order versions of the stock numerical methods.

Methods

showsPrec1 :: Show a => Int -> t a -> ShowS

(==!) :: (Num a, Eq a) => t a -> t a -> Bool

compare1 :: (Num a, Ord a) => t a -> t a -> Ordering

fromInteger1 :: Num a => Integer -> t a

(+!) :: Num a => t a -> t a -> t a

(*!) :: Num a => t a -> t a -> t a

(-!) :: Num a => t a -> t a -> t a

negate1 :: Num a => t a -> t a

signum1 :: Num a => t a -> t a

abs1 :: Num a => t a -> t a

(/!) :: Fractional a => t a -> t a -> t a

recip1 :: Fractional a => t a -> t a

fromRational1 :: Fractional a => Rational -> t a

toRational1 :: Real a => t a -> Rational

pi1 :: Floating a => t a

exp1 :: Floating a => t a -> t a

sqrt1 :: Floating a => t a -> t a

log1 :: Floating a => t a -> t a

(**!) :: Floating a => t a -> t a -> t a

logBase1 :: Floating a => t a -> t a -> t a

sin1 :: Floating a => t a -> t a

atan1 :: Floating a => t a -> t a

acos1 :: Floating a => t a -> t a

asin1 :: Floating a => t a -> t a

tan1 :: Floating a => t a -> t a

cos1 :: Floating a => t a -> t a

sinh1 :: Floating a => t a -> t a

atanh1 :: Floating a => t a -> t a

acosh1 :: Floating a => t a -> t a

asinh1 :: Floating a => t a -> t a

tanh1 :: Floating a => t a -> t a

cosh1 :: Floating a => t a -> t a

properFraction1 :: (RealFrac a, Integral b) => t a -> (b, t a)

truncate1 :: (RealFrac a, Integral b) => t a -> b

floor1 :: (RealFrac a, Integral b) => t a -> b

ceiling1 :: (RealFrac a, Integral b) => t a -> b

round1 :: (RealFrac a, Integral b) => t a -> b

floatRadix1 :: RealFloat a => t a -> Integer

floatDigits1 :: RealFloat a => t a -> Int

floatRange1 :: RealFloat a => t a -> (Int, Int)

decodeFloat1 :: RealFloat a => t a -> (Integer, Int)

encodeFloat1 :: RealFloat a => Integer -> Int -> t a

exponent1 :: RealFloat a => t a -> Int

significand1 :: RealFloat a => t a -> t a

scaleFloat1 :: RealFloat a => Int -> t a -> t a

isNaN1 :: RealFloat a => t a -> Bool

isIEEE1 :: RealFloat a => t a -> Bool

isNegativeZero1 :: RealFloat a => t a -> Bool

isDenormalized1 :: RealFloat a => t a -> Bool

isInfinite1 :: RealFloat a => t a -> Bool

atan21 :: RealFloat a => t a -> t a -> t a

succ1 :: (Num a, Enum a) => t a -> t a

pred1 :: (Num a, Enum a) => t a -> t a

toEnum1 :: (Num a, Enum a) => Int -> t a

fromEnum1 :: (Num a, Enum a) => t a -> Int

enumFrom1 :: (Num a, Enum a) => t a -> [t a]

enumFromThen1 :: (Num a, Enum a) => t a -> t a -> [t a]

enumFromTo1 :: (Num a, Enum a) => t a -> t a -> [t a]

enumFromThenTo1 :: (Num a, Enum a) => t a -> t a -> t a -> [t a]

minBound1 :: (Num a, Bounded a) => t a

maxBound1 :: (Num a, Bounded a) => t a

Instances

Lifted Id

Lifted Forward

Lifted Reverse

Lifted Tower

Lifted f => Lifted (AD f)

(Mode f, Mode g) => Lifted (ComposeMode f g)