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


-- | Base types and classes for statistics, sciences and humanities
--   
--   This library provides a set of basic types and classes for statistics,
--   sciences, and the humanities.
@package SciBaseTypes
@version 0.0.0.1


-- | Discretized floating point numbers, where the scaling factor is kept
--   as two phantom types denoting the rational number used for scaling.
module Numeric.Discretized

-- | A discretized value takes a floating point number <tt>n</tt> and
--   produces <tt>n * fromIntegral l / fromIntegral u</tt> where both
--   <tt>u</tt> and <tt>l</tt> are given as <tt>TypeLits</tt>. I.e. a
--   scaling factor of <tt> (u <i> l) = (1 </i> 100)</tt> does all
--   calculations in subdivisions of 100.
--   
--   The main use of a <a>Discretized</a> value is to enable calculations
--   with <a>Int</a> while somewhat pretending to use floating point
--   values.
--   
--   Be careful with certain operations like <tt>(*)</tt> as they will
--   easily cause the numbers to arbitrarily wrong. <tt>(+)</tt> and
--   <tt>(-)</tt> are fine, however.
--   
--   NOTE Export and import of data is in the form of floating points,
--   which can lead to additional loss of precision if one is careless!
--   
--   TODO fast <a>Show</a> methods required!
--   
--   TODO blaze stuff?
--   
--   TODO We might want to discretize <tt>LogDomain</tt> style values. This
--   requires some thought on in which direction to wrap. Maybe, we want to
--   log-domain Discretized values, which probably just works.
newtype Discretized (u :: Nat) (l :: Nat)
Discretized :: Int -> Discretized
[getDiscretized] :: Discretized -> Int

-- | Discretizes any <tt>Real a</tt> into the <tt>Discretized</tt> value.
--   This conversion is <i>lossy</i>!
discretize :: forall a u l. (Real a, KnownNat u, KnownNat l) => a -> Discretized u l
instance GHC.Read.Read (Numeric.Discretized.Discretized u l)
instance GHC.Show.Show (Numeric.Discretized.Discretized u l)
instance GHC.Generics.Generic (Numeric.Discretized.Discretized u l)
instance GHC.Classes.Ord (Numeric.Discretized.Discretized u l)
instance GHC.Classes.Eq (Numeric.Discretized.Discretized u l)
instance (GHC.TypeNats.KnownNat u, GHC.TypeNats.KnownNat l) => GHC.Num.Num (Numeric.Discretized.Discretized u l)
instance GHC.Enum.Enum (Numeric.Discretized.Discretized u l)
instance (GHC.Enum.Enum (Numeric.Discretized.Discretized u l), GHC.TypeNats.KnownNat u, GHC.TypeNats.KnownNat l) => GHC.Real.Integral (Numeric.Discretized.Discretized u l)
instance (GHC.TypeNats.KnownNat u, GHC.TypeNats.KnownNat l) => GHC.Real.Fractional (Numeric.Discretized.Discretized u l)
instance (GHC.TypeNats.KnownNat u, GHC.TypeNats.KnownNat l) => GHC.Real.Real (Numeric.Discretized.Discretized u l)


-- | Approximate and exact limits around 0 and towards transfinite numbers.
module Numeric.Limits

-- | The class of limits into the transfinite.
class NumericLimits x
minFinite :: NumericLimits x => x
maxFinite :: NumericLimits x => x

-- | The smallest value <tt>/= 0</tt> for numeric values.
class NumericEpsilon x

-- | Numeric epsilon.
epsilon :: NumericEpsilon x => x
instance Numeric.Limits.NumericEpsilon GHC.Types.Double
instance Numeric.Limits.NumericLimits GHC.Types.Word
instance Numeric.Limits.NumericLimits GHC.Types.Int
instance Numeric.Limits.NumericLimits GHC.Types.Double


-- | A set with two binary operations, one for addition (<tt>srplus</tt>),
--   one for multiplication (<tt>srmul</tt>). Together with a neutral
--   element for <tt>srplus</tt>, named <tt>srzero</tt>, and one for
--   <tt>srmul</tt>, named <tt>srone</tt>.
module Algebra.Structure.SemiRing

-- | The semiring operations and neutral elements.
class SemiRing a
srplus :: SemiRing a => a -> a -> a
srmul :: SemiRing a => a -> a -> a
srzero :: SemiRing a => a
srone :: SemiRing a => a
infixl 7 `srmul`
infixl 6 `srplus`

-- | Unicode variant of <tt>srplus</tt>.
(⊕) :: SemiRing a => a -> a -> a
infixl 6 ⊕

-- | Unicode variant of <tt>srmul</tt>.
(⊗) :: SemiRing a => a -> a -> a
infixl 7 ⊗

