    {-# LANGUAGE BangPatterns       #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveFoldable     #-}
    {-# LANGUAGE DeriveFunctor      #-}
    {-# LANGUAGE DeriveGeneric      #-}
    {-# LANGUAGE DeriveTraversable  #-}
    {-# LANGUAGE FlexibleContexts   #-}
    {-# LANGUAGE TypeFamilies       #-}

    -- |
    -- Module    : Statistics.Resampling
    -- Copyright : (c) 2009, 2010 Bryan O'Sullivan
    -- License   : BSD3
    --
    -- Maintainer  : bos@serpentine.com
    -- Stability   : experimental
    -- Portability : portable
    --
    -- Resampling statistics.

    module Statistics.Resampling
        ( -- * Data types
          Resample(..)
        , Bootstrap(..)
        , Estimator(..)
        , estimate
          -- * Resampling
        , resampleST
        , resample
        , resampleVector
          -- * Jackknife
        , jackknife
        , jackknifeMean
        , jackknifeVariance
        , jackknifeVarianceUnb
        , jackknifeStdDev
          -- * Helper functions
        , splitGen
        ) where

    import Data.Aeson (FromJSON, ToJSON)
    import Control.Concurrent.Async (forConcurrently_)
    import Control.Monad (forM_, forM, replicateM, liftM2)
    import Control.Monad.Primitive (PrimMonad(..))
    import Data.Binary (Binary(..))
    import Data.Data (Data, Typeable)
    import Data.Vector.Algorithms.Intro (sort)
    import Data.Vector.Binary ()
    import Data.Vector.Generic (unsafeFreeze,unsafeThaw)
    import Data.Word (Word32)
    import qualified Data.Foldable as T
    import qualified Data.Traversable as T
    import qualified Data.Vector.Generic as G
    import qualified Data.Vector.Unboxed as U
    import qualified Data.Vector.Unboxed.Mutable as MU

    import GHC.Conc (numCapabilities)
    import GHC.Generics (Generic)
    import Numeric.Sum (Summation(..), kbn)
    import Statistics.Function (indices)
    import Statistics.Sample (mean, stdDev, variance, varianceUnbiased)
    import Statistics.Types (Sample)
    import System.Random.MWC (Gen, GenIO, initialize, uniformR, uniformVector)

    ----------------------------------------------------------------
    -- Data types
    ----------------------------------------------------------------

    -- | A resample drawn randomly, with replacement, from a set of data
    -- points.  Distinct from a normal array to make it harder for your
    -- humble author's brain to go wrong.
    newtype Resample = Resample {
          Resample -> Vector Double
    fromResample :: U.Vector Double
        } deriving (Resample -> Resample -> Bool
    (Resample -> Resample -> Bool)
    -> (Resample -> Resample -> Bool) -> Eq Resample
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Resample -> Resample -> Bool
    == :: Resample -> Resample -> Bool
    $c/= :: Resample -> Resample -> Bool
    /= :: Resample -> Resample -> Bool
    Eq, ReadPrec [Resample]
    ReadPrec Resample
    Int -> ReadS Resample
    ReadS [Resample]
    (Int -> ReadS Resample)
    -> ReadS [Resample]
    -> ReadPrec Resample
    -> ReadPrec [Resample]
    -> Read Resample
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Resample
    readsPrec :: Int -> ReadS Resample
    $creadList :: ReadS [Resample]
    readList :: ReadS [Resample]
    $creadPrec :: ReadPrec Resample
    readPrec :: ReadPrec Resample
    $creadListPrec :: ReadPrec [Resample]
    readListPrec :: ReadPrec [Resample]
    Read, Int -> Resample -> ShowS
    [Resample] -> ShowS
    Resample -> String
    (Int -> Resample -> ShowS)
    -> (Resample -> String) -> ([Resample] -> ShowS) -> Show Resample
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Resample -> ShowS
    showsPrec :: Int -> Resample -> ShowS
    $cshow :: Resample -> String
    show :: Resample -> String
    $cshowList :: [Resample] -> ShowS
    showList :: [Resample] -> ShowS
    Show, Typeable, Typeable Resample
    Typeable Resample =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Resample -> c Resample)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Resample)
    -> (Resample -> Constr)
    -> (Resample -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Resample))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Resample))
    -> ((forall b. Data b => b -> b) -> Resample -> Resample)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Resample -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Resample -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Resample -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Resample -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Resample -> m Resample)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Resample -> m Resample)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Resample -> m Resample)
    -> Data Resample
    Resample -> Constr
    Resample -> DataType
    (forall b. Data b => b -> b) -> Resample -> Resample
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Resample -> u
    forall u. (forall d. Data d => d -> u) -> Resample -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Resample -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Resample -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Resample -> m Resample
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Resample -> m Resample
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Resample
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Resample -> c Resample
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Resample)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Resample)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Resample -> c Resample
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Resample -> c Resample
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Resample
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Resample
    $ctoConstr :: Resample -> Constr
    toConstr :: Resample -> Constr
    $cdataTypeOf :: Resample -> DataType
    dataTypeOf :: Resample -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Resample)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Resample)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Resample)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Resample)
    $cgmapT :: (forall b. Data b => b -> b) -> Resample -> Resample
    gmapT :: (forall b. Data b => b -> b) -> Resample -> Resample
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Resample -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Resample -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Resample -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Resample -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Resample -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Resample -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Resample -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Resample -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Resample -> m Resample
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Resample -> m Resample
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Resample -> m Resample
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Resample -> m Resample
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Resample -> m Resample
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Resample -> m Resample
    Data, (forall x. Resample -> Rep Resample x)
    -> (forall x. Rep Resample x -> Resample) -> Generic Resample
    forall x. Rep Resample x -> Resample
    forall x. Resample -> Rep Resample x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Resample -> Rep Resample x
    from :: forall x. Resample -> Rep Resample x
    $cto :: forall x. Rep Resample x -> Resample
    to :: forall x. Rep Resample x -> Resample
    Generic)

    instance FromJSON Resample
    instance ToJSON Resample

    instance Binary Resample where
        put :: Resample -> Put
    put = Vector Double -> Put
    forall t. Binary t => t -> Put
    put (Vector Double -> Put)
    -> (Resample -> Vector Double) -> Resample -> Put
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Resample -> Vector Double
    fromResample
        get :: Get Resample
    get = (Vector Double -> Resample) -> Get (Vector Double) -> Get Resample
    forall a b. (a -> b) -> Get a -> Get b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Vector Double -> Resample
    Resample Get (Vector Double)
    forall t. Binary t => Get t
    get

    data Bootstrap v a = Bootstrap
      { forall (v :: * -> *) a. Bootstrap v a -> a
    fullSample :: !a
      , forall (v :: * -> *) a. Bootstrap v a -> v a
    resamples  :: v a
      }
      deriving (Bootstrap v a -> Bootstrap v a -> Bool
    (Bootstrap v a -> Bootstrap v a -> Bool)
    -> (Bootstrap v a -> Bootstrap v a -> Bool) -> Eq (Bootstrap v a)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall (v :: * -> *) a.
    (Eq a, Eq (v a)) =>
    Bootstrap v a -> Bootstrap v a -> Bool
    $c== :: forall (v :: * -> *) a.
    (Eq a, Eq (v a)) =>
    Bootstrap v a -> Bootstrap v a -> Bool
    == :: Bootstrap v a -> Bootstrap v a -> Bool
    $c/= :: forall (v :: * -> *) a.
    (Eq a, Eq (v a)) =>
    Bootstrap v a -> Bootstrap v a -> Bool
    /= :: Bootstrap v a -> Bootstrap v a -> Bool
    Eq, ReadPrec [Bootstrap v a]
    ReadPrec (Bootstrap v a)
    Int -> ReadS (Bootstrap v a)
    ReadS [Bootstrap v a]
    (Int -> ReadS (Bootstrap v a))
    -> ReadS [Bootstrap v a]
    -> ReadPrec (Bootstrap v a)
    -> ReadPrec [Bootstrap v a]
    -> Read (Bootstrap v a)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall (v :: * -> *) a.
    (Read a, Read (v a)) =>
    ReadPrec [Bootstrap v a]
    forall (v :: * -> *) a.
    (Read a, Read (v a)) =>
    ReadPrec (Bootstrap v a)
    forall (v :: * -> *) a.
    (Read a, Read (v a)) =>
    Int -> ReadS (Bootstrap v a)
    forall (v :: * -> *) a.
    (Read a, Read (v a)) =>
    ReadS [Bootstrap v a]
    $creadsPrec :: forall (v :: * -> *) a.
    (Read a, Read (v a)) =>
    Int -> ReadS (Bootstrap v a)
    readsPrec :: Int -> ReadS (Bootstrap v a)
    $creadList :: forall (v :: * -> *) a.
    (Read a, Read (v a)) =>
    ReadS [Bootstrap v a]
    readList :: ReadS [Bootstrap v a]
    $creadPrec :: forall (v :: * -> *) a.
    (Read a, Read (v a)) =>
    ReadPrec (Bootstrap v a)
    readPrec :: ReadPrec (Bootstrap v a)
    $creadListPrec :: forall (v :: * -> *) a.
    (Read a, Read (v a)) =>
    ReadPrec [Bootstrap v a]
    readListPrec :: ReadPrec [Bootstrap v a]
    Read, Int -> Bootstrap v a -> ShowS
    [Bootstrap v a] -> ShowS
    Bootstrap v a -> String
    (Int -> Bootstrap v a -> ShowS)
    -> (Bootstrap v a -> String)
    -> ([Bootstrap v a] -> ShowS)
    -> Show (Bootstrap v a)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall (v :: * -> *) a.
    (Show a, Show (v a)) =>
    Int -> Bootstrap v a -> ShowS
    forall (v :: * -> *) a.
    (Show a, Show (v a)) =>
    [Bootstrap v a] -> ShowS
    forall (v :: * -> *) a.
    (Show a, Show (v a)) =>
    Bootstrap v a -> String
    $cshowsPrec :: forall (v :: * -> *) a.
    (Show a, Show (v a)) =>
    Int -> Bootstrap v a -> ShowS
    showsPrec :: Int -> Bootstrap v a -> ShowS
    $cshow :: forall (v :: * -> *) a.
    (Show a, Show (v a)) =>
    Bootstrap v a -> String
    show :: Bootstrap v a -> String
    $cshowList :: forall (v :: * -> *) a.
    (Show a, Show (v a)) =>
    [Bootstrap v a] -> ShowS
    showList :: [Bootstrap v a] -> ShowS
    Show , (forall x. Bootstrap v a -> Rep (Bootstrap v a) x)
    -> (forall x. Rep (Bootstrap v a) x -> Bootstrap v a)
    -> Generic (Bootstrap v a)
    forall x. Rep (Bootstrap v a) x -> Bootstrap v a
    forall x. Bootstrap v a -> Rep (Bootstrap v a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall (v :: * -> *) a x. Rep (Bootstrap v a) x -> Bootstrap v a
    forall (v :: * -> *) a x. Bootstrap v a -> Rep (Bootstrap v a) x
    $cfrom :: forall (v :: * -> *) a x. Bootstrap v a -> Rep (Bootstrap v a) x
    from :: forall x. Bootstrap v a -> Rep (Bootstrap v a) x
    $cto :: forall (v :: * -> *) a x. Rep (Bootstrap v a) x -> Bootstrap v a
    to :: forall x. Rep (Bootstrap v a) x -> Bootstrap v a
    Generic, (forall a b. (a -> b) -> Bootstrap v a -> Bootstrap v b)
    -> (forall a b. a -> Bootstrap v b -> Bootstrap v a)
    -> Functor (Bootstrap v)
    forall a b. a -> Bootstrap v b -> Bootstrap v a
    forall a b. (a -> b) -> Bootstrap v a -> Bootstrap v b
    forall (v :: * -> *) a b.
    Functor v =>
    a -> Bootstrap v b -> Bootstrap v a
    forall (v :: * -> *) a b.
    Functor v =>
    (a -> b) -> Bootstrap v a -> Bootstrap v b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall (v :: * -> *) a b.
    Functor v =>
    (a -> b) -> Bootstrap v a -> Bootstrap v b
    fmap :: forall a b. (a -> b) -> Bootstrap v a -> Bootstrap v b
    $c<$ :: forall (v :: * -> *) a b.
    Functor v =>
    a -> Bootstrap v b -> Bootstrap v a
    <$ :: forall a b. a -> Bootstrap v b -> Bootstrap v a
    Functor, (forall m. Monoid m => Bootstrap v m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Bootstrap v a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Bootstrap v a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Bootstrap v a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Bootstrap v a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Bootstrap v a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Bootstrap v a -> b)
    -> (forall a. (a -> a -> a) -> Bootstrap v a -> a)
    -> (forall a. (a -> a -> a) -> Bootstrap v a -> a)
    -> (forall a. Bootstrap v a -> [a])
    -> (forall a. Bootstrap v a -> Bool)
    -> (forall a. Bootstrap v a -> Int)
    -> (forall a. Eq a => a -> Bootstrap v a -> Bool)
    -> (forall a. Ord a => Bootstrap v a -> a)
    -> (forall a. Ord a => Bootstrap v a -> a)
    -> (forall a. Num a => Bootstrap v a -> a)
    -> (forall a. Num a => Bootstrap v a -> a)
    -> Foldable (Bootstrap v)
    forall a. Eq a => a -> Bootstrap v a -> Bool
    forall a. Num a => Bootstrap v a -> a
    forall a. Ord a => Bootstrap v a -> a
    forall m. Monoid m => Bootstrap v m -> m
    forall a. Bootstrap v a -> Bool
    forall a. Bootstrap v a -> Int
    forall a. Bootstrap v a -> [a]
    forall a. (a -> a -> a) -> Bootstrap v a -> a
    forall m a. Monoid m => (a -> m) -> Bootstrap v a -> m
    forall b a. (b -> a -> b) -> b -> Bootstrap v a -> b
    forall a b. (a -> b -> b) -> b -> Bootstrap v a -> b
    forall (v :: * -> *) a.
    (Foldable v, Eq a) =>
    a -> Bootstrap v a -> Bool
    forall (v :: * -> *) a. (Foldable v, Num a) => Bootstrap v a -> a
    forall (v :: * -> *) a. (Foldable v, Ord a) => Bootstrap v a -> a
    forall (v :: * -> *) m.
    (Foldable v, Monoid m) =>
    Bootstrap v m -> m
    forall (v :: * -> *) a. Foldable v => Bootstrap v a -> Bool
    forall (v :: * -> *) a. Foldable v => Bootstrap v a -> Int
    forall (v :: * -> *) a. Foldable v => Bootstrap v a -> [a]
    forall (v :: * -> *) a.
    Foldable v =>
    (a -> a -> a) -> Bootstrap v a -> a
    forall (v :: * -> *) m a.
    (Foldable v, Monoid m) =>
    (a -> m) -> Bootstrap v a -> m
    forall (v :: * -> *) b a.
    Foldable v =>
    (b -> a -> b) -> b -> Bootstrap v a -> b
    forall (v :: * -> *) a b.
    Foldable v =>
    (a -> b -> b) -> b -> Bootstrap v a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall (v :: * -> *) m.
    (Foldable v, Monoid m) =>
    Bootstrap v m -> m
    fold :: forall m. Monoid m => Bootstrap v m -> m
    $cfoldMap :: forall (v :: * -> *) m a.
    (Foldable v, Monoid m) =>
    (a -> m) -> Bootstrap v a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Bootstrap v a -> m
    $cfoldMap' :: forall (v :: * -> *) m a.
    (Foldable v, Monoid m) =>
    (a -> m) -> Bootstrap v a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Bootstrap v a -> m
    $cfoldr :: forall (v :: * -> *) a b.
    Foldable v =>
    (a -> b -> b) -> b -> Bootstrap v a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Bootstrap v a -> b
    $cfoldr' :: forall (v :: * -> *) a b.
    Foldable v =>
    (a -> b -> b) -> b -> Bootstrap v a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Bootstrap v a -> b
    $cfoldl :: forall (v :: * -> *) b a.
    Foldable v =>
    (b -> a -> b) -> b -> Bootstrap v a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Bootstrap v a -> b
    $cfoldl' :: forall (v :: * -> *) b a.
    Foldable v =>
    (b -> a -> b) -> b -> Bootstrap v a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Bootstrap v a -> b
    $cfoldr1 :: forall (v :: * -> *) a.
    Foldable v =>
    (a -> a -> a) -> Bootstrap v a -> a
    foldr1 :: forall a. (a -> a -> a) -> Bootstrap v a -> a
    $cfoldl1 :: forall (v :: * -> *) a.
    Foldable v =>
    (a -> a -> a) -> Bootstrap v a -> a
    foldl1 :: forall a. (a -> a -> a) -> Bootstrap v a -> a
    $ctoList :: forall (v :: * -> *) a. Foldable v => Bootstrap v a -> [a]
    toList :: forall a. Bootstrap v a -> [a]
    $cnull :: forall (v :: * -> *) a. Foldable v => Bootstrap v a -> Bool
    null :: forall a. Bootstrap v a -> Bool
    $clength :: forall (v :: * -> *) a. Foldable v => Bootstrap v a -> Int
    length :: forall a. Bootstrap v a -> Int
    $celem :: forall (v :: * -> *) a.
    (Foldable v, Eq a) =>
    a -> Bootstrap v a -> Bool
    elem :: forall a. Eq a => a -> Bootstrap v a -> Bool
    $cmaximum :: forall (v :: * -> *) a. (Foldable v, Ord a) => Bootstrap v a -> a
    maximum :: forall a. Ord a => Bootstrap v a -> a
    $cminimum :: forall (v :: * -> *) a. (Foldable v, Ord a) => Bootstrap v a -> a
    minimum :: forall a. Ord a => Bootstrap v a -> a
    $csum :: forall (v :: * -> *) a. (Foldable v, Num a) => Bootstrap v a -> a
    sum :: forall a. Num a => Bootstrap v a -> a
    $cproduct :: forall (v :: * -> *) a. (Foldable v, Num a) => Bootstrap v a -> a
    product :: forall a. Num a => Bootstrap v a -> a
    T.Foldable, Functor (Bootstrap v)
    Foldable (Bootstrap v)
    (Functor (Bootstrap v), Foldable (Bootstrap v)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Bootstrap v a -> f (Bootstrap v b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Bootstrap v (f a) -> f (Bootstrap v a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Bootstrap v a -> m (Bootstrap v b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Bootstrap v (m a) -> m (Bootstrap v a))
    -> Traversable (Bootstrap v)
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (v :: * -> *). Traversable v => Functor (Bootstrap v)
    forall (v :: * -> *). Traversable v => Foldable (Bootstrap v)
    forall (v :: * -> *) (m :: * -> *) a.
    (Traversable v, Monad m) =>
    Bootstrap v (m a) -> m (Bootstrap v a)
    forall (v :: * -> *) (f :: * -> *) a.
    (Traversable v, Applicative f) =>
    Bootstrap v (f a) -> f (Bootstrap v a)
    forall (v :: * -> *) (m :: * -> *) a b.
    (Traversable v, Monad m) =>
    (a -> m b) -> Bootstrap v a -> m (Bootstrap v b)
    forall (v :: * -> *) (f :: * -> *) a b.
    (Traversable v, Applicative f) =>
    (a -> f b) -> Bootstrap v a -> f (Bootstrap v b)
    forall (m :: * -> *) a.
    Monad m =>
    Bootstrap v (m a) -> m (Bootstrap v a)
    forall (f :: * -> *) a.
    Applicative f =>
    Bootstrap v (f a) -> f (Bootstrap v a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Bootstrap v a -> m (Bootstrap v b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Bootstrap v a -> f (Bootstrap v b)
    $ctraverse :: forall (v :: * -> *) (f :: * -> *) a b.
    (Traversable v, Applicative f) =>
    (a -> f b) -> Bootstrap v a -> f (Bootstrap v b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Bootstrap v a -> f (Bootstrap v b)
    $csequenceA :: forall (v :: * -> *) (f :: * -> *) a.
    (Traversable v, Applicative f) =>
    Bootstrap v (f a) -> f (Bootstrap v a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Bootstrap v (f a) -> f (Bootstrap v a)
    $cmapM :: forall (v :: * -> *) (m :: * -> *) a b.
    (Traversable v, Monad m) =>
    (a -> m b) -> Bootstrap v a -> m (Bootstrap v b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Bootstrap v a -> m (Bootstrap v b)
    $csequence :: forall (v :: * -> *) (m :: * -> *) a.
    (Traversable v, Monad m) =>
    Bootstrap v (m a) -> m (Bootstrap v a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Bootstrap v (m a) -> m (Bootstrap v a)
    T.Traversable
               , Typeable, Typeable (Bootstrap v a)
    Typeable (Bootstrap v a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Bootstrap v a -> c (Bootstrap v a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Bootstrap v a))
    -> (Bootstrap v a -> Constr)
    -> (Bootstrap v a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Bootstrap v a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Bootstrap v a)))
    -> ((forall b. Data b => b -> b) -> Bootstrap v a -> Bootstrap v a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Bootstrap v a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Bootstrap v a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> Bootstrap v a -> m (Bootstrap v a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> Bootstrap v a -> m (Bootstrap v a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> Bootstrap v a -> m (Bootstrap v a))
    -> Data (Bootstrap v a)
    Bootstrap v a -> Constr
    Bootstrap v a -> DataType
    (forall b. Data b => b -> b) -> Bootstrap v a -> Bootstrap v a
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Bootstrap v a -> u
    forall u. (forall d. Data d => d -> u) -> Bootstrap v a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bootstrap v a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bootstrap v a -> c (Bootstrap v a)
    forall (v :: * -> *) a.
    (Typeable v, Data a, Data (v a)) =>
    Typeable (Bootstrap v a)
    forall (v :: * -> *) a.
    (Typeable v, Data a, Data (v a)) =>
    Bootstrap v a -> Constr
    forall (v :: * -> *) a.
    (Typeable v, Data a, Data (v a)) =>
    Bootstrap v a -> DataType
    forall (v :: * -> *) a.
    (Typeable v, Data a, Data (v a)) =>
    (forall b. Data b => b -> b) -> Bootstrap v a -> Bootstrap v a
    forall (v :: * -> *) a u.
    (Typeable v, Data a, Data (v a)) =>
    Int -> (forall d. Data d => d -> u) -> Bootstrap v a -> u
    forall (v :: * -> *) a u.
    (Typeable v, Data a, Data (v a)) =>
    (forall d. Data d => d -> u) -> Bootstrap v a -> [u]
    forall (v :: * -> *) a r r'.
    (Typeable v, Data a, Data (v a)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r
    forall (v :: * -> *) a r r'.
    (Typeable v, Data a, Data (v a)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r
    forall (v :: * -> *) a (m :: * -> *).
    (Typeable v, Data a, Data (v a), Monad m) =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    forall (v :: * -> *) a (m :: * -> *).
    (Typeable v, Data a, Data (v a), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    forall (v :: * -> *) a (c :: * -> *).
    (Typeable v, Data a, Data (v a)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bootstrap v a)
    forall (v :: * -> *) a (c :: * -> *).
    (Typeable v, Data a, Data (v a)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bootstrap v a -> c (Bootstrap v a)
    forall (v :: * -> *) a (t :: * -> *) (c :: * -> *).
    (Typeable v, Data a, Data (v a), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bootstrap v a))
    forall (v :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
    (Typeable v, Data a, Data (v a), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bootstrap v a))
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bootstrap v a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bootstrap v a))
    $cgfoldl :: forall (v :: * -> *) a (c :: * -> *).
    (Typeable v, Data a, Data (v a)) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bootstrap v a -> c (Bootstrap v a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bootstrap v a -> c (Bootstrap v a)
    $cgunfold :: forall (v :: * -> *) a (c :: * -> *).
    (Typeable v, Data a, Data (v a)) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bootstrap v a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bootstrap v a)
    $ctoConstr :: forall (v :: * -> *) a.
    (Typeable v, Data a, Data (v a)) =>
    Bootstrap v a -> Constr
    toConstr :: Bootstrap v a -> Constr
    $cdataTypeOf :: forall (v :: * -> *) a.
    (Typeable v, Data a, Data (v a)) =>
    Bootstrap v a -> DataType
    dataTypeOf :: Bootstrap v a -> DataType
    $cdataCast1 :: forall (v :: * -> *) a (t :: * -> *) (c :: * -> *).
    (Typeable v, Data a, Data (v a), Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bootstrap v a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bootstrap v a))
    $cdataCast2 :: forall (v :: * -> *) a (t :: * -> * -> *) (c :: * -> *).
    (Typeable v, Data a, Data (v a), Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bootstrap v a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bootstrap v a))
    $cgmapT :: forall (v :: * -> *) a.
    (Typeable v, Data a, Data (v a)) =>
    (forall b. Data b => b -> b) -> Bootstrap v a -> Bootstrap v a
    gmapT :: (forall b. Data b => b -> b) -> Bootstrap v a -> Bootstrap v a
    $cgmapQl :: forall (v :: * -> *) a r r'.
    (Typeable v, Data a, Data (v a)) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r
    $cgmapQr :: forall (v :: * -> *) a r r'.
    (Typeable v, Data a, Data (v a)) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bootstrap v a -> r
    $cgmapQ :: forall (v :: * -> *) a u.
    (Typeable v, Data a, Data (v a)) =>
    (forall d. Data d => d -> u) -> Bootstrap v a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Bootstrap v a -> [u]
    $cgmapQi :: forall (v :: * -> *) a u.
    (Typeable v, Data a, Data (v a)) =>
    Int -> (forall d. Data d => d -> u) -> Bootstrap v a -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bootstrap v a -> u
    $cgmapM :: forall (v :: * -> *) a (m :: * -> *).
    (Typeable v, Data a, Data (v a), Monad m) =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    $cgmapMp :: forall (v :: * -> *) a (m :: * -> *).
    (Typeable v, Data a, Data (v a), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    $cgmapMo :: forall (v :: * -> *) a (m :: * -> *).
    (Typeable v, Data a, Data (v a), MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Bootstrap v a -> m (Bootstrap v a)
    Data
               )

    instance (Binary a,   Binary   (v a)) => Binary   (Bootstrap v a) where
      get :: Get (Bootstrap v a)
    get = (a -> v a -> Bootstrap v a)
    -> Get a -> Get (v a) -> Get (Bootstrap v a)
    forall (m :: * -> *) a1 a2 r.
    Monad m =>
    (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
    liftM2 a -> v a -> Bootstrap v a
    forall (v :: * -> *) a. a -> v a -> Bootstrap v a
    Bootstrap Get a
    forall t. Binary t => Get t
    get Get (v a)
    forall t. Binary t => Get t
    get
      put :: Bootstrap v a -> Put
    put (Bootstrap a
    fs v a
    rs) = a -> Put
    forall t. Binary t => t -> Put
    put a
    fs Put -> Put -> Put
    forall a b. PutM a -> PutM b -> PutM b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> v a -> Put
    forall t. Binary t => t -> Put
    put v a
    rs
    instance (FromJSON a, FromJSON (v a)) => FromJSON (Bootstrap v a)
    instance (ToJSON a,   ToJSON   (v a)) => ToJSON   (Bootstrap v a)

    -- | An estimator of a property of a sample, such as its 'mean'.
    --
    -- The use of an algebraic data type here allows functions such as
    -- 'jackknife' and 'bootstrapBCA' to use more efficient algorithms
    -- when possible.
    data Estimator = Mean
                   | Variance
                   | VarianceUnbiased
                   | StdDev
                   | Function (Sample -> Double)

    -- | Run an 'Estimator' over a sample.
    estimate :: Estimator -> Sample -> Double
    estimate :: Estimator -> Vector Double -> Double
    estimate Estimator
    Mean             = Vector Double -> Double
    forall (v :: * -> *). Vector v Double => v Double -> Double
    mean
    estimate Estimator
    Variance         = Vector Double -> Double
    forall (v :: * -> *). Vector v Double => v Double -> Double
    variance
    estimate Estimator
    VarianceUnbiased = Vector Double -> Double
    forall (v :: * -> *). Vector v Double => v Double -> Double
    varianceUnbiased
    estimate Estimator
    StdDev           = Vector Double -> Double
    forall (v :: * -> *). Vector v Double => v Double -> Double
    stdDev
    estimate (Function Vector Double -> Double
    est) = Vector Double -> Double
    est

    ----------------------------------------------------------------
    -- Resampling
    ----------------------------------------------------------------

    -- | Single threaded and deterministic version of resample.
    resampleST :: PrimMonad m
               => Gen (PrimState m)
               -> [Estimator]         -- ^ Estimation functions.
               -> Int                 -- ^ Number of resamples to compute.
               -> U.Vector Double     -- ^ Original sample.
               -> m [Bootstrap U.Vector Double]
    resampleST :: forall (m :: * -> *).
    PrimMonad m =>
    Gen (PrimState m)
    -> [Estimator]
    -> Int
    -> Vector Double
    -> m [Bootstrap Vector Double]
    resampleST Gen (PrimState m)
    gen [Estimator]
    ests Int
    numResamples Vector Double
    sample = do
      -- Generate resamples
      [Vector Double]
    res <- [Estimator]
    -> (Estimator -> m (Vector Double)) -> m [Vector Double]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    t a -> (a -> m b) -> m (t b)
    forM [Estimator]
    ests ((Estimator -> m (Vector Double)) -> m [Vector Double])
    -> (Estimator -> m (Vector Double)) -> m [Vector Double]
    forall a b. (a -> b) -> a -> b
    $ \Estimator
    e -> Int -> m Double -> m (Vector Double)
    forall (m :: * -> *) a.
    (Monad m, Unbox a) =>
    Int -> m a -> m (Vector a)
    U.replicateM Int
    numResamples (m Double -> m (Vector Double)) -> m Double -> m (Vector Double)
    forall a b. (a -> b) -> a -> b
    $ do
        Vector Double
    v <- Gen (PrimState m) -> Vector Double -> m (Vector Double)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Gen (PrimState m) -> v a -> m (v a)
    resampleVector Gen (PrimState m)
    gen Vector Double
    sample
        Double -> m Double
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> m Double) -> Double -> m Double
    forall a b. (a -> b) -> a -> b
    $! Estimator -> Vector Double -> Double
    estimate Estimator
    e Vector Double
    v
      -- Sort resamples
      [MVector (PrimState m) Double]
    resM <- (Vector Double -> m (MVector (PrimState m) Double))
    -> [Vector Double] -> m [MVector (PrimState m) Double]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Vector Double -> m (Mutable Vector (PrimState m) Double)
    Vector Double -> m (MVector (PrimState m) Double)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    v a -> m (Mutable v (PrimState m) a)
    unsafeThaw [Vector Double]
    res
      (MVector (PrimState m) Double -> m ())
    -> [MVector (PrimState m) Double] -> m ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ MVector (PrimState m) Double -> m ()
    forall (m :: * -> *) (v :: * -> * -> *) e.
    (PrimMonad m, MVector v e, Ord e) =>
    v (PrimState m) e -> m ()
    sort [MVector (PrimState m) Double]
    resM
      [Vector Double]
    resSorted <- (MVector (PrimState m) Double -> m (Vector Double))
    -> [MVector (PrimState m) Double] -> m [Vector Double]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Mutable Vector (PrimState m) Double -> m (Vector Double)
    MVector (PrimState m) Double -> m (Vector Double)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    unsafeFreeze [MVector (PrimState m) Double]
    resM
      [Bootstrap Vector Double] -> m [Bootstrap Vector Double]
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Bootstrap Vector Double] -> m [Bootstrap Vector Double])
    -> [Bootstrap Vector Double] -> m [Bootstrap Vector Double]
    forall a b. (a -> b) -> a -> b
    $ (Double -> Vector Double -> Bootstrap Vector Double)
    -> [Double] -> [Vector Double] -> [Bootstrap Vector Double]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith Double -> Vector Double -> Bootstrap Vector Double
    forall (v :: * -> *) a. a -> v a -> Bootstrap v a
    Bootstrap [Estimator -> Vector Double -> Double
    estimate Estimator
    e Vector Double
    sample | Estimator
    e <- [Estimator]
    ests]
                                 [Vector Double]
    resSorted

    -- | /O(e*r*s)/ Resample a data set repeatedly, with replacement,
    -- computing each estimate over the resampled data.
    --
    -- This function is expensive; it has to do work proportional to
    -- /e*r*s/, where /e/ is the number of estimation functions, /r/ is
    -- the number of resamples to compute, and /s/ is the number of
    -- original samples.
    --
    -- To improve performance, this function will make use of all
    -- available CPUs.  At least with GHC 7.0, parallel performance seems
    -- best if the parallel garbage collector is disabled (RTS option
    -- @-qg@).
    resample :: GenIO
             -> [Estimator]         -- ^ Estimation functions.
             -> Int                 -- ^ Number of resamples to compute.
             -> U.Vector Double     -- ^ Original sample.
             -> IO [(Estimator, Bootstrap U.Vector Double)]
    resample :: GenIO
    -> [Estimator]
    -> Int
    -> Vector Double
    -> IO [(Estimator, Bootstrap Vector Double)]
    resample GenIO
    gen [Estimator]
    ests Int
    numResamples Vector Double
    samples = do
      let ixs :: [Int]
    ixs = (Int -> Int -> Int) -> Int -> [Int] -> [Int]
    forall b a. (b -> a -> b) -> b -> [a] -> [b]
    scanl Int -> Int -> Int
    forall a. Num a => a -> a -> a
    (+) Int
    0 ([Int] -> [Int]) -> [Int] -> [Int]
    forall a b. (a -> b) -> a -> b
    $
                (Int -> Int -> Int) -> [Int] -> [Int] -> [Int]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith Int -> Int -> Int
    forall a. Num a => a -> a -> a
    (+) (Int -> Int -> [Int]
    forall a. Int -> a -> [a]
    replicate Int
    numCapabilities Int
    q)
                            (Int -> Int -> [Int]
    forall a. Int -> a -> [a]
    replicate Int
    r Int
    1 [Int] -> [Int] -> [Int]
    forall a. [a] -> [a] -> [a]
    ++ Int -> [Int]
    forall a. a -> [a]
    repeat Int
    0)
              where (Int
    q,Int
    r) = Int
    numResamples Int -> Int -> (Int, Int)
    forall a. Integral a => a -> a -> (a, a)
    `quotRem` Int
    numCapabilities
      [MVector RealWorld Double]
    results <- (Estimator -> IO (MVector RealWorld Double))
    -> [Estimator] -> IO [MVector RealWorld Double]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (IO (MVector RealWorld Double)
    -> Estimator -> IO (MVector RealWorld Double)
    forall a b. a -> b -> a
    const (Int -> IO (MVector (PrimState IO) Double)
    forall (m :: * -> *) a.
    (PrimMonad m, Unbox a) =>
    Int -> m (MVector (PrimState m) a)
    MU.new Int
    numResamples)) [Estimator]
    ests
      [Gen RealWorld]
    gens <- Int -> GenIO -> IO [GenIO]
    splitGen Int
    numCapabilities GenIO
    gen
      [(Int, Int, Gen RealWorld)]
    -> ((Int, Int, Gen RealWorld) -> IO ()) -> IO ()
    forall (f :: * -> *) a b. Foldable f => f a -> (a -> IO b) -> IO ()
    forConcurrently_ ([Int] -> [Int] -> [Gen RealWorld] -> [(Int, Int, Gen RealWorld)]
    forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
    zip3 [Int]
    ixs ([Int] -> [Int]
    forall a. HasCallStack => [a] -> [a]
    tail [Int]
    ixs) [Gen RealWorld]
    gens) (((Int, Int, Gen RealWorld) -> IO ()) -> IO ())
    -> ((Int, Int, Gen RealWorld) -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ (Int
    start,!Int
    end,Gen RealWorld
    gen') -> do
        -- on GHCJS it doesn't make sense to do any forking.
        -- JavaScript runtime has only single capability.
          let loop :: Int
    -> [(Vector Double -> Double, MVector RealWorld Double)] -> IO ()
    loop Int
    k [(Vector Double -> Double, MVector RealWorld Double)]
    ers | Int
    k Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    end = () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
                         | Bool
    otherwise = do
                Vector Double
    re <- GenIO -> Vector Double -> IO (Vector Double)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Gen (PrimState m) -> v a -> m (v a)
    resampleVector Gen RealWorld
    GenIO
    gen' Vector Double
    samples
                [(Vector Double -> Double, MVector RealWorld Double)]
    -> ((Vector Double -> Double, MVector RealWorld Double) -> IO ())
    -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    t a -> (a -> m b) -> m ()
    forM_ [(Vector Double -> Double, MVector RealWorld Double)]
    ers (((Vector Double -> Double, MVector RealWorld Double) -> IO ())
     -> IO ())
    -> ((Vector Double -> Double, MVector RealWorld Double) -> IO ())
    -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \(Vector Double -> Double
    est,MVector RealWorld Double
    arr) ->
                    MVector (PrimState IO) Double -> Int -> Double -> IO ()
    forall (m :: * -> *) a.
    (PrimMonad m, Unbox a) =>
    MVector (PrimState m) a -> Int -> a -> m ()
    MU.write MVector RealWorld Double
    MVector (PrimState IO) Double
    arr Int
    k (Double -> IO ())
    -> (Vector Double -> Double) -> Vector Double -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector Double -> Double
    est (Vector Double -> IO ()) -> Vector Double -> IO ()
    forall a b. (a -> b) -> a -> b
    $ Vector Double
    re
                Int
    -> [(Vector Double -> Double, MVector RealWorld Double)] -> IO ()
    loop (Int
    kInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) [(Vector Double -> Double, MVector RealWorld Double)]
    ers
          Int
    -> [(Vector Double -> Double, MVector RealWorld Double)] -> IO ()
    loop Int
    start ([Vector Double -> Double]
    -> [MVector RealWorld Double]
    -> [(Vector Double -> Double, MVector RealWorld Double)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [Vector Double -> Double]
    ests' [MVector RealWorld Double]
    results)
      (MVector RealWorld Double -> IO ())
    -> [MVector RealWorld Double] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ MVector RealWorld Double -> IO ()
    MVector (PrimState IO) Double -> IO ()
    forall (m :: * -> *) (v :: * -> * -> *) e.
    (PrimMonad m, MVector v e, Ord e) =>
    v (PrimState m) e -> m ()
    sort [MVector RealWorld Double]
    results
      -- Build resamples
      [Vector Double]
    res <- (MVector RealWorld Double -> IO (Vector Double))
    -> [MVector RealWorld Double] -> IO [Vector Double]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Mutable Vector (PrimState IO) Double -> IO (Vector Double)
    MVector RealWorld Double -> IO (Vector Double)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    unsafeFreeze [MVector RealWorld Double]
    results
      [(Estimator, Bootstrap Vector Double)]
    -> IO [(Estimator, Bootstrap Vector Double)]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([(Estimator, Bootstrap Vector Double)]
     -> IO [(Estimator, Bootstrap Vector Double)])
    -> [(Estimator, Bootstrap Vector Double)]
    -> IO [(Estimator, Bootstrap Vector Double)]
    forall a b. (a -> b) -> a -> b
    $ [Estimator]
    -> [Bootstrap Vector Double]
    -> [(Estimator, Bootstrap Vector Double)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [Estimator]
    ests
             ([Bootstrap Vector Double]
     -> [(Estimator, Bootstrap Vector Double)])
    -> [Bootstrap Vector Double]
    -> [(Estimator, Bootstrap Vector Double)]
    forall a b. (a -> b) -> a -> b
    $ (Double -> Vector Double -> Bootstrap Vector Double)
    -> [Double] -> [Vector Double] -> [Bootstrap Vector Double]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith Double -> Vector Double -> Bootstrap Vector Double
    forall (v :: * -> *) a. a -> v a -> Bootstrap v a
    Bootstrap [Estimator -> Vector Double -> Double
    estimate Estimator
    e Vector Double
    samples | Estimator
    e <- [Estimator]
    ests]
                                 [Vector Double]
    res
     where
      ests' :: [Vector Double -> Double]
    ests' = (Estimator -> Vector Double -> Double)
    -> [Estimator] -> [Vector Double -> Double]
    forall a b. (a -> b) -> [a] -> [b]
    map Estimator -> Vector Double -> Double
    estimate [Estimator]
    ests

    -- | Create vector using resamples
    resampleVector :: (PrimMonad m, G.Vector v a)
                   => Gen (PrimState m) -> v a -> m (v a)
    resampleVector :: forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Gen (PrimState m) -> v a -> m (v a)
    resampleVector Gen (PrimState m)
    gen v a
    v
      = Int -> m a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    Int -> m a -> m (v a)
    G.replicateM Int
    n (m a -> m (v a)) -> m a -> m (v a)
    forall a b. (a -> b) -> a -> b
    $ do Int
    i <- (Int, Int) -> Gen (PrimState m) -> m Int
    forall a (m :: * -> *).
    (Variate a, PrimMonad m) =>
    (a, a) -> Gen (PrimState m) -> m a
    forall (m :: * -> *).
    PrimMonad m =>
    (Int, Int) -> Gen (PrimState m) -> m Int
    uniformR (Int
    0,Int
    nInt -> Int -> Int
    forall a. Num a => a -> a -> a
    -Int
    1) Gen (PrimState m)
    gen
                            a -> m a
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> m a) -> a -> m a
    forall a b. (a -> b) -> a -> b
    $! v a -> Int -> a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> a
    G.unsafeIndex v a
    v Int
    i
      where
        n :: Int
    n = v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    G.length v a
    v

    ----------------------------------------------------------------
    -- Jackknife
    ----------------------------------------------------------------

    -- | /O(n) or O(n^2)/ Compute a statistical estimate repeatedly over a
    -- sample, each time omitting a successive element.
    jackknife :: Estimator -> Sample -> U.Vector Double
    jackknife :: Estimator -> Vector Double -> Vector Double
    jackknife Estimator
    Mean Vector Double
    sample             = Vector Double -> Vector Double
    jackknifeMean Vector Double
    sample
    jackknife Estimator
    Variance Vector Double
    sample         = Vector Double -> Vector Double
    jackknifeVariance Vector Double
    sample
    jackknife Estimator
    VarianceUnbiased Vector Double
    sample = Vector Double -> Vector Double
    jackknifeVarianceUnb Vector Double
    sample
    jackknife Estimator
    StdDev Vector Double
    sample = Vector Double -> Vector Double
    jackknifeStdDev Vector Double
    sample
    jackknife (Function Vector Double -> Double
    est) Vector Double
    sample
      | Vector Double -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    G.length Vector Double
    sample Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 = String -> Vector Double
    forall a. String -> a
    singletonErr String
    "jackknife"
      | Bool
    otherwise            = (Int -> Double) -> Vector Int -> Vector Double
    forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
    U.map Int -> Double
    f (Vector Int -> Vector Double)
    -> (Vector Double -> Vector Int) -> Vector Double -> Vector Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector Double -> Vector Int
    forall (v :: * -> *) a. (Vector v a, Vector v Int) => v a -> v Int
    indices (Vector Double -> Vector Double) -> Vector Double -> Vector Double
    forall a b. (a -> b) -> a -> b
    $ Vector Double
    sample
      where f :: Int -> Double
    f Int
    i = Vector Double -> Double
    est (Int -> Vector Double -> Vector Double
    forall e. Unbox e => Int -> Vector e -> Vector e
    dropAt Int
    i Vector Double
    sample)

    -- | /O(n)/ Compute the jackknife mean of a sample.
    jackknifeMean :: Sample -> U.Vector Double
    jackknifeMean :: Vector Double -> Vector Double
    jackknifeMean Vector Double
    samp
      | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1  = String -> Vector Double
    forall a. String -> a
    singletonErr String
    "jackknifeMean"
      | Bool
    otherwise = (Double -> Double) -> Vector Double -> Vector Double
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    G.map (Double -> Double -> Double
    forall a. Fractional a => a -> a -> a
    /Double
    l) (Vector Double -> Vector Double) -> Vector Double -> Vector Double
    forall a b. (a -> b) -> a -> b
    $ (Double -> Double -> Double)
    -> Vector Double -> Vector Double -> Vector Double
    forall (v :: * -> *) a b c.
    (Vector v a, Vector v b, Vector v c) =>
    (a -> b -> c) -> v a -> v b -> v c
    G.zipWith Double -> Double -> Double
    forall a. Num a => a -> a -> a
    (+) (Vector Double -> Vector Double
    pfxSumL Vector Double
    samp) (Vector Double -> Vector Double
    pfxSumR Vector Double
    samp)
      where
        l :: Double
    l   = Int -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int
    len Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1)
        len :: Int
    len = Vector Double -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    G.length Vector Double
    samp

    -- | /O(n)/ Compute the jackknife variance of a sample with a
    -- correction factor @c@, so we can get either the regular or
    -- \"unbiased\" variance.
    jackknifeVariance_ :: Double -> Sample -> U.Vector Double
    jackknifeVariance_ :: Double -> Vector Double -> Vector Double
    jackknifeVariance_ Double
    c Vector Double
    samp
      | Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1  = String -> Vector Double
    forall a. String -> a
    singletonErr String
    "jackknifeVariance"
      | Bool
    otherwise = (Double -> Double -> Double -> Double -> Double)
    -> Vector Double
    -> Vector Double
    -> Vector Double
    -> Vector Double
    -> Vector Double
    forall (v :: * -> *) a b c d e.
    (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) =>
    (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
    G.zipWith4 Double -> Double -> Double -> Double -> Double
    go Vector Double
    als Vector Double
    ars Vector Double
    bls Vector Double
    brs
      where
        als :: Vector Double
    als = Vector Double -> Vector Double
    pfxSumL (Vector Double -> Vector Double)
    -> (Vector Double -> Vector Double)
    -> Vector Double
    -> Vector Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Double -> Double) -> Vector Double -> Vector Double
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    G.map Double -> Double
    goa (Vector Double -> Vector Double) -> Vector Double -> Vector Double
    forall a b. (a -> b) -> a -> b
    $ Vector Double
    samp
        ars :: Vector Double
    ars = Vector Double -> Vector Double
    pfxSumR (Vector Double -> Vector Double)
    -> (Vector Double -> Vector Double)
    -> Vector Double
    -> Vector Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Double -> Double) -> Vector Double -> Vector Double
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    G.map Double -> Double
    goa (Vector Double -> Vector Double) -> Vector Double -> Vector Double
    forall a b. (a -> b) -> a -> b
    $ Vector Double
    samp
        goa :: Double -> Double
    goa Double
    x = Double
    v Double -> Double -> Double
    forall a. Num a => a -> a -> a
    * Double
    v where v :: Double
    v = Double
    x Double -> Double -> Double
    forall a. Num a => a -> a -> a
    - Double
    m
        bls :: Vector Double
    bls = Vector Double -> Vector Double
    pfxSumL (Vector Double -> Vector Double)
    -> (Vector Double -> Vector Double)
    -> Vector Double
    -> Vector Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Double -> Double) -> Vector Double -> Vector Double
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    G.map (Double -> Double -> Double
    forall a. Num a => a -> a -> a
    subtract Double
    m) (Vector Double -> Vector Double) -> Vector Double -> Vector Double
    forall a b. (a -> b) -> a -> b
    $ Vector Double
    samp
        brs :: Vector Double
    brs = Vector Double -> Vector Double
    pfxSumR (Vector Double -> Vector Double)
    -> (Vector Double -> Vector Double)
    -> Vector Double
    -> Vector Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Double -> Double) -> Vector Double -> Vector Double
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    G.map (Double -> Double -> Double
    forall a. Num a => a -> a -> a
    subtract Double
    m) (Vector Double -> Vector Double) -> Vector Double -> Vector Double
    forall a b. (a -> b) -> a -> b
    $ Vector Double
    samp
        m :: Double
    m = Vector Double -> Double
    forall (v :: * -> *). Vector v Double => v Double -> Double
    mean Vector Double
    samp
        n :: Double
    n = Int -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    len
        go :: Double -> Double -> Double -> Double -> Double
    go Double
    al Double
    ar Double
    bl Double
    br = (Double
    al Double -> Double -> Double
    forall a. Num a => a -> a -> a
    + Double
    ar Double -> Double -> Double
    forall a. Num a => a -> a -> a
    - (Double
    b Double -> Double -> Double
    forall a. Num a => a -> a -> a
    * Double
    b) Double -> Double -> Double
    forall a. Fractional a => a -> a -> a
    / Double
    q) Double -> Double -> Double
    forall a. Fractional a => a -> a -> a
    / (Double
    q Double -> Double -> Double
    forall a. Num a => a -> a -> a
    - Double
    c)
          where b :: Double
    b = Double
    bl Double -> Double -> Double
    forall a. Num a => a -> a -> a
    + Double
    br
                q :: Double
    q = Double
    n Double -> Double -> Double
    forall a. Num a => a -> a -> a
    - Double
    1
        len :: Int
    len = Vector Double -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    G.length Vector Double
    samp

    -- | /O(n)/ Compute the unbiased jackknife variance of a sample.
    jackknifeVarianceUnb :: Sample -> U.Vector Double
    jackknifeVarianceUnb :: Vector Double -> Vector Double
    jackknifeVarianceUnb Vector Double
    samp
      | Vector Double -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    G.length Vector Double
    samp Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    2  = String -> Vector Double
    forall a. String -> a
    singletonErr String
    "jackknifeVariance"
      | Bool
    otherwise           = Double -> Vector Double -> Vector Double
    jackknifeVariance_ Double
    1 Vector Double
    samp

    -- | /O(n)/ Compute the jackknife variance of a sample.
    jackknifeVariance :: Sample -> U.Vector Double
    jackknifeVariance :: Vector Double -> Vector Double
    jackknifeVariance = Double -> Vector Double -> Vector Double
    jackknifeVariance_ Double
    0

    -- | /O(n)/ Compute the jackknife standard deviation of a sample.
    jackknifeStdDev :: Sample -> U.Vector Double
    jackknifeStdDev :: Vector Double -> Vector Double
    jackknifeStdDev = (Double -> Double) -> Vector Double -> Vector Double
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    G.map Double -> Double
    forall a. Floating a => a -> a
    sqrt (Vector Double -> Vector Double)
    -> (Vector Double -> Vector Double)
    -> Vector Double
    -> Vector Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector Double -> Vector Double
    jackknifeVarianceUnb

    pfxSumL :: U.Vector Double -> U.Vector Double
    pfxSumL :: Vector Double -> Vector Double
    pfxSumL = (KBNSum -> Double) -> Vector KBNSum -> Vector Double
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    G.map KBNSum -> Double
    kbn (Vector KBNSum -> Vector Double)
    -> (Vector Double -> Vector KBNSum)
    -> Vector Double
    -> Vector Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (KBNSum -> Double -> KBNSum)
    -> KBNSum -> Vector Double -> Vector KBNSum
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    G.scanl KBNSum -> Double -> KBNSum
    forall s. Summation s => s -> Double -> s
    add KBNSum
    forall s. Summation s => s
    zero

    pfxSumR :: U.Vector Double -> U.Vector Double
    pfxSumR :: Vector Double -> Vector Double
    pfxSumR = Vector Double -> Vector Double
    forall (v :: * -> *) a. Vector v a => v a -> v a
    G.tail (Vector Double -> Vector Double)
    -> (Vector Double -> Vector Double)
    -> Vector Double
    -> Vector Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (KBNSum -> Double) -> Vector KBNSum -> Vector Double
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    G.map KBNSum -> Double
    kbn (Vector KBNSum -> Vector Double)
    -> (Vector Double -> Vector KBNSum)
    -> Vector Double
    -> Vector Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Double -> KBNSum -> KBNSum)
    -> KBNSum -> Vector Double -> Vector KBNSum
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    G.scanr ((KBNSum -> Double -> KBNSum) -> Double -> KBNSum -> KBNSum
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip KBNSum -> Double -> KBNSum
    forall s. Summation s => s -> Double -> s
    add) KBNSum
    forall s. Summation s => s
    zero

    -- | Drop the /k/th element of a vector.
    dropAt :: U.Unbox e => Int -> U.Vector e -> U.Vector e
    dropAt :: forall e. Unbox e => Int -> Vector e -> Vector e
    dropAt Int
    n Vector e
    v = Int -> Int -> Vector e -> Vector e
    forall a. Unbox a => Int -> Int -> Vector a -> Vector a
    U.slice Int
    0 Int
    n Vector e
    v Vector e -> Vector e -> Vector e
    forall a. Unbox a => Vector a -> Vector a -> Vector a
    U.++ Int -> Int -> Vector e -> Vector e
    forall a. Unbox a => Int -> Int -> Vector a -> Vector a
    U.slice (Int
    nInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) (Vector e -> Int
    forall a. Unbox a => Vector a -> Int
    U.length Vector e
    v Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1) Vector e
    v

    singletonErr :: String -> a
    singletonErr :: forall a. String -> a
    singletonErr String
    func = String -> a
    forall a. HasCallStack => String -> a
    error (String -> a) -> String -> a
    forall a b. (a -> b) -> a -> b
    $
                        String
    "Statistics.Resampling." String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    func String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ": not enough elements in sample"

    -- | Split a generator into several that can run independently.
    splitGen :: Int -> GenIO -> IO [GenIO]
    splitGen :: Int -> GenIO -> IO [GenIO]
    splitGen Int
    n GenIO
    gen
      | Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    0    = [Gen RealWorld] -> IO [Gen RealWorld]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return []
      | Bool
    otherwise =
      ([Gen RealWorld] -> [Gen RealWorld])
    -> IO [Gen RealWorld] -> IO [Gen RealWorld]
    forall a b. (a -> b) -> IO a -> IO b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Gen RealWorld
    GenIO
    genGen RealWorld -> [Gen RealWorld] -> [Gen RealWorld]
    forall a. a -> [a] -> [a]
    :) (IO [Gen RealWorld] -> IO [GenIO])
    -> (IO (Gen RealWorld) -> IO [Gen RealWorld])
    -> IO (Gen RealWorld)
    -> IO [GenIO]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> IO (Gen RealWorld) -> IO [Gen RealWorld]
    forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
    replicateM (Int
    nInt -> Int -> Int
    forall a. Num a => a -> a -> a
    -Int
    1) (IO (Gen RealWorld) -> IO [GenIO])
    -> IO (Gen RealWorld) -> IO [GenIO]
    forall a b. (a -> b) -> a -> b
    $
      Vector Word32 -> IO (Gen RealWorld)
    Vector Word32 -> IO GenIO
    forall (m :: * -> *) (v :: * -> *).
    (PrimMonad m, Vector v Word32) =>
    v Word32 -> m (Gen (PrimState m))
    initialize (Vector Word32 -> IO (Gen RealWorld))
    -> IO (Vector Word32) -> IO (Gen RealWorld)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< (Gen RealWorld -> Int -> IO (Vector Word32)
    forall (m :: * -> *) g a (v :: * -> *).
    (PrimMonad m, StatefulGen g m, Uniform a, Vector v a) =>
    g -> Int -> m (v a)
    uniformVector Gen RealWorld
    GenIO
    gen Int
    256 :: IO (U.Vector Word32))