{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, FlexibleContexts,
    FlexibleInstances, UndecidableInstances #-}
-- |
-- Module    : Statistics.Distribution.Transform
-- Copyright : (c) 2013 John McDonnell;
-- License   : BSD3
--
-- Maintainer  : bos@serpentine.com
-- Stability   : experimental
-- Portability : portable
--
-- Transformations over distributions
module Statistics.Distribution.Transform
    (
      LinearTransform (..)
    , linTransFixedPoint
    , scaleAround
    ) where

import Data.Aeson (FromJSON, ToJSON)
import Data.Binary (Binary)
import Data.Binary (put, get)
import Data.Data (Data, Typeable)
import GHC.Generics (Generic)
import qualified Statistics.Distribution as D

-- | Linear transformation applied to distribution.
--
-- > LinearTransform μ σ _
-- > x' = μ + σ·x
data LinearTransform d = LinearTransform
  { forall d. LinearTransform d -> Double
linTransLocation :: {-# UNPACK #-} !Double
    -- ^ Location parameter.
  , forall d. LinearTransform d -> Double
linTransScale    :: {-# UNPACK #-} !Double
    -- ^ Scale parameter.
  , forall d. LinearTransform d -> d
linTransDistr    :: d
    -- ^ Distribution being transformed.
  } deriving (LinearTransform d -> LinearTransform d -> Bool
(LinearTransform d -> LinearTransform d -> Bool)
-> (LinearTransform d -> LinearTransform d -> Bool)
-> Eq (LinearTransform d)
forall d. Eq d => LinearTransform d -> LinearTransform d -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall d. Eq d => LinearTransform d -> LinearTransform d -> Bool
== :: LinearTransform d -> LinearTransform d -> Bool
$c/= :: forall d. Eq d => LinearTransform d -> LinearTransform d -> Bool
/= :: LinearTransform d -> LinearTransform d -> Bool
Eq, Int -> LinearTransform d -> ShowS
[LinearTransform d] -> ShowS
LinearTransform d -> String
(Int -> LinearTransform d -> ShowS)
-> (LinearTransform d -> String)
-> ([LinearTransform d] -> ShowS)
-> Show (LinearTransform d)
forall d. Show d => Int -> LinearTransform d -> ShowS
forall d. Show d => [LinearTransform d] -> ShowS
forall d. Show d => LinearTransform d -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall d. Show d => Int -> LinearTransform d -> ShowS
showsPrec :: Int -> LinearTransform d -> ShowS
$cshow :: forall d. Show d => LinearTransform d -> String
show :: LinearTransform d -> String
$cshowList :: forall d. Show d => [LinearTransform d] -> ShowS
showList :: [LinearTransform d] -> ShowS
Show, ReadPrec [LinearTransform d]
ReadPrec (LinearTransform d)
Int -> ReadS (LinearTransform d)
ReadS [LinearTransform d]
(Int -> ReadS (LinearTransform d))
-> ReadS [LinearTransform d]
-> ReadPrec (LinearTransform d)
-> ReadPrec [LinearTransform d]
-> Read (LinearTransform d)
forall d. Read d => ReadPrec [LinearTransform d]
forall d. Read d => ReadPrec (LinearTransform d)
forall d. Read d => Int -> ReadS (LinearTransform d)
forall d. Read d => ReadS [LinearTransform d]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall d. Read d => Int -> ReadS (LinearTransform d)
readsPrec :: Int -> ReadS (LinearTransform d)
$creadList :: forall d. Read d => ReadS [LinearTransform d]
readList :: ReadS [LinearTransform d]
$creadPrec :: forall d. Read d => ReadPrec (LinearTransform d)
readPrec :: ReadPrec (LinearTransform d)
$creadListPrec :: forall d. Read d => ReadPrec [LinearTransform d]
readListPrec :: ReadPrec [LinearTransform d]
Read, Typeable, Typeable (LinearTransform d)
Typeable (LinearTransform d) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> LinearTransform d
 -> c (LinearTransform d))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (LinearTransform d))
-> (LinearTransform d -> Constr)
-> (LinearTransform d -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (LinearTransform d)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (LinearTransform d)))
-> ((forall b. Data b => b -> b)
    -> LinearTransform d -> LinearTransform d)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> LinearTransform d -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LinearTransform d -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> LinearTransform d -> m (LinearTransform d))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LinearTransform d -> m (LinearTransform d))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LinearTransform d -> m (LinearTransform d))
