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

Copyright (c) 2009 Bryan O'Sullivan BSD3 bos@serpentine.com experimental portable None Haskell98

Statistics.Types

Description

Data types common used in statistics

Synopsis

# Confidence level

data CL a Source #

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 a0 => Vector Vector (CL a0) Source # MethodsbasicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (CL a0) -> m (Vector (CL a0)) #basicUnsafeThaw :: PrimMonad m => Vector (CL a0) -> m (Mutable Vector (PrimState m) (CL a0)) #basicLength :: Vector (CL a0) -> Int #basicUnsafeSlice :: Int -> Int -> Vector (CL a0) -> Vector (CL a0) #basicUnsafeIndexM :: Monad m => Vector (CL a0) -> Int -> m (CL a0) #basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (CL a0) -> Vector (CL a0) -> m () #elemseq :: Vector (CL a0) -> CL a0 -> b -> b # Unbox a0 => MVector MVector (CL a0) Source # MethodsbasicLength :: MVector s (CL a0) -> Int #basicUnsafeSlice :: Int -> Int -> MVector s (CL a0) -> MVector s (CL a0) #basicOverlaps :: MVector s (CL a0) -> MVector s (CL a0) -> Bool #basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (CL a0)) #basicInitialize :: PrimMonad m => MVector (PrimState m) (CL a0) -> m () #basicUnsafeReplicate :: PrimMonad m => Int -> CL a0 -> m (MVector (PrimState m) (CL a0)) #basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (CL a0) -> Int -> m (CL a0) #basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (CL a0) -> Int -> CL a0 -> m () #basicClear :: PrimMonad m => MVector (PrimState m) (CL a0) -> m () #basicSet :: PrimMonad m => MVector (PrimState m) (CL a0) -> CL a0 -> m () #basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (CL a0) -> MVector (PrimState m) (CL a0) -> m () #basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (CL a0) -> MVector (PrimState m) (CL a0) -> m () #basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (CL a0) -> Int -> m (MVector (PrimState m) (CL a0)) # Eq a => Eq (CL a) Source # Methods(==) :: CL a -> CL a -> Bool #(/=) :: CL a -> CL a -> Bool # Data a => Data (CL a) Source # Methodsgfoldl :: (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 :: (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 # >>> cl95 > cl90 True Methodscompare :: 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 # (Num a, Ord a, Read a) => Read (CL a) Source # MethodsreadsPrec :: Int -> ReadS (CL a) #readList :: ReadS [CL a] #readPrec :: ReadPrec (CL a) # Show a => Show (CL a) Source # MethodsshowsPrec :: Int -> CL a -> ShowS #show :: CL a -> String #showList :: [CL a] -> ShowS # Generic (CL a) Source # Associated Typestype Rep (CL a) :: * -> * # Methodsfrom :: CL a -> Rep (CL a) x #to :: Rep (CL a) x -> CL a # NFData a => NFData (CL a) Source # Methodsrnf :: CL a -> () # ToJSON a => ToJSON (CL a) Source # MethodstoJSON :: CL a -> Value #toEncoding :: CL a -> Encoding #toJSONList :: [CL a] -> Value #toEncodingList :: [CL a] -> Encoding # (FromJSON a, Num a, Ord a) => FromJSON (CL a) Source # MethodsparseJSON :: Value -> Parser (CL a) #parseJSONList :: Value -> Parser [CL a] # (Binary a, Num a, Ord a) => Binary (CL a) Source # Methodsput :: CL a -> Put #get :: Get (CL a) #putList :: [CL a] -> Put # Unbox a0 => Unbox (CL a0) Source # data MVector s (CL a0) Source # data MVector s (CL a0) = MV_CL (MVector s a) type Rep (CL a) Source # type Rep (CL a) = D1 (MetaData "CL" "Statistics.Types" "statistics-0.14.0.0-9xPMo3QbnR7BEP0FkvUcUB" True) (C1 (MetaCons "CL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) data Vector (CL a0) Source # data Vector (CL a0) = V_CL (Vector a)

