{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}

-- |
-- Module     : Simulation.Aivika.Statistics
-- Copyright  : Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>
-- License    : BSD3
-- Maintainer : David Sorokin <david.sorokin@gmail.com>
-- Stability  : experimental
-- Tested with: GHC 8.0.1
--
-- Represents statistics.
--

module Simulation.Aivika.Statistics
       (-- * Simple Statistics
        SamplingStats(..),
        SamplingData(..),
        combineSamplingStatsEither,
        samplingStatsVariance,
        samplingStatsDeviation,
        samplingStatsSummary,
        returnSamplingStats,
        listSamplingStats,
        fromIntSamplingStats,
        -- * Timing Statistics
        TimingStats(..),
        TimingData(..),
        timingStatsDeviation,
        timingStatsSummary,
        returnTimingStats,
        fromIntTimingStats,
        normTimingStats,
        -- * Simple Counter
        SamplingCounter(..),
        emptySamplingCounter,
        incSamplingCounter,
        decSamplingCounter,
        setSamplingCounter,
        returnSamplingCounter,
        -- * Timing Counter
        TimingCounter(..),
        emptyTimingCounter,
        incTimingCounter,
        decTimingCounter,
        setTimingCounter,
        returnTimingCounter) where

import GHC.Generics (Generic)

import Control.DeepSeq

import Data.Monoid hiding ((<>))
import Data.Semigroup (Semigroup(..))
import Data.Typeable
import Data.Binary

-- | Defines data types that can be converted to 'Double'.
class Ord a => ConvertableToDouble a where
  
  -- | Convert the value to 'Double'.
  convertToDouble :: a -> Double
  
instance ConvertableToDouble Double where
  convertToDouble :: Double -> Double
convertToDouble = Double -> Double
forall a. a -> a
id
  
instance ConvertableToDouble Int where
  convertToDouble :: Int -> Double
convertToDouble = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral

