module Factory.Math.Probability(
ContinuousDistribution(..),
DiscreteDistribution(..),
boxMullerTransform,
generateStandardizedNormalDistribution,
generateContinuousPopulation,
generatePoissonDistribution,
generateDiscretePopulation
) where
import qualified Control.Arrow
import Control.Arrow((***), (&&&))
import qualified Factory.Data.Interval as Data.Interval
import qualified System.Random
import qualified ToolShed.Data.List
import qualified ToolShed.Data.Pair
import qualified ToolShed.SelfValidate
data ContinuousDistribution f
= UniformDistribution (Data.Interval.Interval f)
| NormalDistribution f f
deriving (Eq, Read, Show)
instance (Num a, Ord a, Show a) => ToolShed.SelfValidate.SelfValidator (ContinuousDistribution a) where
getErrors distribution = ToolShed.SelfValidate.extractErrors $ case distribution of
UniformDistribution interval -> [(Data.Interval.isReversed interval, "Reversed interval='" ++ show interval ++ "'.")]
NormalDistribution _ v -> [(v < 0, "Negative variance=" ++ show v ++ ".")]
data DiscreteDistribution f = PoissonDistribution f deriving (Eq, Read, Show)
instance (Num f, Ord f, Show f) => ToolShed.SelfValidate.SelfValidator (DiscreteDistribution f) where
getErrors (PoissonDistribution lambda) = ToolShed.SelfValidate.extractErrors [(lambda < 0, "Negative lambda=" ++ show lambda ++ ".")]
boxMullerTransform :: (Floating f, Ord f, Show f)
=> (f, f)
-> (f, f)
boxMullerTransform cartesian
| not . uncurry (&&) $ ToolShed.Data.Pair.mirror inSemiClosedUnitInterval cartesian = error $ "Factory.Math.Probability.boxMullerTransform:\tspecified Cartesian coordinates, must be within semi-closed unit-interval (0, 1]; " ++ show cartesian
| otherwise = polarToCartesianTransform $ (sqrt . negate . (* 2) . log *** (* 2) . (* pi)) cartesian
where
inSemiClosedUnitInterval :: (Num n, Ord n) => n -> Bool
inSemiClosedUnitInterval = uncurry (&&) . ((> 0) &&& (<= 1))
polarToCartesianTransform :: Floating f => (f, f) -> (f, f)
polarToCartesianTransform = uncurry (*) . Control.Arrow.second cos &&& uncurry (*) . Control.Arrow.second sin
minPositiveFloat :: RealFloat a => a -> a
minPositiveFloat = encodeFloat 1 . uncurry () . (fst . floatRange &&& floatDigits)
generateStandardizedNormalDistribution :: (
RealFloat f,
Show f,
System.Random.Random f,
System.Random.RandomGen randomGen
) => randomGen -> [f]
generateStandardizedNormalDistribution = ToolShed.Data.List.linearise . uncurry (zipWith $ curry boxMullerTransform) . ToolShed.Data.Pair.mirror (
System.Random.randomRs (minPositiveFloat undefined, 1)
) . System.Random.split
reProfile :: Num n => n -> n -> [n] -> [n]
reProfile mean standardDeviation = map ((+ mean) . (* standardDeviation))
generateContinuousPopulation :: (
RealFloat f,
Show f,
System.Random.Random f,
System.Random.RandomGen randomGen
)
=> Int
-> ContinuousDistribution f
-> randomGen
-> [f]
generateContinuousPopulation 0 _ _ = []
generateContinuousPopulation populationSize probabilityDistribution randomGen
| populationSize < 0 = error $ "Factory.Math.Probability.generateContinuousPopulation:\tinvalid population-size=" ++ show populationSize
| not $ ToolShed.SelfValidate.isValid probabilityDistribution = error $ "Factory.Math.Probability.generateContinuousPopulation:\t" ++ ToolShed.SelfValidate.getFirstError probabilityDistribution
| otherwise = take populationSize $ (
case probabilityDistribution of
UniformDistribution interval -> System.Random.randomRs interval
NormalDistribution requiredMean requiredVariance -> reProfile requiredMean (sqrt requiredVariance) . generateStandardizedNormalDistribution
) randomGen
generatePoissonDistribution :: (
Integral events,
RealFloat lambda,
Show lambda,
System.Random.Random lambda,
System.Random.RandomGen randomGen
)
=> lambda
-> randomGen
-> [events]
generatePoissonDistribution lambda
| lambda < 0 = error $ "Factory.Math.Probability.generatePoissonDistribution:\tinvalid lambda=" ++ show lambda
| lambda > (
negate . log $ minPositiveFloat lambda
) = filter (>= 0) . map round . reProfile lambda (sqrt lambda) . generateStandardizedNormalDistribution
| otherwise = generator
where
generator = uncurry (:) . (
fst . head . dropWhile (
(> exp (negate lambda)) . snd
) . scanl (
\accumulator random -> succ *** (* random) $ accumulator
) (negate 1, 1) . System.Random.randomRs (0, 1) *** generator
) . System.Random.split
generateDiscretePopulation :: (
Ord f,
RealFloat f,
Show f,
System.Random.Random f,
System.Random.RandomGen randomGen,
Integral events
)
=> Int
-> DiscreteDistribution f
-> randomGen
-> [events]
generateDiscretePopulation 0 _ _ = []
generateDiscretePopulation populationSize probabilityDistribution randomGen
| populationSize < 0 = error $ "Factory.Math.Probability.generateDiscretePopulation:\tinvalid populationSize=" ++ show populationSize
| not $ ToolShed.SelfValidate.isValid probabilityDistribution = error $ "Factory.Math.Probability.generateDiscretePopulation:\t" ++ ToolShed.SelfValidate.getFirstError probabilityDistribution
| otherwise = take populationSize $ (
case probabilityDistribution of
PoissonDistribution lambda -> generatePoissonDistribution lambda
) randomGen