## 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

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).

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

Express confidence level in sigmas

Express confidence level in sigmas for one-tailed hypothesis.

# p-value

data PValue a Source #

Newtype wrapper for p-value.

Instances

 Unbox a0 => Vector Vector (PValue a0) Source # MethodsbasicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (PValue a0) -> m (Vector (PValue a0)) #basicUnsafeThaw :: PrimMonad m => Vector (PValue a0) -> m (Mutable Vector (PrimState m) (PValue a0)) #basicLength :: Vector (PValue a0) -> Int #basicUnsafeSlice :: Int -> Int -> Vector (PValue a0) -> Vector (PValue a0) #basicUnsafeIndexM :: Monad m => Vector (PValue a0) -> Int -> m (PValue a0) #basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (PValue a0) -> Vector (PValue a0) -> m () #elemseq :: Vector (PValue a0) -> PValue a0 -> b -> b # Unbox a0 => MVector MVector (PValue a0) Source # MethodsbasicLength :: MVector s (PValue a0) -> Int #basicUnsafeSlice :: Int -> Int -> MVector s (PValue a0) -> MVector s (PValue a0) #basicOverlaps :: MVector s (PValue a0) -> MVector s (PValue a0) -> Bool #basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (PValue a0)) #basicInitialize :: PrimMonad m => MVector (PrimState m) (PValue a0) -> m () #basicUnsafeReplicate :: PrimMonad m => Int -> PValue a0 -> m (MVector (PrimState m) (PValue a0)) #basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (PValue a0) -> Int -> m (PValue a0) #basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (PValue a0) -> Int -> PValue a0 -> m () #basicClear :: PrimMonad m => MVector (PrimState m) (PValue a0) -> m () #basicSet :: PrimMonad m => MVector (PrimState m) (PValue a0) -> PValue a0 -> m () #basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (PValue a0) -> MVector (PrimState m) (PValue a0) -> m () #basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (PValue a0) -> MVector (PrimState m) (PValue a0) -> m () #basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (PValue a0) -> Int -> m (MVector (PrimState m) (PValue a0)) # Eq a => Eq (PValue a) Source # Methods(==) :: PValue a -> PValue a -> Bool #(/=) :: PValue a -> PValue a -> Bool # Data a => Data (PValue a) Source # Methodsgfoldl :: (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 #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 # Methodscompare :: 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 # (Num a, Ord a, Read a) => Read (PValue a) Source # MethodsreadsPrec :: Int -> ReadS (PValue a) #readList :: ReadS [PValue a] # Show a => Show (PValue a) Source # MethodsshowsPrec :: Int -> PValue a -> ShowS #show :: PValue a -> String #showList :: [PValue a] -> ShowS # Source # Associated Typestype Rep (PValue a) :: * -> * # Methodsfrom :: PValue a -> Rep (PValue a) x #to :: Rep (PValue a) x -> PValue a # NFData a => NFData (PValue a) Source # Methodsrnf :: PValue a -> () # ToJSON a => ToJSON (PValue a) Source # MethodstoJSON :: PValue a -> Value #toJSONList :: [PValue a] -> Value #toEncodingList :: [PValue a] -> Encoding # (FromJSON a, Num a, Ord a) => FromJSON (PValue a) Source # MethodsparseJSON :: Value -> Parser (PValue a) # (Binary a, Num a, Ord a) => Binary (PValue a) Source # Methodsput :: PValue a -> Put #get :: Get (PValue a) #putList :: [PValue a] -> Put # Unbox a0 => Unbox (PValue a0) Source # data MVector s (PValue a0) Source # data MVector s (PValue a0) = MV_PValue (MVector s a) type Rep (PValue a) Source # type Rep (PValue a) = D1 (MetaData "PValue" "Statistics.Types" "statistics-0.14.0.0-9xPMo3QbnR7BEP0FkvUcUB" True) (C1 (MetaCons "PValue" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) data Vector (PValue a0) Source # data Vector (PValue a0) = V_PValue (Vector a)