-- | The Viterbi SemiRing. It maximizes over the product.
newtype Viterbi x
Viterbi :: x -> Viterbi x
[getViterbi] :: Viterbi x -> x

-- | The tropical MinPlus SemiRing. It minimizes over the sum.
newtype MinPlus x
MinPlus :: x -> MinPlus x
[getMinPlus] :: MinPlus x -> x

-- | The tropical MaxPlus SemiRing. It maximizes over the sum.
newtype MaxPlus x
MaxPlus :: x -> MaxPlus x
[getMaxPlus] :: MaxPlus x -> x

-- | The generic semiring, defined over two <a>Semigroup</a> and
--   <a>Monoid</a> constructions.
--   
--   It can be used like this: <tt> srzero ∷ GSemiRing Min Sum Int ==
--   maxBound srone ∷ GSemiRing Min Sum Int == 0 </tt>
--   
--   It is generally useful to still provide explicit instances, since
--   <tt>Min</tt> requires a <tt>Bounded</tt> instance.
newtype GSemiRing (zeroMonoid :: * -> *) (oneMonoid :: * -> *) (x :: *)
GSemiRing :: x -> GSemiRing
[getSemiRing] :: GSemiRing -> x
instance GHC.Generics.Generic (Algebra.Structure.SemiRing.GSemiRing zeroMonoid oneMonoid x)
instance GHC.Show.Show x => GHC.Show.Show (Algebra.Structure.SemiRing.GSemiRing zeroMonoid oneMonoid x)
instance GHC.Read.Read x => GHC.Read.Read (Algebra.Structure.SemiRing.GSemiRing zeroMonoid oneMonoid x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Algebra.Structure.SemiRing.GSemiRing zeroMonoid oneMonoid x)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Algebra.Structure.SemiRing.GSemiRing zeroMonoid oneMonoid x)
instance (GHC.Base.Semigroup (zeroMonoid x), GHC.Base.Monoid (zeroMonoid x), GHC.Base.Semigroup (oneMonoid x), GHC.Base.Monoid (oneMonoid x)) => Algebra.Structure.SemiRing.SemiRing (Algebra.Structure.SemiRing.GSemiRing zeroMonoid oneMonoid x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Unboxed.Base.Unbox (Algebra.Structure.SemiRing.MaxPlus x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Algebra.Structure.SemiRing.MaxPlus x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Algebra.Structure.SemiRing.MaxPlus x)
instance Control.DeepSeq.NFData x => Control.DeepSeq.NFData (Algebra.Structure.SemiRing.MaxPlus x)
instance Numeric.Limits.NumericLimits x => Numeric.Limits.NumericLimits (Algebra.Structure.SemiRing.MaxPlus x)
instance (GHC.Classes.Ord x, GHC.Num.Num x, Numeric.Limits.NumericLimits x) => Algebra.Structure.SemiRing.SemiRing (Algebra.Structure.SemiRing.MaxPlus x)
instance GHC.Num.Num x => GHC.Num.Num (Algebra.Structure.SemiRing.MaxPlus x)
instance GHC.Generics.Generic1 Algebra.Structure.SemiRing.MaxPlus
instance GHC.Generics.Generic (Algebra.Structure.SemiRing.MaxPlus x)
instance GHC.Enum.Bounded x => GHC.Enum.Bounded (Algebra.Structure.SemiRing.MaxPlus x)
instance GHC.Show.Show x => GHC.Show.Show (Algebra.Structure.SemiRing.MaxPlus x)
instance GHC.Read.Read x => GHC.Read.Read (Algebra.Structure.SemiRing.MaxPlus x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Algebra.Structure.SemiRing.MaxPlus x)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Algebra.Structure.SemiRing.MaxPlus x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Unboxed.Base.Unbox (Algebra.Structure.SemiRing.MinPlus x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Algebra.Structure.SemiRing.MinPlus x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Algebra.Structure.SemiRing.MinPlus x)
instance Control.DeepSeq.NFData x => Control.DeepSeq.NFData (Algebra.Structure.SemiRing.MinPlus x)
instance (GHC.Classes.Ord x, GHC.Num.Num x, Numeric.Limits.NumericLimits x) => Algebra.Structure.SemiRing.SemiRing (Algebra.Structure.SemiRing.MinPlus x)
instance GHC.Num.Num x => GHC.Num.Num (Algebra.Structure.SemiRing.MinPlus x)
instance GHC.Generics.Generic1 Algebra.Structure.SemiRing.MinPlus
instance GHC.Generics.Generic (Algebra.Structure.SemiRing.MinPlus x)
instance GHC.Enum.Bounded x => GHC.Enum.Bounded (Algebra.Structure.SemiRing.MinPlus x)
instance GHC.Show.Show x => GHC.Show.Show (Algebra.Structure.SemiRing.MinPlus x)
instance GHC.Read.Read x => GHC.Read.Read (Algebra.Structure.SemiRing.MinPlus x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Algebra.Structure.SemiRing.MinPlus x)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Algebra.Structure.SemiRing.MinPlus x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Unboxed.Base.Unbox (Algebra.Structure.SemiRing.Viterbi x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Algebra.Structure.SemiRing.Viterbi x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Algebra.Structure.SemiRing.Viterbi x)
instance Control.DeepSeq.NFData x => Control.DeepSeq.NFData (Algebra.Structure.SemiRing.Viterbi x)
instance (GHC.Classes.Ord x, GHC.Num.Num x) => Algebra.Structure.SemiRing.SemiRing (Algebra.Structure.SemiRing.Viterbi x)
instance GHC.Num.Num x => GHC.Num.Num (Algebra.Structure.SemiRing.Viterbi x)
instance GHC.Generics.Generic1 Algebra.Structure.SemiRing.Viterbi
instance GHC.Generics.Generic (Algebra.Structure.SemiRing.Viterbi x)
instance GHC.Enum.Bounded x => GHC.Enum.Bounded (Algebra.Structure.SemiRing.Viterbi x)
instance GHC.Show.Show x => GHC.Show.Show (Algebra.Structure.SemiRing.Viterbi x)
instance GHC.Read.Read x => GHC.Read.Read (Algebra.Structure.SemiRing.Viterbi x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Algebra.Structure.SemiRing.Viterbi x)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Algebra.Structure.SemiRing.Viterbi x)


