Hi,

I'm working with some classes that handle probabilities in terms of their log or log-odds.  Such classes only handle non-negative real numbers.  For example, from Numeric.Log:

    newtype Log a = Exp { ln :: a }

Since the log of a positive number can be negative, we don't want to use the same type to hold the number and its logarithm.  Standard functions exp, log, and (**) are awkward because they all assume that numbers and their powers have the same type:

   log,exp :: a -> a
   (**) :: a -> a -> a

In comparison the ln function from Numeric.Log has a different signature that allows a number and its logarithm to have different types:

   ln :: Log a -> a
   Exp :: a -> Log a

In order to address this, I have tried defining a type class Pow:

   class Fractional a => Pow a where
      pow :: a -> Double -> a
      ln  :: a -> Double
      expTo :: Double -> a

Probably I should replace "Double" here by a type variable b, but I have not done so yet.  I'm mostly interested in abstracting over the type of non-negative number, because I have another type Prob that is designed to handle numbers like 1e - 100000, and 1.0 - 1e-100000.

    data Prob = Zero | Odds Double | One | IOdds Double | Infinity  -- store probability in terms of log odds = log (p/(1-p))

Q1. Does anybody know of an existing Haskell module that implements something like the Pow class above?

Also, it would be nice (notationally) if I could use log, exp, and (**) instead of ln, expTo, and pow.  In theory we could factor out log, exp, (**), sqrt, and logBase from Floating into a new superclass of Floating, so that Floating only contains trig and hyper-trig functions.

But I suspect this will not work because the methods in class Pow are more ambiguous. For example, if (x :: Double) then you can do (expTo x :: Prob) and (expTo x :: Log Double) and they will yield different types.

Q2. Does anybody have a suggestion for a nicer design?

Thanks!

-BenRI