{-# LANGUAGE BangPatterns               #-}
{-# LANGUAGE DeriveAnyClass             #-}
{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveFoldable             #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE DeriveTraversable          #-}
{-# LANGUAGE DerivingStrategies         #-}
{-# LANGUAGE DerivingVia                #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE ScopedTypeVariables        #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE TemplateHaskell            #-}
{-# LANGUAGE TypeFamilies               #-}
{-# LANGUAGE TypeOperators              #-}
{-# LANGUAGE ViewPatterns               #-}
-- |
-- Monoids for calculating various statistics in constant space
module Data.Monoid.Statistics.Numeric (
    -- * Mean & Variance
    -- ** Number of elements
    CountG(..)
  , Count
  , asCount
  , CountW(..)
    -- ** Mean algorithms
    -- ** Default algorithms
  , Mean
  , asMean
  , WMean
  , asWMean
    -- *** Mean
  , MeanNaive(..)
  , asMeanNaive
  , MeanKBN(..)
  , asMeanKBN
    -- *** Weighted mean
  , WMeanNaive(..)
  , asWMeanNaive
  , WMeanKBN(..)
  , asWMeanKBN
    -- ** Variance
  , Variance(..)
  , asVariance
    -- * Maximum and minimum
  , Max(..)
  , Min(..)
  , MaxD(..)
  , MinD(..)
    -- * Binomial trials
  , BinomAcc(..)
  , asBinomAcc
    -- * Rest
  , Weighted(..)
    -- * References
    -- $references
  ) where

import Control.Monad.Catch          (MonadThrow(..))
import Data.Bifunctor
import Data.Data                    (Typeable,Data)
import Data.Vector.Unboxed          (Unbox)
import Data.Vector.Unboxed.Deriving (derivingUnbox)
import qualified Data.Vector.Unboxed          as VU
import qualified Data.Vector.Generic          as VG
import qualified Data.Vector.Generic.Mutable  as VGM
import Foreign.Storable             (Storable)
import Numeric.Sum
import GHC.Generics                 (Generic)

import Data.Monoid.Statistics.Class


----------------------------------------------------------------
-- Statistical monoids
----------------------------------------------------------------

-- | Calculate number of elements in the sample.
newtype CountG a = CountG { forall a. CountG a -> a
calcCountN :: a }
  deriving stock   (Int -> CountG a -> ShowS
forall a. Show a => Int -> CountG a -> ShowS
forall a. Show a => [CountG a] -> ShowS
forall a. Show a => CountG a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CountG a] -> ShowS
$cshowList :: forall a. Show a => [CountG a] -> ShowS
show :: CountG a -> String
$cshow :: forall a. Show a => CountG a -> String
showsPrec :: Int -> CountG a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> CountG a -> ShowS
Show,CountG a -> CountG a -> Bool
forall a. Eq a => CountG a -> CountG a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CountG a -> CountG a -> Bool
$c/= :: forall a. Eq a => CountG a -> CountG a -> Bool
== :: CountG a -> CountG a -> Bool
$c== :: forall a. Eq a => CountG a -> CountG a -> Bool
Eq,CountG a -> CountG a -> Bool
CountG a -> CountG a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (CountG a)
forall a. Ord a => CountG a -> CountG a -> Bool
forall a. Ord a => CountG a -> CountG a -> Ordering
forall a. Ord a => CountG a -> CountG a -> CountG a
min :: CountG a -> CountG a -> CountG a
$cmin :: forall a. Ord a => CountG a -> CountG a -> CountG a
max :: CountG a -> CountG a -> CountG a
$cmax :: forall a. Ord a => CountG a -> CountG a -> CountG a
>= :: CountG a -> CountG a -> Bool
$c>= :: forall a. Ord a => CountG a -> CountG a -> Bool
> :: CountG a -> CountG a -> Bool
$c> :: forall a. Ord a => CountG a -> CountG a -> Bool
<= :: CountG a -> CountG a -> Bool
$c<= :: forall a. Ord a => CountG a -> CountG a -> Bool
< :: CountG a -> CountG a -> Bool
$c< :: forall a. Ord a => CountG a -> CountG a -> Bool
compare :: CountG a -> CountG a -> Ordering
$ccompare :: forall a. Ord a => CountG a -> CountG a -> Ordering
Ord,CountG a -> DataType
CountG a -> Constr
forall {a}. Data a => Typeable (CountG a)
forall a. Data a => CountG a -> DataType
forall a. Data a => CountG a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> CountG a -> CountG a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CountG a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> CountG a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CountG a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CountG a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> CountG a -> m (CountG a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CountG a -> m (CountG a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CountG a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CountG a -> c (CountG a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CountG a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CountG a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CountG a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CountG a -> c (CountG a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CountG a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CountG a -> m (CountG a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CountG a -> m (CountG a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CountG a -> m (CountG a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CountG a -> m (CountG a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CountG a -> m (CountG a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> CountG a -> m (CountG a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CountG a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CountG a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CountG a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CountG a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CountG a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CountG a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CountG a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CountG a -> r
gmapT :: (forall b. Data b => b -> b) -> CountG a -> CountG a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> CountG a -> CountG a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CountG a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CountG a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CountG a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CountG a))
dataTypeOf :: CountG a -> DataType
$cdataTypeOf :: forall a. Data a => CountG a -> DataType
toConstr :: CountG a -> Constr
$ctoConstr :: forall a. Data a => CountG a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CountG a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CountG a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CountG a -> c (CountG a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CountG a -> c (CountG a)
Data)
  deriving newtype (Ptr (CountG a) -> IO (CountG a)
Ptr (CountG a) -> Int -> IO (CountG a)
Ptr (CountG a) -> Int -> CountG a -> IO ()
Ptr (CountG a) -> CountG a -> IO ()
CountG a -> Int
forall b. Ptr b -> Int -> IO (CountG a)
forall b. Ptr b -> Int -> CountG a -> IO ()
forall a. Storable a => Ptr (CountG a) -> IO (CountG a)
forall a. Storable a => Ptr (CountG a) -> Int -> IO (CountG a)
forall a. Storable a => Ptr (CountG a) -> Int -> CountG a -> IO ()
forall a. Storable a => Ptr (CountG a) -> CountG a -> IO ()
forall a. Storable a => CountG a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (CountG a)
forall a b. Storable a => Ptr b -> Int -> CountG a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr (CountG a) -> CountG a -> IO ()
$cpoke :: forall a. Storable a => Ptr (CountG a) -> CountG a -> IO ()
peek :: Ptr (CountG a) -> IO (CountG a)
$cpeek :: forall a. Storable a => Ptr (CountG a) -> IO (CountG a)
pokeByteOff :: forall b. Ptr b -> Int -> CountG a -> IO ()
$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> CountG a -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (CountG a)
$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (CountG a)
pokeElemOff :: Ptr (CountG a) -> Int -> CountG a -> IO ()
$cpokeElemOff :: forall a. Storable a => Ptr (CountG a) -> Int -> CountG a -> IO ()
peekElemOff :: Ptr (CountG a) -> Int -> IO (CountG a)
$cpeekElemOff :: forall a. Storable a => Ptr (CountG a) -> Int -> IO (CountG a)
alignment :: CountG a -> Int
$calignment :: forall a. Storable a => CountG a -> Int
sizeOf :: CountG a -> Int
$csizeOf :: forall a. Storable a => CountG a -> Int
Storable)

type Count = CountG Int

-- | Type restricted 'id'
asCount :: CountG a -> CountG a
asCount :: forall a. CountG a -> CountG a
asCount = forall a. a -> a
id

instance Integral a => Semigroup (CountG a) where
  CountG a
i <> :: CountG a -> CountG a -> CountG a
<> CountG a
j = forall a. a -> CountG a
CountG (a
i forall a. Num a => a -> a -> a
+ a
j)

instance Integral a => Monoid (CountG a) where
  mempty :: CountG a
mempty  = forall a. a -> CountG a
CountG a
0
  mappend :: CountG a -> CountG a -> CountG a
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance (Integral a) => StatMonoid (CountG a) b where
  singletonMonoid :: b -> CountG a
singletonMonoid b
_            = forall a. a -> CountG a
CountG a
1
  addValue :: CountG a -> b -> CountG a
addValue        (CountG a
n) b
_ = forall a. a -> CountG a
CountG (a
n forall a. Num a => a -> a -> a
+ a
1)


instance CalcCount (CountG Int) where
  calcCount :: CountG Int -> Int
calcCount = forall a. CountG a -> a
calcCountN

instance Real a => CalcNEvt (CountG a) where
  calcEvtsW :: CountG a -> Double
calcEvtsW    = forall a b. (Real a, Fractional b) => a -> b
realToFrac forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. CountG a -> a
calcCountN
  calcEvtsWErr :: CountG a -> Double
calcEvtsWErr = forall a. Floating a => a -> a
sqrt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. CalcNEvt a => a -> Double
calcEvtsW
  {-# INLINE calcEvtsW    #-}
  {-# INLINE calcEvtsWErr #-}

----------------------------------------------------------------

-- | Accumulator type for counting weighted events. Weights are
--   presumed to be independent and follow same distribution \[W\].
--   In this case sum of weights follows compound Poisson
--   distribution. Its expectation could be then estimated as
--   \[\sum_iw_i\] and variance as \[\sum_iw_i^2\].
--
--   Main use of this data type is as accumulator in histograms which
--   count weighted events.
data CountW = CountW
  !Double -- Sum of weights
  !Double -- Sum of weight squares
  deriving stock (Int -> CountW -> ShowS
[CountW] -> ShowS
CountW -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CountW] -> ShowS
$cshowList :: [CountW] -> ShowS
show :: CountW -> String
$cshow :: CountW -> String
showsPrec :: Int -> CountW -> ShowS
$cshowsPrec :: Int -> CountW -> ShowS
Show,CountW -> CountW -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CountW -> CountW -> Bool
$c/= :: CountW -> CountW -> Bool
== :: CountW -> CountW -> Bool
$c== :: CountW -> CountW -> Bool
Eq,forall x. Rep CountW x -> CountW
forall x. CountW -> Rep CountW x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CountW x -> CountW
$cfrom :: forall x. CountW -> Rep CountW x
Generic)

instance Semigroup CountW where
  CountW Double
wA Double
w2A <> :: CountW -> CountW -> CountW
<> CountW Double
wB Double
w2B = Double -> Double -> CountW
CountW (Double
wAforall a. Num a => a -> a -> a
+Double
wB) (Double
w2Aforall a. Num a => a -> a -> a
+Double
w2B)
  {-# INLINE (<>) #-}
instance Monoid CountW where
  mempty :: CountW
mempty = Double -> Double -> CountW
CountW Double
0 Double
0

instance Real a => StatMonoid CountW a where
  addValue :: CountW -> a -> CountW
addValue (CountW Double
w Double
w2) a
a = Double -> Double -> CountW
CountW (Double
w forall a. Num a => a -> a -> a
+ Double
x) (Double
w2 forall a. Num a => a -> a -> a
+ Double
xforall a. Num a => a -> a -> a
*Double
x)
    where
      x :: Double
x = forall a b. (Real a, Fractional b) => a -> b
realToFrac a
a

instance CalcNEvt CountW where
  calcEvtsW :: CountW -> Double
calcEvtsW    (CountW Double
w Double
_ ) = Double
w
  calcEvtsWErr :: CountW -> Double
calcEvtsWErr (CountW Double
_ Double
w2) = forall a. Floating a => a -> a
sqrt Double
w2
  calcEffNEvt :: CountW -> Double
calcEffNEvt  (CountW Double
w Double
w2) = Double
w forall a. Num a => a -> a -> a
* Double
w forall a. Fractional a => a -> a -> a
/ Double
w2

----------------------------------------------------------------

-- | Type alias for currently recommended algorithms for calculation
--   of mean. It should be default choice
type Mean = MeanKBN

asMean :: Mean -> Mean
asMean :: MeanKBN -> MeanKBN
asMean = forall a. a -> a
id

-- | Type alias for currently recommended algorithms for calculation
--   of weighted mean. It should be default choice
type WMean = WMeanKBN

asWMean :: WMean -> WMean
asWMean :: WMeanKBN -> WMeanKBN
asWMean = forall a. a -> a
id


----------------------------------------------------------------

-- | Incremental calculation of mean. It tracks separately number of
--   elements and running sum. Note that summation of floating point
--   numbers loses precision and genrally use 'MeanKBN' is
--   recommended.
data MeanNaive = MeanNaive !Int !Double
  deriving stock (Int -> MeanNaive -> ShowS
[MeanNaive] -> ShowS
MeanNaive -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MeanNaive] -> ShowS
$cshowList :: [MeanNaive] -> ShowS
show :: MeanNaive -> String
$cshow :: MeanNaive -> String
showsPrec :: Int -> MeanNaive -> ShowS
$cshowsPrec :: Int -> MeanNaive -> ShowS
Show,MeanNaive -> MeanNaive -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MeanNaive -> MeanNaive -> Bool
$c/= :: MeanNaive -> MeanNaive -> Bool
== :: MeanNaive -> MeanNaive -> Bool
$c== :: MeanNaive -> MeanNaive -> Bool
Eq,Typeable MeanNaive
MeanNaive -> DataType
MeanNaive -> Constr
(forall b. Data b => b -> b) -> MeanNaive -> MeanNaive
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) -> MeanNaive -> u
forall u. (forall d. Data d => d -> u) -> MeanNaive -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MeanNaive -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MeanNaive -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MeanNaive -> m MeanNaive
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanNaive -> m MeanNaive
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MeanNaive
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MeanNaive -> c MeanNaive
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MeanNaive)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MeanNaive)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanNaive -> m MeanNaive
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanNaive -> m MeanNaive
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanNaive -> m MeanNaive
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanNaive -> m MeanNaive
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MeanNaive -> m MeanNaive
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MeanNaive -> m MeanNaive
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MeanNaive -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MeanNaive -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MeanNaive -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MeanNaive -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MeanNaive -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MeanNaive -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MeanNaive -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MeanNaive -> r
gmapT :: (forall b. Data b => b -> b) -> MeanNaive -> MeanNaive
$cgmapT :: (forall b. Data b => b -> b) -> MeanNaive -> MeanNaive
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MeanNaive)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MeanNaive)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MeanNaive)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MeanNaive)
dataTypeOf :: MeanNaive -> DataType
$cdataTypeOf :: MeanNaive -> DataType
toConstr :: MeanNaive -> Constr
$ctoConstr :: MeanNaive -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MeanNaive
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MeanNaive
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MeanNaive -> c MeanNaive
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MeanNaive -> c MeanNaive
Data,forall x. Rep MeanNaive x -> MeanNaive
forall x. MeanNaive -> Rep MeanNaive x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MeanNaive x -> MeanNaive
$cfrom :: forall x. MeanNaive -> Rep MeanNaive x
Generic)

asMeanNaive :: MeanNaive -> MeanNaive
asMeanNaive :: MeanNaive -> MeanNaive
asMeanNaive = forall a. a -> a
id


instance Semigroup MeanNaive where
  MeanNaive Int
0  Double
_  <> :: MeanNaive -> MeanNaive -> MeanNaive
<> MeanNaive
m               = MeanNaive
m
  MeanNaive
m               <> MeanNaive Int
0  Double
_  = MeanNaive
m
  MeanNaive Int
n1 Double
s1 <> MeanNaive Int
n2 Double
s2 = Int -> Double -> MeanNaive
MeanNaive (Int
n1forall a. Num a => a -> a -> a
+Int
n2) (Double
s1 forall a. Num a => a -> a -> a
+ Double
s2)

instance Monoid MeanNaive where
  mempty :: MeanNaive
mempty  = Int -> Double -> MeanNaive
MeanNaive Int
0 Double
0
  mappend :: MeanNaive -> MeanNaive -> MeanNaive
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Real a => StatMonoid MeanNaive a where
  addValue :: MeanNaive -> a -> MeanNaive
addValue (MeanNaive Int
n Double
m) a
x = Int -> Double -> MeanNaive
MeanNaive (Int
nforall a. Num a => a -> a -> a
+Int
1) (Double
m forall a. Num a => a -> a -> a
+ forall a b. (Real a, Fractional b) => a -> b
realToFrac a
x)
  {-# INLINE addValue #-}

instance CalcCount MeanNaive where
  calcCount :: MeanNaive -> Int
calcCount (MeanNaive Int
n Double
_) = Int
n
instance CalcMean MeanNaive where
  calcMean :: forall (m :: * -> *). MonadThrow m => MeanNaive -> m Double
calcMean (MeanNaive Int
0 Double
_) = forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM forall a b. (a -> b) -> a -> b
$ String -> SampleError
EmptySample String
"Data.Monoid.Statistics.Numeric.MeanNaive: calcMean"
  calcMean (MeanNaive Int
n Double
s) = forall (m :: * -> *) a. Monad m => a -> m a
return (Double
s forall a. Fractional a => a -> a -> a
/ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)


----------------------------------------------------------------

-- | Incremental calculation of mean. It tracks separately number of
--   elements and running sum. It uses algorithm for compensated
--   summation which works with mantissa of double size at cost of
--   doing more operations. This means that it's usually possible to
--   compute sum (and therefore mean) within 1 ulp.
data MeanKBN = MeanKBN !Int {-# UNPACK #-} !KBNSum
  deriving stock (Int -> MeanKBN -> ShowS
[MeanKBN] -> ShowS
MeanKBN -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MeanKBN] -> ShowS
$cshowList :: [MeanKBN] -> ShowS
show :: MeanKBN -> String
$cshow :: MeanKBN -> String
showsPrec :: Int -> MeanKBN -> ShowS
$cshowsPrec :: Int -> MeanKBN -> ShowS
Show,MeanKBN -> MeanKBN -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MeanKBN -> MeanKBN -> Bool
$c/= :: MeanKBN -> MeanKBN -> Bool
== :: MeanKBN -> MeanKBN -> Bool
$c== :: MeanKBN -> MeanKBN -> Bool
Eq,Typeable MeanKBN
MeanKBN -> DataType
MeanKBN -> Constr
(forall b. Data b => b -> b) -> MeanKBN -> MeanKBN
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) -> MeanKBN -> u
forall u. (forall d. Data d => d -> u) -> MeanKBN -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MeanKBN -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MeanKBN -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MeanKBN -> m MeanKBN
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanKBN -> m MeanKBN
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MeanKBN
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MeanKBN -> c MeanKBN
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MeanKBN)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MeanKBN)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanKBN -> m MeanKBN
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanKBN -> m MeanKBN
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanKBN -> m MeanKBN
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MeanKBN -> m MeanKBN
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MeanKBN -> m MeanKBN
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MeanKBN -> m MeanKBN
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MeanKBN -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MeanKBN -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MeanKBN -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MeanKBN -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MeanKBN -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MeanKBN -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MeanKBN -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MeanKBN -> r
gmapT :: (forall b. Data b => b -> b) -> MeanKBN -> MeanKBN
$cgmapT :: (forall b. Data b => b -> b) -> MeanKBN -> MeanKBN
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MeanKBN)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MeanKBN)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MeanKBN)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MeanKBN)
dataTypeOf :: MeanKBN -> DataType
$cdataTypeOf :: MeanKBN -> DataType
toConstr :: MeanKBN -> Constr
$ctoConstr :: MeanKBN -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MeanKBN
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MeanKBN
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MeanKBN -> c MeanKBN
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MeanKBN -> c MeanKBN
Data,forall x. Rep MeanKBN x -> MeanKBN
forall x. MeanKBN -> Rep MeanKBN x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MeanKBN x -> MeanKBN
$cfrom :: forall x. MeanKBN -> Rep MeanKBN x
Generic)

asMeanKBN :: MeanKBN -> MeanKBN
asMeanKBN :: MeanKBN -> MeanKBN
asMeanKBN = forall a. a -> a
id


instance Semigroup MeanKBN where
  MeanKBN Int
0  KBNSum
_  <> :: MeanKBN -> MeanKBN -> MeanKBN
<> MeanKBN
m             = MeanKBN
m
  MeanKBN
m             <> MeanKBN Int
0  KBNSum
_  = MeanKBN
m
  MeanKBN Int
n1 KBNSum
s1 <> MeanKBN Int
n2 KBNSum
s2 = Int -> KBNSum -> MeanKBN
MeanKBN (Int
n1forall a. Num a => a -> a -> a
+Int
n2) (KBNSum
s1 forall a. Semigroup a => a -> a -> a
<> KBNSum
s2)

instance Monoid MeanKBN where
  mempty :: MeanKBN
mempty  = Int -> KBNSum -> MeanKBN
MeanKBN Int
0 forall a. Monoid a => a
mempty
  mappend :: MeanKBN -> MeanKBN -> MeanKBN
mappend = forall a. Semigroup a => a -> a -> a
(<>)
  
instance Real a => StatMonoid MeanKBN a where
  addValue :: MeanKBN -> a -> MeanKBN
addValue (MeanKBN Int
n KBNSum
m) a
x = Int -> KBNSum -> MeanKBN
MeanKBN (Int
nforall a. Num a => a -> a -> a
+Int
1) (forall m a. StatMonoid m a => m -> a -> m
addValue KBNSum
m a
x)
  {-# INLINE addValue #-}

instance CalcCount MeanKBN where
  calcCount :: MeanKBN -> Int
calcCount (MeanKBN Int
n KBNSum
_) = Int
n
instance CalcMean MeanKBN where
  calcMean :: forall (m :: * -> *). MonadThrow m => MeanKBN -> m Double
calcMean (MeanKBN Int
0 KBNSum
_) = forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM forall a b. (a -> b) -> a -> b
$ String -> SampleError
EmptySample String
"Data.Monoid.Statistics.Numeric.MeanKBN: calcMean"
  calcMean (MeanKBN Int
n KBNSum
s) = forall (m :: * -> *) a. Monad m => a -> m a
return (KBNSum -> Double
kbn KBNSum
s forall a. Fractional a => a -> a -> a
/ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)


----------------------------------------------------------------

-- | Incremental calculation of weighed mean.
data WMeanNaive = WMeanNaive
  !Double  -- Weight
  !Double  -- Weighted sum
  deriving stock (Int -> WMeanNaive -> ShowS
[WMeanNaive] -> ShowS
WMeanNaive -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WMeanNaive] -> ShowS
$cshowList :: [WMeanNaive] -> ShowS
show :: WMeanNaive -> String
$cshow :: WMeanNaive -> String
showsPrec :: Int -> WMeanNaive -> ShowS
$cshowsPrec :: Int -> WMeanNaive -> ShowS
Show,WMeanNaive -> WMeanNaive -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WMeanNaive -> WMeanNaive -> Bool
$c/= :: WMeanNaive -> WMeanNaive -> Bool
== :: WMeanNaive -> WMeanNaive -> Bool
$c== :: WMeanNaive -> WMeanNaive -> Bool
Eq,Typeable WMeanNaive
WMeanNaive -> DataType
WMeanNaive -> Constr
(forall b. Data b => b -> b) -> WMeanNaive -> WMeanNaive
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) -> WMeanNaive -> u
forall u. (forall d. Data d => d -> u) -> WMeanNaive -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanNaive -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanNaive -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WMeanNaive -> m WMeanNaive
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanNaive -> m WMeanNaive
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WMeanNaive
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WMeanNaive -> c WMeanNaive
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WMeanNaive)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WMeanNaive)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanNaive -> m WMeanNaive
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanNaive -> m WMeanNaive
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanNaive -> m WMeanNaive
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanNaive -> m WMeanNaive
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WMeanNaive -> m WMeanNaive
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WMeanNaive -> m WMeanNaive
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WMeanNaive -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WMeanNaive -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> WMeanNaive -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WMeanNaive -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanNaive -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanNaive -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanNaive -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanNaive -> r
gmapT :: (forall b. Data b => b -> b) -> WMeanNaive -> WMeanNaive
$cgmapT :: (forall b. Data b => b -> b) -> WMeanNaive -> WMeanNaive
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WMeanNaive)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WMeanNaive)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WMeanNaive)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WMeanNaive)
dataTypeOf :: WMeanNaive -> DataType
$cdataTypeOf :: WMeanNaive -> DataType
toConstr :: WMeanNaive -> Constr
$ctoConstr :: WMeanNaive -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WMeanNaive
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WMeanNaive
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WMeanNaive -> c WMeanNaive
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WMeanNaive -> c WMeanNaive
Data,forall x. Rep WMeanNaive x -> WMeanNaive
forall x. WMeanNaive -> Rep WMeanNaive x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep WMeanNaive x -> WMeanNaive
$cfrom :: forall x. WMeanNaive -> Rep WMeanNaive x
Generic)

