Statistics.Types

Data types common used in statistics

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

Methods

basicUnsafeFreeze :: 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)

Methods

basicLength :: 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)

Methods

(==) :: CL a -> CL a -> Bool

(/=) :: CL a -> CL a -> Bool

Data a => Data (CL a)

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 :: (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)

>>> cl95 > cl90
True

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

(Num a, Ord a, Read a) => Read (CL a)

Methods

readsPrec :: Int -> ReadS (CL a)

readList :: ReadS [CL a]

readPrec :: ReadPrec (CL a)

readListPrec :: ReadPrec [CL a]

Show a => Show (CL a)

Methods

showsPrec :: Int -> CL a -> ShowS

show :: CL a -> String

showList :: [CL a] -> ShowS

Generic (CL a)

Associated Types

type Rep (CL a) :: * -> *

Methods

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

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

NFData a => NFData (CL a)

Methods

rnf :: CL a -> ()

ToJSON a => ToJSON (CL a)

Methods

toJSON :: CL a -> Value

toEncoding :: CL a -> Encoding

toJSONList :: [CL a] -> Value

toEncodingList :: [CL a] -> Encoding

(FromJSON a, Num a, Ord a) => FromJSON (CL a)

Methods

parseJSON :: Value -> Parser (CL a)

parseJSONList :: Value -> Parser [CL a]

(Binary a, Num a, Ord a) => Binary (CL a)

Methods

put :: CL a -> Put

get :: Get (CL a)

putList :: [CL a] -> Put

Unbox a0 => Unbox (CL a0)

data MVector s (CL a0)

data MVector s (CL a0) = MV_CL (MVector s a)

type Rep (CL a)

type Rep (CL a) = D1 (MetaData "CL" "Statistics.Types" "statistics-0.14.0.2-9wDz1lVU92ZDJSrAe5uHzb" True) (C1 (MetaCons "CL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

data Vector (CL a0)

data Vector (CL a0) = 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 0.05

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

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 0.05

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

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

Unbox a0 => Vector Vector (PValue a0)

Methods

basicUnsafeFreeze :: 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)

Methods

basicLength :: 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)

Methods

(==) :: PValue a -> PValue a -> Bool

(/=) :: PValue a -> PValue a -> Bool

Data a => Data (PValue a)

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)

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

(Num a, Ord a, Read a) => Read (PValue a)

Methods

readsPrec :: Int -> ReadS (PValue a)

readList :: ReadS [PValue a]

readPrec :: ReadPrec (PValue a)

readListPrec :: ReadPrec [PValue a]

Show a => Show (PValue a)

Methods

showsPrec :: Int -> PValue a -> ShowS

show :: PValue a -> String

showList :: [PValue a] -> ShowS

Generic (PValue a)

Associated Types

type Rep (PValue a) :: * -> *

Methods

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

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

NFData a => NFData (PValue a)

Methods

rnf :: PValue a -> ()

ToJSON a => ToJSON (PValue a)

Methods

toJSON :: PValue a -> Value

toEncoding :: PValue a -> Encoding

toJSONList :: [PValue a] -> Value

toEncodingList :: [PValue a] -> Encoding

(FromJSON a, Num a, Ord a) => FromJSON (PValue a)

Methods

parseJSON :: Value -> Parser (PValue a)

parseJSONList :: Value -> Parser [PValue a]

(Binary a, Num a, Ord a) => Binary (PValue a)

Methods

put :: PValue a -> Put

get :: Get (PValue a)

putList :: [PValue a] -> Put

Unbox a0 => Unbox (PValue a0)

data MVector s (PValue a0)

data MVector s (PValue a0) = MV_PValue (MVector s a)

type Rep (PValue a)

type Rep (PValue a) = D1 (MetaData "PValue" "Statistics.Types" "statistics-0.14.0.2-9wDz1lVU92ZDJSrAe5uHzb" True) (C1 (MetaCons "PValue" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

data Vector (PValue a0)

data Vector (PValue a0) = 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 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

(Unbox a0, Unbox (e0 a0)) => Vector Vector (Estimate e0 a0)

Methods

basicUnsafeFreeze :: 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)

Methods

basicLength :: 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)

Methods

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

(Eq (e a), Eq a) => Eq (Estimate e a)

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)

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

Methods

readsPrec :: Int -> ReadS (Estimate e a)

readList :: ReadS [Estimate e a]

readPrec :: ReadPrec (Estimate e a)

readListPrec :: ReadPrec [Estimate e a]

(Show (e a), Show a) => Show (Estimate e a)

Methods

showsPrec :: Int -> Estimate e a -> ShowS

show :: Estimate e a -> String

showList :: [Estimate e a] -> ShowS

Generic (Estimate e a)

Associated Types

type Rep (Estimate e a) :: * -> *

Methods

from :: 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)

Methods

rnf :: Estimate e a -> ()

(ToJSON (e a), ToJSON a) => ToJSON (Estimate e a)