-- | Describes when the statistics consists of only samples 
-- not bound to the simulation time.
data SamplingStats a =       
  SamplingStats { SamplingStats a -> Int
samplingStatsCount :: !Int,
                  -- ^ The total number of samples.
                  SamplingStats a -> a
samplingStatsMin   :: !a,
                  -- ^ The minimum value among the samples.
                  SamplingStats a -> a
samplingStatsMax   :: !a,
                  -- ^ The maximum value among the samples.
                  SamplingStats a -> Double
samplingStatsMean  :: !Double,
                  -- ^ The average value.
                  SamplingStats a -> Double
samplingStatsMean2 :: !Double 
                  -- ^ The average square value.
                }
  deriving (SamplingStats a -> SamplingStats a -> Bool
(SamplingStats a -> SamplingStats a -> Bool)
-> (SamplingStats a -> SamplingStats a -> Bool)
-> Eq (SamplingStats a)
forall a. Eq a => SamplingStats a -> SamplingStats a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SamplingStats a -> SamplingStats a -> Bool
$c/= :: forall a. Eq a => SamplingStats a -> SamplingStats a -> Bool
== :: SamplingStats a -> SamplingStats a -> Bool
$c== :: forall a. Eq a => SamplingStats a -> SamplingStats a -> Bool
Eq, Eq (SamplingStats a)
Eq (SamplingStats a)
-> (SamplingStats a -> SamplingStats a -> Ordering)
-> (SamplingStats a -> SamplingStats a -> Bool)
-> (SamplingStats a -> SamplingStats a -> Bool)
-> (SamplingStats a -> SamplingStats a -> Bool)
-> (SamplingStats a -> SamplingStats a -> Bool)
-> (SamplingStats a -> SamplingStats a -> SamplingStats a)
-> (SamplingStats a -> SamplingStats a -> SamplingStats a)
-> Ord (SamplingStats a)
SamplingStats a -> SamplingStats a -> Bool
SamplingStats a -> SamplingStats a -> Ordering
SamplingStats a -> SamplingStats a -> SamplingStats a
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 (SamplingStats a)
forall a. Ord a => SamplingStats a -> SamplingStats a -> Bool
forall a. Ord a => SamplingStats a -> SamplingStats a -> Ordering
forall a.
Ord a =>
SamplingStats a -> SamplingStats a -> SamplingStats a
min :: SamplingStats a -> SamplingStats a -> SamplingStats a
$cmin :: forall a.
Ord a =>
SamplingStats a -> SamplingStats a -> SamplingStats a
max :: SamplingStats a -> SamplingStats a -> SamplingStats a
$cmax :: forall a.
Ord a =>
SamplingStats a -> SamplingStats a -> SamplingStats a
>= :: SamplingStats a -> SamplingStats a -> Bool
$c>= :: forall a. Ord a => SamplingStats a -> SamplingStats a -> Bool
> :: SamplingStats a -> SamplingStats a -> Bool
$c> :: forall a. Ord a => SamplingStats a -> SamplingStats a -> Bool
<= :: SamplingStats a -> SamplingStats a -> Bool
$c<= :: forall a. Ord a => SamplingStats a -> SamplingStats a -> Bool
< :: SamplingStats a -> SamplingStats a -> Bool
$c< :: forall a. Ord a => SamplingStats a -> SamplingStats a -> Bool
compare :: SamplingStats a -> SamplingStats a -> Ordering
$ccompare :: forall a. Ord a => SamplingStats a -> SamplingStats a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (SamplingStats a)
Ord, Typeable, (forall x. SamplingStats a -> Rep (SamplingStats a) x)
-> (forall x. Rep (SamplingStats a) x -> SamplingStats a)
-> Generic (SamplingStats a)
forall x. Rep (SamplingStats a) x -> SamplingStats a
forall x. SamplingStats a -> Rep (SamplingStats a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (SamplingStats a) x -> SamplingStats a
forall a x. SamplingStats a -> Rep (SamplingStats a) x
$cto :: forall a x. Rep (SamplingStats a) x -> SamplingStats a
$cfrom :: forall a x. SamplingStats a -> Rep (SamplingStats a) x
Generic)

instance NFData a => NFData (SamplingStats a)
instance Binary a => Binary (SamplingStats a)

-- | Specifies data type from which values we can gather the statistics.           
class Num a => SamplingData a where           
  
  -- | An empty statistics that has no samples.           
  emptySamplingStats :: SamplingStats a
           
  -- | Add a new sample to the statistics.
  addSamplingStats :: a -> SamplingStats a -> SamplingStats a

  -- | Combine two statistics.
  combineSamplingStats :: SamplingStats a -> SamplingStats a -> SamplingStats a

instance SamplingData a => Semigroup (SamplingStats a) where
  <> :: SamplingStats a -> SamplingStats a -> SamplingStats a
(<>) = SamplingStats a -> SamplingStats a -> SamplingStats a
forall a.
SamplingData a =>
SamplingStats a -> SamplingStats a -> SamplingStats a
combineSamplingStats

instance SamplingData a => Monoid (SamplingStats a) where 
  
  mempty :: SamplingStats a
mempty = SamplingStats a
forall a. SamplingData a => SamplingStats a
emptySamplingStats
  
  mappend :: SamplingStats a -> SamplingStats a -> SamplingStats a
mappend = SamplingStats a -> SamplingStats a -> SamplingStats a
forall a. Semigroup a => a -> a -> a
(<>)

instance SamplingData Double where

  emptySamplingStats :: SamplingStats Double
emptySamplingStats =
    SamplingStats :: forall a. Int -> a -> a -> Double -> Double -> SamplingStats a
SamplingStats { samplingStatsCount :: Int
samplingStatsCount = Int
0,
                    samplingStatsMin :: Double
samplingStatsMin   = Double
1 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                    samplingStatsMax :: Double
samplingStatsMax   = (-Double
1) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                    samplingStatsMean :: Double
samplingStatsMean  = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                    samplingStatsMean2 :: Double
samplingStatsMean2 = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0 }
    
  addSamplingStats :: Double -> SamplingStats Double -> SamplingStats Double
addSamplingStats = Double -> SamplingStats Double -> SamplingStats Double
forall a.
ConvertableToDouble a =>
a -> SamplingStats a -> SamplingStats a
addSamplingStatsGeneric
  
  combineSamplingStats :: SamplingStats Double
-> SamplingStats Double -> SamplingStats Double
combineSamplingStats = SamplingStats Double
-> SamplingStats Double -> SamplingStats Double
forall a.
ConvertableToDouble a =>
SamplingStats a -> SamplingStats a -> SamplingStats a
combineSamplingStatsGeneric
  
instance SamplingData Int where

  emptySamplingStats :: SamplingStats Int
emptySamplingStats =
    SamplingStats :: forall a. Int -> a -> a -> Double -> Double -> SamplingStats a
SamplingStats { samplingStatsCount :: Int
samplingStatsCount = Int
0,
                    samplingStatsMin :: Int
samplingStatsMin   = Int
forall a. Bounded a => a
maxBound,
                    samplingStatsMax :: Int
samplingStatsMax   = Int
forall a. Bounded a => a
minBound,
                    samplingStatsMean :: Double
samplingStatsMean  = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                    samplingStatsMean2 :: Double
samplingStatsMean2 = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0 }
    
  addSamplingStats :: Int -> SamplingStats Int -> SamplingStats Int
addSamplingStats = Int -> SamplingStats Int -> SamplingStats Int
forall a.
ConvertableToDouble a =>
a -> SamplingStats a -> SamplingStats a
addSamplingStatsGeneric

  combineSamplingStats :: SamplingStats Int -> SamplingStats Int -> SamplingStats Int
combineSamplingStats = SamplingStats Int -> SamplingStats Int -> SamplingStats Int
forall a.
ConvertableToDouble a =>
SamplingStats a -> SamplingStats a -> SamplingStats a
combineSamplingStatsGeneric
  
addSamplingStatsGeneric :: ConvertableToDouble a => a -> SamplingStats a -> SamplingStats a
addSamplingStatsGeneric :: a -> SamplingStats a -> SamplingStats a
addSamplingStatsGeneric a
a SamplingStats a
stats 
  | Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
x    = SamplingStats a
stats
  | Int
count Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = SamplingStats :: forall a. Int -> a -> a -> Double -> Double -> SamplingStats a
SamplingStats { samplingStatsCount :: Int
samplingStatsCount = Int
1,
                                 samplingStatsMin :: a
samplingStatsMin   = a
a,
                                 samplingStatsMax :: a
samplingStatsMax   = a
a,
                                 samplingStatsMean :: Double
samplingStatsMean  = Double
x,
                                 samplingStatsMean2 :: Double
samplingStatsMean2 = Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x }
  | Bool
otherwise  = SamplingStats :: forall a. Int -> a -> a -> Double -> Double -> SamplingStats a
SamplingStats { samplingStatsCount :: Int
samplingStatsCount = Int
count,
                                 samplingStatsMin :: a
samplingStatsMin   = a
minX,
                                 samplingStatsMax :: a
samplingStatsMax   = a
maxX,
                                 samplingStatsMean :: Double
samplingStatsMean  = Double
meanX,
                                 samplingStatsMean2 :: Double
samplingStatsMean2 = Double
meanX2 }
    where count :: Int
count  = Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SamplingStats a -> Int
forall a. SamplingStats a -> Int
samplingStatsCount SamplingStats a
stats
          minX :: a
minX   = a
a a -> a -> a
`seq` a -> a -> a
forall a. Ord a => a -> a -> a
min a
a (SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMin SamplingStats a
stats)
          maxX :: a
maxX   = a
a a -> a -> a
`seq` a -> a -> a
forall a. Ord a => a -> a -> a
max a
a (SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMax SamplingStats a
stats)
          meanX :: Double
meanX  = Double
k1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
k2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean SamplingStats a
stats
          meanX2 :: Double
meanX2 = Double
k1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
k2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean2 SamplingStats a
stats
          n :: Double
n      = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
count
          x :: Double
x      = a -> Double
forall a. ConvertableToDouble a => a -> Double
convertToDouble a
a
          k1 :: Double
k1     = Double
1.0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
n
          k2 :: Double
k2     = (Double
n Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
1.0) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
n

combineSamplingStatsGeneric :: ConvertableToDouble a =>
                               SamplingStats a -> SamplingStats a -> SamplingStats a
combineSamplingStatsGeneric :: SamplingStats a -> SamplingStats a -> SamplingStats a
combineSamplingStatsGeneric SamplingStats a
stats1 SamplingStats a
stats2
  | Int
c1 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0   = SamplingStats a
stats2
  | Int
c2 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0   = SamplingStats a
stats1
  | Bool
otherwise = SamplingStats :: forall a. Int -> a -> a -> Double -> Double -> SamplingStats a
SamplingStats { samplingStatsCount :: Int
samplingStatsCount = Int
c,
                                samplingStatsMin :: a
samplingStatsMin   = a
minZ,
                                samplingStatsMax :: a
samplingStatsMax   = a
maxZ,
                                samplingStatsMean :: Double
samplingStatsMean  = Double
meanZ,
                                samplingStatsMean2 :: Double
samplingStatsMean2 = Double
meanZ2 }
  where c1 :: Int
c1     = SamplingStats a -> Int
forall a. SamplingStats a -> Int
samplingStatsCount SamplingStats a
stats1
        c2 :: Int
c2     = SamplingStats a -> Int
forall a. SamplingStats a -> Int
samplingStatsCount SamplingStats a
stats2
        c :: Int
c      = Int
c1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
c2
        n1 :: Double
n1     = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
c1
        n2 :: Double
n2     = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
c2
        n :: Double
n      = Double
n1 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
n2
        minX :: a
minX   = SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMin SamplingStats a
stats1
        minY :: a
minY   = SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMin SamplingStats a
stats2
        minZ :: a
minZ   = a -> a -> a
forall a. Ord a => a -> a -> a
min a
minX a
minY
        maxX :: a
maxX   = SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMax SamplingStats a
stats1
        maxY :: a
maxY   = SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMax SamplingStats a
stats2
        maxZ :: a
maxZ   = a -> a -> a
forall a. Ord a => a -> a -> a
max a
maxX a
maxY
        meanX :: Double
meanX  = SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean SamplingStats a
stats1
        meanY :: Double
meanY  = SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean SamplingStats a
stats2
        meanZ :: Double
meanZ  = Double
k1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
meanX Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
k2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
meanY
        meanX2 :: Double
meanX2 = SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean2 SamplingStats a
stats1
        meanY2 :: Double
meanY2 = SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean2 SamplingStats a
stats2
        meanZ2 :: Double
meanZ2 = Double
k1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
meanX2 Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
k2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
meanY2
        k1 :: Double
k1     = Double
n1 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
n
        k2 :: Double
k2     = Double
n2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
n

-- | If allows combining statistics more efficiently if we know that the first argument can be a scalar.
combineSamplingStatsEither :: SamplingData a => Either a (SamplingStats a) -> SamplingStats a -> SamplingStats a
combineSamplingStatsEither :: Either a (SamplingStats a) -> SamplingStats a -> SamplingStats a
combineSamplingStatsEither (Left a
a) SamplingStats a
stats2 = a -> SamplingStats a -> SamplingStats a
forall a. SamplingData a => a -> SamplingStats a -> SamplingStats a
addSamplingStats a
a SamplingStats a
stats2
combineSamplingStatsEither (Right SamplingStats a
stats1) SamplingStats a
stats2 = SamplingStats a -> SamplingStats a -> SamplingStats a
forall a.
SamplingData a =>
SamplingStats a -> SamplingStats a -> SamplingStats a
combineSamplingStats SamplingStats a
stats1 SamplingStats a
stats2

-- | Return the variance.
samplingStatsVariance :: SamplingStats a -> Double
samplingStatsVariance :: SamplingStats a -> Double
samplingStatsVariance SamplingStats a
stats
  | Int
count Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = Double
0
  | Bool
otherwise  = (Double
meanX2 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
meanX Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
meanX) Double -> Double -> Double
forall a. Num a => a -> a -> a
* (Double
n Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (Double
n Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
1))
    where count :: Int
count  = SamplingStats a -> Int
forall a. SamplingStats a -> Int
samplingStatsCount SamplingStats a
stats
          meanX :: Double
meanX  = SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean SamplingStats a
stats
          meanX2 :: Double
meanX2 = SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean2 SamplingStats a
stats
          n :: Double
n      = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
count
          
-- | Return the deviation.          
samplingStatsDeviation :: SamplingStats a -> Double
samplingStatsDeviation :: SamplingStats a -> Double
samplingStatsDeviation = Double -> Double
forall a. Floating a => a -> a
sqrt (Double -> Double)
-> (SamplingStats a -> Double) -> SamplingStats a -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsVariance

-- | Return the statistics by a single sample.
returnSamplingStats :: SamplingData a => a -> SamplingStats a
returnSamplingStats :: a -> SamplingStats a
returnSamplingStats a
x = a -> SamplingStats a -> SamplingStats a
forall a. SamplingData a => a -> SamplingStats a -> SamplingStats a
addSamplingStats a
x SamplingStats a
forall a. SamplingData a => SamplingStats a
emptySamplingStats

-- | Create the statistics by the specified list of data.
listSamplingStats :: SamplingData a => [a] -> SamplingStats a
listSamplingStats :: [a] -> SamplingStats a
listSamplingStats = (a -> SamplingStats a -> SamplingStats a)
-> SamplingStats a -> [a] -> SamplingStats a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> SamplingStats a -> SamplingStats a
forall a. SamplingData a => a -> SamplingStats a -> SamplingStats a
addSamplingStats SamplingStats a
forall a. SamplingData a => SamplingStats a
emptySamplingStats

-- | Convert the statistics from integer to double values.
fromIntSamplingStats :: SamplingStats Int -> SamplingStats Double
fromIntSamplingStats :: SamplingStats Int -> SamplingStats Double
fromIntSamplingStats SamplingStats Int
stats =
  SamplingStats Int
stats { samplingStatsMin :: Double
samplingStatsMin = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Double) -> Int -> Double
forall a b. (a -> b) -> a -> b
$ SamplingStats Int -> Int
forall a. SamplingStats a -> a
samplingStatsMin SamplingStats Int
stats,
          samplingStatsMax :: Double
samplingStatsMax = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Double) -> Int -> Double
forall a b. (a -> b) -> a -> b
$ SamplingStats Int -> Int
forall a. SamplingStats a -> a
samplingStatsMax SamplingStats Int
stats }

