statistics-0.16.3.0: A library of statistical types, data, and functions

Copyright | (c) 2009 Bryan O'Sullivan
License | BSD3
Maintainer | bos@serpentine.com
Stability | experimental
Portability | portable
Safe Haskell | None
Language | Haskell2010

Statistics.Types

Contents

- Confidence level
  - Accessors
  - Constructors
  - Constants and conversion to nσ
    - Normal approximation
- p-value
  - Accessors
  - Constructors
- Estimates and upper/lower limits
  - Constructors
  - Accessors
- Other

Description

Data types common used in statistics

Synopsis

- data CL a
- confidenceLevel :: Num a => CL a -> a
- significanceLevel :: CL a -> a
- mkCL :: (Ord a, Num a) => a -> CL a
- mkCLE :: (Ord a, Num a) => a -> Maybe (CL a)
- mkCLFromSignificance :: (Ord a, Num a) => a -> CL a
- mkCLFromSignificanceE :: (Ord a, Num a) => a -> Maybe (CL a)
- cl90 :: Fractional a => CL a
- cl95 :: Fractional a => CL a
- cl99 :: Fractional a => CL a
- nSigma :: Double -> PValue Double
- nSigma1 :: Double -> PValue Double
- getNSigma :: PValue Double -> Double
- getNSigma1 :: PValue Double -> Double
- data PValue a
- pValue :: PValue a -> a
- mkPValue :: (Ord a, Num a) => a -> PValue a
- mkPValueE :: (Ord a, Num a) => a -> Maybe (PValue a)
- data Estimate (e :: Type -> Type) a = Estimate {
  - estPoint :: !a
  - estError :: !(e a)
  }
- newtype NormalErr a = NormalErr {
  - normalError :: a
  }
- data ConfInt a = ConfInt {
  - confIntLDX :: !a
  - confIntUDX :: !a
  - confIntCL :: !(CL Double)
  }
- data UpperLimit a = UpperLimit {
  - upperLimit :: !a
  - ulConfidenceLevel :: !(CL Double)
  }
- data LowerLimit a = LowerLimit {
  - lowerLimit :: !a
  - llConfidenceLevel :: !(CL Double)
  }
- estimateNormErr :: a -> a -> Estimate NormalErr a
- (±) :: a -> a -> Estimate NormalErr a
- estimateFromInterval :: Num a => a -> (a, a) -> CL Double -> Estimate ConfInt a
- estimateFromErr :: a -> (a, a) -> CL Double -> Estimate ConfInt a
- confidenceInterval :: Num a => Estimate ConfInt a -> (a, a)
- asymErrors :: Estimate ConfInt a -> (a, a)
- class Scale (e :: Type -> Type) where
  - scale :: (Ord a, Num a) => a -> e a -> e a
- type Sample = Vector Double
- type WeightedSample = Vector (Double, Double)
- type Weights = Vector Double

# Confidence level

data CL a #

Confidence level. In context of confidence intervals it's probability of said interval covering true value of measured value. In context of statistical tests it's `1-α` where α is significance of test.

Since confidence level are usually close to 1 they are stored as `1-CL` internally. There are two smart constructors for `CL`: `mkCL` and `mkCLFromSignificance` (and corresponding variant returning `Maybe`). First creates `CL` from confidence level and second from `1 - CL` or significance level.

    >>> cl95
    mkCLFromSignificance 5.0e-2

Prior to 0.14 confidence levels were passed to function as plain `Doubles`. Use `mkCL` to convert them to `CL`.

#### Instances

Instances details

Unbox a => Vector Vector (CL a) # |

Instance details

Defined in Statistics.Types

Methods

basicUnsafeFreeze :: Mutable Vector s (CL a) -> ST s (Vector (CL a))

basicUnsafeThaw :: Vector (CL a) -> ST s (Mutable Vector s (CL a))

