{-# 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 Control.Applicative ((<*>))
import Data.Data (Data, Typeable)
import Data.Functor ((<$>))
import GHC.Generics (Generic)
import qualified Statistics.Distribution as D

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

-- | Apply linear transformation to distribution.
scaleAround :: Double           -- ^ Fixed point
            -> Double           -- ^ Scale parameter
            -> d                -- ^ Distribution
            -> LinearTransform d
scaleAround :: 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 :: 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 :: (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 :: LinearTransform d -> Gen (PrimState m) -> m Double
genContVar (LinearTransform Double
loc Double
sc d
d) Gen (PrimState m)
g = do
    Double
x <- d -> Gen (PrimState m) -> m Double
forall d (m :: * -> *).
(ContGen d, PrimMonad m) =>
d -> Gen (PrimState m) -> m Double
D.genContVar d
d Gen (PrimState m)
g
    Double -> m Double
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