-- | Show the summary of the statistics.       
showSamplingStats :: (Show a) => SamplingStats a -> ShowS
showSamplingStats :: SamplingStats a -> ShowS
showSamplingStats SamplingStats a
stats =
  String -> ShowS
showString String
"{ count = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> Int
forall a. SamplingStats a -> Int
samplingStatsCount SamplingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
  String -> ShowS
showString String
", mean = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean SamplingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
  String -> ShowS
showString String
", std = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsDeviation SamplingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
  String -> ShowS
showString String
", min = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMin SamplingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
  String -> ShowS
showString String
", max = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMax SamplingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  String -> ShowS
showString String
" }"

instance Show a => Show (SamplingStats a) where
  showsPrec :: Int -> SamplingStats a -> ShowS
showsPrec Int
prec = SamplingStats a -> ShowS
forall a. Show a => SamplingStats a -> ShowS
showSamplingStats

-- | Show the summary of the statistics using the specified indent.       
samplingStatsSummary :: (Show a) => SamplingStats a -> Int -> ShowS
samplingStatsSummary :: SamplingStats a -> Int -> ShowS
samplingStatsSummary SamplingStats a
stats Int
indent =
  let tab :: String
tab = Int -> Char -> String
forall a. Int -> a -> [a]
replicate Int
indent Char
' '
  in String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"count = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> Int
forall a. SamplingStats a -> Int
samplingStatsCount SamplingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"\n" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"mean = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsMean SamplingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
     String -> ShowS
showString String
"\n" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"std = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> Double
forall a. SamplingStats a -> Double
samplingStatsDeviation SamplingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
     String -> ShowS
showString String
"\n" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"min = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMin SamplingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
     String -> ShowS
showString String
"\n" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"max = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ShowS
forall a. Show a => a -> ShowS
shows (SamplingStats a -> a
forall a. SamplingStats a -> a
samplingStatsMax SamplingStats a
stats)
     