asWMeanNaive :: WMeanNaive -> WMeanNaive
asWMeanNaive :: WMeanNaive -> WMeanNaive
asWMeanNaive = forall a. a -> a
id


instance Semigroup WMeanNaive where
  WMeanNaive Double
w1 Double
s1 <> :: WMeanNaive -> WMeanNaive -> WMeanNaive
<> WMeanNaive Double
w2 Double
s2 = Double -> Double -> WMeanNaive
WMeanNaive (Double
w1 forall a. Num a => a -> a -> a
+ Double
w2) (Double
s1 forall a. Num a => a -> a -> a
+ Double
s2)

instance Monoid WMeanNaive where
  mempty :: WMeanNaive
mempty  = Double -> Double -> WMeanNaive
WMeanNaive Double
0 Double
0
  mappend :: WMeanNaive -> WMeanNaive -> WMeanNaive
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance (Real w, Real a) => StatMonoid WMeanNaive (Weighted w a) where
  addValue :: WMeanNaive -> Weighted w a -> WMeanNaive
addValue (WMeanNaive Double
n Double
s) (Weighted w
w a
a)
    = Double -> Double -> WMeanNaive
WMeanNaive (Double
n forall a. Num a => a -> a -> a
+ Double
w') (Double
s forall a. Num a => a -> a -> a
+ (Double
w' forall a. Num a => a -> a -> a
* Double
a'))
    where
      w' :: Double
w' = forall a b. (Real a, Fractional b) => a -> b
realToFrac w
w
      a' :: Double
a' = forall a b. (Real a, Fractional b) => a -> b
realToFrac a
a
  {-# INLINE addValue #-}

instance CalcMean WMeanNaive where
  calcMean :: forall (m :: * -> *). MonadThrow m => WMeanNaive -> m Double
calcMean (WMeanNaive Double
w Double
s)
    | Double
w forall a. Ord a => a -> a -> Bool
<= Double
0    = forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM forall a b. (a -> b) -> a -> b
$ String -> SampleError
EmptySample String
"Data.Monoid.Statistics.Numeric.WMeanNaive: calcMean"
    | Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return (Double
s forall a. Fractional a => a -> a -> a
/ Double
w)

----------------------------------------------------------------

-- | Incremental calculation of weighed mean. Sum of both weights and
--   elements is calculated using Kahan-Babuška-Neumaier summation.
data WMeanKBN = WMeanKBN
  {-# UNPACK #-} !KBNSum  -- Weight
  {-# UNPACK #-} !KBNSum  -- Weighted sum
  deriving stock (Int -> WMeanKBN -> ShowS
[WMeanKBN] -> ShowS
WMeanKBN -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WMeanKBN] -> ShowS
$cshowList :: [WMeanKBN] -> ShowS
show :: WMeanKBN -> String
$cshow :: WMeanKBN -> String
showsPrec :: Int -> WMeanKBN -> ShowS
$cshowsPrec :: Int -> WMeanKBN -> ShowS
Show,WMeanKBN -> WMeanKBN -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WMeanKBN -> WMeanKBN -> Bool
$c/= :: WMeanKBN -> WMeanKBN -> Bool
== :: WMeanKBN -> WMeanKBN -> Bool
$c== :: WMeanKBN -> WMeanKBN -> Bool
Eq,Typeable WMeanKBN
WMeanKBN -> DataType
WMeanKBN -> Constr
(forall b. Data b => b -> b) -> WMeanKBN -> WMeanKBN
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) -> WMeanKBN -> u
forall u. (forall d. Data d => d -> u) -> WMeanKBN -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanKBN -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanKBN -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WMeanKBN -> m WMeanKBN
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanKBN -> m WMeanKBN
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WMeanKBN
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WMeanKBN -> c WMeanKBN
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WMeanKBN)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WMeanKBN)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanKBN -> m WMeanKBN
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanKBN -> m WMeanKBN
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanKBN -> m WMeanKBN
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WMeanKBN -> m WMeanKBN
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WMeanKBN -> m WMeanKBN
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WMeanKBN -> m WMeanKBN
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WMeanKBN -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WMeanKBN -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> WMeanKBN -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WMeanKBN -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanKBN -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanKBN -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanKBN -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WMeanKBN -> r
gmapT :: (forall b. Data b => b -> b) -> WMeanKBN -> WMeanKBN
$cgmapT :: (forall b. Data b => b -> b) -> WMeanKBN -> WMeanKBN
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WMeanKBN)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WMeanKBN)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WMeanKBN)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WMeanKBN)
dataTypeOf :: WMeanKBN -> DataType
$cdataTypeOf :: WMeanKBN -> DataType
toConstr :: WMeanKBN -> Constr
$ctoConstr :: WMeanKBN -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WMeanKBN
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WMeanKBN
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WMeanKBN -> c WMeanKBN
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WMeanKBN -> c WMeanKBN
Data,forall x. Rep WMeanKBN x -> WMeanKBN
forall x. WMeanKBN -> Rep WMeanKBN x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep WMeanKBN x -> WMeanKBN
$cfrom :: forall x. WMeanKBN -> Rep WMeanKBN x
Generic)