## Accessors

pValue :: PValue a -> a Source #

Get p-value

## 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

data Estimate e a Source #

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 FieldsestPoint :: !aPoint estimate.estError :: !(e a)Confidence interval for estimate.

Instances

 (Unbox a0, Unbox (e0 a0)) => Vector Vector (Estimate e0 a0) Source # MethodsbasicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Estimate e0 a0) -> m (Vector (Estimate e0 a0)) #basicUnsafeThaw :: PrimMonad m => Vector (Estimate e0 a0) -> m (Mutable Vector (PrimState m) (Estimate e0 a0)) #basicLength :: Vector (Estimate e0 a0) -> Int #basicUnsafeSlice :: Int -> Int -> Vector (Estimate e0 a0) -> Vector (Estimate e0 a0) #basicUnsafeIndexM :: Monad m => Vector (Estimate e0 a0) -> Int -> m (Estimate e0 a0) #basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Estimate e0 a0) -> Vector (Estimate e0 a0) -> m () #elemseq :: Vector (Estimate e0 a0) -> Estimate e0 a0 -> b -> b # (Unbox a0, Unbox (e0 a0)) => MVector MVector (Estimate e0 a0) Source # MethodsbasicLength :: MVector s (Estimate e0 a0) -> Int #basicUnsafeSlice :: Int -> Int -> MVector s (Estimate e0 a0) -> MVector s (Estimate e0 a0) #basicOverlaps :: MVector s (Estimate e0 a0) -> MVector s (Estimate e0 a0) -> Bool #basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Estimate e0 a0)) #basicInitialize :: PrimMonad m => MVector (PrimState m) (Estimate e0 a0) -> m () #basicUnsafeReplicate :: PrimMonad m => Int -> Estimate e0 a0 -> m (MVector (PrimState m) (Estimate e0 a0)) #basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Estimate e0 a0) -> Int -> m (Estimate e0 a0) #basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Estimate e0 a0) -> Int -> Estimate e0 a0 -> m () #basicClear :: PrimMonad m => MVector (PrimState m) (Estimate e0 a0) -> m () #basicSet :: PrimMonad m => MVector (PrimState m) (Estimate e0 a0) -> Estimate e0 a0 -> m () #basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Estimate e0 a0) -> MVector (PrimState m) (Estimate e0 a0) -> m () #basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Estimate e0 a0) -> MVector (PrimState m) (Estimate e0 a0) -> m () #basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Estimate e0 a0) -> Int -> m (MVector (PrimState m) (Estimate e0 a0)) # Scale e => Scale (Estimate e) Source # Methodsscale :: (Ord a, Num a) => a -> Estimate e a -> Estimate e a Source # (Eq (e a), Eq a) => Eq (Estimate e a) Source # Methods(==) :: Estimate e a -> Estimate e a -> Bool #(/=) :: Estimate e a -> Estimate e a -> Bool # (Data (e a), Data a, Typeable (* -> *) e) => Data (Estimate e a) Source # Methodsgfoldl :: (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 b. (Data d, Data b) => c (t d b)) -> 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 (e a), Read a) => Read (Estimate e a) Source # MethodsreadsPrec :: Int -> ReadS (Estimate e a) #readList :: ReadS [Estimate e a] #readPrec :: ReadPrec (Estimate e a) # (Show (e a), Show a) => Show (Estimate e a) Source # MethodsshowsPrec :: Int -> Estimate e a -> ShowS #show :: Estimate e a -> String #showList :: [Estimate e a] -> ShowS # Generic (Estimate e a) Source # Associated Typestype Rep (Estimate e a) :: * -> * # Methodsfrom :: Estimate e a -> Rep (Estimate e a) x #to :: Rep (Estimate e a) x -> Estimate e a # (NFData (e a), NFData a) => NFData (Estimate e a) Source # Methodsrnf :: Estimate e a -> () # (ToJSON (e a), ToJSON a) => ToJSON (Estimate e a) Source # MethodstoJSON :: Estimate e a -> Value #toEncoding :: Estimate e a -> Encoding #toJSONList :: [Estimate e a] -> Value #toEncodingList :: [Estimate e a] -> Encoding # (FromJSON (e a), FromJSON a) => FromJSON (Estimate e a) Source # MethodsparseJSON :: Value -> Parser (Estimate e a) #parseJSONList :: Value -> Parser [Estimate e a] # (Binary (e a), Binary a) => Binary (Estimate e a) Source # Methodsput :: Estimate e a -> Put #get :: Get (Estimate e a) #putList :: [Estimate e a] -> Put # (Unbox a0, Unbox (e0 a0)) => Unbox (Estimate e0 a0) Source # data MVector s (Estimate e0 a0) Source # data MVector s (Estimate e0 a0) = MV_Estimate (MVector s (a, e a)) type Rep (Estimate e a) Source # type Rep (Estimate e a) = D1 (MetaData "Estimate" "Statistics.Types" "statistics-0.14.0.0-9xPMo3QbnR7BEP0FkvUcUB" False) (C1 (MetaCons "Estimate" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "estPoint") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Just Symbol "estError") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (e a))))) data Vector (Estimate e0 a0) Source # data Vector (Estimate e0 a0) = V_Estimate (Vector (a, e a))