Methods

toJSON :: 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)

Methods

parseJSON :: Value -> Parser (Estimate e a)

parseJSONList :: Value -> Parser [Estimate e a]

(Binary (e a), Binary a) => Binary (Estimate e a)

Methods

put :: Estimate e a -> Put

get :: Get (Estimate e a)

putList :: [Estimate e a] -> Put

(Unbox a0, Unbox (e0 a0)) => Unbox (Estimate e0 a0)

data MVector s (Estimate e0 a0)

data MVector s (Estimate e0 a0) = MV_Estimate (MVector s (a, e a))

type Rep (Estimate e a)

type Rep (Estimate e a) = D1 (MetaData "Estimate" "Statistics.Types" "statistics-0.14.0.2-9wDz1lVU92ZDJSrAe5uHzb" 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)

data Vector (Estimate e0 a0) = 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

Scale NormalErr

Methods

scale :: (Ord a, Num a) => a -> NormalErr a -> NormalErr a

Unbox a0 => Vector Vector (NormalErr a0)

Methods

basicUnsafeFreeze :: 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)

Methods

basicLength :: 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)

Methods

(==) :: NormalErr a -> NormalErr a -> Bool

(/=) :: NormalErr a -> NormalErr a -> Bool

Data a => Data (NormalErr a)

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)

Methods

readsPrec :: Int -> ReadS (NormalErr a)

readList :: ReadS [NormalErr a]

readPrec :: ReadPrec (NormalErr a)

readListPrec :: ReadPrec [NormalErr a]

Show a => Show (NormalErr a)

Methods

showsPrec :: Int -> NormalErr a -> ShowS

show :: NormalErr a -> String

showList :: [NormalErr a] -> ShowS

Generic (NormalErr a)

Associated Types

type Rep (NormalErr a) :: * -> *

Methods

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

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

NFData a => NFData (NormalErr a)

Methods

rnf :: NormalErr a -> ()

ToJSON a => ToJSON (NormalErr a)

Methods

toJSON :: NormalErr a -> Value

toEncoding :: NormalErr a -> Encoding

toJSONList :: [NormalErr a] -> Value

toEncodingList :: [NormalErr a] -> Encoding

FromJSON a => FromJSON (NormalErr a)

Methods

parseJSON :: Value -> Parser (NormalErr a)

parseJSONList :: Value -> Parser [NormalErr a]

Binary a => Binary (NormalErr a)

Methods

put :: NormalErr a -> Put

get :: Get (NormalErr a)

putList :: [NormalErr a] -> Put

Unbox a0 => Unbox (NormalErr a0)

data MVector s (NormalErr a0)

data MVector s (NormalErr a0) = MV_NormalErr (MVector s a)

type Rep (NormalErr a)

type Rep (NormalErr a) = D1 (MetaData "NormalErr" "Statistics.Types" "statistics-0.14.0.2-9wDz1lVU92ZDJSrAe5uHzb" True) (C1 (MetaCons "NormalErr" PrefixI True) (S1 (MetaSel (Just Symbol "normalError") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

data Vector (NormalErr a0)

data Vector (NormalErr a0) = 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

Scale ConfInt

Methods

scale :: (Ord a, Num a) => a -> ConfInt a -> ConfInt a

Unbox a0 => Vector Vector (ConfInt a0)

Methods

basicUnsafeFreeze :: 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)

Methods

basicLength :: 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)

Methods

(==) :: ConfInt a -> ConfInt a -> Bool

(/=) :: ConfInt a -> ConfInt a -> Bool

Data a => Data (ConfInt a)

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)

Methods

readsPrec :: Int -> ReadS (ConfInt a)

readList :: ReadS [ConfInt a]

readPrec :: ReadPrec (ConfInt a)

readListPrec :: ReadPrec [ConfInt a]

Show a => Show (ConfInt a)

Methods

showsPrec :: Int -> ConfInt a -> ShowS

show :: ConfInt a -> String

showList :: [ConfInt a] -> ShowS

Generic (ConfInt a)

Associated Types

type Rep (ConfInt a) :: * -> *

Methods

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

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

NFData a => NFData (ConfInt a)

Methods

rnf :: ConfInt a -> ()

ToJSON a => ToJSON (ConfInt a)

Methods

toJSON :: ConfInt a -> Value

toEncoding :: ConfInt a -> Encoding

toJSONList :: [ConfInt a] -> Value

toEncodingList :: [ConfInt a] -> Encoding

FromJSON a => FromJSON (ConfInt a)

Methods

parseJSON :: Value -> Parser (ConfInt a)

parseJSONList :: Value -> Parser [ConfInt a]

Binary a => Binary (ConfInt a)

Methods

put :: ConfInt a -> Put

get :: Get (ConfInt a)

putList :: [ConfInt a] -> Put

Unbox a0 => Unbox (ConfInt a0)

data MVector s (ConfInt a0)

data MVector s (ConfInt a0) = MV_ConfInt (MVector s (a, a, CL Double))