asWMeanKBN :: WMeanKBN -> WMeanKBN
asWMeanKBN :: WMeanKBN -> WMeanKBN
asWMeanKBN = forall a. a -> a
id


instance Semigroup WMeanKBN where
  WMeanKBN KBNSum
n1 KBNSum
s1 <> :: WMeanKBN -> WMeanKBN -> WMeanKBN
<> WMeanKBN KBNSum
n2 KBNSum
s2 = KBNSum -> KBNSum -> WMeanKBN
WMeanKBN (KBNSum
n1 forall a. Semigroup a => a -> a -> a
<> KBNSum
n2) (KBNSum
s1 forall a. Semigroup a => a -> a -> a
<> KBNSum
s2)

instance Monoid WMeanKBN where
  mempty :: WMeanKBN
mempty  = KBNSum -> KBNSum -> WMeanKBN
WMeanKBN forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty
  mappend :: WMeanKBN -> WMeanKBN -> WMeanKBN
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance (Real w, Real a) => StatMonoid WMeanKBN (Weighted w a) where
  addValue :: WMeanKBN -> Weighted w a -> WMeanKBN
addValue (WMeanKBN KBNSum
n KBNSum
m) (Weighted w
w a
a)
    = KBNSum -> KBNSum -> WMeanKBN
