{-# 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 #-}
module Data.Monoid.Statistics.Numeric (
CountG(..)
, Count
, asCount
, CountW(..)
, Mean
, asMean
, WMean
, asWMean
, MeanNaive(..)
, asMeanNaive
, MeanKBN(..)
, asMeanKBN
, WMeanNaive(..)
, asWMeanNaive
, WMeanKBN(..)
, asWMeanKBN
, Variance(..)
, asVariance
, Max(..)
, Min(..)
, MaxD(..)
, MinD(..)
, BinomAcc(..)
, asBinomAcc
, Weighted(..)
) 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
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
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 #-}
data CountW = CountW
!Double
!Double
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 Mean = MeanKBN
asMean :: Mean -> Mean
asMean :: MeanKBN -> MeanKBN
asMean = forall a. a -> a
id
type WMean = WMeanKBN
asWMean :: WMean -> WMean
asWMean :: WMeanKBN -> WMeanKBN
asWMean = forall a. a -> a
id
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)
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)
data WMeanNaive = WMeanNaive
!Double
!Double
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)
data WMeanKBN = WMeanKBN
{-# UNPACK #-} !KBNSum
{-# UNPACK #-} !KBNSum
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)
data VarWelfordKBN = VarWelfordKBN
{-# UNPACK #-} !Int
{-# UNPACK #-} !KBNSum
{-# UNPACK #-} !KBNSum
asVarWelfordKBN :: VarWelfordKBN -> VarWelfordKBN
asVarWelfordKBN :: VarWelfordKBN -> VarWelfordKBN
asVarWelfordKBN = forall a. a -> a
id
data Variance = Variance {-# UNPACK #-} !Int
{-# UNPACK #-} !Double
{-# UNPACK #-} !Double
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)
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
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)
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)
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)
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
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
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)
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)
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 #-}
sqr :: Double -> Double
sqr :: Double -> Double
sqr Double
x = Double
x forall a. Num a => a -> a -> a
* Double
x
{-# INLINE sqr #-}
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