-- | This is the timing statistics where data are bound to the time.
data TimingStats a =
  TimingStats { TimingStats a -> Int
timingStatsCount     :: !Int,
                -- ^ Return the number of samples.
                TimingStats a -> a
timingStatsMin       :: !a,
                -- ^ Return the minimum value.
                TimingStats a -> a
timingStatsMax       :: !a,
                -- ^ Return the maximum value.
                TimingStats a -> a
timingStatsLast      :: !a,
                -- ^ Return the last value.
                TimingStats a -> Double
timingStatsMinTime   :: !Double,
                -- ^ Return the time at which the minimum is attained.
                TimingStats a -> Double
timingStatsMaxTime   :: !Double,
                -- ^ Return the time at which the maximum is attained.
                TimingStats a -> Double
timingStatsStartTime :: !Double,
                -- ^ Return the start time of sampling.
                TimingStats a -> Double
timingStatsLastTime  :: !Double,
                -- ^ Return the last time of sampling.
                TimingStats a -> Double
timingStatsSum       :: !Double,
                -- ^ Return the sum of values.
                TimingStats a -> Double
timingStatsSum2      :: !Double 
                -- ^ Return the sum of square values.
                } deriving (TimingStats a -> TimingStats a -> Bool
(TimingStats a -> TimingStats a -> Bool)
-> (TimingStats a -> TimingStats a -> Bool) -> Eq (TimingStats a)
forall a. Eq a => TimingStats a -> TimingStats a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TimingStats a -> TimingStats a -> Bool
$c/= :: forall a. Eq a => TimingStats a -> TimingStats a -> Bool
== :: TimingStats a -> TimingStats a -> Bool
$c== :: forall a. Eq a => TimingStats a -> TimingStats a -> Bool
Eq, Eq (TimingStats a)
Eq (TimingStats a)
-> (TimingStats a -> TimingStats a -> Ordering)
-> (TimingStats a -> TimingStats a -> Bool)
-> (TimingStats a -> TimingStats a -> Bool)
-> (TimingStats a -> TimingStats a -> Bool)
-> (TimingStats a -> TimingStats a -> Bool)
-> (TimingStats a -> TimingStats a -> TimingStats a)
-> (TimingStats a -> TimingStats a -> TimingStats a)
-> Ord (TimingStats a)
TimingStats a -> TimingStats a -> Bool
TimingStats a -> TimingStats a -> Ordering
TimingStats a -> TimingStats a -> TimingStats a
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 (TimingStats a)
forall a. Ord a => TimingStats a -> TimingStats a -> Bool
forall a. Ord a => TimingStats a -> TimingStats a -> Ordering
forall a. Ord a => TimingStats a -> TimingStats a -> TimingStats a
min :: TimingStats a -> TimingStats a -> TimingStats a
$cmin :: forall a. Ord a => TimingStats a -> TimingStats a -> TimingStats a
max :: TimingStats a -> TimingStats a -> TimingStats a
$cmax :: forall a. Ord a => TimingStats a -> TimingStats a -> TimingStats a
>= :: TimingStats a -> TimingStats a -> Bool
$c>= :: forall a. Ord a => TimingStats a -> TimingStats a -> Bool
> :: TimingStats a -> TimingStats a -> Bool
$c> :: forall a. Ord a => TimingStats a -> TimingStats a -> Bool
<= :: TimingStats a -> TimingStats a -> Bool
$c<= :: forall a. Ord a => TimingStats a -> TimingStats a -> Bool
< :: TimingStats a -> TimingStats a -> Bool
$c< :: forall a. Ord a => TimingStats a -> TimingStats a -> Bool
compare :: TimingStats a -> TimingStats a -> Ordering
$ccompare :: forall a. Ord a => TimingStats a -> TimingStats a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (TimingStats a)
Ord, Typeable, (forall x. TimingStats a -> Rep (TimingStats a) x)
-> (forall x. Rep (TimingStats a) x -> TimingStats a)
-> Generic (TimingStats a)
forall x. Rep (TimingStats a) x -> TimingStats a
forall x. TimingStats a -> Rep (TimingStats a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (TimingStats a) x -> TimingStats a
forall a x. TimingStats a -> Rep (TimingStats a) x
$cto :: forall a x. Rep (TimingStats a) x -> TimingStats a
$cfrom :: forall a x. TimingStats a -> Rep (TimingStats a) x
Generic)

instance NFData a => NFData (TimingStats a)
instance Binary a => Binary (TimingStats a)
                           
-- | Defines the data type from which values we can gather the timing statistics.
class Num a => TimingData a where                           
  
  -- | An empty statistics that has no samples.
  emptyTimingStats :: TimingStats a
  
  -- | Add a sample with the specified time to the statistics.
  addTimingStats :: Double -> a -> TimingStats a -> TimingStats a
  
  -- | Return the average value.
  timingStatsMean :: TimingStats a -> Double
  
  -- | Return the average square value.
  timingStatsMean2 :: TimingStats a -> Double
  
  -- | Return the variance.
  timingStatsVariance :: TimingStats a -> Double
  
instance TimingData Double where
  
  emptyTimingStats :: TimingStats Double
emptyTimingStats = 
    TimingStats :: forall a.
Int
-> a
-> a
-> a
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> TimingStats a
TimingStats { timingStatsCount :: Int
timingStatsCount     = Int
0,
                  timingStatsMin :: Double
timingStatsMin       = Double
1 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsMax :: Double
timingStatsMax       = (-Double
1) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsLast :: Double
timingStatsLast      = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsMinTime :: Double
timingStatsMinTime   = Double
1 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsMaxTime :: Double
timingStatsMaxTime   = (-Double
1) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsStartTime :: Double
timingStatsStartTime = Double
1 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsLastTime :: Double
timingStatsLastTime  = (-Double
1) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsSum :: Double
timingStatsSum       = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsSum2 :: Double
timingStatsSum2      = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0 }
    
  addTimingStats :: Double -> Double -> TimingStats Double -> TimingStats Double
addTimingStats      = Double -> Double -> TimingStats Double -> TimingStats Double
forall a.
ConvertableToDouble a =>
Double -> a -> TimingStats a -> TimingStats a
addTimingStatsGeneric
  timingStatsMean :: TimingStats Double -> Double
timingStatsMean     = TimingStats Double -> Double
forall a. ConvertableToDouble a => TimingStats a -> Double
timingStatsMeanGeneric
  timingStatsMean2 :: TimingStats Double -> Double
timingStatsMean2    = TimingStats Double -> Double
forall a. ConvertableToDouble a => TimingStats a -> Double
timingStatsMean2Generic
  timingStatsVariance :: TimingStats Double -> Double
timingStatsVariance = TimingStats Double -> Double
forall a. ConvertableToDouble a => TimingStats a -> Double
timingStatsVarianceGeneric

instance TimingData Int where
  
  emptyTimingStats :: TimingStats Int
emptyTimingStats = 
    TimingStats :: forall a.
Int
-> a
-> a
-> a
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> TimingStats a
TimingStats { timingStatsCount :: Int
timingStatsCount     = Int
0,
                  timingStatsMin :: Int
timingStatsMin       = Int
forall a. Bounded a => a
maxBound,
                  timingStatsMax :: Int
timingStatsMax       = Int
forall a. Bounded a => a
minBound,
                  timingStatsLast :: Int
timingStatsLast      = Int
0,
                  timingStatsMinTime :: Double
timingStatsMinTime   = Double
1 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsMaxTime :: Double
timingStatsMaxTime   = (-Double
1) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsStartTime :: Double
timingStatsStartTime = Double
1 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsLastTime :: Double
timingStatsLastTime  = (-Double
1) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsSum :: Double
timingStatsSum       = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0,
                  timingStatsSum2 :: Double
timingStatsSum2      = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0 }
    
  addTimingStats :: Double -> Int -> TimingStats Int -> TimingStats Int
addTimingStats      = Double -> Int -> TimingStats Int -> TimingStats Int
forall a.
ConvertableToDouble a =>
Double -> a -> TimingStats a -> TimingStats a
addTimingStatsGeneric
  timingStatsMean :: TimingStats Int -> Double
timingStatsMean     = TimingStats Int -> Double
forall a. ConvertableToDouble a => TimingStats a -> Double
timingStatsMeanGeneric
  timingStatsMean2 :: TimingStats Int -> Double
timingStatsMean2    = TimingStats Int -> Double
forall a. ConvertableToDouble a => TimingStats a -> Double
timingStatsMean2Generic
  timingStatsVariance :: TimingStats Int -> Double
timingStatsVariance = TimingStats Int -> Double
forall a. ConvertableToDouble a => TimingStats a -> Double
timingStatsVarianceGeneric

addTimingStatsGeneric :: ConvertableToDouble a => Double -> a -> TimingStats a -> TimingStats a
addTimingStatsGeneric :: Double -> a -> TimingStats a -> TimingStats a
addTimingStatsGeneric Double
t a
a TimingStats a
stats
  | Double
t Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
< Double
t'     = String -> TimingStats a
forall a. HasCallStack => String -> a
error String
"The current time cannot be less than the previous one: addTimingStats"
  | Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
x    = TimingStats a
stats
  | Int
count Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = TimingStats :: forall a.
Int
-> a
-> a
-> a
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> TimingStats a
TimingStats { timingStatsCount :: Int
timingStatsCount     = Int
1,
                               timingStatsMin :: a
timingStatsMin       = a
a,
                               timingStatsMax :: a
timingStatsMax       = a
a,
                               timingStatsLast :: a
timingStatsLast      = a
a,
                               timingStatsMinTime :: Double
timingStatsMinTime   = Double
t,
                               timingStatsMaxTime :: Double
timingStatsMaxTime   = Double
t,
                               timingStatsStartTime :: Double
timingStatsStartTime = Double
t,
                               timingStatsLastTime :: Double
timingStatsLastTime  = Double
t,
                               timingStatsSum :: Double
timingStatsSum       = Double
0,
                               timingStatsSum2 :: Double
timingStatsSum2      = Double
0 }
  | Bool
otherwise  = TimingStats :: forall a.
Int
-> a
-> a
-> a
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> TimingStats a
TimingStats { timingStatsCount :: Int
timingStatsCount     = Int
count,
                               timingStatsMin :: a
timingStatsMin       = a
minX,
                               timingStatsMax :: a
timingStatsMax       = a
maxX,
                               timingStatsLast :: a
timingStatsLast      = a
a,
                               timingStatsMinTime :: Double
timingStatsMinTime   = Double
minT,
                               timingStatsMaxTime :: Double
timingStatsMaxTime   = Double
maxT,
                               timingStatsStartTime :: Double
timingStatsStartTime = Double
t0,
                               timingStatsLastTime :: Double
timingStatsLastTime  = Double
t,
                               timingStatsSum :: Double
timingStatsSum       = Double
sumX,
                               timingStatsSum2 :: Double
timingStatsSum2      = Double
sumX2 }
    where count :: Int
count = Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ TimingStats a -> Int
forall a. TimingStats a -> Int
timingStatsCount TimingStats a
stats
          minX' :: a
minX' = TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMin TimingStats a
stats
          maxX' :: a
maxX' = TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMax TimingStats a
stats
          minX :: a
minX  = a
a a -> a -> a
`seq` a -> a -> a
forall a. Ord a => a -> a -> a
min a
a a
minX'
          maxX :: a
maxX  = a
a a -> a -> a
`seq` a -> a -> a
forall a. Ord a => a -> a -> a
max a
a a
maxX'
          minT :: Double
minT | a
a a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
minX' = Double
t
               | Bool
otherwise = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsMinTime TimingStats a
stats
          maxT :: Double
maxT | a
a a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
maxX' = Double
t
               | Bool
otherwise = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsMaxTime TimingStats a
stats
          t0 :: Double
t0 = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsStartTime TimingStats a
stats
          t' :: Double
t' = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsLastTime TimingStats a
stats
          a' :: a
a' = TimingStats a -> a
forall a. TimingStats a -> a
timingStatsLast TimingStats a
stats
          x :: Double
x  = a -> Double
forall a. ConvertableToDouble a => a -> Double
convertToDouble a
a
          x' :: Double
x' = a -> Double
forall a. ConvertableToDouble a => a -> Double
convertToDouble a
a'
          sumX' :: Double
sumX'  = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsSum TimingStats a
stats
          sumX :: Double
sumX   = Double
sumX' Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
t Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
t') Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x'
          sumX2' :: Double
sumX2' = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsSum2 TimingStats a
stats
          sumX2 :: Double
sumX2  = Double
sumX2' Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (Double
t Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
t') Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x' Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
x'
      
timingStatsMeanGeneric :: ConvertableToDouble a => TimingStats a -> Double
timingStatsMeanGeneric :: TimingStats a -> Double
timingStatsMeanGeneric TimingStats a
stats
  | Int
count Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0
  | Double
t1 Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
> Double
t0    = Double
sumX Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (Double
t1 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
t0)
  | Bool
otherwise  = Double
minX
    where t0 :: Double
t0    = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsStartTime TimingStats a
stats
          t1 :: Double
t1    = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsLastTime TimingStats a
stats
          sumX :: Double
sumX  = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsSum TimingStats a
stats
          minX :: Double
minX  = a -> Double
forall a. ConvertableToDouble a => a -> Double
convertToDouble (a -> Double) -> a -> Double
forall a b. (a -> b) -> a -> b
$ TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMin TimingStats a
stats
          count :: Int
count = TimingStats a -> Int
forall a. TimingStats a -> Int
timingStatsCount TimingStats a
stats
  
timingStatsMean2Generic :: ConvertableToDouble a => TimingStats a -> Double
timingStatsMean2Generic :: TimingStats a -> Double
timingStatsMean2Generic TimingStats a
stats
  | Int
count Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = Double
0 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
0
  | Double
t1 Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
> Double
t0    = Double
sumX2 Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (Double
t1 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
t0)
  | Bool
otherwise  = Double
minX Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
minX
    where t0 :: Double
t0    = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsStartTime TimingStats a
stats
          t1 :: Double
t1    = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsLastTime TimingStats a
stats
          sumX2 :: Double
sumX2 = TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsSum2 TimingStats a
stats
          minX :: Double
minX  = a -> Double
forall a. ConvertableToDouble a => a -> Double
convertToDouble (a -> Double) -> a -> Double
forall a b. (a -> b) -> a -> b
$ TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMin TimingStats a
stats
          count :: Int
count = TimingStats a -> Int
forall a. TimingStats a -> Int
timingStatsCount TimingStats a
stats

timingStatsVarianceGeneric :: ConvertableToDouble a => TimingStats a -> Double
timingStatsVarianceGeneric :: TimingStats a -> Double
timingStatsVarianceGeneric TimingStats a
stats = Double
ex2 Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
ex Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
ex
  where ex :: Double
ex  = TimingStats a -> Double
forall a. ConvertableToDouble a => TimingStats a -> Double
timingStatsMeanGeneric TimingStats a
stats
        ex2 :: Double
ex2 = TimingStats a -> Double
forall a. ConvertableToDouble a => TimingStats a -> Double
timingStatsMean2Generic TimingStats a
stats
                
-- | Return the deviation.              
timingStatsDeviation :: TimingData a => TimingStats a -> Double
timingStatsDeviation :: TimingStats a -> Double
timingStatsDeviation = Double -> Double
forall a. Floating a => a -> a
sqrt (Double -> Double)
-> (TimingStats a -> Double) -> TimingStats a -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimingStats a -> Double
forall a. TimingData a => TimingStats a -> Double
timingStatsVariance

-- | Return the statistics by single timing data.
returnTimingStats :: TimingData a => Double -> a -> TimingStats a
returnTimingStats :: Double -> a -> TimingStats a
returnTimingStats Double
t a
a = Double -> a -> TimingStats a -> TimingStats a
forall a.
TimingData a =>
Double -> a -> TimingStats a -> TimingStats a
addTimingStats Double
t a
a TimingStats a
forall a. TimingData a => TimingStats a
emptyTimingStats

-- | Convert the statistics from integer to double values.
fromIntTimingStats :: TimingStats Int -> TimingStats Double
fromIntTimingStats :: TimingStats Int -> TimingStats Double
fromIntTimingStats TimingStats Int
stats =
  TimingStats Int
stats { timingStatsMin :: Double
timingStatsMin  = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Double) -> Int -> Double
forall a b. (a -> b) -> a -> b
$ TimingStats Int -> Int
forall a. TimingStats a -> a
timingStatsMin TimingStats Int
stats,
          timingStatsMax :: Double
timingStatsMax  = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Double) -> Int -> Double
forall a b. (a -> b) -> a -> b
$ TimingStats Int -> Int
forall a. TimingStats a -> a
timingStatsMax TimingStats Int
stats,
          timingStatsLast :: Double