newtype NormalErr a Source #

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 FieldsnormalError :: a

Instances

 Source # Methodsscale :: (Ord a, Num a) => a -> NormalErr a -> NormalErr a Source # Unbox a0 => Vector Vector (NormalErr a0) Source # MethodsbasicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (NormalErr a0) -> m (Vector (NormalErr a0)) #basicUnsafeThaw :: PrimMonad m => Vector (NormalErr a0) -> m (Mutable Vector (PrimState m) (NormalErr a0)) #basicLength :: Vector (NormalErr a0) -> Int #basicUnsafeSlice :: Int -> Int -> Vector (NormalErr a0) -> Vector (NormalErr a0) #basicUnsafeIndexM :: Monad m => Vector (NormalErr a0) -> Int -> m (NormalErr a0) #basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (NormalErr a0) -> Vector (NormalErr a0) -> m () #elemseq :: Vector (NormalErr a0) -> NormalErr a0 -> b -> b # Unbox a0 => MVector MVector (NormalErr a0) Source # MethodsbasicLength :: MVector s (NormalErr a0) -> Int #basicUnsafeSlice :: Int -> Int -> MVector s (NormalErr a0) -> MVector s (NormalErr a0) #basicOverlaps :: MVector s (NormalErr a0) -> MVector s (NormalErr a0) -> Bool #basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (NormalErr a0)) #basicInitialize :: PrimMonad m => MVector (PrimState m) (NormalErr a0) -> m () #basicUnsafeReplicate :: PrimMonad m => Int -> NormalErr a0 -> m (MVector (PrimState m) (NormalErr a0)) #basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (NormalErr a0) -> Int -> m (NormalErr a0) #basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (NormalErr a0) -> Int -> NormalErr a0 -> m () #basicClear :: PrimMonad m => MVector (PrimState m) (NormalErr a0) -> m () #basicSet :: PrimMonad m => MVector (PrimState m) (NormalErr a0) -> NormalErr a0 -> m () #basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (NormalErr a0) -> MVector (PrimState m) (NormalErr a0) -> m () #basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (NormalErr a0) -> MVector (PrimState m) (NormalErr a0) -> m () #basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (NormalErr a0) -> Int -> m (MVector (PrimState m) (NormalErr a0)) # Eq a => Eq (NormalErr a) Source # Methods(==) :: NormalErr a -> NormalErr a -> Bool #(/=) :: NormalErr a -> NormalErr a -> Bool # Data a => Data (NormalErr a) Source # Methodsgfoldl :: (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 #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 # MethodsreadsPrec :: Int -> ReadS (NormalErr a) # Show a => Show (NormalErr a) Source # MethodsshowsPrec :: Int -> NormalErr a -> ShowS #show :: NormalErr a -> String #showList :: [NormalErr a] -> ShowS # Source # Associated Typestype Rep (NormalErr a) :: * -> * # Methodsfrom :: NormalErr a -> Rep (NormalErr a) x #to :: Rep (NormalErr a) x -> NormalErr a # NFData a => NFData (NormalErr a) Source # Methodsrnf :: NormalErr a -> () # ToJSON a => ToJSON (NormalErr a) Source # MethodstoJSON :: NormalErr a -> Value #toJSONList :: [NormalErr a] -> Value #toEncodingList :: [NormalErr a] -> Encoding # FromJSON a => FromJSON (NormalErr a) Source # Methods Binary a => Binary (NormalErr a) Source # Methodsput :: NormalErr a -> Put #get :: Get (NormalErr a) #putList :: [NormalErr a] -> Put # Unbox a0 => Unbox (NormalErr a0) Source # data MVector s (NormalErr a0) Source # data MVector s (NormalErr a0) = MV_NormalErr (MVector s a) type Rep (NormalErr a) Source # type Rep (NormalErr a) = D1 (MetaData "NormalErr" "Statistics.Types" "statistics-0.14.0.0-9xPMo3QbnR7BEP0FkvUcUB" True) (C1 (MetaCons "NormalErr" PrefixI True) (S1 (MetaSel (Just Symbol "normalError") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) data Vector (NormalErr a0) Source # data Vector (NormalErr a0) = V_NormalErr (Vector a)

