-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Log-domain arithmetic
--   
--   This package provides log-domain floats, doubles and complex numbers.
@package log-domain
@version 0.11.2


module Numeric.Log

-- | <tt>Log</tt>-domain <tt>Float</tt> and <tt>Double</tt> values.
newtype Log a
Exp :: a -> Log a
[ln] :: Log a -> a

-- | This provides <tt>log1p</tt> and <tt>expm1</tt> for working more
--   accurately with small numbers.
class Floating a => Precise a where log1pexp a = log1p (exp a) log1mexp a = log1p (negate (exp a))

-- | Computes <tt>log(1 + x)</tt>
--   
--   This is far enough from 0 that the Taylor series is defined.
--   
--   This can provide much more accurate answers for logarithms of numbers
--   close to 1 (x near 0).
--   
--   These arise when working wth log-scale probabilities a lot.
log1p :: Precise a => a -> a

-- | The Taylor series for exp(x) is given by
--   
--   <pre>
--   exp(x) = 1 + x + x^2/2! + ...
--   </pre>
--   
--   When <tt>x</tt> is small, the leading 1 consumes all of the available
--   precision.
--   
--   This computes:
--   
--   <pre>
--   exp(x) - 1 = x + x^2/2! + ..
--   </pre>
--   
--   which can afford you a great deal of additional precision if you move
--   things around algebraically to provide the 1 by other means.
expm1 :: Precise a => a -> a
log1pexp :: Precise a => a -> a
log1mexp :: Precise a => a -> a

-- | Efficiently and accurately compute the sum of a set of log-domain
--   numbers
--   
--   While folding with <tt>(+)</tt> accomplishes the same end, it requires
--   an additional <tt>n-2</tt> logarithms to sum <tt>n</tt> terms. In
--   addition, here we introduce fewer opportunities for round-off error.
--   
--   While for small quantities the naive sum accumulates error,
--   
--   <pre>
--   &gt;&gt;&gt; let xs = Prelude.replicate 40000 (Exp 1e-4) :: [Log Float]
--   
--   &gt;&gt;&gt; Prelude.sum xs ~= 4.00e4
--   True
--   </pre>
--   
--   This sum gives a more accurate result,
--   
--   <pre>
--   &gt;&gt;&gt; Numeric.Log.sum xs ~= 4.00e4
--   True
--   </pre>
--   
--   <i>NB:</i> This does require two passes over the data.
sum :: (RealFloat a, Ord a, Precise a, Foldable f) => f (Log a) -> Log a
instance GHC.Generics.Generic (Numeric.Log.Log a)
instance Data.Data.Data a => Data.Data.Data (Numeric.Log.Log a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Numeric.Log.Log a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Numeric.Log.Log a)
instance Data.SafeCopy.SafeCopy.SafeCopy a => Data.SafeCopy.SafeCopy.SafeCopy (Numeric.Log.Log a)
instance (GHC.Float.Floating a, GHC.Show.Show a) => GHC.Show.Show (Numeric.Log.Log a)
instance (GHC.Float.Floating a, GHC.Read.Read a) => GHC.Read.Read (Numeric.Log.Log a)
instance Data.Binary.Class.Binary a => Data.Binary.Class.Binary (Numeric.Log.Log a)
instance Data.Serialize.Serialize a => Data.Serialize.Serialize (Numeric.Log.Log a)
instance Data.Bytes.Serial.Serial a => Data.Bytes.Serial.Serial (Numeric.Log.Log a)
instance Data.Bytes.Serial.Serial1 Numeric.Log.Log
instance GHC.Base.Functor Numeric.Log.Log
instance Data.Hashable.Class.Hashable a => Data.Hashable.Class.Hashable (Numeric.Log.Log a)
instance Data.Hashable.Class.Hashable1 Numeric.Log.Log
instance Foreign.Storable.Storable a => Foreign.Storable.Storable (Numeric.Log.Log a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Numeric.Log.Log a)
instance Data.Foldable.Foldable Numeric.Log.Log
instance Data.Semigroup.Foldable.Class.Foldable1 Numeric.Log.Log
instance Data.Traversable.Traversable Numeric.Log.Log
instance Data.Semigroup.Traversable.Class.Traversable1 Numeric.Log.Log
instance Data.Distributive.Distributive Numeric.Log.Log
instance Data.Functor.Extend.Extend Numeric.Log.Log
instance Control.Comonad.Comonad Numeric.Log.Log
instance GHC.Base.Applicative Numeric.Log.Log
instance Control.Comonad.ComonadApply Numeric.Log.Log
instance Data.Functor.Bind.Class.Apply Numeric.Log.Log
instance Data.Functor.Bind.Class.Bind Numeric.Log.Log
instance GHC.Base.Monad Numeric.Log.Log
instance (GHC.Float.RealFloat a, Numeric.Log.Precise a, GHC.Enum.Enum a) => GHC.Enum.Enum (Numeric.Log.Log a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a) => GHC.Num.Num (Numeric.Log.Log a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a, GHC.Classes.Eq a) => GHC.Real.Fractional (Numeric.Log.Log a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a) => GHC.Real.RealFrac (Numeric.Log.Log a)
instance (GHC.Float.RealFloat a, Data.Vector.Unboxed.Base.Unbox a) => Data.Vector.Unboxed.Base.Unbox (Numeric.Log.Log a)
instance (GHC.Float.RealFloat a, Data.Vector.Unboxed.Base.Unbox a) => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Numeric.Log.Log a)
instance (GHC.Float.RealFloat a, Data.Vector.Unboxed.Base.Unbox a) => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Numeric.Log.Log a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a, GHC.Classes.Ord a) => GHC.Real.Real (Numeric.Log.Log a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a) => GHC.Base.Monoid (Numeric.Log.Log a)
instance (GHC.Float.RealFloat a, Numeric.Log.Precise a) => GHC.Float.Floating (Numeric.Log.Log a)
instance Numeric.Log.Precise GHC.Types.Double
instance Numeric.Log.Precise GHC.Types.Float
instance (GHC.Float.RealFloat a, Numeric.Log.Precise a) => Numeric.Log.Precise (Data.Complex.Complex a)


