Copyright | (c) 2009 Bryan O'Sullivan |
---|---|
License | BSD3 |
Maintainer | bos@serpentine.com |
Stability | experimental |
Portability | portable |
Safe Haskell | None |
Language | Haskell98 |
Statistics.Types
Contents
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 a = Estimate {}
- 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 where
- type Sample = Vector Double
- type WeightedSample = Vector (Double, Double)
- type Weights = Vector Double
Confidence level
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 0.05
Prior to 0.14 confidence levels were passed to function as plain
Doubles
. Use mkCL
to convert them to CL
.
Instances
Unbox a => MVector MVector (CL a) Source # | |
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 :: PrimMonad m => Int -> m (MVector (PrimState m) (CL a)) basicInitialize :: PrimMonad m => MVector (PrimState m) (CL a) -> m () basicUnsafeReplicate :: PrimMonad m => Int -> CL a -> m (MVector (PrimState m) (CL a)) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (CL a) -> Int -> m (CL a) basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (CL a) -> Int -> CL a -> m () basicClear :: PrimMonad m => MVector (PrimState m) (CL a) -> m () basicSet :: PrimMonad m => MVector (PrimState m) (CL a) -> CL a -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (CL a) -> MVector (PrimState m) (CL a) -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (CL a) -> MVector (PrimState m) (CL a) -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (CL a) -> Int -> m (MVector (PrimState m) (CL a)) | |
Unbox a => Vector Vector (CL a) Source # | |
Defined in Statistics.Types Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (CL a) -> m (Vector (CL a)) basicUnsafeThaw :: PrimMonad m => Vector (CL a) -> m (Mutable Vector (PrimState m) (CL a)) basicLength :: Vector (CL a) -> Int basicUnsafeSlice :: Int -> Int -> Vector (CL a) -> Vector (CL a) basicUnsafeIndexM :: Monad m => Vector (CL a) -> Int -> m (CL a) basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (CL a) -> Vector (CL a) -> m () | |
Eq a => Eq (CL a) Source # | |
Data a => Data (CL a) Source # | |
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) # 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 :: (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) # | |
Ord a => Ord (CL a) Source # |
|
(Num a, Ord a, Read a) => Read (CL a) Source # | |
Show a => Show (CL a) Source # | |
Generic (CL a) Source # | |
ToJSON a => ToJSON (CL a) Source # | |
Defined in Statistics.Types | |
(FromJSON a, Num a, Ord a) => FromJSON (CL a) Source # | |
(Binary a, Num a, Ord a) => Binary (CL a) Source # | |
NFData a => NFData (CL a) Source # | |
Defined in Statistics.Types | |
Unbox a => Unbox (CL a) Source # | |
Defined in Statistics.Types | |
data MVector s (CL a) Source # | |
Defined in Statistics.Types | |
type Rep (CL a) Source # | |
Defined in Statistics.Types | |
data Vector (CL a) Source # | |
Defined in Statistics.Types |
Accessors
confidenceLevel :: Num a => CL a -> a Source #
Get confidence level. This function is subject to rounding
errors. If 1 - CL
is needed use significanceLevel
instead
significanceLevel :: CL a -> a Source #
Get significance level.
Constructors
mkCL :: (Ord a, Num a) => a -> CL a Source #
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 0.05
mkCLE :: (Ord a, Num a) => a -> Maybe (CL a) Source #
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 0.05)
mkCLFromSignificance :: (Ord a, Num a) => a -> CL a Source #
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 0.05
mkCLFromSignificanceE :: (Ord a, Num a) => a -> Maybe (CL a) Source #
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 0.05)
Constants and conversion to nσ
cl90 :: Fractional a => CL a Source #
90% confidence level
cl95 :: Fractional a => CL a Source #
95% confidence level
cl99 :: Fractional a => CL a Source #
99% confidence level
Normal approximation
nSigma :: Double -> PValue Double Source #
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 Source #
P-value expressed in sigma for one-tail hypothesis. This correspond to
probability of obtaining value less than N·σ
.
getNSigma1 :: PValue Double -> Double Source #
Express confidence level in sigmas for one-tailed hypothesis.
p-value
Newtype wrapper for p-value.
Instances
Unbox a => MVector MVector (PValue a) Source # | |
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 :: PrimMonad m => Int -> m (MVector (PrimState m) (PValue a)) basicInitialize :: PrimMonad m => MVector (PrimState m) (PValue a) -> m () basicUnsafeReplicate :: PrimMonad m => Int -> PValue a -> m (MVector (PrimState m) (PValue a)) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (PValue a) -> Int -> m (PValue a) basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (PValue a) -> Int -> PValue a -> m () basicClear :: PrimMonad m => MVector (PrimState m) (PValue a) -> m () basicSet :: PrimMonad m => MVector (PrimState m) (PValue a) -> PValue a -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (PValue a) -> MVector (PrimState m) (PValue a) -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (PValue a) -> MVector (PrimState m) (PValue a) -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (PValue a) -> Int -> m (MVector (PrimState m) (PValue a)) | |
Unbox a => Vector Vector (PValue a) Source # | |
Defined in Statistics.Types Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (PValue a) -> m (Vector (PValue a)) basicUnsafeThaw :: PrimMonad m => Vector (PValue a) -> m (Mutable Vector (PrimState m) (PValue a)) basicLength :: Vector (PValue a) -> Int basicUnsafeSlice :: Int -> Int -> Vector (PValue a) -> Vector (PValue a) basicUnsafeIndexM :: Monad m => Vector (PValue a) -> Int -> m (PValue a) basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (PValue a) -> Vector (PValue a) -> m () | |
Eq a => Eq (PValue a) Source # | |
Data a => Data (PValue a) Source # | |
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 :: (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) # | |
Ord a => Ord (PValue a) Source # | |
Defined in Statistics.Types | |
(Num a, Ord a, Read a) => Read (PValue a) Source # | |
Show a => Show (PValue a) Source # | |
Generic (PValue a) Source # | |
ToJSON a => ToJSON (PValue a) Source # | |
Defined in Statistics.Types | |
(FromJSON a, Num a, Ord a) => FromJSON (PValue a) Source # | |
(Binary a, Num a, Ord a) => Binary (PValue a) Source # | |
NFData a => NFData (PValue a) Source # | |
Defined in Statistics.Types | |
Unbox a => Unbox (PValue a) Source # | |
Defined in Statistics.Types | |
data MVector s (PValue a) Source # | |
Defined in Statistics.Types | |
type Rep (PValue a) Source # | |
Defined in Statistics.Types | |
data Vector (PValue a) Source # | |
Defined in Statistics.Types |
Accessors
Constructors
mkPValue :: (Ord a, Num a) => a -> PValue a Source #
Construct PValue. Throws error if argument is out of [0,1] range.
mkPValueE :: (Ord a, Num a) => a -> Maybe (PValue a) Source #
Construct PValue. Returns Nothing
if argument is out of [0,1] range.
Estimates and upper/lower limits
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 | |
Instances
(Unbox a, Unbox (e a)) => MVector MVector (Estimate e a) Source # | |
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 :: PrimMonad m => Int -> m (MVector (PrimState m) (Estimate e a)) basicInitialize :: PrimMonad m => MVector (PrimState m) (Estimate e a) -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Estimate e a -> m (MVector (PrimState m) (Estimate e a)) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Estimate e a) -> Int -> m (Estimate e a) basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Estimate e a) -> Int -> Estimate e a -> m () basicClear :: PrimMonad m => MVector (PrimState m) (Estimate e a) -> m () basicSet :: PrimMonad m => MVector (PrimState m) (Estimate e a) -> Estimate e a -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Estimate e a) -> MVector (PrimState m) (Estimate e a) -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Estimate e a) -> MVector (PrimState m) (Estimate e a) -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Estimate e a) -> Int -> m (MVector (PrimState m) (Estimate e a)) | |
(Unbox a, Unbox (e a)) => Vector Vector (Estimate e a) Source # | |
Defined in Statistics.Types Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Estimate e a) -> m (Vector (Estimate e a)) basicUnsafeThaw :: PrimMonad m => Vector (Estimate e a) -> m (Mutable Vector (PrimState m) (Estimate e a)) basicLength :: Vector (Estimate e a) -> Int basicUnsafeSlice :: Int -> Int -> Vector (Estimate e a) -> Vector (Estimate e a) basicUnsafeIndexM :: Monad m => Vector (Estimate e a) -> Int -> m (Estimate e a) basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Estimate e a) -> Vector (Estimate e a) -> m () | |
Scale e => Scale (Estimate e) Source # | |
(Eq a, Eq (e a)) => Eq (Estimate e a) Source # | |
(Typeable e, Data a, Data (e a)) => Data (Estimate e a) Source # | |
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 :: (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) # | |
(Read a, Read (e a)) => Read (Estimate e a) Source # | |
(Show a, Show (e a)) => Show (Estimate e a) Source # | |
Generic (Estimate e a) Source # | |
(ToJSON (e a), ToJSON a) => ToJSON (Estimate e a) Source # | |
Defined in Statistics.Types | |
(FromJSON (e a), FromJSON a) => FromJSON (Estimate e a) Source # | |
(Binary (e a), Binary a) => Binary (Estimate e a) Source # | |
(NFData (e a), NFData a) => NFData (Estimate e a) Source # | |
Defined in Statistics.Types | |
(Unbox a, Unbox (e a)) => Unbox (Estimate e a) Source # | |
Defined in Statistics.Types | |
data MVector s (Estimate e a) Source # | |
Defined in Statistics.Types | |
type Rep (Estimate e a) Source # | |
Defined in Statistics.Types type Rep (Estimate e a) = D1 (MetaData "Estimate" "Statistics.Types" "statistics-0.14.0.2-BDKqksdEpEI86sJmTEeZh7" 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)))) | |
data Vector (Estimate e a) Source # | |
Defined in Statistics.Types |
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
|
Instances
Scale NormalErr Source # | |
Unbox a => MVector MVector (NormalErr a) Source # | |
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 :: PrimMonad m => Int -> m (MVector (PrimState m) (NormalErr a)) basicInitialize :: PrimMonad m => MVector (PrimState m) (NormalErr a) -> m () basicUnsafeReplicate :: PrimMonad m => Int -> NormalErr a -> m (MVector (PrimState m) (NormalErr a)) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (NormalErr a) -> Int -> m (NormalErr a) basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (NormalErr a) -> Int -> NormalErr a -> m () basicClear :: PrimMonad m => MVector (PrimState m) (NormalErr a) -> m () basicSet :: PrimMonad m => MVector (PrimState m) (NormalErr a) -> NormalErr a -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (NormalErr a) -> MVector (PrimState m) (NormalErr a) -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (NormalErr a) -> MVector (PrimState m) (NormalErr a) -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (NormalErr a) -> Int -> m (MVector (PrimState m) (NormalErr a)) | |
Unbox a => Vector Vector (NormalErr a) Source # | |
Defined in Statistics.Types Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (NormalErr a) -> m (Vector (NormalErr a)) basicUnsafeThaw :: PrimMonad m => Vector (NormalErr a) -> m (Mutable Vector (PrimState m) (NormalErr a)) basicLength :: Vector (NormalErr a) -> Int basicUnsafeSlice :: Int -> Int -> Vector (NormalErr a) -> Vector (NormalErr a) basicUnsafeIndexM :: Monad m => Vector (NormalErr a) -> Int -> m (NormalErr a) basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (NormalErr a) -> Vector (NormalErr a) -> m () | |
Eq a => Eq (NormalErr a) Source # | |
Data a => Data (NormalErr a) Source # | |
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 :: (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) # | |
Read a => Read (NormalErr a) Source # | |
Show a => Show (NormalErr a) Source # | |
Generic (NormalErr a) Source # | |
ToJSON a => ToJSON (NormalErr a) Source # | |
Defined in Statistics.Types | |
FromJSON a => FromJSON (NormalErr a) Source # | |
Binary a => Binary (NormalErr a) Source # | |
NFData a => NFData (NormalErr a) Source # | |
Defined in Statistics.Types | |
Unbox a => Unbox (NormalErr a) Source # | |
Defined in Statistics.Types | |
data MVector s (NormalErr a) Source # | |
Defined in Statistics.Types | |
type Rep (NormalErr a) Source # | |
Defined in Statistics.Types | |
data Vector (NormalErr a) Source # | |
Defined in Statistics.Types |
Confidence interval. It assumes that confidence interval forms single interval and isn't set of disjoint intervals.
Constructors
ConfInt | |
Fields
|
Instances
Scale ConfInt Source # | |
Unbox a => MVector MVector (ConfInt a) Source # | |
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 :: PrimMonad m => Int -> m (MVector (PrimState m) (ConfInt a)) basicInitialize :: PrimMonad m => MVector (PrimState m) (ConfInt a) -> m () basicUnsafeReplicate :: PrimMonad m => Int -> ConfInt a -> m (MVector (PrimState m) (ConfInt a)) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (ConfInt a) -> Int -> m (ConfInt a) basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (ConfInt a) -> Int -> ConfInt a -> m () basicClear :: PrimMonad m => MVector (PrimState m) (ConfInt a) -> m () basicSet :: PrimMonad m => MVector (PrimState m) (ConfInt a) -> ConfInt a -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (ConfInt a) -> MVector (PrimState m) (ConfInt a) -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (ConfInt a) -> MVector (PrimState m) (ConfInt a) -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (ConfInt a) -> Int -> m (MVector (PrimState m) (ConfInt a)) | |
Unbox a => Vector Vector (ConfInt a) Source # | |
Defined in Statistics.Types Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (ConfInt a) -> m (Vector (ConfInt a)) basicUnsafeThaw :: PrimMonad m => Vector (ConfInt a) -> m (Mutable Vector (PrimState m) (ConfInt a)) basicLength :: Vector (ConfInt a) -> Int basicUnsafeSlice :: Int -> Int -> Vector (ConfInt a) -> Vector (ConfInt a) basicUnsafeIndexM :: Monad m => Vector (ConfInt a) -> Int -> m (ConfInt a) basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (ConfInt a) -> Vector (ConfInt a) -> m () | |
Eq a => Eq (ConfInt a) Source # | |
Data a => Data (ConfInt a) Source # | |
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 :: (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) # | |
Read a => Read (ConfInt a) Source # | |
Show a => Show (ConfInt a) Source # | |
Generic (ConfInt a) Source # | |
ToJSON a => ToJSON (ConfInt a) Source # | |
Defined in Statistics.Types | |
FromJSON a => FromJSON (ConfInt a) Source # | |
Binary a => Binary (ConfInt a) Source # | |
NFData a => NFData (ConfInt a) Source # | |
Defined in Statistics.Types | |
Unbox a => Unbox (ConfInt a) Source # | |
Defined in Statistics.Types | |
data MVector s (ConfInt a) Source # | |
Defined in Statistics.Types | |
type Rep (ConfInt a) Source # | |
Defined in Statistics.Types type Rep (ConfInt a) = D1 (MetaData "ConfInt" "Statistics.Types" "statistics-0.14.0.2-BDKqksdEpEI86sJmTEeZh7" 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))))) | |
data Vector (ConfInt a) Source # | |
Defined in Statistics.Types |
data UpperLimit a Source #
Upper limit. They are usually given for small non-negative values when it's not possible detect difference from zero.
Constructors
UpperLimit | |
Fields
|
Instances
data LowerLimit a Source #
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
|
Instances
Constructors
Create estimate with normal errors
Synonym for estimateNormErr
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.
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
asymErrors :: Estimate ConfInt a -> (a, a) Source #
Get asymmetric errors
Data types which could be multiplied by constant.
Minimal complete definition
Other
type WeightedSample = Vector (Double, Double) Source #
Sample with weights. First element of sample is data, second is weight