Numeric.AD.Mode.Sparse

Higher order derivatives via a "dual number tower".

Documentation

data AD s a

Instances

Bounded a => Bounded (AD s a)

Enum a => Enum (AD s a)

Eq a => Eq (AD s a)

Floating a => Floating (AD s a)

Fractional a => Fractional (AD s a)

Num a => Num (AD s a)

Ord a => Ord (AD s a)

Read a => Read (AD s a)

Real a => Real (AD s a)

RealFloat a => RealFloat (AD s a)

RealFrac a => RealFrac (AD s a)

Show a => Show (AD s a)

Erf a => Erf (AD s a)

InvErf a => InvErf (AD s a)

Mode a => Mode (AD s a)

Typeable (* -> * -> *) AD

type Scalar (AD s a) = Scalar a

data Sparse a

We only store partials in sorted order, so the map contained in a partial will only contain partials with equal or greater keys to that of the map in which it was found. This should be key for efficiently computing sparse hessians. there are only (n + k - 1) choose k distinct nth partial derivatives of a function with k inputs.

Instances

(Num a, Bounded a) => Bounded (Sparse a)

(Num a, Enum a) => Enum (Sparse a)

(Num a, Eq a) => Eq (Sparse a)

Floating a => Floating (Sparse a)

Fractional a => Fractional (Sparse a)

Data a => Data (Sparse a)

Num a => Num (Sparse a)

(Num a, Ord a) => Ord (Sparse a)

Real a => Real (Sparse a)

RealFloat a => RealFloat (Sparse a)

RealFrac a => RealFrac (Sparse a)

Show a => Show (Sparse a)

Erf a => Erf (Sparse a)

InvErf a => InvErf (Sparse a)

Num a => Mode (Sparse a)

Num a => Jacobian (Sparse a)

Num a => Grad (Sparse a) [a] (a, [a]) a

Num a => Grads (Sparse a) (Cofree [] a) a

Typeable (* -> *) Sparse

Grads i o a => Grads (Sparse a -> i) (a -> o) a

Grad i o o' a => Grad (Sparse a -> i) (a -> o) (a -> o') a

type Scalar (Sparse a) = a

type D (Sparse a) = Sparse a

auto :: Mode t => Scalar t -> t

Embed a constant

Sparse Gradients

grad :: (Traversable f, Num a) => (forall s. f (AD s (Sparse a)) -> AD s (Sparse a)) -> f a -> f a

grad' :: (Traversable f, Num a) => (forall s. f (AD s (Sparse a)) -> AD s (Sparse a)) -> f a -> (a, f a)

grads :: (Traversable f, Num a) => (forall s. f (AD s (Sparse a)) -> AD s (Sparse a)) -> f a -> Cofree f a

gradWith :: (Traversable f, Num a) => (a -> a -> b) -> (forall s. f (AD s (Sparse a)) -> AD s (Sparse a)) -> f a -> f b

gradWith' :: (Traversable f, Num a) => (a -> a -> b) -> (forall s. f (AD s (Sparse a)) -> AD s (Sparse a)) -> f a -> (a, f b)

Sparse Jacobians (synonyms)

jacobian :: (Traversable f, Functor g, Num a) => (forall s. f (AD s (Sparse a)) -> g (AD s (Sparse a))) -> f a -> g (f a)

jacobian' :: (Traversable f, Functor g, Num a) => (forall s. f (AD s (Sparse a)) -> g (AD s (Sparse a))) -> f a -> g (a, f a)

jacobianWith :: (Traversable f, Functor g, Num a) => (a -> a -> b) -> (forall s. f (AD s (Sparse a)) -> g (AD s (Sparse a))) -> f a -> g (f b)

jacobianWith' :: (Traversable f, Functor g, Num a) => (a -> a -> b) -> (forall s. f (AD s (Sparse a)) -> g (AD s (Sparse a))) -> f a -> g (a, f b)

jacobians :: (Traversable f, Functor g, Num a) => (forall s. f (AD s (Sparse a)) -> g (AD s (Sparse a))) -> f a -> g (Cofree f a)

Sparse Hessians

hessian :: (Traversable f, Num a) => (forall s. f (AD s (Sparse a)) -> AD s (Sparse a)) -> f a -> f (f a)

hessian' :: (Traversable f, Num a) => (forall s. f (AD s (Sparse a)) -> AD s (Sparse a)) -> f a -> (a, f (a, f a))

hessianF :: (Traversable f, Functor g, Num a) => (forall s. f (AD s (Sparse a)) -> g (AD s (Sparse a))) -> f a -> g (f (f a))

hessianF' :: (Traversable f, Functor g, Num a) => (forall s. f (AD s (Sparse a)) -> g (AD s (Sparse a))) -> f a -> g (a, f (a, f a))