-- | This module provides log-domain functionality. Ed Kmett provides, with
--   <tt>log-domain</tt>, a generic way to handle numbers in the
--   log-domain, some which is used under the hood here. We want some
--   additional type safety and also connect with the <tt>SemiRing</tt>
--   module.
module Numeric.LogDomain

-- | Instances for <tt>LogDomain x</tt> should be for specific types.
class LogDomain x where {
    
    -- | The data family to connect a type <tt>x</tt> with the type <tt>Ln
    --   x</tt> in the log-domain.
    data family Ln x :: *;
}

-- | Transport a value in <tt>x</tt> into the log-domain. <tt>logdom</tt>
--   should throw an exception if <tt>log x</tt> is not valid.
logdom :: (LogDomain x, MonadError String m) => x -> m (Ln x)

-- | Unsafely transport x into the log-domain.
unsafelogdom :: LogDomain x => x -> Ln x

-- | Transport a value <tt>Ln x</tt> back into the linear domain
--   <tt>x</tt>.
lindom :: LogDomain x => Ln x -> x


-- | This module provides generic functionality to deal with ensembles in
--   statistical mechanics.
module StatisticalMechanics.Ensemble

-- | The state probability functions provide conversion from some types
--   <tt>a</tt> into non-normalized probabilities. For "real" applications,
--   using the <tt>logProbability</tt> function is preferred. This
--   functions allows for easy abstraction when types <tt>a</tt> are given
--   as fractions of some actual value (say: deka-cal), or are discretized.
--   
--   The returned values are not normalized, because we do not now the
--   total evidence <tt>Z</tt> until integration over all states has
--   happened -- which is not feasible in a number of problems.
--   
--   TODO replace <tt>()</tt> with temperature and results with
--   non-normalized <tt>P</tt> or <tt>LogP</tt>, depending.
class StateProbability a

-- | Given a temperature and a state "energy", return the corresponding
--   non-normalized probability.
stateProbability :: StateProbability a => () -> a -> ()
stateLogProbability :: StateProbability a => () -> a -> ()


-- | Provides newtypes for odds, log-odds, and discretized versions.
module Statistics.Odds

-- | Odds.
newtype Odds
Odds :: Double -> Odds
[getOdds] :: Odds -> Double

-- | Encodes log-odds that have been rounded or clamped to integral
--   numbers. One advantage this provides is more efficient
--   "maximum/minimum" calculations compared to using <tt>Double</tt>s.
--   
--   Note that these are "explicit" log-odds. Each numeric operation uses
--   the underlying operation on <tt>Int</tt>.
newtype DiscLogOdds
DiscLogOdds :: Int -> DiscLogOdds
[getDiscLogOdds] :: DiscLogOdds -> Int
instance Data.Vector.Unboxed.Base.Unbox Statistics.Odds.DiscLogOdds
instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector Statistics.Odds.DiscLogOdds
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector Statistics.Odds.DiscLogOdds
instance Data.Binary.Class.Binary Statistics.Odds.DiscLogOdds
instance Data.Serialize.Serialize Statistics.Odds.DiscLogOdds
instance Data.Aeson.Types.FromJSON.FromJSON Statistics.Odds.DiscLogOdds
instance Data.Aeson.Types.ToJSON.ToJSON Statistics.Odds.DiscLogOdds
instance Data.Hashable.Class.Hashable Statistics.Odds.DiscLogOdds
instance Control.DeepSeq.NFData Statistics.Odds.DiscLogOdds
instance Numeric.Limits.NumericLimits Statistics.Odds.DiscLogOdds
instance GHC.Num.Num Statistics.Odds.DiscLogOdds
instance GHC.Read.Read Statistics.Odds.DiscLogOdds
instance GHC.Show.Show Statistics.Odds.DiscLogOdds
instance GHC.Classes.Ord Statistics.Odds.DiscLogOdds
instance GHC.Classes.Eq Statistics.Odds.DiscLogOdds
instance GHC.Generics.Generic Statistics.Odds.DiscLogOdds
instance GHC.Num.Num Statistics.Odds.Odds
instance GHC.Read.Read Statistics.Odds.Odds
instance GHC.Show.Show Statistics.Odds.Odds
instance GHC.Classes.Ord Statistics.Odds.Odds
instance GHC.Classes.Eq Statistics.Odds.Odds
instance GHC.Generics.Generic Statistics.Odds.Odds