-> Data (LinearTransform d)
LinearTransform d -> Constr
LinearTransform d -> DataType
(forall b. Data b => b -> b)
-> LinearTransform d -> LinearTransform d
forall d. Data d => Typeable (LinearTransform d)
forall d. Data d => LinearTransform d -> Constr
forall d. Data d => LinearTransform d -> DataType
forall d.
Data d =>
(forall b. Data b => b -> b)
-> LinearTransform d -> LinearTransform d
forall d u.
Data d =>
Int -> (forall d. Data d => d -> u) -> LinearTransform d -> u
forall d u.
Data d =>
(forall d. Data d => d -> u) -> LinearTransform d -> [u]
forall d r r'.
Data d =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r
forall d r r'.
Data d =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r
forall d (m :: * -> *).
(Data d, Monad m) =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
forall d (m :: * -> *).
(Data d, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
forall d (c :: * -> *).
Data d =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LinearTransform d)
forall d (c :: * -> *).
Data d =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> LinearTransform d
-> c (LinearTransform d)
forall d (t :: * -> *) (c :: * -> *).
(Data d, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (LinearTransform d))
forall d (t :: * -> * -> *) (c :: * -> *).
(Data d, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LinearTransform d))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> LinearTransform d -> u
forall u. (forall d. Data d => d -> u) -> LinearTransform d -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LinearTransform d)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> LinearTransform d
-> c (LinearTransform d)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (LinearTransform d))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LinearTransform d))
$cgfoldl :: forall d (c :: * -> *).
Data d =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> LinearTransform d
-> c (LinearTransform d)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> LinearTransform d
-> c (LinearTransform d)
$cgunfold :: forall d (c :: * -> *).
Data d =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LinearTransform d)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LinearTransform d)
$ctoConstr :: forall d. Data d => LinearTransform d -> Constr
toConstr :: LinearTransform d -> Constr
$cdataTypeOf :: forall d. Data d => LinearTransform d -> DataType
dataTypeOf :: LinearTransform d -> DataType
$cdataCast1 :: forall d (t :: * -> *) (c :: * -> *).
(Data d, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (LinearTransform d))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (LinearTransform d))
$cdataCast2 :: forall d (t :: * -> * -> *) (c :: * -> *).
(Data d, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LinearTransform d))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LinearTransform d))
$cgmapT :: forall d.
Data d =>
(forall b. Data b => b -> b)
-> LinearTransform d -> LinearTransform d
gmapT :: (forall b. Data b => b -> b)
-> LinearTransform d -> LinearTransform d
$cgmapQl :: forall d r r'.
Data d =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r
$cgmapQr :: forall d r r'.
Data d =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LinearTransform d -> r
$cgmapQ :: forall d u.
Data d =>
(forall d. Data d => d -> u) -> LinearTransform d -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LinearTransform d -> [u]
$cgmapQi :: forall d u.
Data d =>
Int -> (forall d. Data d => d -> u) -> LinearTransform d -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LinearTransform d -> u
$cgmapM :: forall d (m :: * -> *).
(Data d, Monad m) =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
$cgmapMp :: forall d (m :: * -> *).
(Data d, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
$cgmapMo :: forall d (m :: * -> *).
(Data d, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LinearTransform d -> m (LinearTransform d)
Data, (forall x. LinearTransform d -> Rep (LinearTransform d) x)
-> (forall x. Rep (LinearTransform d) x -> LinearTransform d)
-> Generic (LinearTransform d)
forall x. Rep (LinearTransform d) x -> LinearTransform d
forall x. LinearTransform d -> Rep (LinearTransform d) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall d x. Rep (LinearTransform d) x -> LinearTransform d
forall d x. LinearTransform d -> Rep (LinearTransform d) x
$cfrom :: forall d x. LinearTransform d -> Rep (LinearTransform d) x
from :: forall x. LinearTransform d -> Rep (LinearTransform d) x
$cto :: forall d x. Rep (LinearTransform d) x -> LinearTransform d
to :: forall x. Rep (LinearTransform d) x -> LinearTransform d
Generic)

instance (FromJSON d) => FromJSON (LinearTransform d)
instance (ToJSON d) => ToJSON (LinearTransform d)

instance (Binary d) => Binary (LinearTransform d) where
    get :: Get (LinearTransform d)
get = Double -> Double -> d -> LinearTransform d
forall d. Double -> Double -> d -> LinearTransform d
LinearTransform (Double -> Double -> d -> LinearTransform d)
-> Get Double -> Get (Double -> d -> LinearTransform d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Double
forall t. Binary t => Get t
get Get (Double -> d -> LinearTransform d)
-> Get Double -> Get (d -> LinearTransform d)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Double
forall t. Binary t => Get t
get Get (d -> LinearTransform d) -> Get d -> Get (LinearTransform d)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get d
forall t. Binary t => Get t
get
    put :: LinearTransform d -> Put
put (LinearTransform Double
x Double
y d
z) = Double -> Put
forall t. Binary t => t -> Put
put Double
x Put -> Put -> Put
forall a b. PutM a -> PutM b -> PutM b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Double -> Put
forall t. Binary t => t -> Put
put Double
y Put -> Put -> Put
forall a b. PutM a -> PutM b -> PutM b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> d -> Put
forall t. Binary t => t -> Put
put d
z

-- | Apply linear transformation to distribution.
scaleAround :: Double           -- ^ Fixed point
            -> Double           -- ^ Scale parameter
            -> d                -- ^ Distribution
            -> LinearTransform d
scaleAround :: forall d. Double -> Double -> d -> LinearTransform d
scaleAround Double
x0 Double
sc = Double -> Double -> d -> LinearTransform d
forall d. Double -> Double -> d -> LinearTransform d
LinearTransform (Double
x0 Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
sc)) Double
sc

-- | Get fixed point of linear transformation
linTransFixedPoint :: LinearTransform d -> Double
linTransFixedPoint :: forall d. LinearTransform d -> Double
linTransFixedPoint (LinearTransform Double
loc Double
sc d
_) = Double
loc Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
sc)