basicLength :: Vector (CL a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (CL a) -> Vector (CL a)

basicUnsafeIndexM :: Vector (CL a) -> Int -> Box (CL a)

basicUnsafeCopy :: Mutable Vector s (CL a) -> Vector (CL a) -> ST s ()

elemseq :: Vector (CL a) -> CL a -> b -> b

Unbox a => MVector MVector (CL a) # |

Instance details

Defined in Statistics.Types

Methods

basicLength :: MVector s (CL a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (CL a) -> MVector s (CL a)

basicOverlaps :: MVector s (CL a) -> MVector s (CL a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (CL a))

basicInitialize :: MVector s (CL a) -> ST s ()

basicUnsafeReplicate :: Int -> CL a -> ST s (MVector s (CL a))

basicUnsafeRead :: MVector s (CL a) -> Int -> ST s (CL a)

basicUnsafeWrite :: MVector s (CL a) -> Int -> CL a -> ST s ()

basicClear :: MVector s (CL a) -> ST s ()

basicSet :: MVector s (CL a) -> CL a -> ST s ()

basicUnsafeCopy :: MVector s (CL a) -> MVector s (CL a) -> ST s ()

basicUnsafeMove :: MVector s (CL a) -> MVector s (CL a) -> ST s ()

basicUnsafeGrow :: MVector s (CL a) -> Int -> ST s (MVector s (CL a))

(FromJSON a, Num a, Ord a) => FromJSON (CL a) # |
Instance details Defined in Statistics.Types Methods parseJSON :: Value -> Parser (CL a) # parseJSONList :: Value -> Parser [CL a] # omittedField :: Maybe (CL a) #
ToJSON a => ToJSON (CL a) # |
Instance details Defined in Statistics.Types Methods toJSON :: CL a -> Value # toEncoding :: CL a -> Encoding # toJSONList :: [CL a] -> Value # toEncodingList :: [CL a] -> Encoding # omitField :: CL a -> Bool #
(Binary a, Num a, Ord a) => Binary (CL a) # |
Instance details Defined in Statistics.Types Methods put :: CL a -> Put # get :: Get (CL a) # putList :: [CL a] -> Put #
NFData a => NFData (CL a) # |
Instance details Defined in Statistics.Types Methods rnf :: CL a -> () #
Data a => Data (CL a) # |

Instance details

Defined in Statistics.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CL a -> c (CL a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CL a) #

toConstr :: CL a -> Constr #

dataTypeOf :: CL a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (CL a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CL a)) #

gmapT :: (forall b. Data b => b -> b) -> CL a -> CL a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CL a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CL a -> r #

gmapQ :: (forall d. Data d => d -> u) -> CL a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CL a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CL a -> m (CL a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CL a -> m (CL a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CL a -> m (CL a) #

Generic (CL a) # |

Instance details

Defined in Statistics.Types

Associated Types

type Rep (CL a) |
Instance details Defined in Statistics.Types type Rep (CL a) = D1 ('MetaData "CL" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'True) (C1 ('MetaCons "CL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

Methods

from :: CL a -> Rep (CL a) x #

to :: Rep (CL a) x -> CL a #

(Num a, Ord a, Read a) => Read (CL a) # |
Instance details Defined in Statistics.Types Methods readsPrec :: Int -> ReadS (CL a) # readList :: ReadS [CL a] # readPrec :: ReadPrec (CL a) # readListPrec :: ReadPrec [CL a] #
Show a => Show (CL a) # |
Instance details Defined in Statistics.Types Methods showsPrec :: Int -> CL a -> ShowS # show :: CL a -> String # showList :: [CL a] -> ShowS #
Eq a => Eq (CL a) # |
Instance details Defined in Statistics.Types Methods (==) :: CL a -> CL a -> Bool # (/=) :: CL a -> CL a -> Bool #

Ord a => Ord (CL a) #

    >>> cl95 > cl90
    True

Instance details Defined in Statistics.Types Methods compare :: CL a -> CL a -> Ordering # (<) :: CL a -> CL a -> Bool # (<=) :: CL a -> CL a -> Bool # (>) :: CL a -> CL a -> Bool # (>=) :: CL a -> CL a -> Bool # max :: CL a -> CL a -> CL a # min :: CL a -> CL a -> CL a #
Unbox a => Unbox (CL a) # |
Instance details Defined in Statistics.Types
newtype MVector s (CL a) # |
Instance details Defined in Statistics.Types newtype MVector s (CL a) = MV_CL (MVector s a)
type Rep (CL a) # |
Instance details Defined in Statistics.Types type Rep (CL a) = D1 ('MetaData "CL" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'True) (C1 ('MetaCons "CL" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
newtype Vector (CL a) # |
Instance details Defined in Statistics.Types newtype Vector (CL a) = V_CL (Vector a)

## Accessors

confidenceLevel :: Num a => CL a -> a #

Get confidence level. This function is subject to rounding errors. If `1 - CL` is needed use `significanceLevel` instead

significanceLevel :: CL a -> a #

Get significance level.

## Constructors

mkCL :: (Ord a, Num a) => a -> CL a #

Create confidence level from probability β or probability confidence interval contain true value of estimate. Will throw exception if parameter is out of [0,1] range

    >>> mkCL 0.95    -- same as cl95
    mkCLFromSignificance 5.0000000000000044e-2

mkCLE :: (Ord a, Num a) => a -> Maybe (CL a) #

Same as `mkCL` but returns `Nothing` instead of error if parameter is out of [0,1] range

    >>> mkCLE 0.95    -- same as cl95
    Just (mkCLFromSignificance 5.0000000000000044e-2)

mkCLFromSignificance :: (Ord a, Num a) => a -> CL a #

Create confidence level from probability α or probability that confidence interval does not contain true value of estimate. Will throw exception if parameter is out of [0,1] range

    >>> mkCLFromSignificance 0.05    -- same as cl95
    mkCLFromSignificance 5.0e-2

mkCLFromSignificanceE :: (Ord a, Num a) => a -> Maybe (CL a) #

Same as `mkCLFromSignificance` but returns `Nothing` instead of error if parameter is out of [0,1] range

    >>> mkCLFromSignificanceE 0.05    -- same as cl95
    Just (mkCLFromSignificance 5.0e-2)

## Constants and conversion to nσ

cl90 :: Fractional a => CL a #

90% confidence level

cl95 :: Fractional a => CL a #

95% confidence level

cl99 :: Fractional a => CL a #

99% confidence level

### Normal approximation

nSigma :: Double -> PValue Double #

P-value expressed in sigma. This is convention widely used in experimental physics. N sigma confidence level corresponds to probability within N sigma of normal distribution.

Note that this correspondence is for normal distribution. Other distribution will have different dependency. Also experimental distribution usually only approximately normal (especially at extreme tails).

nSigma1 :: Double -> PValue Double #

P-value expressed in sigma for one-tail hypothesis. This correspond to probability of obtaining value less than `N·σ`.

getNSigma :: PValue Double -> Double #

Express confidence level in sigmas

getNSigma1 :: PValue Double -> Double #

Express confidence level in sigmas for one-tailed hypothesis.

# p-value

data PValue a #

Newtype wrapper for p-value.

#### Instances

Instances details

Unbox a => Vector Vector (PValue a) # |

Instance details

Defined in Statistics.Types

Methods

basicUnsafeFreeze :: Mutable Vector s (PValue a) -> ST s (Vector (PValue a))

basicUnsafeThaw :: Vector (PValue a) -> ST s (Mutable Vector s (PValue a))

basicLength :: Vector (PValue a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (PValue a) -> Vector (PValue a)

basicUnsafeIndexM :: Vector (PValue a) -> Int -> Box (PValue a)

basicUnsafeCopy :: Mutable Vector s (PValue a) -> Vector (PValue a) -> ST s ()

elemseq :: Vector (PValue a) -> PValue a -> b -> b

Unbox a => MVector MVector (PValue a) # |

Instance details

Defined in Statistics.Types

Methods

basicLength :: MVector s (PValue a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (PValue a) -> MVector s (PValue a)

basicOverlaps :: MVector s (PValue a) -> MVector s (PValue a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (PValue a))

basicInitialize :: MVector s (PValue a) -> ST s ()

basicUnsafeReplicate :: Int -> PValue a -> ST s (MVector s (PValue a))

basicUnsafeRead :: MVector s (PValue a) -> Int -> ST s (PValue a)

basicUnsafeWrite :: MVector s (PValue a) -> Int -> PValue a -> ST s ()

basicClear :: MVector s (PValue a) -> ST s ()

basicSet :: MVector s (PValue a) -> PValue a -> ST s ()

basicUnsafeCopy :: MVector s (PValue a) -> MVector s (PValue a) -> ST s ()

basicUnsafeMove :: MVector s (PValue a) -> MVector s (PValue a) -> ST s ()

basicUnsafeGrow :: MVector s (PValue a) -> Int -> ST s (MVector s (PValue a))

(FromJSON a, Num a, Ord a) => FromJSON (PValue a) # |
Instance details Defined in Statistics.Types Methods parseJSON :: Value -> Parser (PValue a) # parseJSONList :: Value -> Parser [PValue a] # omittedField :: Maybe (PValue a) #
ToJSON a => ToJSON (PValue a) # |
Instance details Defined in Statistics.Types Methods toJSON :: PValue a -> Value # toEncoding :: PValue a -> Encoding # toJSONList :: [PValue a] -> Value # toEncodingList :: [PValue a] -> Encoding # omitField :: PValue a -> Bool #
(Binary a, Num a, Ord a) => Binary (PValue a) # |
Instance details Defined in Statistics.Types Methods put :: PValue a -> Put # get :: Get (PValue a) # putList :: [PValue a] -> Put #
NFData a => NFData (PValue a) # |
Instance details Defined in Statistics.Types Methods rnf :: PValue a -> () #
Data a => Data (PValue a) # |

Instance details

Defined in Statistics.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PValue a -> c (PValue a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PValue a) #

toConstr :: PValue a -> Constr #

dataTypeOf :: PValue a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PValue a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PValue a)) #

gmapT :: (forall b. Data b => b -> b) -> PValue a -> PValue a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PValue a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PValue a -> r #

gmapQ :: (forall d. Data d => d -> u) -> PValue a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PValue a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PValue a -> m (PValue a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PValue a -> m (PValue a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PValue a -> m (PValue a) #

Generic (PValue a) # |

Instance details

Defined in Statistics.Types

Associated Types

type Rep (PValue a) |
Instance details Defined in Statistics.Types type Rep (PValue a) = D1 ('MetaData "PValue" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'True) (C1 ('MetaCons "PValue" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

Methods

from :: PValue a -> Rep (PValue a) x #

to :: Rep (PValue a) x -> PValue a #

(Num a, Ord a, Read a) => Read (PValue a) # |
Instance details Defined in Statistics.Types Methods readsPrec :: Int -> ReadS (PValue a) # readList :: ReadS [PValue a] # readPrec :: ReadPrec (PValue a) # readListPrec :: ReadPrec [PValue a] #
Show a => Show (PValue a) # |
Instance details Defined in Statistics.Types Methods showsPrec :: Int -> PValue a -> ShowS # show :: PValue a -> String # showList :: [PValue a] -> ShowS #
Eq a => Eq (PValue a) # |
Instance details Defined in Statistics.Types Methods (==) :: PValue a -> PValue a -> Bool # (/=) :: PValue a -> PValue a -> Bool #
Ord a => Ord (PValue a) # |
Instance details Defined in Statistics.Types Methods compare :: PValue a -> PValue a -> Ordering # (<) :: PValue a -> PValue a -> Bool # (<=) :: PValue a -> PValue a -> Bool # (>) :: PValue a -> PValue a -> Bool # (>=) :: PValue a -> PValue a -> Bool # max :: PValue a -> PValue a -> PValue a # min :: PValue a -> PValue a -> PValue a #
Unbox a => Unbox (PValue a) # |
Instance details Defined in Statistics.Types
newtype MVector s (PValue a) # |
Instance details Defined in Statistics.Types newtype MVector s (PValue a) = MV_PValue (MVector s a)
type Rep (PValue a) # |
Instance details Defined in Statistics.Types type Rep (PValue a) = D1 ('MetaData "PValue" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'True) (C1 ('MetaCons "PValue" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
newtype Vector (PValue a) # |
Instance details Defined in Statistics.Types newtype Vector (PValue a) = V_PValue (Vector a)

## Accessors

pValue :: PValue a -> a #

Get p-value

## Constructors

mkPValue :: (Ord a, Num a) => a -> PValue a #

Construct PValue. Throws error if argument is out of [0,1] range.

mkPValueE :: (Ord a, Num a) => a -> Maybe (PValue a) #

Construct PValue. Returns `Nothing` if argument is out of [0,1] range.

# Estimates and upper/lower limits

data Estimate (e :: Type -> Type) a #

A point estimate and its confidence interval. It's parametrized by both error type `e` and value type `a`. This module provides two types of error: `NormalErr` for normally distributed errors and `ConfInt` for error with normal distribution. See their documentation for more details.

For example `144 ± 5` (assuming normality) could be expressed as

    Estimate { estPoint = 144
             , estError = NormalErr 5
             }

Or if we want to express `144 + 6 - 4` at CL95 we could write:

    Estimate { estPoint = 144
             , estError = ConfInt
                          { confIntLDX = 4
                          , confIntUDX = 6
                          , confIntCL  = cl95
                          }
             }

Prior to statistics 0.14 `Estimate` data type used following definition:

    data Estimate = Estimate {
         estPoint           :: {-# UNPACK #-} !Double
       , estLowerBound      :: {-# UNPACK #-} !Double
       , estUpperBound      :: {-# UNPACK #-} !Double
       , estConfidenceLevel :: {-# UNPACK #-} !Double
       }

Now type `Estimate ConfInt Double` should be used instead. Function `estimateFromInterval` allow to easily construct estimate from same inputs.

Constructors

Estimate |

Fields

- estPoint :: !a

  Point estimate.

- estError :: !(e a)

  Confidence interval for estimate.

#### Instances

Instances details

(Unbox a, Unbox (e a)) => Vector Vector (Estimate e a) # |

Instance details

Defined in Statistics.Types

Methods

basicUnsafeFreeze :: Mutable Vector s (Estimate e a) -> ST s (Vector (Estimate e a))

basicUnsafeThaw :: Vector (Estimate e a) -> ST s (Mutable Vector s (Estimate e a))

basicLength :: Vector (Estimate e a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Estimate e a) -> Vector (Estimate e a)

basicUnsafeIndexM :: Vector (Estimate e a) -> Int -> Box (Estimate e a)

basicUnsafeCopy :: Mutable Vector s (Estimate e a) -> Vector (Estimate e a) -> ST s ()

elemseq :: Vector (Estimate e a) -> Estimate e a -> b -> b

(Unbox a, Unbox (e a)) => MVector MVector (Estimate e a) # |

Instance details

Defined in Statistics.Types

Methods

basicLength :: MVector s (Estimate e a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Estimate e a) -> MVector s (Estimate e a)

basicOverlaps :: MVector s (Estimate e a) -> MVector s (Estimate e a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Estimate e a))

basicInitialize :: MVector s (Estimate e a) -> ST s ()

basicUnsafeReplicate :: Int -> Estimate e a -> ST s (MVector s (Estimate e a))

basicUnsafeRead :: MVector s (Estimate e a) -> Int -> ST s (Estimate e a)

basicUnsafeWrite :: MVector s (Estimate e a) -> Int -> Estimate e a -> ST s ()

basicClear :: MVector s (Estimate e a) -> ST s ()

basicSet :: MVector s (Estimate e a) -> Estimate e a -> ST s ()

basicUnsafeCopy :: MVector s (Estimate e a) -> MVector s (Estimate e a) -> ST s ()

basicUnsafeMove :: MVector s (Estimate e a) -> MVector s (Estimate e a) -> ST s ()

basicUnsafeGrow :: MVector s (Estimate e a) -> Int -> ST s (MVector s (Estimate e a))

Scale e => Scale (Estimate e) # |
Instance details Defined in Statistics.Types Methods scale :: (Ord a, Num a) => a -> Estimate e a -> Estimate e a #
(FromJSON (e a), FromJSON a) => FromJSON (Estimate e a) # |
Instance details Defined in Statistics.Types Methods parseJSON :: Value -> Parser (Estimate e a) # parseJSONList :: Value -> Parser [Estimate e a] # omittedField :: Maybe (Estimate e a) #
(ToJSON (e a), ToJSON a) => ToJSON (Estimate e a) # |
Instance details Defined in Statistics.Types Methods toJSON :: Estimate e a -> Value # toEncoding :: Estimate e a -> Encoding # toJSONList :: [Estimate e a] -> Value # toEncodingList :: [Estimate e a] -> Encoding # omitField :: Estimate e a -> Bool #
(Binary (e a), Binary a) => Binary (Estimate e a) # |
Instance details Defined in Statistics.Types Methods put :: Estimate e a -> Put # get :: Get (Estimate e a) # putList :: [Estimate e a] -> Put #
(NFData (e a), NFData a) => NFData (Estimate e a) # |
Instance details Defined in Statistics.Types Methods rnf :: Estimate e a -> () #
(Typeable e, Data a, Data (e a)) => Data (Estimate e a) # |

Instance details

Defined in Statistics.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Estimate e a -> c (Estimate e a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Estimate e a) #

toConstr :: Estimate e a -> Constr #

dataTypeOf :: Estimate e a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Estimate e a)) #

dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (Estimate e a)) #

gmapT :: (forall b. Data b => b -> b) -> Estimate e a -> Estimate e a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Estimate e a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Estimate e a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Estimate e a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Estimate e a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Estimate e a -> m (Estimate e a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Estimate e a -> m (Estimate e a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Estimate e a -> m (Estimate e a) #

Generic (Estimate e a) # |

Instance details

Defined in Statistics.Types

Associated Types

type Rep (Estimate e a) |

Instance details

Defined in Statistics.Types

type Rep (Estimate e a) = D1 ('MetaData "Estimate" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'False) (C1 ('MetaCons "Estimate" 'PrefixI 'True) (S1 ('MetaSel ('Just "estPoint") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "estError") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (e a))))

Methods

from :: Estimate e a -> Rep (Estimate e a) x #

to :: Rep (Estimate e a) x -> Estimate e a #

(Read a, Read (e a)) => Read (Estimate e a) # |
Instance details Defined in Statistics.Types Methods readsPrec :: Int -> ReadS (Estimate e a) # readList :: ReadS [Estimate e a] # readPrec :: ReadPrec (Estimate e a) # readListPrec :: ReadPrec [Estimate e a] #
(Show a, Show (e a)) => Show (Estimate e a) # |
Instance details Defined in Statistics.Types Methods showsPrec :: Int -> Estimate e a -> ShowS # show :: Estimate e a -> String # showList :: [Estimate e a] -> ShowS #
(Eq a, Eq (e a)) => Eq (Estimate e a) # |
Instance details Defined in Statistics.Types Methods (==) :: Estimate e a -> Estimate e a -> Bool # (/=) :: Estimate e a -> Estimate e a -> Bool #
(Unbox a, Unbox (e a)) => Unbox (Estimate e a) # |
Instance details Defined in Statistics.Types
newtype MVector s (Estimate e a) # |
Instance details Defined in Statistics.Types newtype MVector s (Estimate e a) = MV_Estimate (MVector s (a, e a))
type Rep (Estimate e a) # |

Instance details

Defined in Statistics.Types

type Rep (Estimate e a) = D1 ('MetaData "Estimate" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'False) (C1 ('MetaCons "Estimate" 'PrefixI 'True) (S1 ('MetaSel ('Just "estPoint") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "estError") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (e a))))

newtype Vector (Estimate e a) # |
Instance details Defined in Statistics.Types newtype Vector (Estimate e a) = V_Estimate (Vector (a, e a))

newtype NormalErr a #

Normal errors. They are stored as 1σ errors which corresponds to 68.8% CL. Since we can recalculate them to any confidence level if needed we don't store it.

Constructors

NormalErr |

Fields

- normalError :: a

#### Instances

Instances details

Scale NormalErr # |
Instance details Defined in Statistics.Types Methods scale :: (Ord a, Num a) => a -> NormalErr a -> NormalErr a #
Unbox a => Vector Vector (NormalErr a) # |

Instance details

Defined in Statistics.Types

Methods

basicUnsafeFreeze :: Mutable Vector s (NormalErr a) -> ST s (Vector (NormalErr a))

basicUnsafeThaw :: Vector (NormalErr a) -> ST s (Mutable Vector s (NormalErr a))

basicLength :: Vector (NormalErr a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (NormalErr a) -> Vector (NormalErr a)

basicUnsafeIndexM :: Vector (NormalErr a) -> Int -> Box (NormalErr a)

basicUnsafeCopy :: Mutable Vector s (NormalErr a) -> Vector (NormalErr a) -> ST s ()

elemseq :: Vector (NormalErr a) -> NormalErr a -> b -> b

Unbox a => MVector MVector (NormalErr a) # |

Instance details

Defined in Statistics.Types

Methods

basicLength :: MVector s (NormalErr a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (NormalErr a) -> MVector s (NormalErr a)

basicOverlaps :: MVector s (NormalErr a) -> MVector s (NormalErr a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (NormalErr a))

basicInitialize :: MVector s (NormalErr a) -> ST s ()

basicUnsafeReplicate :: Int -> NormalErr a -> ST s (MVector s (NormalErr a))

basicUnsafeRead :: MVector s (NormalErr a) -> Int -> ST s (NormalErr a)

basicUnsafeWrite :: MVector s (NormalErr a) -> Int -> NormalErr a -> ST s ()

basicClear :: MVector s (NormalErr a) -> ST s ()

basicSet :: MVector s (NormalErr a) -> NormalErr a -> ST s ()

basicUnsafeCopy :: MVector s (NormalErr a) -> MVector s (NormalErr a) -> ST s ()

basicUnsafeMove :: MVector s (NormalErr a) -> MVector s (NormalErr a) -> ST s ()

basicUnsafeGrow :: MVector s (NormalErr a) -> Int -> ST s (MVector s (NormalErr a))

FromJSON a => FromJSON (NormalErr a) # |
Instance details Defined in Statistics.Types Methods parseJSON :: Value -> Parser (NormalErr a) # parseJSONList :: Value -> Parser [NormalErr a] # omittedField :: Maybe (NormalErr a) #
ToJSON a => ToJSON (NormalErr a) # |
Instance details Defined in Statistics.Types Methods toJSON :: NormalErr a -> Value # toEncoding :: NormalErr a -> Encoding # toJSONList :: [NormalErr a] -> Value # toEncodingList :: [NormalErr a] -> Encoding # omitField :: NormalErr a -> Bool #
Binary a => Binary (NormalErr a) # |
Instance details Defined in Statistics.Types Methods put :: NormalErr a -> Put # get :: Get (NormalErr a) # putList :: [NormalErr a] -> Put #
NFData a => NFData (NormalErr a) # |
Instance details Defined in Statistics.Types Methods rnf :: NormalErr a -> () #
Data a => Data (NormalErr a) # |

Instance details

Defined in Statistics.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NormalErr a -> c (NormalErr a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NormalErr a) #

toConstr :: NormalErr a -> Constr #

dataTypeOf :: NormalErr a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NormalErr a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NormalErr a)) #

gmapT :: (forall b. Data b => b -> b) -> NormalErr a -> NormalErr a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NormalErr a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NormalErr a -> r #

gmapQ :: (forall d. Data d => d -> u) -> NormalErr a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NormalErr a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NormalErr a -> m (NormalErr a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NormalErr a -> m (NormalErr a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NormalErr a -> m (NormalErr a) #

Generic (NormalErr a) # |

Instance details

Defined in Statistics.Types

Associated Types

type Rep (NormalErr a) |
Instance details Defined in Statistics.Types type Rep (NormalErr a) = D1 ('MetaData "NormalErr" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'True) (C1 ('MetaCons "NormalErr" 'PrefixI 'True) (S1 ('MetaSel ('Just "normalError") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

Methods

from :: NormalErr a -> Rep (NormalErr a) x #

to :: Rep (NormalErr a) x -> NormalErr a #

Read a => Read (NormalErr a) # |
Instance details Defined in Statistics.Types Methods readsPrec :: Int -> ReadS (NormalErr a) # readList :: ReadS [NormalErr a] # readPrec :: ReadPrec (NormalErr a) # readListPrec :: ReadPrec [NormalErr a] #
Show a => Show (NormalErr a) # |
Instance details Defined in Statistics.Types Methods showsPrec :: Int -> NormalErr a -> ShowS # show :: NormalErr a -> String # showList :: [NormalErr a] -> ShowS #
Eq a => Eq (NormalErr a) # |
Instance details Defined in Statistics.Types Methods (==) :: NormalErr a -> NormalErr a -> Bool # (/=) :: NormalErr a -> NormalErr a -> Bool #
Unbox a => Unbox (NormalErr a) # |
Instance details Defined in Statistics.Types
newtype MVector s (NormalErr a) # |
Instance details Defined in Statistics.Types newtype MVector s (NormalErr a) = MV_NormalErr (MVector s a)
type Rep (NormalErr a) # |
Instance details Defined in Statistics.Types type Rep (NormalErr a) = D1 ('MetaData "NormalErr" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'True) (C1 ('MetaCons "NormalErr" 'PrefixI 'True) (S1 ('MetaSel ('Just "normalError") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
newtype Vector (NormalErr a) # |
Instance details Defined in Statistics.Types newtype Vector (NormalErr a) = V_NormalErr (Vector a)

data ConfInt a #

Confidence interval. It assumes that confidence interval forms single interval and isn't set of disjoint intervals.

Constructors

ConfInt |

Fields

- confIntLDX :: !a

  Lower error estimate, or distance between point estimate and lower bound of confidence interval.

- confIntUDX :: !a

  Upper error estimate, or distance between point estimate and upper bound of confidence interval.

- confIntCL :: !(CL Double)

  Confidence level corresponding to given confidence interval.

#### Instances

Instances details

Scale ConfInt # |
Instance details Defined in Statistics.Types Methods scale :: (Ord a, Num a) => a -> ConfInt a -> ConfInt a #
Unbox a => Vector Vector (ConfInt a) # |

Instance details

Defined in Statistics.Types

Methods

basicUnsafeFreeze :: Mutable Vector s (ConfInt a) -> ST s (Vector (ConfInt a))

basicUnsafeThaw :: Vector (ConfInt a) -> ST s (Mutable Vector s (ConfInt a))

basicLength :: Vector (ConfInt a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (ConfInt a) -> Vector (ConfInt a)

basicUnsafeIndexM :: Vector (ConfInt a) -> Int -> Box (ConfInt a)

basicUnsafeCopy :: Mutable Vector s (ConfInt a) -> Vector (ConfInt a) -> ST s ()

elemseq :: Vector (ConfInt a) -> ConfInt a -> b -> b

Unbox a => MVector MVector (ConfInt a) # |

Instance details

Defined in Statistics.Types

Methods

basicLength :: MVector s (ConfInt a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (ConfInt a) -> MVector s (ConfInt a)

basicOverlaps :: MVector s (ConfInt a) -> MVector s (ConfInt a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (ConfInt a))

basicInitialize :: MVector s (ConfInt a) -> ST s ()

basicUnsafeReplicate :: Int -> ConfInt a -> ST s (MVector s (ConfInt a))

basicUnsafeRead :: MVector s (ConfInt a) -> Int -> ST s (ConfInt a)

basicUnsafeWrite :: MVector s (ConfInt a) -> Int -> ConfInt a -> ST s ()

basicClear :: MVector s (ConfInt a) -> ST s ()

basicSet :: MVector s (ConfInt a) -> ConfInt a -> ST s ()

basicUnsafeCopy :: MVector s (ConfInt a) -> MVector s (ConfInt a) -> ST s ()

basicUnsafeMove :: MVector s (ConfInt a) -> MVector s (ConfInt a) -> ST s ()

basicUnsafeGrow :: MVector s (ConfInt a) -> Int -> ST s (MVector s (ConfInt a))

FromJSON a => FromJSON (ConfInt a) # |
Instance details Defined in Statistics.Types Methods parseJSON :: Value -> Parser (ConfInt a) # parseJSONList :: Value -> Parser [ConfInt a] # omittedField :: Maybe (ConfInt a) #
ToJSON a => ToJSON (ConfInt a) # |
Instance details Defined in Statistics.Types Methods toJSON :: ConfInt a -> Value # toEncoding :: ConfInt a -> Encoding # toJSONList :: [ConfInt a] -> Value # toEncodingList :: [ConfInt a] -> Encoding # omitField :: ConfInt a -> Bool #
Binary a => Binary (ConfInt a) # |
Instance details Defined in Statistics.Types Methods put :: ConfInt a -> Put # get :: Get (ConfInt a) # putList :: [ConfInt a] -> Put #
NFData a => NFData (ConfInt a) # |
Instance details Defined in Statistics.Types Methods rnf :: ConfInt a -> () #
Data a => Data (ConfInt a) # |

Instance details

Defined in Statistics.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConfInt a -> c (ConfInt a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConfInt a) #

toConstr :: ConfInt a -> Constr #

dataTypeOf :: ConfInt a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConfInt a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConfInt a)) #

gmapT :: (forall b. Data b => b -> b) -> ConfInt a -> ConfInt a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConfInt a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConfInt a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConfInt a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConfInt a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConfInt a -> m (ConfInt a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConfInt a -> m (ConfInt a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConfInt a -> m (ConfInt a) #

Generic (ConfInt a) # |

Instance details

Defined in Statistics.Types

Associated Types

type Rep (ConfInt a) |

Instance details

Defined in Statistics.Types

type Rep (ConfInt a) = D1 ('MetaData "ConfInt" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'False) (C1 ('MetaCons "ConfInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "confIntLDX") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: (S1 ('MetaSel ('Just "confIntUDX") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "confIntCL") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (CL Double)))))

Methods

from :: ConfInt a -> Rep (ConfInt a) x #

to :: Rep (ConfInt a) x -> ConfInt a #

Read a => Read (ConfInt a) # |
Instance details Defined in Statistics.Types Methods readsPrec :: Int -> ReadS (ConfInt a) # readList :: ReadS [ConfInt a] # readPrec :: ReadPrec (ConfInt a) # readListPrec :: ReadPrec [ConfInt a] #
Show a => Show (ConfInt a) # |
Instance details Defined in Statistics.Types Methods showsPrec :: Int -> ConfInt a -> ShowS # show :: ConfInt a -> String # showList :: [ConfInt a] -> ShowS #
Eq a => Eq (ConfInt a) # |
Instance details Defined in Statistics.Types Methods (==) :: ConfInt a -> ConfInt a -> Bool # (/=) :: ConfInt a -> ConfInt a -> Bool #
Unbox a => Unbox (ConfInt a) # |
Instance details Defined in Statistics.Types
newtype MVector s (ConfInt a) # |
Instance details Defined in Statistics.Types newtype MVector s (ConfInt a) = MV_ConfInt (MVector s (a, a, CL Double))
type Rep (ConfInt a) # |

Instance details

Defined in Statistics.Types

type Rep (ConfInt a) = D1 ('MetaData "ConfInt" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'False) (C1 ('MetaCons "ConfInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "confIntLDX") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: (S1 ('MetaSel ('Just "confIntUDX") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "confIntCL") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (CL Double)))))

newtype Vector (ConfInt a) # |
Instance details Defined in Statistics.Types newtype Vector (ConfInt a) = V_ConfInt (Vector (a, a, CL Double))

data UpperLimit a #

Upper limit. They are usually given for small non-negative values when it's not possible detect difference from zero.

Constructors

UpperLimit |

Fields

- upperLimit :: !a

  Upper limit

- ulConfidenceLevel :: !(CL Double)

  Confidence level for which limit was calculated

#### Instances

Instances details

Unbox a => Vector Vector (UpperLimit a) # |

Instance details

Defined in Statistics.Types

Methods

basicUnsafeFreeze :: Mutable Vector s (UpperLimit a) -> ST s (Vector (UpperLimit a))

basicUnsafeThaw :: Vector (UpperLimit a) -> ST s (Mutable Vector s (UpperLimit a))

basicLength :: Vector (UpperLimit a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (UpperLimit a) -> Vector (UpperLimit a)

basicUnsafeIndexM :: Vector (UpperLimit a) -> Int -> Box (UpperLimit a)

basicUnsafeCopy :: Mutable Vector s (UpperLimit a) -> Vector (UpperLimit a) -> ST s ()

elemseq :: Vector (UpperLimit a) -> UpperLimit a -> b -> b

Unbox a => MVector MVector (UpperLimit a) # |

Instance details

Defined in Statistics.Types

Methods

basicLength :: MVector s (UpperLimit a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (UpperLimit a) -> MVector s (UpperLimit a)

basicOverlaps :: MVector s (UpperLimit a) -> MVector s (UpperLimit a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (UpperLimit a))

basicInitialize :: MVector s (UpperLimit a) -> ST s ()

basicUnsafeReplicate :: Int -> UpperLimit a -> ST s (MVector s (UpperLimit a))

basicUnsafeRead :: MVector s (UpperLimit a) -> Int -> ST s (UpperLimit a)

basicUnsafeWrite :: MVector s (UpperLimit a) -> Int -> UpperLimit a -> ST s ()

basicClear :: MVector s (UpperLimit a) -> ST s ()

basicSet :: MVector s (UpperLimit a) -> UpperLimit a -> ST s ()

basicUnsafeCopy :: MVector s (UpperLimit a) -> MVector s (UpperLimit a) -> ST s ()

basicUnsafeMove :: MVector s (UpperLimit a) -> MVector s (UpperLimit a) -> ST s ()

basicUnsafeGrow :: MVector s (UpperLimit a) -> Int -> ST s (MVector s (UpperLimit a))

FromJSON a => FromJSON (UpperLimit a) # |
Instance details Defined in Statistics.Types Methods parseJSON :: Value -> Parser (UpperLimit a) # parseJSONList :: Value -> Parser [UpperLimit a] # omittedField :: Maybe (UpperLimit a) #
ToJSON a => ToJSON (UpperLimit a) # |
Instance details Defined in Statistics.Types Methods toJSON :: UpperLimit a -> Value # toEncoding :: UpperLimit a -> Encoding # toJSONList :: [UpperLimit a] -> Value # toEncodingList :: [UpperLimit a] -> Encoding # omitField :: UpperLimit a -> Bool #
Binary a => Binary (UpperLimit a) # |
Instance details Defined in Statistics.Types Methods put :: UpperLimit a -> Put # get :: Get (UpperLimit a) # putList :: [UpperLimit a] -> Put #
NFData a => NFData (UpperLimit a) # |
Instance details Defined in Statistics.Types Methods rnf :: UpperLimit a -> () #
Data a => Data (UpperLimit a) # |

Instance details

Defined in Statistics.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UpperLimit a -> c (UpperLimit a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UpperLimit a) #

toConstr :: UpperLimit a -> Constr #

dataTypeOf :: UpperLimit a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UpperLimit a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UpperLimit a)) #

gmapT :: (forall b. Data b => b -> b) -> UpperLimit a -> UpperLimit a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UpperLimit a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UpperLimit a -> r #

gmapQ :: (forall d. Data d => d -> u) -> UpperLimit a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UpperLimit a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UpperLimit a -> m (UpperLimit a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UpperLimit a -> m (UpperLimit a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UpperLimit a -> m (UpperLimit a) #

Generic (UpperLimit a) # |

Instance details

Defined in Statistics.Types

Associated Types

type Rep (UpperLimit a) |

Instance details

Defined in Statistics.Types

type Rep (UpperLimit a) = D1 ('MetaData "UpperLimit" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'False) (C1 ('MetaCons "UpperLimit" 'PrefixI 'True) (S1 ('MetaSel ('Just "upperLimit") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "ulConfidenceLevel") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (CL Double))))

Methods

from :: UpperLimit a -> Rep (UpperLimit a) x #

to :: Rep (UpperLimit a) x -> UpperLimit a #

Read a => Read (UpperLimit a) # |
Instance details Defined in Statistics.Types Methods readsPrec :: Int -> ReadS (UpperLimit a) # readList :: ReadS [UpperLimit a] # readPrec :: ReadPrec (UpperLimit a) # readListPrec :: ReadPrec [UpperLimit a] #
Show a => Show (UpperLimit a) # |
Instance details Defined in Statistics.Types Methods showsPrec :: Int -> UpperLimit a -> ShowS # show :: UpperLimit a -> String # showList :: [UpperLimit a] -> ShowS #
Eq a => Eq (UpperLimit a) # |
Instance details Defined in Statistics.Types Methods (==) :: UpperLimit a -> UpperLimit a -> Bool # (/=) :: UpperLimit a -> UpperLimit a -> Bool #
Unbox a => Unbox (UpperLimit a) # |
Instance details Defined in Statistics.Types
newtype MVector s (UpperLimit a) # |
Instance details Defined in Statistics.Types newtype MVector s (UpperLimit a) = MV_UpperLimit (MVector s (a, CL Double))
type Rep (UpperLimit a) # |

Instance details

Defined in Statistics.Types

type Rep (UpperLimit a) = D1 ('MetaData "UpperLimit" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'False) (C1 ('MetaCons "UpperLimit" 'PrefixI 'True) (S1 ('MetaSel ('Just "upperLimit") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "ulConfidenceLevel") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (CL Double))))

newtype Vector (UpperLimit a) # |
Instance details Defined in Statistics.Types newtype Vector (UpperLimit a) = V_UpperLimit (Vector (a, CL Double))

data LowerLimit a #

Lower limit. They are usually given for large quantities when it's not possible to measure them. For example: proton half-life

Constructors

LowerLimit |

Fields

- lowerLimit :: !a

  Lower limit

- llConfidenceLevel :: !(CL Double)

  Confidence level for which limit was calculated

#### Instances

Instances details

Unbox a => Vector Vector (LowerLimit a) # |

Instance details

Defined in Statistics.Types

Methods

basicUnsafeFreeze :: Mutable Vector s (LowerLimit a) -> ST s (Vector (LowerLimit a))

basicUnsafeThaw :: Vector (LowerLimit a) -> ST s (Mutable Vector s (LowerLimit a))

basicLength :: Vector (LowerLimit a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (LowerLimit a) -> Vector (LowerLimit a)

basicUnsafeIndexM :: Vector (LowerLimit a) -> Int -> Box (LowerLimit a)

basicUnsafeCopy :: Mutable Vector s (LowerLimit a) -> Vector (LowerLimit a) -> ST s ()

elemseq :: Vector (LowerLimit a) -> LowerLimit a -> b -> b

Unbox a => MVector MVector (LowerLimit a) # |

Instance details

Defined in Statistics.Types

Methods

basicLength :: MVector s (LowerLimit a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (LowerLimit a) -> MVector s (LowerLimit a)

basicOverlaps :: MVector s (LowerLimit a) -> MVector s (LowerLimit a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (LowerLimit a))

basicInitialize :: MVector s (LowerLimit a) -> ST s ()

basicUnsafeReplicate :: Int -> LowerLimit a -> ST s (MVector s (LowerLimit a))

basicUnsafeRead :: MVector s (LowerLimit a) -> Int -> ST s (LowerLimit a)

basicUnsafeWrite :: MVector s (LowerLimit a) -> Int -> LowerLimit a -> ST s ()

basicClear :: MVector s (LowerLimit a) -> ST s ()

basicSet :: MVector s (LowerLimit a) -> LowerLimit a -> ST s ()

basicUnsafeCopy :: MVector s (LowerLimit a) -> MVector s (LowerLimit a) -> ST s ()

basicUnsafeMove :: MVector s (LowerLimit a) -> MVector s (LowerLimit a) -> ST s ()

basicUnsafeGrow :: MVector s (LowerLimit a) -> Int -> ST s (MVector s (LowerLimit a))

FromJSON a => FromJSON (LowerLimit a) # |
Instance details Defined in Statistics.Types Methods parseJSON :: Value -> Parser (LowerLimit a) # parseJSONList :: Value -> Parser [LowerLimit a] # omittedField :: Maybe (LowerLimit a) #
ToJSON a => ToJSON (LowerLimit a) # |
Instance details Defined in Statistics.Types Methods toJSON :: LowerLimit a -> Value # toEncoding :: LowerLimit a -> Encoding # toJSONList :: [LowerLimit a] -> Value # toEncodingList :: [LowerLimit a] -> Encoding # omitField :: LowerLimit a -> Bool #
Binary a => Binary (LowerLimit a) # |
Instance details Defined in Statistics.Types Methods put :: LowerLimit a -> Put # get :: Get (LowerLimit a) # putList :: [LowerLimit a] -> Put #
NFData a => NFData (LowerLimit a) # |
Instance details Defined in Statistics.Types Methods rnf :: LowerLimit a -> () #
Data a => Data (LowerLimit a) # |

Instance details

Defined in Statistics.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LowerLimit a -> c (LowerLimit a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LowerLimit a) #

toConstr :: LowerLimit a -> Constr #

dataTypeOf :: LowerLimit a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LowerLimit a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LowerLimit a)) #

gmapT :: (forall b. Data b => b -> b) -> LowerLimit a -> LowerLimit a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LowerLimit a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LowerLimit a -> r #

gmapQ :: (forall d. Data d => d -> u) -> LowerLimit a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LowerLimit a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LowerLimit a -> m (LowerLimit a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LowerLimit a -> m (LowerLimit a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LowerLimit a -> m (LowerLimit a) #

Generic (LowerLimit a) # |

Instance details

Defined in Statistics.Types

Associated Types

type Rep (LowerLimit a) |

Instance details

Defined in Statistics.Types

type Rep (LowerLimit a) = D1 ('MetaData "LowerLimit" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'False) (C1 ('MetaCons "LowerLimit" 'PrefixI 'True) (S1 ('MetaSel ('Just "lowerLimit") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "llConfidenceLevel") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (CL Double))))

Methods

from :: LowerLimit a -> Rep (LowerLimit a) x #

to :: Rep (LowerLimit a) x -> LowerLimit a #

Read a => Read (LowerLimit a) # |
Instance details Defined in Statistics.Types Methods readsPrec :: Int -> ReadS (LowerLimit a) # readList :: ReadS [LowerLimit a] # readPrec :: ReadPrec (LowerLimit a) # readListPrec :: ReadPrec [LowerLimit a] #
Show a => Show (LowerLimit a) # |
Instance details Defined in Statistics.Types Methods showsPrec :: Int -> LowerLimit a -> ShowS # show :: LowerLimit a -> String # showList :: [LowerLimit a] -> ShowS #
Eq a => Eq (LowerLimit a) # |
Instance details Defined in Statistics.Types Methods (==) :: LowerLimit a -> LowerLimit a -> Bool # (/=) :: LowerLimit a -> LowerLimit a -> Bool #
Unbox a => Unbox (LowerLimit a) # |
Instance details Defined in Statistics.Types
newtype MVector s (LowerLimit a) # |
Instance details Defined in Statistics.Types newtype MVector s (LowerLimit a) = MV_LowerLimit (MVector s (a, CL Double))
type Rep (LowerLimit a) # |

Instance details

Defined in Statistics.Types

type Rep (LowerLimit a) = D1 ('MetaData "LowerLimit" "Statistics.Types" "statistics-0.16.3.0-JhFVwN7Kv9y2XSvDlj54t" 'False) (C1 ('MetaCons "LowerLimit" 'PrefixI 'True) (S1 ('MetaSel ('Just "lowerLimit") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "llConfidenceLevel") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (CL Double))))

newtype Vector (LowerLimit a) # |
Instance details Defined in Statistics.Types newtype Vector (LowerLimit a) = V_LowerLimit (Vector (a, CL Double))

## Constructors

estimateNormErr #

Arguments

:: a | Point estimate
-> a | 1σ error
-> Estimate NormalErr a |

Create estimate with normal errors

(±) #

Arguments

:: a | Point estimate
-> a | 1σ error
-> Estimate NormalErr a |

Synonym for `estimateNormErr`

estimateFromInterval #

Arguments

:: Num a |
=> a | Point estimate. Should lie within interval but it's not checked.
-> (a, a) | Lower and upper bounds of interval
-> CL Double | Confidence level for interval
-> Estimate ConfInt a |

Create estimate with asymmetric error.

estimateFromErr #

Arguments

:: a | Central estimate
-> (a, a) | Lower and upper errors. Both should be positive but it's not checked.
-> CL Double | Confidence level for interval
-> Estimate ConfInt a |

Create estimate with asymmetric error.

## Accessors

confidenceInterval :: Num a => Estimate ConfInt a -> (a, a) #

Get confidence interval

asymErrors :: Estimate ConfInt a -> (a, a) #

Get asymmetric errors

class Scale (e :: Type -> Type) where #

Data types which could be multiplied by constant.

Methods

scale :: (Ord a, Num a) => a -> e a -> e a #

#### Instances

Instances details

Scale ConfInt # |
Instance details Defined in Statistics.Types Methods scale :: (Ord a, Num a) => a -> ConfInt a -> ConfInt a #
Scale NormalErr # |
Instance details Defined in Statistics.Types Methods scale :: (Ord a, Num a) => a -> NormalErr a -> NormalErr a #
Scale e => Scale (Estimate e) # |
Instance details Defined in Statistics.Types Methods scale :: (Ord a, Num a) => a -> Estimate e a -> Estimate e a #

# Other

type Sample = Vector Double #

Sample data.

type WeightedSample = Vector (Double, Double) #

Sample with weights. First element of sample is data, second is weight

type Weights = Vector Double #

Weights for affecting the importance of elements of a sample.