WMeanKBN (forall s. Summation s => s -> Double -> s
add KBNSum
n Double
w') (forall s. Summation s => s -> Double -> s
add KBNSum
m (Double
w' forall a. Num a => a -> a -> a
* Double
a'))
    where
      w' :: Double
w' = forall a b. (Real a, Fractional b) => a -> b
realToFrac w
w :: Double
      a' :: Double
a' = forall a b. (Real a, Fractional b) => a -> b
realToFrac a
a :: Double
  {-# INLINE addValue #-}

instance CalcMean WMeanKBN where
  calcMean :: forall (m :: * -> *). MonadThrow m => WMeanKBN -> m Double
calcMean (WMeanKBN (KBNSum -> Double
kbn -> Double
w) (KBNSum -> Double
kbn -> Double
s))
    | Double
w forall a. Ord a => a -> a -> Bool
<= Double
0    = forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM forall a b. (a -> b) -> a -> b
$ String -> SampleError
EmptySample String
"Data.Monoid.Statistics.Numeric.WMeanKBN: calcMean"
    | Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return (Double
s forall a. Fractional a => a -> a -> a
/ Double
w)


----------------------------------------------------------------

-- | This is algorithm for estimation of mean and variance of sample
--   which uses modified Welford algorithm. It uses KBN summation and
--   provides approximately 2 additional decimal digits
data VarWelfordKBN = VarWelfordKBN
  {-# UNPACK #-} !Int    --  Number of elements in the sample
  {-# UNPACK #-} !KBNSum -- Current sum of elements of sample
  {-# UNPACK #-} !KBNSum -- Current sum of squares of deviations from current mean

asVarWelfordKBN :: VarWelfordKBN -> VarWelfordKBN
asVarWelfordKBN :: VarWelfordKBN -> VarWelfordKBN
asVarWelfordKBN = forall a. a -> a
id


-- | Incremental algorithms for calculation the standard deviation [Chan1979].
data Variance = Variance {-# UNPACK #-} !Int    --  Number of elements in the sample
                         {-# UNPACK #-} !Double -- Current sum of elements of sample
                         {-# UNPACK #-} !Double -- Current sum of squares of deviations from current mean
  deriving stock (Int -> Variance -> ShowS
[Variance] -> ShowS
Variance -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Variance] -> ShowS
$cshowList :: [Variance] -> ShowS
show :: Variance -> String
$cshow :: Variance -> String
showsPrec :: Int -> Variance -> ShowS
$cshowsPrec :: Int -> Variance -> ShowS
Show,Variance -> Variance -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Variance -> Variance -> Bool
$c/= :: Variance -> Variance -> Bool
== :: Variance -> Variance -> Bool
$c== :: Variance -> Variance -> Bool
Eq,Typeable)

-- | Type restricted 'id '
asVariance :: Variance -> Variance
asVariance :: Variance -> Variance
asVariance = forall a. a -> a
id

instance Semigroup Variance where
  Variance Int
n1 Double
ta Double
sa <> :: Variance -> Variance -> Variance
<> Variance Int
n2 Double
tb Double
sb
    = Int -> Double -> Double -> Variance
Variance (Int
n1forall a. Num a => a -> a -> a
+Int
n2) (Double
taforall a. Num a => a -> a -> a
+Double
tb) Double
sumsq
    where
      na :: Double
na = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n1
      nb :: Double
nb = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n2
      nom :: Double
nom = Double -> Double
sqr (Double
ta forall a. Num a => a -> a -> a
* Double
nb forall a. Num a => a -> a -> a
- Double
tb forall a. Num a => a -> a -> a
* Double
na)
      sumsq :: Double
sumsq | Int
n1 forall a. Eq a => a -> a -> Bool
== Int
0   = Double
sb
            | Int
n2 forall a. Eq a => a -> a -> Bool
== Int
0   = Double
sa
            | Bool
otherwise = Double
sa forall a. Num a => a -> a -> a
+ Double
sb forall a. Num a => a -> a -> a
+ Double
nom forall a. Fractional a => a -> a -> a
/ ((Double
na forall a. Num a => a -> a -> a
+ Double
nb) forall a. Num a => a -> a -> a
* Double
na forall a. Num a => a -> a -> a
* Double
nb)

instance Monoid Variance where
  mempty :: Variance
mempty  = Int -> Double -> Double -> Variance
Variance Int
0 Double
0 Double
0
  mappend :: Variance -> Variance -> Variance
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Real a => StatMonoid Variance a where
  addValue :: Variance -> a -> Variance
addValue (Variance Int
0 Double
_ Double
_) a
x = forall m a. StatMonoid m a => a -> m
singletonMonoid a
x
  addValue (Variance Int
n Double
t Double
s) (forall a b. (Real a, Fractional b) => a -> b
realToFrac -> Double
x)
    = Int -> Double -> Double -> Variance
Variance (Int
n forall a. Num a => a -> a -> a
+ Int
1) (Double
t forall a. Num a => a -> a -> a
+ Double
x) (Double
s forall a. Num a => a -> a -> a
+ Double -> Double
sqr (Double
t  forall a. Num a => a -> a -> a
- Double
n' forall a. Num a => a -> a -> a
* Double
x) forall a. Fractional a => a -> a -> a
/ (Double
n' forall a. Num a => a -> a -> a
* (Double
n'forall a. Num a => a -> a -> a
+Double
1)))
    where
      n' :: Double
n' = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n
  {-# INLINE addValue #-}
  singletonMonoid :: a -> Variance
singletonMonoid a
x = Int -> Double -> Double -> Variance
Variance Int
1 (forall a b. (Real a, Fractional b) => a -> b
realToFrac a
x) Double
0
  {-# INLINE singletonMonoid #-}

instance CalcCount Variance where
  calcCount :: Variance -> Int
calcCount (Variance Int
n Double
_ Double
_) = Int
n

instance CalcMean Variance where
  calcMean :: forall (m :: * -> *). MonadThrow m => Variance -> m Double
calcMean (Variance Int
0 Double
_ Double
_) = forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM forall a b. (a -> b) -> a -> b
$ String -> SampleError
EmptySample String
"Data.Monoid.Statistics.Numeric.Variance: calcMean"
  calcMean (Variance Int
n Double
s Double
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (Double
s forall a. Fractional a => a -> a -> a
/ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)

instance CalcVariance Variance where
  calcVariance :: forall (m :: * -> *). MonadThrow m => Variance -> m Double
calcVariance (Variance Int
n Double
_ Double
s)
    | Int
n forall a. Ord a => a -> a -> Bool
< Int
2     = forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM forall a b. (a -> b) -> a -> b
$ String -> String -> SampleError
InvalidSample
                    String
"Data.Monoid.Statistics.Numeric.Variance: calcVariance"
                    String
"Need at least 2 elements"
    | Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! Double
s forall a. Fractional a => a -> a -> a
/ forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
n forall a. Num a => a -> a -> a
- Int
1)
  calcVarianceML :: forall (m :: * -> *). MonadThrow m => Variance -> m Double
calcVarianceML (Variance Int
n Double
_ Double
s)
    | Int
n forall a. Ord a => a -> a -> Bool
< Int
1     = forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM forall a b. (a -> b) -> a -> b
$ String -> String -> SampleError
InvalidSample
                    String
"Data.Monoid.Statistics.Numeric.Variance: calcVarianceML"
                    String
"Need at least 1 element"
    | Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! Double
s forall a. Fractional a => a -> a -> a
/ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n



----------------------------------------------------------------

-- | Calculate minimum of sample
newtype Min a = Min { forall a. Min a -> Maybe a
calcMin :: Maybe a }
  deriving stock (Int -> Min a -> ShowS
forall a. Show a => Int -> Min a -> ShowS
forall a. Show a => [Min a] -> ShowS
forall a. Show a => Min a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Min a] -> ShowS
$cshowList :: forall a. Show a => [Min a] -> ShowS
show :: Min a -> String
$cshow :: forall a. Show a => Min a -> String
showsPrec :: Int -> Min a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Min a -> ShowS
Show,Min a -> Min a -> Bool
forall a. Eq a => Min a -> Min a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Min a -> Min a -> Bool
$c/= :: forall a. Eq a => Min a -> Min a -> Bool
== :: Min a -> Min a -> Bool
$c== :: forall a. Eq a => Min a -> Min a -> Bool
Eq,Min a -> Min a -> Bool
Min a -> Min a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Min a)
forall a. Ord a => Min a -> Min a -> Bool
forall a. Ord a => Min a -> Min a -> Ordering
forall a. Ord a => Min a -> Min a -> Min a
min :: Min a -> Min a -> Min a
$cmin :: forall a. Ord a => Min a -> Min a -> Min a
max :: Min a -> Min a -> Min a
$cmax :: forall a. Ord a => Min a -> Min a -> Min a
>= :: Min a -> Min a -> Bool
$c>= :: forall a. Ord a => Min a -> Min a -> Bool
> :: Min a -> Min a -> Bool
$c> :: forall a. Ord a => Min a -> Min a -> Bool
<= :: Min a -> Min a -> Bool
$c<= :: forall a. Ord a => Min a -> Min a -> Bool
< :: Min a -> Min a -> Bool
$c< :: forall a. Ord a => Min a -> Min a -> Bool
compare :: Min a -> Min a -> Ordering
$ccompare :: forall a. Ord a => Min a -> Min a -> Ordering
Ord,Min a -> DataType
Min a -> Constr
forall {a}. Data a => Typeable (Min a)
forall a. Data a => Min a -> DataType
forall a. Data a => Min a -> Constr
forall a. Data a => (forall b. Data b => b -> b) -> Min a -> Min a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Min a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Min a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Min a -> m (Min a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Min a -> m (Min a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Min a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Min a -> c (Min a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Min a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Min a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Min a -> c (Min a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Min a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Min a -> m (Min a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Min a -> m (Min a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Min a -> m (Min a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Min a -> m (Min a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Min a -> m (Min a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Min a -> m (Min a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Min a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Min a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Min a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Min a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
gmapT :: (forall b. Data b => b -> b) -> Min a -> Min a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Min a -> Min a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Min a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Min a))
dataTypeOf :: Min a -> DataType
$cdataTypeOf :: forall a. Data a => Min a -> DataType
toConstr :: Min a -> Constr
$ctoConstr :: forall a. Data a => Min a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Min a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Min a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Min a -> c (Min a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Min a -> c (Min a)
Data,forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Min a) x -> Min a
forall a x. Min a -> Rep (Min a) x
$cto :: forall a x. Rep (Min a) x -> Min a
$cfrom :: forall a x. Min a -> Rep (Min a) x
Generic)

instance Ord a => Semigroup (Min a) where
  Min (Just a
a) <> :: Min a -> Min a -> Min a
<> Min (Just a
b) = forall a. Maybe a -> Min a
Min (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$! forall a. Ord a => a -> a -> a
min a
a a
b)
  Min Maybe a
a        <> Min Maybe a
Nothing  = forall a. Maybe a -> Min a
Min Maybe a
a
  Min Maybe a
Nothing  <> Min Maybe a
b        = forall a. Maybe a -> Min a
Min Maybe a
b

instance Ord a => Monoid (Min a) where
  mempty :: Min a
mempty  = forall a. Maybe a -> Min a
Min forall a. Maybe a
Nothing
  mappend :: Min a -> Min a -> Min a
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance (Ord a, a ~ a') => StatMonoid (Min a) a' where
  singletonMonoid :: a' -> Min a
singletonMonoid a'
a = forall a. Maybe a -> Min a
Min (forall a. a -> Maybe a
Just a'
a)


----------------------------------------------------------------

-- | Calculate maximum of sample
newtype Max a = Max { forall a. Max a -> Maybe a
calcMax :: Maybe a }
  deriving stock (Int -> Max a -> ShowS
forall a. Show a => Int -> Max a -> ShowS
forall a. Show a => [Max a] -> ShowS
forall a. Show a => Max a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Max a] -> ShowS
$cshowList :: forall a. Show a => [Max a] -> ShowS
show :: Max a -> String
$cshow :: forall a. Show a => Max a -> String
showsPrec :: Int -> Max a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Max a -> ShowS
Show,Max a -> Max a -> Bool
forall a. Eq a => Max a -> Max a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Max a -> Max a -> Bool
$c/= :: forall a. Eq a => Max a -> Max a -> Bool
== :: Max a -> Max a -> Bool
$c== :: forall a. Eq a => Max a -> Max a -> Bool
Eq,Max a -> Max a -> Bool
Max a -> Max a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Max a)
forall a. Ord a => Max a -> Max a -> Bool
forall a. Ord a => Max a -> Max a -> Ordering
forall a. Ord a => Max a -> Max a -> Max a
min :: Max a -> Max a -> Max a
$cmin :: forall a. Ord a => Max a -> Max a -> Max a
max :: Max a -> Max a -> Max a
$cmax :: forall a. Ord a => Max a -> Max a -> Max a
>= :: Max a -> Max a -> Bool
$c>= :: forall a. Ord a => Max a -> Max a -> Bool
> :: Max a -> Max a -> Bool
$c> :: forall a. Ord a => Max a -> Max a -> Bool
<= :: Max a -> Max a -> Bool
$c<= :: forall a. Ord a => Max a -> Max a -> Bool
< :: Max a -> Max a -> Bool
$c< :: forall a. Ord a => Max a -> Max a -> Bool
compare :: Max a -> Max a -> Ordering
$ccompare :: forall a. Ord a => Max a -> Max a -> Ordering
Ord,Max a -> DataType
Max a -> Constr
forall {a}. Data a => Typeable (Max a)
forall a. Data a => Max a -> DataType
forall a. Data a => Max a -> Constr
forall a. Data a => (forall b. Data b => b -> b) -> Max a -> Max a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Max a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Max a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Max a -> m (Max a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Max a -> m (Max a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Max a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Max a -> c (Max a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Max a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a))
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 (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Max a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Max a -> c (Max a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Max a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Max a -> m (Max a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Max a -> m (Max a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Max a -> m (Max a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Max a -> m (Max a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Max a -> m (Max a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Max a -> m (Max a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Max a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Max a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Max a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Max a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
gmapT :: (forall b. Data b => b -> b) -> Max a -> Max a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Max a -> Max a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Max a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Max a))
dataTypeOf :: Max a -> DataType
$cdataTypeOf :: forall a. Data a => Max a -> DataType
toConstr :: Max a -> Constr
$ctoConstr :: forall a. Data a => Max a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Max a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Max a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Max a -> c (Max a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Max a -> c (Max a)
Data,forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Max a) x -> Max a
forall a x. Max a -> Rep (Max a) x
$cto :: forall a x. Rep (Max a) x -> Max a
$cfrom :: forall a x. Max a -> Rep (Max a) x
Generic)

instance Ord a => Semigroup (Max a) where
  Max (Just a
a) <> :: Max a -> Max a -> Max a
<> Max (Just a
b) = forall a. Maybe a -> Max a
Max (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$! forall a. Ord a => a -> a -> a
max a
a a
b)
  Max Maybe a
a        <> Max Maybe a
Nothing  = forall a. Maybe a -> Max a
Max Maybe a
a
  Max Maybe a
Nothing  <> Max Maybe a
b        = forall a. Maybe a -> Max a
Max Maybe a
b

instance Ord a => Monoid (Max a) where
  mempty :: Max a
mempty  = forall a. Maybe a -> Max a
Max forall a. Maybe a
Nothing
  mappend :: Max a -> Max a -> Max a
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance (Ord a, a ~ a') => StatMonoid (Max a) a' where
  singletonMonoid :: a' -> Max a
singletonMonoid a'
a = forall a. Maybe a -> Max a
Max (forall a. a -> Maybe a
Just a'
a)


----------------------------------------------------------------

-- | Calculate minimum of sample of Doubles. For empty sample returns NaN. Any
--   NaN encountered will be ignored.
newtype MinD = MinD { MinD -> Double
calcMinD :: Double }
  deriving stock (Int -> MinD -> ShowS
[MinD] -> ShowS
MinD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MinD] -> ShowS
$cshowList :: [MinD] -> ShowS
show :: MinD -> String
$cshow :: MinD -> String
showsPrec :: Int -> MinD -> ShowS
$cshowsPrec :: Int -> MinD -> ShowS
Show,Typeable MinD
MinD -> DataType
MinD -> Constr
(forall b. Data b => b -> b) -> MinD -> MinD
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) -> MinD -> u
forall u. (forall d. Data d => d -> u) -> MinD -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MinD -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MinD -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MinD -> m MinD
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MinD -> m MinD
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MinD
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MinD -> c MinD
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MinD)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MinD)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MinD -> m MinD
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MinD -> m MinD
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MinD -> m MinD
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MinD -> m MinD
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MinD -> m MinD
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MinD -> m MinD
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MinD -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MinD -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MinD -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MinD -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MinD -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MinD -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MinD -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MinD -> r
gmapT :: (forall b. Data b => b -> b) -> MinD -> MinD
$cgmapT :: (forall b. Data b => b -> b) -> MinD -> MinD
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MinD)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MinD)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MinD)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MinD)
dataTypeOf :: MinD -> DataType
$cdataTypeOf :: MinD -> DataType
toConstr :: MinD -> Constr
$ctoConstr :: MinD -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MinD
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MinD
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MinD -> c MinD
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MinD -> c MinD
Data,forall x. Rep MinD x -> MinD
forall x. MinD -> Rep MinD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MinD x -> MinD
$cfrom :: forall x. MinD -> Rep MinD x
Generic)

instance Eq MinD where
  MinD Double
a == :: MinD -> MinD -> Bool
== MinD Double
b
    | forall a. RealFloat a => a -> Bool
isNaN Double
a Bool -> Bool -> Bool
&& forall a. RealFloat a => a -> Bool
isNaN Double
b = Bool
True
    | Bool
otherwise          = Double
a forall a. Eq a => a -> a -> Bool
== Double
b

instance Semigroup MinD where
  MinD Double
x <> :: MinD -> MinD -> MinD
<> MinD Double
y
    | forall a. RealFloat a => a -> Bool
isNaN Double
x   = Double -> MinD
MinD Double
y
    | forall a. RealFloat a => a -> Bool
isNaN Double
y   = Double -> MinD
MinD Double
x
    | Bool
otherwise = Double -> MinD
MinD (forall a. Ord a => a -> a -> a
min Double
x Double
y)

-- N.B. forall (x :: Double) (x <= NaN) == False
instance Monoid MinD where
  mempty :: MinD
mempty  = Double -> MinD
MinD (Double
0forall a. Fractional a => a -> a -> a
/Double
0)
  mappend :: MinD -> MinD -> MinD
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance a ~ Double => StatMonoid MinD a where
  singletonMonoid :: a -> MinD
singletonMonoid = Double -> MinD
MinD



-- | Calculate maximum of sample. For empty sample returns NaN. Any
--   NaN encountered will be ignored.
newtype MaxD = MaxD { MaxD -> Double
calcMaxD :: Double }
  deriving stock (Int -> MaxD -> ShowS
[MaxD] -> ShowS
MaxD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MaxD] -> ShowS
$cshowList :: [MaxD] -> ShowS
show :: MaxD -> String
$cshow :: MaxD -> String
showsPrec :: Int -> MaxD -> ShowS
$cshowsPrec :: Int -> MaxD -> ShowS
Show,Typeable MaxD
MaxD -> DataType
MaxD -> Constr
(forall b. Data b => b -> b) -> MaxD -> MaxD
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) -> MaxD -> u
forall u. (forall d. Data d => d -> u) -> MaxD -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MaxD -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MaxD -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MaxD -> m MaxD
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MaxD -> m MaxD
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MaxD
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MaxD -> c MaxD
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MaxD)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MaxD)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MaxD -> m MaxD
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MaxD -> m MaxD
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MaxD -> m MaxD
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MaxD -> m MaxD
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MaxD -> m MaxD
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MaxD -> m MaxD
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MaxD -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MaxD -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MaxD -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MaxD -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MaxD -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MaxD -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MaxD -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MaxD -> r
gmapT :: (forall b. Data b => b -> b) -> MaxD -> MaxD
$cgmapT :: (forall b. Data b => b -> b) -> MaxD -> MaxD
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MaxD)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MaxD)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MaxD)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MaxD)
dataTypeOf :: MaxD -> DataType
$cdataTypeOf :: MaxD -> DataType
toConstr :: MaxD -> Constr
$ctoConstr :: MaxD -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MaxD
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MaxD
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MaxD -> c MaxD
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MaxD -> c MaxD
Data,forall x. Rep MaxD x -> MaxD
forall x. MaxD -> Rep MaxD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MaxD x -> MaxD
$cfrom :: forall x. MaxD -> Rep MaxD x
Generic)

instance Eq MaxD where
  MaxD Double
a == :: MaxD -> MaxD -> Bool
== MaxD Double
b
    | forall a. RealFloat a => a -> Bool
isNaN Double
a Bool -> Bool -> Bool
&& forall a. RealFloat a => a -> Bool
isNaN Double
b = Bool
True
    | Bool
otherwise          = Double
a forall a. Eq a => a -> a -> Bool
== Double
b

instance Semigroup MaxD where
  MaxD Double
x <> :: MaxD -> MaxD -> MaxD
<> MaxD Double
y
    | forall a. RealFloat a => a -> Bool
isNaN Double
x   = Double -> MaxD
MaxD Double
y
    | forall a. RealFloat a => a -> Bool
isNaN Double
y   = Double -> MaxD
MaxD Double
x
    | Bool
otherwise = Double -> MaxD
MaxD (forall a. Ord a => a -> a -> a
max Double
x Double
y)

instance Monoid MaxD where
  mempty :: MaxD
mempty  = Double -> MaxD
MaxD (Double
0forall a. Fractional a => a -> a -> a
/Double
0)
  mappend :: MaxD -> MaxD -> MaxD
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance a ~ Double => StatMonoid MaxD a where
  singletonMonoid :: a -> MaxD
singletonMonoid = Double -> MaxD
MaxD


----------------------------------------------------------------

-- | Accumulator for binomial trials.
data BinomAcc = BinomAcc { BinomAcc -> Int
binomAccSuccess :: !Int
                         , BinomAcc -> Int
binomAccTotal   :: !Int
                         }
  deriving stock (Int -> BinomAcc -> ShowS
[BinomAcc] -> ShowS
BinomAcc -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BinomAcc] -> ShowS
$cshowList :: [BinomAcc] -> ShowS
show :: BinomAcc -> String
$cshow :: BinomAcc -> String
showsPrec :: Int -> BinomAcc -> ShowS
$cshowsPrec :: Int -> BinomAcc -> ShowS
Show,BinomAcc -> BinomAcc -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BinomAcc -> BinomAcc -> Bool
$c/= :: BinomAcc -> BinomAcc -> Bool
== :: BinomAcc -> BinomAcc -> Bool
$c== :: BinomAcc -> BinomAcc -> Bool
Eq,Eq BinomAcc
BinomAcc -> BinomAcc -> Bool
BinomAcc -> BinomAcc -> Ordering
BinomAcc -> BinomAcc -> BinomAcc
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BinomAcc -> BinomAcc -> BinomAcc
$cmin :: BinomAcc -> BinomAcc -> BinomAcc
max :: BinomAcc -> BinomAcc -> BinomAcc
$cmax :: BinomAcc -> BinomAcc -> BinomAcc
>= :: BinomAcc -> BinomAcc -> Bool
$c>= :: BinomAcc -> BinomAcc -> Bool
> :: BinomAcc -> BinomAcc -> Bool
$c> :: BinomAcc -> BinomAcc -> Bool
<= :: BinomAcc -> BinomAcc -> Bool
$c<= :: BinomAcc -> BinomAcc -> Bool
< :: BinomAcc -> BinomAcc -> Bool
$c< :: BinomAcc -> BinomAcc -> Bool
compare :: BinomAcc -> BinomAcc -> Ordering
$ccompare :: BinomAcc -> BinomAcc -> Ordering
Ord,Typeable BinomAcc
BinomAcc -> DataType
BinomAcc -> Constr
(forall b. Data b => b -> b) -> BinomAcc -> BinomAcc
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) -> BinomAcc -> u
forall u. (forall d. Data d => d -> u) -> BinomAcc -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinomAcc -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinomAcc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BinomAcc -> m BinomAcc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinomAcc -> m BinomAcc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinomAcc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinomAcc -> c BinomAcc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinomAcc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinomAcc)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinomAcc -> m BinomAcc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinomAcc -> m BinomAcc
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinomAcc -> m BinomAcc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BinomAcc -> m BinomAcc
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BinomAcc -> m BinomAcc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BinomAcc -> m BinomAcc
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BinomAcc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BinomAcc -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BinomAcc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BinomAcc -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinomAcc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinomAcc -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinomAcc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinomAcc -> r
gmapT :: (forall b. Data b => b -> b) -> BinomAcc -> BinomAcc
$cgmapT :: (forall b. Data b => b -> b) -> BinomAcc -> BinomAcc
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinomAcc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BinomAcc)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinomAcc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinomAcc)
dataTypeOf :: BinomAcc -> DataType
$cdataTypeOf :: BinomAcc -> DataType
toConstr :: BinomAcc -> Constr
$ctoConstr :: BinomAcc -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinomAcc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinomAcc
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinomAcc -> c BinomAcc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinomAcc -> c BinomAcc
Data,forall x. Rep BinomAcc x -> BinomAcc
forall x. BinomAcc -> Rep BinomAcc x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BinomAcc x -> BinomAcc
$cfrom :: forall x. BinomAcc -> Rep BinomAcc x
Generic)

-- | Type restricted 'id'
asBinomAcc :: BinomAcc -> BinomAcc
asBinomAcc :: BinomAcc -> BinomAcc
asBinomAcc = forall a. a -> a
id

instance Semigroup BinomAcc where
  BinomAcc Int
n1 Int
m1 <> :: BinomAcc -> BinomAcc -> BinomAcc
<> BinomAcc Int
n2 Int
m2 = Int -> Int -> BinomAcc
BinomAcc (Int
n1forall a. Num a => a -> a -> a
+Int
n2) (Int
m1forall a. Num a => a -> a -> a
+Int
m2)

instance Monoid BinomAcc where
  mempty :: BinomAcc
mempty  = Int -> Int -> BinomAcc
BinomAcc Int
0 Int
0
  mappend :: BinomAcc -> BinomAcc -> BinomAcc
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance StatMonoid BinomAcc Bool where
  addValue :: BinomAcc -> Bool -> BinomAcc
addValue (BinomAcc Int
nS Int
nT) Bool
True  = Int -> Int -> BinomAcc
BinomAcc (Int
nSforall a. Num a => a -> a -> a
+Int
1) (Int
nTforall a. Num a => a -> a -> a
+Int
1)
  addValue (BinomAcc Int
nS Int
nT) Bool
False = Int -> Int -> BinomAcc
BinomAcc  Int
nS    (Int
nTforall a. Num a => a -> a -> a
+Int
1)


-- | Value @a@ weighted by weight @w@
data Weighted w a = Weighted w a
  deriving stock (Int -> Weighted w a -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall w a. (Show w, Show a) => Int -> Weighted w a -> ShowS
forall w a. (Show w, Show a) => [Weighted w a] -> ShowS
forall w a. (Show w, Show a) => Weighted w a -> String
showList :: [Weighted w a] -> ShowS
$cshowList :: forall w a. (Show w, Show a) => [Weighted w a] -> ShowS
show :: Weighted w a -> String
$cshow :: forall w a. (Show w, Show a) => Weighted w a -> String
showsPrec :: Int -> Weighted w a -> ShowS
$cshowsPrec :: forall w a. (Show w, Show a) => Int -> Weighted w a -> ShowS
Show,Weighted w a -> Weighted w a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall w a. (Eq w, Eq a) => Weighted w a -> Weighted w a -> Bool
/= :: Weighted w a -> Weighted w a -> Bool
$c/= :: forall w a. (Eq w, Eq a) => Weighted w a -> Weighted w a -> Bool
== :: Weighted w a -> Weighted w a -> Bool
$c== :: forall w a. (Eq w, Eq a) => Weighted w a -> Weighted w a -> Bool
Eq,Weighted w a -> Weighted w a -> Bool
Weighted w a -> Weighted w a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {w} {a}. (Ord w, Ord a) => Eq (Weighted w a)
forall w a. (Ord w, Ord a) => Weighted w a -> Weighted w a -> Bool
forall w a.
(Ord w, Ord a) =>
Weighted w a -> Weighted w a -> Ordering
forall w a.
(Ord w, Ord a) =>
Weighted w a -> Weighted w a -> Weighted w a
min :: Weighted w a -> Weighted w a -> Weighted w a
$cmin :: forall w a.
(Ord w, Ord a) =>
Weighted w a -> Weighted w a -> Weighted w a
max :: Weighted w a -> Weighted w a -> Weighted w a
$cmax :: forall w a.
(Ord w, Ord a) =>
Weighted w a -> Weighted w a -> Weighted w a
>= :: Weighted w a -> Weighted w a -> Bool
$c>= :: forall w a. (Ord w, Ord a) => Weighted w a -> Weighted w a -> Bool
> :: Weighted w a -> Weighted w a -> Bool
$c> :: forall w a. (Ord w, Ord a) => Weighted w a -> Weighted w a -> Bool
<= :: Weighted w a -> Weighted w a -> Bool
$c<= :: forall w a. (Ord w, Ord a) => Weighted w a -> Weighted w a -> Bool
< :: Weighted w a -> Weighted w a -> Bool
$c< :: forall w a. (Ord w, Ord a) => Weighted w a -> Weighted w a -> Bool
compare :: Weighted w a -> Weighted w a -> Ordering
$ccompare :: forall w a.
(Ord w, Ord a) =>
Weighted w a -> Weighted w a -> Ordering
Ord,Weighted w a -> DataType
Weighted w a -> Constr
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 {w} {a}. (Data w, Data a) => Typeable (Weighted w a)
forall w a. (Data w, Data a) => Weighted w a -> DataType
forall w a. (Data w, Data a) => Weighted w a -> Constr
forall w a.
(Data w, Data a) =>
(forall b. Data b => b -> b) -> Weighted w a -> Weighted w a
forall w a u.
(Data w, Data a) =>
Int -> (forall d. Data d => d -> u) -> Weighted w a -> u
forall w a u.
(Data w, Data a) =>
(forall d. Data d => d -> u) -> Weighted w a -> [u]
forall w a r r'.
(Data w, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Weighted w a -> r
forall w a r r'.
(Data w, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Weighted w a -> r
forall w a (m :: * -> *).
(Data w, Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Weighted w a -> m (Weighted w a)
forall w a (m :: * -> *).
(Data w, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Weighted w a -> m (Weighted w a)
forall w a (c :: * -> *).
(Data w, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Weighted w a)
forall w a (c :: * -> *).
(Data w, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Weighted w a -> c (Weighted w a)
forall w a (t :: * -> *) (c :: * -> *).
(Data w, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Weighted w a))
forall w a (t :: * -> * -> *) (c :: * -> *).
(Data w, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Weighted w a))
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Weighted w a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Weighted w a -> c (Weighted w a)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Weighted w a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Weighted w a -> m (Weighted w a)
$cgmapMo :: forall w a (m :: * -> *).
(Data w, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Weighted w a -> m (Weighted w a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Weighted w a -> m (Weighted w a)
$cgmapMp :: forall w a (m :: * -> *).
(Data w, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Weighted w a -> m (Weighted w a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Weighted w a -> m (Weighted w a)
$cgmapM :: forall w a (m :: * -> *).
(Data w, Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Weighted w a -> m (Weighted w a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Weighted w a -> u
$cgmapQi :: forall w a u.
(Data w, Data a) =>
Int -> (forall d. Data d => d -> u) -> Weighted w a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Weighted w a -> [u]
$cgmapQ :: forall w a u.
(Data w, Data a) =>
(forall d. Data d => d -> u) -> Weighted w a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Weighted w a -> r
$cgmapQr :: forall w a r r'.
(Data w, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Weighted w a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Weighted w a -> r
$cgmapQl :: forall w a r r'.
(Data w, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Weighted w a -> r
gmapT :: (forall b. Data b => b -> b) -> Weighted w a -> Weighted w a
$cgmapT :: forall w a.
(Data w, Data a) =>
(forall b. Data b => b -> b) -> Weighted w a -> Weighted w a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Weighted w a))
$cdataCast2 :: forall w a (t :: * -> * -> *) (c :: * -> *).
(Data w, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Weighted w a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Weighted w a))
$cdataCast1 :: forall w a (t :: * -> *) (c :: * -> *).
(Data w, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Weighted w a))
dataTypeOf :: Weighted w a -> DataType
$cdataTypeOf :: forall w a. (Data w, Data a) => Weighted w a -> DataType
toConstr :: Weighted w a -> Constr
$ctoConstr :: forall w a. (Data w, Data a) => Weighted w a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Weighted w a)
$cgunfold :: forall w a (c :: * -> *).
(Data w, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Weighted w a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Weighted w a -> c (Weighted w a)
$cgfoldl :: forall w a (c :: * -> *).
(Data w, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Weighted w a -> c (Weighted w a)
Data,forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall w a x. Rep (Weighted w a) x -> Weighted w a
forall w a x. Weighted w a -> Rep (Weighted w a) x
$cto :: forall w a x. Rep (Weighted w a) x -> Weighted w a
$cfrom :: forall w a x. Weighted w a -> Rep (Weighted w a) x
Generic,forall a b. a -> Weighted w b -> Weighted w a
forall a b. (a -> b) -> Weighted w a -> Weighted w b
forall w a b. a -> Weighted w b -> Weighted w a
forall w a b. (a -> b) -> Weighted w a -> Weighted w b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Weighted w b -> Weighted w a
$c<$ :: forall w a b. a -> Weighted w b -> Weighted w a
fmap :: forall a b. (a -> b) -> Weighted w a -> Weighted w b
$cfmap :: forall w a b. (a -> b) -> Weighted w a -> Weighted w b
Functor,forall a. Weighted w a -> Bool
forall w a. Eq a => a -> Weighted w a -> Bool
forall w a. Num a => Weighted w a -> a
forall w a. Ord a => Weighted w a -> a
forall m a. Monoid m => (a -> m) -> Weighted w a -> m
forall w m. Monoid m => Weighted w m -> m
forall w a. Weighted w a -> Bool
forall w a. Weighted w a -> Int
forall w a. Weighted w a -> [a]
forall a b. (a -> b -> b) -> b -> Weighted w a -> b
forall w a. (a -> a -> a) -> Weighted w a -> a
forall w m a. Monoid m => (a -> m) -> Weighted w a -> m
forall w b a. (b -> a -> b) -> b -> Weighted w a -> b
forall w a b. (a -> b -> b) -> b -> Weighted w a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Weighted w a -> a
$cproduct :: forall w a. Num a => Weighted w a -> a
sum :: forall a. Num a => Weighted w a -> a
$csum :: forall w a. Num a => Weighted w a -> a
minimum :: forall a. Ord a => Weighted w a -> a
$cminimum :: forall w a. Ord a => Weighted w a -> a
maximum :: forall a. Ord a => Weighted w a -> a
$cmaximum :: forall w a. Ord a => Weighted w a -> a
elem :: forall a. Eq a => a -> Weighted w a -> Bool
$celem :: forall w a. Eq a => a -> Weighted w a -> Bool
length :: forall a. Weighted w a -> Int
$clength :: forall w a. Weighted w a -> Int
null :: forall a. Weighted w a -> Bool
$cnull :: forall w a. Weighted w a -> Bool
toList :: forall a. Weighted w a -> [a]
$ctoList :: forall w a. Weighted w a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Weighted w a -> a
$cfoldl1 :: forall w a. (a -> a -> a) -> Weighted w a -> a
foldr1 :: forall a. (a -> a -> a) -> Weighted w a -> a
$cfoldr1 :: forall w a. (a -> a -> a) -> Weighted w a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Weighted w a -> b
$cfoldl' :: forall w b a. (b -> a -> b) -> b -> Weighted w a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Weighted w a -> b
$cfoldl :: forall w b a. (b -> a -> b) -> b -> Weighted w a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Weighted w a -> b
$cfoldr' :: forall w a b. (a -> b -> b) -> b -> Weighted w a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Weighted w a -> b
$cfoldr :: forall w a b. (a -> b -> b) -> b -> Weighted w a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Weighted w a -> m
$cfoldMap' :: forall w m a. Monoid m => (a -> m) -> Weighted w a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Weighted w a -> m
$cfoldMap :: forall w m a. Monoid m => (a -> m) -> Weighted w a -> m
fold :: forall m. Monoid m => Weighted w m -> m
$cfold :: forall w m. Monoid m => Weighted w m -> m
Foldable,forall w. Functor (Weighted w)
forall w. Foldable (Weighted w)
forall w (m :: * -> *) a.
Monad m =>
Weighted w (m a) -> m (Weighted w a)
forall w (f :: * -> *) a.
Applicative f =>
Weighted w (f a) -> f (Weighted w a)
forall w (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Weighted w a -> m (Weighted w b)
forall w (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Weighted w a -> f (Weighted w b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Weighted w a -> f (Weighted w b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Weighted w (m a) -> m (Weighted w a)
$csequence :: forall w (m :: * -> *) a.
Monad m =>
Weighted w (m a) -> m (Weighted w a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Weighted w a -> m (Weighted w b)
$cmapM :: forall w (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Weighted w a -> m (Weighted w b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Weighted w (f a) -> f (Weighted w a)
$csequenceA :: forall w (f :: * -> *) a.
Applicative f =>
Weighted w (f a) -> f (Weighted w a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Weighted w a -> f (Weighted w b)
$ctraverse :: forall w (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Weighted w a -> f (Weighted w b)
Traversable)

instance Bifunctor Weighted where
  first :: forall a b c. (a -> b) -> Weighted a c -> Weighted b c
first  a -> b
f   (Weighted a
w c
a) = forall w a. w -> a -> Weighted w a
Weighted (a -> b
f a
w) c
a
  second :: forall b c a. (b -> c) -> Weighted a b -> Weighted a c
second b -> c
f   (Weighted a
w b
a) = forall w a. w -> a -> Weighted w a
Weighted a
w (b -> c
f b
a)
  bimap :: forall a b c d.
(a -> b) -> (c -> d) -> Weighted a c -> Weighted b d
bimap  a -> b
f c -> d
g (Weighted a
w c
a) =forall w a. w -> a -> Weighted w a
Weighted (a -> b
f a
w) (c -> d
g c
a)
  {-# INLINE first  #-}
  {-# INLINE second #-}
  {-# INLINE bimap  #-}


----------------------------------------------------------------
-- Helpers
----------------------------------------------------------------

sqr :: Double -> Double
sqr :: Double -> Double
sqr Double
x = Double
x forall a. Num a => a -> a -> a
* Double
x
{-# INLINE sqr #-}


----------------------------------------------------------------
-- Unboxed instances
----------------------------------------------------------------

derivingUnbox "CountG"
  [t| forall a. Unbox a => CountG a -> a |]
  [| calcCountN |]
  [| CountG     |]

derivingUnbox "MeanNaive"
  [t| MeanNaive -> (Int,Double) |]
  [| \(MeanNaive a b) -> (a,b)  |]
  [| \(a,b) -> MeanNaive a b    |]

derivingUnbox "MeanKBN"
  [t| MeanKBN -> (Int,Double,Double)      |]
  [| \(MeanKBN a (KBNSum b c)) -> (a,b,c) |]
  [| \(a,b,c) -> MeanKBN a (KBNSum b c)   |]

derivingUnbox "WMeanNaive"
  [t| WMeanNaive -> (Double,Double) |]
  [| \(WMeanNaive a b) -> (a,b)     |]
  [| \(a,b) -> WMeanNaive a b       |]

derivingUnbox "WMeanKBN"
  [t| WMeanKBN -> (Double,Double,Double,Double)         |]
  [| \(WMeanKBN (KBNSum a b) (KBNSum c d)) -> (a,b,c,d) |]
  [| \(a,b,c,d) -> WMeanKBN (KBNSum a b) (KBNSum c d)   |]

derivingUnbox "Variance"
  [t| Variance -> (Int,Double,Double) |]
  [| \(Variance a b c) -> (a,b,c)     |]
  [| \(a,b,c) -> Variance a b c       |]

derivingUnbox "MinD"
  [t| MinD -> Double |]
  [| calcMinD |]
  [| MinD     |]

derivingUnbox "MaxD"
  [t| MaxD -> Double |]
  [| calcMaxD |]
  [| MaxD     |]

derivingUnbox "Weighted"
  [t| forall w a. (Unbox w, Unbox a) => Weighted w a -> (w,a) |]
  [| \(Weighted w a) -> (w,a) |]
  [| \(w,a) -> Weighted w a   |]

derivingUnbox "BinomAcc"
  [t| BinomAcc -> (Int,Int)   |]
  [| \(BinomAcc k n) -> (k,n) |]
  [| \(k,n) -> BinomAcc k n   |]

instance VU.IsoUnbox CountW (Double,Double) where
  toURepr :: CountW -> (Double, Double)
toURepr (CountW Double
w Double
w2) = (Double
w,Double
w2)
  fromURepr :: (Double, Double) -> CountW
fromURepr (Double
w,Double
w2) = Double -> Double -> CountW
CountW Double
w Double
w2
  {-# INLINE toURepr   #-}
  {-# INLINE fromURepr #-}
newtype instance VU.MVector s CountW = MV_CountW (VU.MVector s (Double,Double))
newtype instance VU.Vector    CountW = V_CountW  (VU.Vector    (Double,Double))
deriving via (CountW `VU.As` (Double,Double)) instance VGM.MVector VU.MVector CountW
deriving via (CountW `VU.As` (Double,Double)) instance VG.Vector   VU.Vector  CountW
instance VU.Unbox CountW

-- $references
--
-- * [Welford1962] Welford, B.P. (1962) Note on a method for
--   calculating corrected sums of squares and
--   products. /Technometrics/
--   4(3):419-420. <http://www.jstor.org/stable/1266577>
--
-- * [Chan1979] Chan, Tony F.; Golub, Gene H.; LeVeque, Randall
--   J. (1979), Updating Formulae and a Pairwise Algorithm for
--   Computing Sample Variances., Technical Report STAN-CS-79-773,
--   Department of Computer Science, Stanford University. Page 4.