-- | Probability-related types.
--   
--   TODO instances for serialization and further stuff TODO vector
--   instances
module Statistics.Probability
data IsNormalized
Normalized :: IsNormalized
NotNormalized :: IsNormalized

-- | <tt>Prob</tt> wraps a <tt>Double</tt> that encodes probabilities. If
--   <tt>Prob</tt> is tagged as <tt>Normalized</tt>, the contained values
--   are in the range <tt>[0,...,1]</tt>, otherwise they are in the range
--   <tt>[0,...,∞]</tt>.
newtype Prob (n :: IsNormalized) x
Prob :: x -> Prob x
[getProb] :: Prob x -> x

-- | Turns a value into a normalized probability. <tt>error</tt> if the
--   value is not in the range <tt>[0,...,1]</tt>.
prob :: (Ord x, Num x, Show x) => x -> Prob Normalized x

-- | Simple wrapper around <tt>Prob</tt> that fixes non-normalization.
prob' :: (Ord x, Num x, Show x) => x -> Prob NotNormalized x
newtype LogProb (n :: IsNormalized) x
LogProb :: x -> LogProb x
[getLogProb] :: LogProb x -> x
withLog1 :: (Log x -> Log y) -> LogProb n x -> LogProb n y
withLog2 :: (Log x -> Log y -> Log z) -> LogProb n x -> LogProb n y -> LogProb n z

-- | Turn probability into log-probability.
p2lp :: Floating x => Prob n x -> LogProb n x

-- | Turn log-probability into probability.
lp2p :: Floating x => LogProb n x -> Prob n x

-- | An isomorphism between <tt>Prob</tt> and <tt>LogProb</tt>.
aslp :: Floating x => Iso' (Prob n x) (LogProb n x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Unboxed.Base.Unbox (Statistics.Probability.LogProb n x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Statistics.Probability.LogProb n x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Statistics.Probability.LogProb n x)
instance (Numeric.Log.Precise x, GHC.Float.RealFloat x) => GHC.Num.Num (Statistics.Probability.LogProb n x)
instance (GHC.Num.Num d, GHC.Real.Fractional d) => Numeric.Limits.NumericLimits (Statistics.Probability.LogProb n d)
instance GHC.Show.Show x => GHC.Show.Show (Statistics.Probability.LogProb n x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Statistics.Probability.LogProb n x)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Statistics.Probability.LogProb n x)
instance GHC.Enum.Enum x => GHC.Enum.Enum (Statistics.Probability.Prob n x)
instance GHC.Num.Num x => GHC.Num.Num (Statistics.Probability.Prob n x)
instance GHC.Real.Fractional x => GHC.Real.Fractional (Statistics.Probability.Prob n x)
instance GHC.Float.Floating x => GHC.Float.Floating (Statistics.Probability.Prob n x)
instance GHC.Real.Real x => GHC.Real.Real (Statistics.Probability.Prob n x)
instance GHC.Real.RealFrac x => GHC.Real.RealFrac (Statistics.Probability.Prob n x)
instance GHC.Float.RealFloat x => GHC.Float.RealFloat (Statistics.Probability.Prob n x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Unboxed.Base.Unbox (Statistics.Probability.Prob n x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Statistics.Probability.Prob n x)
instance Data.Vector.Unboxed.Base.Unbox x => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Statistics.Probability.Prob n x)
instance GHC.Num.Num r => Algebra.Structure.SemiRing.SemiRing (Statistics.Probability.Prob n r)
instance GHC.Read.Read x => GHC.Read.Read (Statistics.Probability.Prob n x)
instance GHC.Show.Show x => GHC.Show.Show (Statistics.Probability.Prob n x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Statistics.Probability.Prob n x)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Statistics.Probability.Prob n x)