data ConfInt a Source #

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

Constructors

 ConfInt FieldsconfIntLDX :: !aLower error estimate, or distance between point estimate and lower bound of confidence interval.confIntUDX :: !aUpper error estimate, or distance between point estimate and upper bound of confidence interval.confIntCL :: !(CL Double)Confidence level corresponding to given confidence interval.

Instances

 Source # Methodsscale :: (Ord a, Num a) => a -> ConfInt a -> ConfInt a Source # Unbox a0 => Vector Vector (ConfInt a0) Source # MethodsbasicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (ConfInt a0) -> m (Vector (ConfInt a0)) #basicUnsafeThaw :: PrimMonad m => Vector (ConfInt a0) -> m (Mutable Vector (PrimState m) (ConfInt a0)) #basicLength :: Vector (ConfInt a0) -> Int #basicUnsafeSlice :: Int -> Int -> Vector (ConfInt a0) -> Vector (ConfInt a0) #basicUnsafeIndexM :: Monad m => Vector (ConfInt a0) -> Int -> m (ConfInt a0) #basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (ConfInt a0) -> Vector (ConfInt a0) -> m () #elemseq :: Vector (ConfInt a0) -> ConfInt a0 -> b -> b # Unbox a0 => MVector MVector (ConfInt a0) Source # MethodsbasicLength :: MVector s (ConfInt a0) -> Int #basicUnsafeSlice :: Int -> Int -> MVector s (ConfInt a0) -> MVector s (ConfInt a0) #basicOverlaps :: MVector s (ConfInt a0) -> MVector s (ConfInt a0) -> Bool #basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (ConfInt a0)) #basicInitialize :: PrimMonad m => MVector (PrimState m) (ConfInt a0) -> m () #basicUnsafeReplicate :: PrimMonad m => Int -> ConfInt a0 -> m (MVector (PrimState m) (ConfInt a0)) #basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (ConfInt a0) -> Int -> m (ConfInt a0) #basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (ConfInt a0) -> Int -> ConfInt a0 -> m () #basicClear :: PrimMonad m => MVector (PrimState m) (ConfInt a0) -> m () #basicSet :: PrimMonad m => MVector (PrimState m) (ConfInt a0) -> ConfInt a0 -> m () #basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (ConfInt a0) -> MVector (PrimState m) (ConfInt a0) -> m () #basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (ConfInt a0) -> MVector (PrimState m) (ConfInt a0) -> m () #basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (ConfInt a0) -> Int -> m (MVector (PrimState m) (ConfInt a0)) # Eq a => Eq (ConfInt a) Source # Methods(==) :: ConfInt a -> ConfInt a -> Bool #(/=) :: ConfInt a -> ConfInt a -> Bool # Data a => Data (ConfInt a) Source # Methodsgfoldl :: (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 #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 # MethodsreadsPrec :: Int -> ReadS (ConfInt a) # Show a => Show (ConfInt a) Source # MethodsshowsPrec :: Int -> ConfInt a -> ShowS #show :: ConfInt a -> String #showList :: [ConfInt a] -> ShowS # Source # Associated Typestype Rep (ConfInt a) :: * -> * # Methodsfrom :: ConfInt a -> Rep (ConfInt a) x #to :: Rep (ConfInt a) x -> ConfInt a # NFData a => NFData (ConfInt a) Source # Methodsrnf :: ConfInt a -> () # ToJSON a => ToJSON (ConfInt a) Source # MethodstoJSON :: ConfInt a -> Value #toJSONList :: [ConfInt a] -> Value #toEncodingList :: [ConfInt a] -> Encoding # FromJSON a => FromJSON (ConfInt a) Source # MethodsparseJSON :: Value -> Parser (ConfInt a) # Binary a => Binary (ConfInt a) Source # Methodsput :: ConfInt a -> Put #get :: Get (ConfInt a) #putList :: [ConfInt a] -> Put # Unbox a0 => Unbox (ConfInt a0) Source # data MVector s (ConfInt a0) Source # data MVector s (ConfInt a0) = MV_ConfInt (MVector s (a, a, CL Double)) type Rep (ConfInt a) Source # type Rep (ConfInt a) = D1 (MetaData "ConfInt" "Statistics.Types" "statistics-0.14.0.0-9xPMo3QbnR7BEP0FkvUcUB" False) (C1 (MetaCons "ConfInt" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "confIntLDX") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Just Symbol "confIntUDX") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Just Symbol "confIntCL") NoSourceUnpackedness SourceStrict DecidedUnpack) (Rec0 (CL Double)))))) data Vector (ConfInt a0) Source # data Vector (ConfInt a0) = V_ConfInt (Vector (a, a, CL Double))

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 FieldsupperLimit :: !aUpper limitulConfidenceLevel :: !(CL Double)Confidence level for which limit was calculated