timingStatsLast = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Double) -> Int -> Double
forall a b. (a -> b) -> a -> b
$ TimingStats Int -> Int
forall a. TimingStats a -> a
timingStatsLast TimingStats Int
stats }

-- | Convert the statistics to its normalised sampling-based representation,
-- where the first argument specifies the number of pseudo-samples.
normTimingStats :: TimingData a => Int -> TimingStats a -> SamplingStats a
normTimingStats :: Int -> TimingStats a -> SamplingStats a
normTimingStats Int
n TimingStats a
stats =
  SamplingStats :: forall a. Int -> a -> a -> Double -> Double -> SamplingStats a
SamplingStats { samplingStatsCount :: Int
samplingStatsCount = Int
n,
                  samplingStatsMin :: a
samplingStatsMin   = TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMin TimingStats a
stats,
                  samplingStatsMax :: a
samplingStatsMax   = TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMax TimingStats a
stats,
                  samplingStatsMean :: Double
samplingStatsMean  = TimingStats a -> Double
forall a. TimingData a => TimingStats a -> Double
timingStatsMean TimingStats a
stats,
                  samplingStatsMean2 :: Double
samplingStatsMean2 = TimingStats a -> Double
forall a. TimingData a => TimingStats a -> Double
timingStatsMean2 TimingStats a
stats }