instance Functor LinearTransform where
  fmap :: forall a b. (a -> b) -> LinearTransform a -> LinearTransform b
fmap a -> b
f (LinearTransform Double
loc Double
sc a
dist) = Double -> Double -> b -> LinearTransform b
forall d. Double -> Double -> d -> LinearTransform d
LinearTransform Double
loc Double
sc (a -> b
f a
dist)

instance D.Distribution d => D.Distribution (LinearTransform d) where
  cumulative :: LinearTransform d -> Double -> Double
cumulative (LinearTransform Double
loc Double
sc d
dist) Double
x = d -> Double -> Double
forall d. Distribution d => d -> Double -> Double
D.cumulative d
dist (Double -> Double) -> Double -> Double
forall a b. (a -> b) -> a -> b
$ (Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
-Double
loc) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sc

instance D.ContDistr d => D.ContDistr (LinearTransform d) where
  density :: LinearTransform d -> Double -> Double
density    (LinearTransform Double
loc Double
sc d
dist) Double
x = d -> Double -> Double
forall d. ContDistr d => d -> Double -> Double
D.density    d
dist ((Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
-Double
loc) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sc) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sc
  logDensity :: LinearTransform d -> Double -> Double
logDensity (LinearTransform Double
loc Double
sc d
dist) Double
x = d -> Double -> Double
forall d. ContDistr d => d -> Double -> Double
D.logDensity d
dist ((Double
xDouble -> Double -> Double
forall a. Num a => a -> a -> a
-Double
loc) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
sc) Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double -> Double
forall a. Floating a => a -> a
log Double
sc
  quantile :: LinearTransform d -> Double -> Double