Instances

 Unbox a0 => Vector Vector (UpperLimit a0) Source # MethodsbasicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (UpperLimit a0) -> m (Vector (UpperLimit a0)) #basicUnsafeThaw :: PrimMonad m => Vector (UpperLimit a0) -> m (Mutable Vector (PrimState m) (UpperLimit a0)) #basicLength :: Vector (UpperLimit a0) -> Int #basicUnsafeSlice :: Int -> Int -> Vector (UpperLimit a0) -> Vector (UpperLimit a0) #basicUnsafeIndexM :: Monad m => Vector (UpperLimit a0) -> Int -> m (UpperLimit a0) #basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (UpperLimit a0) -> Vector (UpperLimit a0) -> m () #elemseq :: Vector (UpperLimit a0) -> UpperLimit a0 -> b -> b # Unbox a0 => MVector MVector (UpperLimit a0) Source # MethodsbasicLength :: MVector s (UpperLimit a0) -> Int #basicUnsafeSlice :: Int -> Int -> MVector s (UpperLimit a0) -> MVector s (UpperLimit a0) #basicOverlaps :: MVector s (UpperLimit a0) -> MVector s (UpperLimit a0) -> Bool #basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (UpperLimit a0)) #basicInitialize :: PrimMonad m => MVector (PrimState m) (UpperLimit a0) -> m () #basicUnsafeReplicate :: PrimMonad m => Int -> UpperLimit a0 -> m (MVector (PrimState m) (UpperLimit a0)) #basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (UpperLimit a0) -> Int -> m (UpperLimit a0) #basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (UpperLimit a0) -> Int -> UpperLimit a0 -> m () #basicClear :: PrimMonad m => MVector (PrimState m) (UpperLimit a0) -> m () #basicSet :: PrimMonad m => MVector (PrimState m) (UpperLimit a0) -> UpperLimit a0 -> m () #basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (UpperLimit a0) -> MVector (PrimState m) (UpperLimit a0) -> m () #basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (UpperLimit a0) -> MVector (PrimState m) (UpperLimit a0) -> m () #basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (UpperLimit a0) -> Int -> m (MVector (PrimState m) (UpperLimit a0)) # Eq a => Eq (UpperLimit a) Source # Methods(==) :: UpperLimit a -> UpperLimit a -> Bool #(/=) :: UpperLimit a -> UpperLimit a -> Bool # Data a => Data (UpperLimit a) Source # Methodsgfoldl :: (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) #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 :: (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) # Read a => Read (UpperLimit a) Source # MethodsreadsPrec :: Int -> ReadS (UpperLimit a) # Show a => Show (UpperLimit a) Source # MethodsshowsPrec :: Int -> UpperLimit a -> ShowS #show :: UpperLimit a -> String #showList :: [UpperLimit a] -> ShowS # Source # Associated Typestype Rep (UpperLimit a) :: * -> * # Methodsfrom :: UpperLimit a -> Rep (UpperLimit a) x #to :: Rep (UpperLimit a) x -> UpperLimit a # NFData a => NFData (UpperLimit a) Source # Methodsrnf :: UpperLimit a -> () # ToJSON a => ToJSON (UpperLimit a) Source # MethodstoJSON :: UpperLimit a -> Value #toJSONList :: [UpperLimit a] -> Value #toEncodingList :: [UpperLimit a] -> Encoding # FromJSON a => FromJSON (UpperLimit a) Source # Methods Binary a => Binary (UpperLimit a) Source # Methodsput :: UpperLimit a -> Put #get :: Get (UpperLimit a) #putList :: [UpperLimit a] -> Put # Unbox a0 => Unbox (UpperLimit a0) Source # data MVector s (UpperLimit a0) Source # data MVector s (UpperLimit a0) = MV_UpperLimit (MVector s (a, CL Double)) type Rep (UpperLimit a) Source # type Rep (UpperLimit a) = D1 (MetaData "UpperLimit" "Statistics.Types" "statistics-0.14.0.0-9xPMo3QbnR7BEP0FkvUcUB" False) (C1 (MetaCons "UpperLimit" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "upperLimit") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Just Symbol "ulConfidenceLevel") NoSourceUnpackedness SourceStrict DecidedUnpack) (Rec0 (CL Double))))) data Vector (UpperLimit a0) Source # data Vector (UpperLimit a0) = V_UpperLimit (Vector (a, CL Double))

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 FieldslowerLimit :: !aLower limitllConfidenceLevel :: !(CL Double)Confidence level for which limit was calculated