-- | Show the summary of the statistics.       
showTimingStats :: (Show a, TimingData a) => TimingStats a -> ShowS
showTimingStats :: TimingStats a -> ShowS
showTimingStats TimingStats a
stats =
  String -> ShowS
showString String
"{ count = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Int
forall a. TimingStats a -> Int
timingStatsCount TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
  String -> ShowS
showString String
", mean = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingData a => TimingStats a -> Double
timingStatsMean TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
  String -> ShowS
showString String
", std = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingData a => TimingStats a -> Double
timingStatsDeviation TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
  String -> ShowS
showString String
", min = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMin TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
  String -> ShowS
showString String
" (t = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsMinTime TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  String -> ShowS
showString String
"), max = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMax TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  String -> ShowS
showString String
" (t = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsMaxTime TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  String -> ShowS
showString String
"), t in [" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsStartTime TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  String -> ShowS
showString String
", " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsLastTime TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  String -> ShowS
showString String
"] }"

instance (Show a, TimingData a) => Show (TimingStats a) where
  showsPrec :: Int -> TimingStats a -> ShowS
showsPrec Int
prec = TimingStats a -> ShowS
forall a. (Show a, TimingData a) => TimingStats a -> ShowS
showTimingStats

-- | Show the summary of the statistics using the specified indent.       
timingStatsSummary :: (Show a, TimingData a) => TimingStats a -> Int -> ShowS
timingStatsSummary :: TimingStats a -> Int -> ShowS
timingStatsSummary TimingStats a
stats Int
indent =
  let tab :: String
tab = Int -> Char -> String
forall a. Int -> a -> [a]
replicate Int
indent Char
' '
  in String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"count = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Int
forall a. TimingStats a -> Int
timingStatsCount TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
     String -> ShowS
showString String
"\n" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"mean = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingData a => TimingStats a -> Double
timingStatsMean TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
     String -> ShowS
showString String
"\n" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"std = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingData a => TimingStats a -> Double
timingStatsDeviation TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
     String -> ShowS
showString String
"\n" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"min = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMin TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
     String -> ShowS
showString String
" (t = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsMinTime TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
")\n" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"max = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> a
forall a. TimingStats a -> a
timingStatsMax TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
" (t = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsMaxTime TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
")\n" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
tab ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"t in [" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsStartTime TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
", " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ShowS
forall a. Show a => a -> ShowS
shows (TimingStats a -> Double
forall a. TimingStats a -> Double
timingStatsLastTime TimingStats a
stats) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
     String -> ShowS
showString String
"]"

-- | A counter for which the statistics is collected too.
data SamplingCounter a =
  SamplingCounter { SamplingCounter a -> a
samplingCounterValue :: a,
                    -- ^ The counter value.
                    SamplingCounter a -> SamplingStats a
samplingCounterStats :: SamplingStats a
                    -- ^ The counter statistics.
                  } deriving (SamplingCounter a -> SamplingCounter a -> Bool
(SamplingCounter a -> SamplingCounter a -> Bool)
-> (SamplingCounter a -> SamplingCounter a -> Bool)
-> Eq (SamplingCounter a)
forall a. Eq a => SamplingCounter a -> SamplingCounter a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SamplingCounter a -> SamplingCounter a -> Bool
$c/= :: forall a. Eq a => SamplingCounter a -> SamplingCounter a -> Bool
== :: SamplingCounter a -> SamplingCounter a -> Bool
$c== :: forall a. Eq a => SamplingCounter a -> SamplingCounter a -> Bool
Eq, Eq (SamplingCounter a)
Eq (SamplingCounter a)
-> (SamplingCounter a -> SamplingCounter a -> Ordering)
-> (SamplingCounter a -> SamplingCounter a -> Bool)
-> (SamplingCounter a -> SamplingCounter a -> Bool)
-> (SamplingCounter a -> SamplingCounter a -> Bool)
-> (SamplingCounter a -> SamplingCounter a -> Bool)
-> (SamplingCounter a -> SamplingCounter a -> SamplingCounter a)
-> (SamplingCounter a -> SamplingCounter a -> SamplingCounter a)
-> Ord (SamplingCounter a)
SamplingCounter a -> SamplingCounter a -> Bool
SamplingCounter a -> SamplingCounter a -> Ordering
SamplingCounter a -> SamplingCounter a -> SamplingCounter a
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 (SamplingCounter a)
forall a. Ord a => SamplingCounter a -> SamplingCounter a -> Bool
forall a.
Ord a =>
SamplingCounter a -> SamplingCounter a -> Ordering
forall a.
Ord a =>
SamplingCounter a -> SamplingCounter a -> SamplingCounter a
min :: SamplingCounter a -> SamplingCounter a -> SamplingCounter a
$cmin :: forall a.
Ord a =>
SamplingCounter a -> SamplingCounter a -> SamplingCounter a
max :: SamplingCounter a -> SamplingCounter a -> SamplingCounter a
$cmax :: forall a.
Ord a =>
SamplingCounter a -> SamplingCounter a -> SamplingCounter a
>= :: SamplingCounter a -> SamplingCounter a -> Bool
$c>= :: forall a. Ord a => SamplingCounter a -> SamplingCounter a -> Bool
> :: SamplingCounter a -> SamplingCounter a -> Bool
$c> :: forall a. Ord a => SamplingCounter a -> SamplingCounter a -> Bool
<= :: SamplingCounter a -> SamplingCounter a -> Bool
$c<= :: forall a. Ord a => SamplingCounter a -> SamplingCounter a -> Bool
< :: SamplingCounter a -> SamplingCounter a -> Bool
$c< :: forall a. Ord a => SamplingCounter a -> SamplingCounter a -> Bool
compare :: SamplingCounter a -> SamplingCounter a -> Ordering
$ccompare :: forall a.
Ord a =>
SamplingCounter a -> SamplingCounter a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (SamplingCounter a)
Ord, Int -> SamplingCounter a -> ShowS
[SamplingCounter a] -> ShowS
SamplingCounter a -> String
(Int -> SamplingCounter a -> ShowS)
-> (SamplingCounter a -> String)
-> ([SamplingCounter a] -> ShowS)
-> Show (SamplingCounter a)
forall a. Show a => Int -> SamplingCounter a -> ShowS
forall a. Show a => [SamplingCounter a] -> ShowS
forall a. Show a => SamplingCounter a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SamplingCounter a] -> ShowS
$cshowList :: forall a. Show a => [SamplingCounter a] -> ShowS
show :: SamplingCounter a -> String
$cshow :: forall a. Show a => SamplingCounter a -> String
showsPrec :: Int -> SamplingCounter a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> SamplingCounter a -> ShowS
Show, Typeable, (forall x. SamplingCounter a -> Rep (SamplingCounter a) x)
-> (forall x. Rep (SamplingCounter a) x -> SamplingCounter a)
-> Generic (SamplingCounter a)
forall x. Rep (SamplingCounter a) x -> SamplingCounter a
forall x. SamplingCounter a -> Rep (SamplingCounter a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (SamplingCounter a) x -> SamplingCounter a
forall a x. SamplingCounter a -> Rep (SamplingCounter a) x
$cto :: forall a x. Rep (SamplingCounter a) x -> SamplingCounter a
$cfrom :: forall a x. SamplingCounter a -> Rep (SamplingCounter a) x
Generic)