module Numeric.Log.Signed

-- | <tt>Log</tt>-domain <tt>Float</tt> and <tt>Double</tt> values, with a
--   sign bit.
data SignedLog a
SLExp :: Bool -> a -> SignedLog a
[signSL] :: SignedLog a -> Bool
[lnSL] :: SignedLog a -> a
instance GHC.Generics.Generic (Numeric.Log.Signed.SignedLog a)
instance Data.Data.Data a => Data.Data.Data (Numeric.Log.Signed.SignedLog a)
instance (GHC.Classes.Eq a, GHC.Real.Fractional a) => GHC.Classes.Eq (Numeric.Log.Signed.SignedLog a)
instance (GHC.Classes.Ord a, GHC.Real.Fractional a) => GHC.Classes.Ord (Numeric.Log.Signed.SignedLog a)
instance (GHC.Show.Show a, GHC.Float.RealFloat a, GHC.Classes.Eq a, GHC.Real.Fractional a) => GHC.Show.Show (Numeric.Log.Signed.SignedLog a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a, GHC.Real.Fractional a, GHC.Read.Read a) => GHC.Read.Read (Numeric.Log.Signed.SignedLog a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a) => GHC.Num.Num (Numeric.Log.Signed.SignedLog a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a) => GHC.Real.Fractional (Numeric.Log.Signed.SignedLog a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a, GHC.Classes.Ord a) => GHC.Real.Real (Numeric.Log.Signed.SignedLog a)
instance (GHC.Float.RealFloat a, Numeric.Log.Precise a) => GHC.Float.Floating (Numeric.Log.Signed.SignedLog a)
instance (Numeric.Log.Precise a, GHC.Float.RealFloat a) => GHC.Real.RealFrac (Numeric.Log.Signed.SignedLog a)