Instances

 Unbox a0 => Vector Vector (LowerLimit a0) Source # MethodsbasicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (LowerLimit a0) -> m (Vector (LowerLimit a0)) #basicUnsafeThaw :: PrimMonad m => Vector (LowerLimit a0) -> m (Mutable Vector (PrimState m) (LowerLimit a0)) #basicLength :: Vector (LowerLimit a0) -> Int #basicUnsafeSlice :: Int -> Int -> Vector (LowerLimit a0) -> Vector (LowerLimit a0) #basicUnsafeIndexM :: Monad m => Vector (LowerLimit a0) -> Int -> m (LowerLimit a0) #basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (LowerLimit a0) -> Vector (LowerLimit a0) -> m () #elemseq :: Vector (LowerLimit a0) -> LowerLimit a0 -> b -> b # Unbox a0 => MVector MVector (LowerLimit a0) Source # MethodsbasicLength :: MVector s (LowerLimit a0) -> Int #basicUnsafeSlice :: Int -> Int -> MVector s (LowerLimit a0) -> MVector s (LowerLimit a0) #basicOverlaps :: MVector s (LowerLimit a0) -> MVector s (LowerLimit a0) -> Bool #basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (LowerLimit a0)) #basicInitialize :: PrimMonad m => MVector (PrimState m) (LowerLimit a0) -> m () #basicUnsafeReplicate :: PrimMonad m => Int -> LowerLimit a0 -> m (MVector (PrimState m) (LowerLimit a0)) #basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (LowerLimit a0) -> Int -> m (LowerLimit a0) #basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (LowerLimit a0) -> Int -> LowerLimit a0 -> m () #basicClear :: PrimMonad m => MVector (PrimState m) (LowerLimit a0) -> m () #basicSet :: PrimMonad m => MVector (PrimState m) (LowerLimit a0) -> LowerLimit a0 -> m () #basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (LowerLimit a0) -> MVector (PrimState m) (LowerLimit a0) -> m () #basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (LowerLimit a0) -> MVector (PrimState m) (LowerLimit a0) -> m () #basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (LowerLimit a0) -> Int -> m (MVector (PrimState m) (LowerLimit a0)) # Eq a => Eq (LowerLimit a) Source # Methods(==) :: LowerLimit a -> LowerLimit a -> Bool #(/=) :: LowerLimit a -> LowerLimit a -> Bool # Data a => Data (LowerLimit a) Source # Methodsgfoldl :: (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) #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 :: (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) # Read a => Read (LowerLimit a) Source # MethodsreadsPrec :: Int -> ReadS (LowerLimit a) # Show a => Show (LowerLimit a) Source # MethodsshowsPrec :: Int -> LowerLimit a -> ShowS #show :: LowerLimit a -> String #showList :: [LowerLimit a] -> ShowS # Source # Associated Typestype Rep (LowerLimit a) :: * -> * # Methodsfrom :: LowerLimit a -> Rep (LowerLimit a) x #to :: Rep (LowerLimit a) x -> LowerLimit a # NFData a => NFData (LowerLimit a) Source # Methodsrnf :: LowerLimit a -> () # ToJSON a => ToJSON (LowerLimit a) Source # MethodstoJSON :: LowerLimit a -> Value #toJSONList :: [LowerLimit a] -> Value #toEncodingList :: [LowerLimit a] -> Encoding # FromJSON a => FromJSON (LowerLimit a) Source # Methods Binary a => Binary (LowerLimit a) Source # Methodsput :: LowerLimit a -> Put #get :: Get (LowerLimit a) #putList :: [LowerLimit a] -> Put # Unbox a0 => Unbox (LowerLimit a0) Source # data MVector s (LowerLimit a0) Source # data MVector s (LowerLimit a0) = MV_LowerLimit (MVector s (a, CL Double)) type Rep (LowerLimit a) Source # type Rep (LowerLimit a) = D1 (MetaData "LowerLimit" "Statistics.Types" "statistics-0.14.0.0-9xPMo3QbnR7BEP0FkvUcUB" False) (C1 (MetaCons "LowerLimit" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "lowerLimit") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Just Symbol "llConfidenceLevel") NoSourceUnpackedness SourceStrict DecidedUnpack) (Rec0 (CL Double))))) data Vector (LowerLimit a0) Source # data Vector (LowerLimit a0) = V_LowerLimit (Vector (a, CL Double))

## Constructors

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

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

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

Get confidence interval

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

Get asymmetric errors

class Scale e where Source #

Data types which could be multiplied by constant.

Minimal complete definition

scale

Methods

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

Instances

 Source # Methodsscale :: (Ord a, Num a) => a -> ConfInt a -> ConfInt a Source # Source # Methodsscale :: (Ord a, Num a) => a -> NormalErr a -> NormalErr a Source # Scale e => Scale (Estimate e) Source # Methodsscale :: (Ord a, Num a) => a -> Estimate e a -> Estimate e a Source #

# Other

Sample data.

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

Weights for affecting the importance of elements of a sample.