instance NFData a => NFData (SamplingCounter a)
instance Binary a => Binary (SamplingCounter a)

-- | An empty counter.
emptySamplingCounter :: SamplingData a => SamplingCounter a
emptySamplingCounter :: SamplingCounter a
emptySamplingCounter =
  SamplingCounter :: forall a. a -> SamplingStats a -> SamplingCounter a
SamplingCounter { samplingCounterValue :: a
samplingCounterValue = a
0,
                    samplingCounterStats :: SamplingStats a
samplingCounterStats = SamplingStats a
forall a. SamplingData a => SamplingStats a
emptySamplingStats }

-- | Increase the counter.
incSamplingCounter :: SamplingData a => a -> SamplingCounter a -> SamplingCounter a
incSamplingCounter :: a -> SamplingCounter a -> SamplingCounter a
incSamplingCounter a
a SamplingCounter a
counter =
  SamplingCounter :: forall a. a -> SamplingStats a -> SamplingCounter a
SamplingCounter { samplingCounterValue :: a
samplingCounterValue = a
a',
                    samplingCounterStats :: SamplingStats a
samplingCounterStats = a -> SamplingStats a -> SamplingStats a
forall a. SamplingData a => a -> SamplingStats a -> SamplingStats a
addSamplingStats a
a' (SamplingCounter a -> SamplingStats a
forall a. SamplingCounter a -> SamplingStats a
samplingCounterStats SamplingCounter a
counter) }
  where a' :: a
a' = SamplingCounter a -> a
forall a. SamplingCounter a -> a
samplingCounterValue SamplingCounter a
counter a -> a -> a
forall a. Num a => a -> a -> a
+ a
a

-- | Decrease the counter.
decSamplingCounter :: SamplingData a => a -> SamplingCounter a -> SamplingCounter a
decSamplingCounter :: a -> SamplingCounter a -> SamplingCounter a
decSamplingCounter a
a SamplingCounter a
counter =
  SamplingCounter :: forall a. a -> SamplingStats a -> SamplingCounter a
SamplingCounter { samplingCounterValue :: a
samplingCounterValue = a
a',
                    samplingCounterStats :: SamplingStats a
samplingCounterStats = a -> SamplingStats a -> SamplingStats a
forall a. SamplingData a => a -> SamplingStats a -> SamplingStats a
addSamplingStats a
a' (SamplingCounter a -> SamplingStats a
forall a. SamplingCounter a -> SamplingStats a
samplingCounterStats SamplingCounter a
counter) }
  where a' :: a
a' = SamplingCounter a -> a
forall a. SamplingCounter a -> a
samplingCounterValue SamplingCounter a
counter a -> a -> a
forall a. Num a => a -> a -> a
- a
a

-- | Set a new value for the counter.
setSamplingCounter :: SamplingData a => a -> SamplingCounter a -> SamplingCounter a
setSamplingCounter :: a -> SamplingCounter a -> SamplingCounter a
setSamplingCounter a
a SamplingCounter a
counter =
  SamplingCounter :: forall a. a -> SamplingStats a -> SamplingCounter a
SamplingCounter { samplingCounterValue :: a
samplingCounterValue = a
a,
                    samplingCounterStats :: SamplingStats a
samplingCounterStats = a -> SamplingStats a -> SamplingStats a
forall a. SamplingData a => a -> SamplingStats a -> SamplingStats a
addSamplingStats a
a (SamplingCounter a -> SamplingStats a
forall a. SamplingCounter a -> SamplingStats a
samplingCounterStats SamplingCounter a
counter) }

-- | Create a counter with the specified initial value.
returnSamplingCounter :: SamplingData  a => a -> SamplingCounter a
returnSamplingCounter :: a -> SamplingCounter a
returnSamplingCounter a
a =
  SamplingCounter :: forall a. a -> SamplingStats a -> SamplingCounter a
SamplingCounter { samplingCounterValue :: a
samplingCounterValue = a
a,
                    samplingCounterStats :: SamplingStats a
samplingCounterStats = a -> SamplingStats a
forall a. SamplingData a => a -> SamplingStats a
returnSamplingStats a
a }