quantile      (LinearTransform Double
loc Double
sc d
dist) Double
p = Double
loc Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sc Double -> Double -> Double
forall a. Num a => a -> a -> a
* d -> Double -> Double
forall d. ContDistr d => d -> Double -> Double
D.quantile      d
dist Double
p
  complQuantile :: LinearTransform d -> Double -> Double
complQuantile (LinearTransform Double
loc Double
sc d
dist) Double
p = Double
loc Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sc Double -> Double -> Double
forall a. Num a => a -> a -> a
* d -> Double -> Double
forall d. ContDistr d => d -> Double -> Double
D.complQuantile d
dist Double
p

instance D.MaybeMean d => D.MaybeMean (LinearTransform d) where
  maybeMean :: LinearTransform d -> Maybe Double
maybeMean (LinearTransform Double
loc Double
_ d
dist) = (Double -> Double -> Double
forall a. Num a => a -> a -> a
+Double
loc) (Double -> Double) -> Maybe Double -> Maybe Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Maybe Double
forall d. MaybeMean d => d -> Maybe Double
D.maybeMean d
dist

instance (D.Mean d) => D.Mean (LinearTransform d) where
  mean :: LinearTransform d -> Double
mean (LinearTransform Double
loc Double
_ d
dist) = Double
loc Double -> Double -> Double
forall a. Num a => a -> a -> a
+ d -> Double
forall d. Mean d => d -> Double
D.mean d
dist

instance D.MaybeVariance  d => D.MaybeVariance (LinearTransform d) where
  maybeVariance :: LinearTransform d -> Maybe Double
maybeVariance (LinearTransform Double
_ Double
sc d
dist) = (Double -> Double -> Double
forall a. Num a => a -> a -> a
*(Double
scDouble -> Double -> Double
forall a. Num a => a -> a -> a
*Double
sc)) (Double -> Double) -> Maybe Double -> Maybe Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Maybe Double
forall d. MaybeVariance d => d -> Maybe Double
D.maybeVariance d
dist
  maybeStdDev :: LinearTransform d -> Maybe Double
maybeStdDev   (LinearTransform Double
_ Double
sc d
dist) = (Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
sc)      (Double -> Double) -> Maybe Double -> Maybe Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Maybe Double
forall d. MaybeVariance d => d -> Maybe Double
D.maybeStdDev d
dist

instance (D.Variance d) => D.Variance (LinearTransform d) where
  variance :: LinearTransform d -> Double
variance (LinearTransform Double
_ Double
sc d
dist) = Double
sc Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
sc Double -> Double -> Double
forall a. Num a => a -> a -> a
* d -> Double
forall d. Variance d => d -> Double
D.variance d
dist
  stdDev :: LinearTransform d -> Double
stdDev   (LinearTransform Double
_ Double
sc d
dist) = Double
sc Double -> Double -> Double
forall a. Num a => a -> a -> a
* d -> Double
forall d. Variance d => d -> Double
D.stdDev d
dist

instance (D.MaybeEntropy d) => D.MaybeEntropy (LinearTransform d) where
  maybeEntropy :: LinearTransform d -> Maybe Double
maybeEntropy (LinearTransform Double
_ Double
_ d
dist) = d -> Maybe Double
forall d. MaybeEntropy d => d -> Maybe Double
D.maybeEntropy d
dist

instance (D.Entropy d) => D.Entropy (LinearTransform d) where
  entropy :: LinearTransform d -> Double
entropy (LinearTransform Double
_ Double
_ d
dist) = d -> Double
forall d. Entropy d => d -> Double
D.entropy d
dist

instance D.ContGen d => D.ContGen (LinearTransform d) where
  genContVar :: forall g (m :: * -> *).
StatefulGen g m =>
LinearTransform d -> g -> m Double
genContVar (LinearTransform Double
loc Double
sc d
d) g
g = do
    Double
x <- d -> g -> m Double
forall d g (m :: * -> *).
(ContGen d, StatefulGen g m) =>
d -> g -> m Double
forall g (m :: * -> *). StatefulGen g m => d -> g -> m Double
D.genContVar d
d g
g
    Double -> m Double
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double -> m Double) -> Double -> m Double
forall a b. (a -> b) -> a -> b
$! Double
loc Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
sc Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x