type Rep (ConfInt a)

type Rep (ConfInt a) = D1 (MetaData "ConfInt" "Statistics.Types" "statistics-0.14.0.2-9wDz1lVU92ZDJSrAe5uHzb" 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)

data Vector (ConfInt a0) = 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

Unbox a0 => Vector Vector (UpperLimit a0)

Methods

basicUnsafeFreeze :: 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)

Methods

basicLength :: 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)

Methods

(==) :: UpperLimit a -> UpperLimit a -> Bool

(/=) :: UpperLimit a -> UpperLimit a -> Bool

Data a => Data (UpperLimit a)

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 :: (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)

Methods

readsPrec :: Int -> ReadS (UpperLimit a)

readList :: ReadS [UpperLimit a]

readPrec :: ReadPrec (UpperLimit a)

readListPrec :: ReadPrec [UpperLimit a]

Show a => Show (UpperLimit a)

Methods

showsPrec :: Int -> UpperLimit a -> ShowS

show :: UpperLimit a -> String

showList :: [UpperLimit a] -> ShowS

Generic (UpperLimit a)

Associated Types

type Rep (UpperLimit a) :: * -> *

Methods

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

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

NFData a => NFData (UpperLimit a)

Methods

rnf :: UpperLimit a -> ()

ToJSON a => ToJSON (UpperLimit a)

Methods

toJSON :: UpperLimit a -> Value

toEncoding :: UpperLimit a -> Encoding

toJSONList :: [UpperLimit a] -> Value

toEncodingList :: [UpperLimit a] -> Encoding

FromJSON a => FromJSON (UpperLimit a)

Methods

parseJSON :: Value -> Parser (UpperLimit a)

parseJSONList :: Value -> Parser [UpperLimit a]

Binary a => Binary (UpperLimit a)

Methods

put :: UpperLimit a -> Put

get :: Get (UpperLimit a)

putList :: [UpperLimit a] -> Put

Unbox a0 => Unbox (UpperLimit a0)

data MVector s (UpperLimit a0)

data MVector s (UpperLimit a0) = MV_UpperLimit (MVector s (a, CL Double))

type Rep (UpperLimit a)

type Rep (UpperLimit a) = D1 (MetaData "UpperLimit" "Statistics.Types" "statistics-0.14.0.2-9wDz1lVU92ZDJSrAe5uHzb" 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)

data Vector (UpperLimit a0) = 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

Unbox a0 => Vector Vector (LowerLimit a0)

Methods

basicUnsafeFreeze :: 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)

Methods

basicLength :: 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)

Methods

(==) :: LowerLimit a -> LowerLimit a -> Bool

(/=) :: LowerLimit a -> LowerLimit a -> Bool

Data a => Data (LowerLimit a)

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 :: (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)

Methods

readsPrec :: Int -> ReadS (LowerLimit a)

readList :: ReadS [LowerLimit a]

readPrec :: ReadPrec (LowerLimit a)

readListPrec :: ReadPrec [LowerLimit a]

Show a => Show (LowerLimit a)

Methods

showsPrec :: Int -> LowerLimit a -> ShowS

show :: LowerLimit a -> String

showList :: [LowerLimit a] -> ShowS

Generic (LowerLimit a)

Associated Types

type Rep (LowerLimit a) :: * -> *

Methods

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

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

NFData a => NFData (LowerLimit a)

Methods

rnf :: LowerLimit a -> ()

ToJSON a => ToJSON (LowerLimit a)

Methods

toJSON :: LowerLimit a -> Value

toEncoding :: LowerLimit a -> Encoding

toJSONList :: [LowerLimit a] -> Value

toEncodingList :: [LowerLimit a] -> Encoding

FromJSON a => FromJSON (LowerLimit a)

Methods

parseJSON :: Value -> Parser (LowerLimit a)

parseJSONList :: Value -> Parser [LowerLimit a]

Binary a => Binary (LowerLimit a)

Methods

put :: LowerLimit a -> Put

get :: Get (LowerLimit a)

putList :: [LowerLimit a] -> Put

Unbox a0 => Unbox (LowerLimit a0)

data MVector s (LowerLimit a0)

data MVector s (LowerLimit a0) = MV_LowerLimit (MVector s (a, CL Double))

type Rep (LowerLimit a)

type Rep (LowerLimit a) = D1 (MetaData "LowerLimit" "Statistics.Types" "statistics-0.14.0.2-9wDz1lVU92ZDJSrAe5uHzb" 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)

data Vector (LowerLimit a0) = 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 where

Data types which could be multiplied by constant.

Minimal complete definition

scale

Methods

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

Instances

Scale ConfInt

Methods

scale :: (Ord a, Num a) => a -> ConfInt a -> ConfInt a

Scale NormalErr

Methods

scale :: (Ord a, Num a) => a -> NormalErr a -> NormalErr a

Scale e => Scale (Estimate e)

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.