-- | A counter for which the timing statistics is collected too.
data TimingCounter a =
  TimingCounter { TimingCounter a -> a
timingCounterValue :: a,
                  -- ^ The counter value.
                  TimingCounter a -> TimingStats a
timingCounterStats :: TimingStats a
                  -- ^ The counter statistics.
                } deriving (TimingCounter a -> TimingCounter a -> Bool
(TimingCounter a -> TimingCounter a -> Bool)
-> (TimingCounter a -> TimingCounter a -> Bool)
-> Eq (TimingCounter a)
forall a. Eq a => TimingCounter a -> TimingCounter a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TimingCounter a -> TimingCounter a -> Bool
$c/= :: forall a. Eq a => TimingCounter a -> TimingCounter a -> Bool
== :: TimingCounter a -> TimingCounter a -> Bool
$c== :: forall a. Eq a => TimingCounter a -> TimingCounter a -> Bool
Eq, Eq (TimingCounter a)
Eq (TimingCounter a)
-> (TimingCounter a -> TimingCounter a -> Ordering)
-> (TimingCounter a -> TimingCounter a -> Bool)
-> (TimingCounter a -> TimingCounter a -> Bool)
-> (TimingCounter a -> TimingCounter a -> Bool)
-> (TimingCounter a -> TimingCounter a -> Bool)
-> (TimingCounter a -> TimingCounter a -> TimingCounter a)
-> (TimingCounter a -> TimingCounter a -> TimingCounter a)
-> Ord (TimingCounter a)
TimingCounter a -> TimingCounter a -> Bool
TimingCounter a -> TimingCounter a -> Ordering
TimingCounter a -> TimingCounter a -> TimingCounter a
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 (TimingCounter a)
forall a. Ord a => TimingCounter a -> TimingCounter a -> Bool
forall a. Ord a => TimingCounter a -> TimingCounter a -> Ordering
forall a.
Ord a =>
TimingCounter a -> TimingCounter a -> TimingCounter a
min :: TimingCounter a -> TimingCounter a -> TimingCounter a
$cmin :: forall a.
Ord a =>
TimingCounter a -> TimingCounter a -> TimingCounter a
max :: TimingCounter a -> TimingCounter a -> TimingCounter a
$cmax :: forall a.
Ord a =>
TimingCounter a -> TimingCounter a -> TimingCounter a
>= :: TimingCounter a -> TimingCounter a -> Bool
$c>= :: forall a. Ord a => TimingCounter a -> TimingCounter a -> Bool
> :: TimingCounter a -> TimingCounter a -> Bool
$c> :: forall a. Ord a => TimingCounter a -> TimingCounter a -> Bool
<= :: TimingCounter a -> TimingCounter a -> Bool
$c<= :: forall a. Ord a => TimingCounter a -> TimingCounter a -> Bool
< :: TimingCounter a -> TimingCounter a -> Bool
$c< :: forall a. Ord a => TimingCounter a -> TimingCounter a -> Bool
compare :: TimingCounter a -> TimingCounter a -> Ordering
$ccompare :: forall a. Ord a => TimingCounter a -> TimingCounter a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (TimingCounter a)
Ord, Int -> TimingCounter a -> ShowS
[TimingCounter a] -> ShowS
TimingCounter a -> String
(Int -> TimingCounter a -> ShowS)
-> (TimingCounter a -> String)
-> ([TimingCounter a] -> ShowS)
-> Show (TimingCounter a)
forall a. (Show a, TimingData a) => Int -> TimingCounter a -> ShowS
forall a. (Show a, TimingData a) => [TimingCounter a] -> ShowS
forall a. (Show a, TimingData a) => TimingCounter a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TimingCounter a] -> ShowS
$cshowList :: forall a. (Show a, TimingData a) => [TimingCounter a] -> ShowS
show :: TimingCounter a -> String
$cshow :: forall a. (Show a, TimingData a) => TimingCounter a -> String
showsPrec :: Int -> TimingCounter a -> ShowS
$cshowsPrec :: forall a. (Show a, TimingData a) => Int -> TimingCounter a -> ShowS
Show, Typeable, (forall x. TimingCounter a -> Rep (TimingCounter a) x)
-> (forall x. Rep (TimingCounter a) x -> TimingCounter a)
-> Generic (TimingCounter a)
forall x. Rep (TimingCounter a) x -> TimingCounter a
forall x. TimingCounter a -> Rep (TimingCounter a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (TimingCounter a) x -> TimingCounter a
forall a x. TimingCounter a -> Rep (TimingCounter a) x
$cto :: forall a x. Rep (TimingCounter a) x -> TimingCounter a
$cfrom :: forall a x. TimingCounter a -> Rep (TimingCounter a) x
Generic)

instance NFData a => NFData (TimingCounter a)
instance Binary a => Binary (TimingCounter a)

-- | An empty counter.
emptyTimingCounter :: TimingData a => TimingCounter a
emptyTimingCounter :: TimingCounter a
emptyTimingCounter =
  TimingCounter :: forall a. a -> TimingStats a -> TimingCounter a
TimingCounter { timingCounterValue :: a
timingCounterValue = a
0,
                  timingCounterStats :: TimingStats a
timingCounterStats = TimingStats a
forall a. TimingData a => TimingStats a
emptyTimingStats }

-- | Increase the counter at the specified time.
incTimingCounter :: TimingData a => Double -> a -> TimingCounter a -> TimingCounter a
incTimingCounter :: Double -> a -> TimingCounter a -> TimingCounter a
incTimingCounter Double
t a
a TimingCounter a
counter =
  TimingCounter :: forall a. a -> TimingStats a -> TimingCounter a
TimingCounter { timingCounterValue :: a
timingCounterValue = a
a',
                  timingCounterStats :: TimingStats a
timingCounterStats = Double -> a -> TimingStats a -> TimingStats a
forall a.
TimingData a =>
Double -> a -> TimingStats a -> TimingStats a
addTimingStats Double
t a
a' (TimingCounter a -> TimingStats a
forall a. TimingCounter a -> TimingStats a
timingCounterStats TimingCounter a
counter) }
  where a' :: a
a' = TimingCounter a -> a
forall a. TimingCounter a -> a
timingCounterValue TimingCounter a
counter a -> a -> a
forall a. Num a => a -> a -> a
+ a
a

-- | Decrease the counter at the specified time.
decTimingCounter :: TimingData a => Double -> a -> TimingCounter a -> TimingCounter a
decTimingCounter :: Double -> a -> TimingCounter a -> TimingCounter a
decTimingCounter Double
t a
a TimingCounter a
counter =
  TimingCounter :: forall a. a -> TimingStats a -> TimingCounter a
TimingCounter { timingCounterValue :: a
timingCounterValue = a
a',
                  timingCounterStats :: TimingStats a
timingCounterStats = Double -> a -> TimingStats a -> TimingStats a
forall a.
TimingData a =>
Double -> a -> TimingStats a -> TimingStats a
addTimingStats Double
t a
a' (TimingCounter a -> TimingStats a
forall a. TimingCounter a -> TimingStats a
timingCounterStats TimingCounter a
counter) }
  where a' :: a
a' = TimingCounter a -> a
forall a. TimingCounter a -> a
timingCounterValue TimingCounter a
counter a -> a -> a
forall a. Num a => a -> a -> a
- a
a

-- | Set a new value for the counter at the specified time.
setTimingCounter :: TimingData a => Double -> a -> TimingCounter a -> TimingCounter a
setTimingCounter :: Double -> a -> TimingCounter a -> TimingCounter a
setTimingCounter Double
t a
a TimingCounter a
counter =
  TimingCounter :: forall a. a -> TimingStats a -> TimingCounter a
TimingCounter { timingCounterValue :: a
timingCounterValue = a
a,
                  timingCounterStats :: TimingStats a
timingCounterStats = Double -> a -> TimingStats a -> TimingStats a
forall a.
TimingData a =>
Double -> a -> TimingStats a -> TimingStats a
addTimingStats Double
t a
a (TimingCounter a -> TimingStats a
forall a. TimingCounter a -> TimingStats a
timingCounterStats TimingCounter a
counter) }

-- | Create a timing counter with the specified initial value at the given time.
returnTimingCounter :: TimingData a => Double -> a -> TimingCounter a
returnTimingCounter :: Double -> a -> TimingCounter a
returnTimingCounter Double
t a
a =
  TimingCounter :: forall a. a -> TimingStats a -> TimingCounter a
TimingCounter { timingCounterValue :: a
timingCounterValue = a
a,
                  timingCounterStats :: TimingStats a
timingCounterStats = Double -> a -> TimingStats a
forall a. TimingData a => Double -> a -> TimingStats a
returnTimingStats Double
t a
a }