Numeric.Log

Documentation

newtype Log a

Log-domain Float and Double values.

Constructors

Log

Fields

runLog :: a

Instances

Monad Log

Functor Log

Typeable1 Log

Applicative Log

Foldable Log

Traversable Log

Comonad Log

ComonadApply Log

Distributive Log

Traversable1 Log

Foldable1 Log

Apply Log

Bind Log

Extend Log

(RealFloat a, Precise a, Enum a) => Enum (Log a)

Eq a => Eq (Log a)

(RealFloat a, Precise a) => Floating (Log a)

(Precise a, RealFloat a, Eq a) => Fractional (Log a)

Data a => Data (Log a)

(Precise a, RealFloat a) => Num (Log a)

Ord a => Ord (Log a)

(Floating a, Read a) => Read (Log a)

(Precise a, RealFloat a, Ord a) => Real (Log a)

(Floating a, Show a) => Show (Log a)

Generic (Log a)

(Precise a, RealFloat a) => Monoid (Log a)

Storable a => Storable (Log a)

Binary a => Binary (Log a)

Serialize a => Serialize (Log a)

NFData a => NFData (Log a)

Hashable a => Hashable (Log a)

SafeCopy a0 => SafeCopy (Log a0)

class Floating a => Precise a where

This provides log1p and expm1 for working more accurately with small numbers.

Methods

log1p :: a -> a

Computes log(1 + x)

This is far enough from 0 that the Taylor series is defined.

expm1 :: a -> a

The Taylor series for exp(x) is given by

 exp(x) = 1 + x + x^2/2! + ...

When x is small, the leading 1 consumes all of the available precision.

This computes:

 exp(x) - 1 = x + x^2/2! + ..

which can afford you a great deal of additional precision if you move things around algebraically to provide the 1 by other means.

Instances

Precise Double

Precise Float

(RealFloat a, Precise a) => Precise (Complex a)

sum :: (RealFloat a, Ord a, Precise a, Foldable f) => f (Log a) -> Log a

Efficiently and accurately compute the sum of a set of log-domain numbers

While folding with (+) accomplishes the same end, it requires an additional n-2 logarithms to sum n terms. In addition, here we introduce fewer opportunities for round-off error.

While for small quantities the naive sum accumulates error,

>>> let xs = replicate 40000 (Log 1e-4) :: [Log Float]
>>> Prelude.sum xs
40001.3

This sum gives a more accurate result,

>>> Numeric.Log.sum xs
40004.01

NB: This does require two passes over the data.