-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Sample from a posterior using Markov chain Monte Carlo
--   
--   Please see the README on GitHub at
--   <a>https://github.com/dschrempf/mcmc#readme</a>
@package mcmc
@version 0.2.2


-- | Creation date: Mon Aug 3 10:46:27 2020.
module Mcmc.Internal.ByteString

-- | For a given width, align string to the right; use given fill
--   character; trim on the left if string is longer.
alignRightWith :: Char -> Int -> ByteString -> ByteString

-- | For a given width, align string to the right; trim on the left if
--   string is longer.
alignRight :: Int -> ByteString -> ByteString

-- | For a given width, align string to the left; use given fill character;
--   trim on the right if string is longer.
alignLeftWith :: Char -> Int -> ByteString -> ByteString

-- | For a given width, align string to the left; trim on the right if
--   string is longer.
alignLeft :: Int -> ByteString -> ByteString


-- | Creation date: Wed May 20 09:10:27 2020.
module Mcmc.Item

-- | An <a>Item</a>, or link of the Markov chain. For reasons of
--   computational efficiency, each state is associated with the
--   corresponding prior and likelihood.
data Item a
Item :: a -> Log Double -> Log Double -> Item a

-- | The current state in the state space <tt>a</tt>.
[state] :: Item a -> a

-- | The current prior.
[prior] :: Item a -> Log Double

-- | The current likelihood.
[likelihood] :: Item a -> Log Double
instance GHC.Read.Read a => GHC.Read.Read (Mcmc.Item.Item a)
instance GHC.Show.Show a => GHC.Show.Show (Mcmc.Item.Item a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Mcmc.Item.Item a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Mcmc.Item.Item a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (Mcmc.Item.Item a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (Mcmc.Item.Item a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (Numeric.Log.Log a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (Numeric.Log.Log a)


-- | Creation date: Fri May 29 12:30:03 2020.
module Mcmc.Monitor.Log

-- | Print a log value.
renderLog :: Log Double -> ByteString


-- | Creation date: Fri May 29 11:11:49 2020.
module Mcmc.Monitor.Parameter

-- | Instruction about a parameter to monitor.
data MonitorParameter a
MonitorParameter :: String -> (a -> Builder) -> MonitorParameter a

-- | Name of parameter.
[mpName] :: MonitorParameter a -> String

-- | Instruction about how to extract the parameter from the state.
[mpFunc] :: MonitorParameter a -> a -> Builder

-- | Convert a parameter monitor from one data type to another using a
--   lens.
--   
--   For example, to monitor a <a>Double</a> value being the first entry of
--   a tuple:
--   
--   <pre>
--   mon = _1 @@ monitorDouble
--   </pre>
(@.) :: Lens' b a -> MonitorParameter a -> MonitorParameter b

-- | Monitor <a>Int</a>.
monitorInt :: String -> MonitorParameter Int

-- | Monitor <a>Double</a> with eight decimal places (half precision).
monitorDouble :: String -> MonitorParameter Double

-- | Monitor <a>Double</a> with full precision computing the shortest
--   string of digits that correctly represent the number.
monitorDoubleF :: String -> MonitorParameter Double

-- | Monitor <a>Double</a> in exponential format and half precision.
monitorDoubleE :: String -> MonitorParameter Double


-- | Creation date: Fri May 29 11:11:49 2020.
--   
--   Batch mean monitors.
module Mcmc.Monitor.ParameterBatch

-- | Instruction about a parameter to monitor via batch means. Usually, the
--   monitored parameter is average over the batch size. However, arbitrary
--   functions performing more complicated analyses on the states in the
--   batch can be provided.
--   
--   XXX: Batch monitors are slow at the moment because the monitored
--   parameter has to be extracted from the state for each iteration.
data MonitorParameterBatch a
MonitorParameterBatch :: String -> ([a] -> Builder) -> MonitorParameterBatch a

-- | Name of batch monitored parameter.
[mbpName] :: MonitorParameterBatch a -> String

-- | Instruction about how to extract the batch mean from the trace.
[mbpFunc] :: MonitorParameterBatch a -> [a] -> Builder

-- | Convert a batch parameter monitor from one data type to another using
--   a lens.
--   
--   For example, to batch monitor a real float value being the first entry
--   of a tuple:
--   
--   <pre>
--   mon = _1 @# monitorBatchMeanRealFloat
--   </pre>
(@#) :: Lens' b a -> MonitorParameterBatch a -> MonitorParameterBatch b

-- | Batch monitor. Print the mean with eight decimal places (half
--   precision).
monitorBatchMean :: Real a => String -> MonitorParameterBatch a

-- | Batch monitor. Print the mean with full precision computing the
--   shortest string of digits that correctly represent the number.
monitorBatchMeanF :: Real a => String -> MonitorParameterBatch a

-- | Batch monitor real float parameters such as <a>Double</a> with
--   scientific notation and eight decimal places.
monitorBatchMeanE :: Real a => String -> MonitorParameterBatch a

-- | Batch monitor parameters with custom lens and builder.
monitorBatchCustom :: String -> ([a] -> a) -> (a -> Builder) -> MonitorParameterBatch a


-- | Creation date: Fri May 29 12:36:43 2020.
module Mcmc.Monitor.Time

-- | Adapted from System.ProgressBar.renderDuration of package
--   <a>terminal-progressbar-0.4.1</a>.
renderDuration :: NominalDiffTime -> ByteString

-- | Render duration in seconds.
renderDurationS :: NominalDiffTime -> ByteString


-- | Creation date: Wed May 20 14:37:09 2020.
--   
--   From <a>https://wiki.haskell.org/Random_shuffle</a>.
module Mcmc.Tools.Shuffle

-- | Shuffle a list.
shuffle :: [a] -> GenIO -> IO [a]

-- | Shuffle a list <tt>n</tt> times.
shuffleN :: [a] -> Int -> GenIO -> IO [[a]]

-- | <tt>grabble xs m n</tt> is <i>O(m*n')</i>, where <tt>n' = min n
--   (length xs)</tt>. Choose <tt>n'</tt> elements from <tt>xs</tt>,
--   without replacement, and that <tt>m</tt> times.
grabble :: [a] -> Int -> Int -> GenIO -> IO [[a]]


-- | Creation date: Wed May 20 13:42:53 2020.
module Mcmc.Proposal

-- | A <a>Proposal</a> is an instruction about how the Markov chain will
--   traverse the state space <tt>a</tt>. Essentially, it is a probability
--   mass or probability density conditioned on the current state (i.e., a
--   kernel).
--   
--   A <a>Proposal</a> may be tuneable in that it contains information
--   about how to enlarge or shrink the step size to tune the acceptance
--   ratio.
data Proposal a
Proposal :: String -> Int -> ProposalSimple a -> Maybe (Tuner a) -> Proposal a

-- | Name (no proposals with the same name are allowed in a <a>Cycle</a>).
[pName] :: Proposal a -> String

-- | The weight determines how often a <a>Proposal</a> is executed per
--   iteration of the Markov chain.
[pWeight] :: Proposal a -> Int

-- | Simple proposal without tuning information.
[pSimple] :: Proposal a -> ProposalSimple a

-- | Tuning is disabled if set to <a>Nothing</a>.
[pTuner] :: Proposal a -> Maybe (Tuner a)

-- | Convert a proposal from one data type to another using a lens.
--   
--   For example:
--   
--   <pre>
--   scaleFirstEntryOfTuple = scale &gt;&gt;&gt; _1
--   </pre>
(@~) :: Lens' b a -> Proposal a -> Proposal b

-- | Simple proposal without tuning information.
--   
--   Instruction about randomly moving from the current state to a new
--   state, given some source of randomness.
--   
--   In order to calculate the Metropolis-Hastings ratio, we need to know
--   the ratio of the backward to forward kernels (i.e., the probability
--   masses or probability densities). For unbiased proposals, this ratio
--   is 1.0.
newtype ProposalSimple a
ProposalSimple :: (a -> GenIO -> IO (a, Log Double)) -> ProposalSimple a
[pSample] :: ProposalSimple a -> a -> GenIO -> IO (a, Log Double)

-- | Tune the acceptance ratio of a <a>Proposal</a>; see <a>tune</a>, or
--   <a>autotuneCycle</a>.
data Tuner a

-- | Create a possibly tuneable proposal.
createProposal :: String -> Int -> (Double -> ProposalSimple a) -> Bool -> Proposal a

-- | Tune a <a>Proposal</a>. Return <a>Nothing</a> if <a>Proposal</a> is
--   not tuneable. If the parameter <tt>dt</tt> is larger than 1.0, the
--   <a>Proposal</a> is enlarged, if <tt>0&lt;dt&lt;1.0</tt>, it is shrunk.
--   Negative tuning parameters are not allowed.
tune :: Double -> Proposal a -> Maybe (Proposal a)

-- | Define the order in which <a>Proposal</a>s are executed in a
--   <a>Cycle</a>. The total number of <a>Proposal</a>s per <a>Cycle</a>
--   may differ between <a>Order</a>s (e.g., compare <a>RandomO</a> and
--   <a>RandomReversibleO</a>).
data Order

-- | Shuffle the <a>Proposal</a>s in the <a>Cycle</a>. The <a>Proposal</a>s
--   are replicated according to their weights and executed in random
--   order. If a <a>Proposal</a> has weight <tt>w</tt>, it is executed
--   exactly <tt>w</tt> times per iteration.
RandomO :: Order

-- | The <a>Proposal</a>s are executed sequentially, in the order they
--   appear in the <a>Cycle</a>. <a>Proposal</a>s with weight
--   <tt>w&gt;1</tt> are repeated immediately <tt>w</tt> times (and not
--   appended to the end of the list).
SequentialO :: Order

-- | Similar to <a>RandomO</a>. However, a reversed copy of the list of
--   shuffled <a>Proposal</a>s is appended such that the resulting Markov
--   chain is reversible. Note: the total number of <a>Proposal</a>s
--   executed per cycle is twice the number of <a>RandomO</a>.
RandomReversibleO :: Order

-- | Similar to <a>SequentialO</a>. However, a reversed copy of the list of
--   sequentially ordered <a>Proposal</a>s is appended such that the
--   resulting Markov chain is reversible.
SequentialReversibleO :: Order

-- | In brief, a <a>Cycle</a> is a list of proposals. The state of the
--   Markov chain will be logged only after all <a>Proposal</a>s in the
--   <a>Cycle</a> have been completed, and the iteration counter will be
--   increased by one. The order in which the <a>Proposal</a>s are executed
--   is specified by <a>Order</a>. The default is <a>RandomO</a>.
--   
--   <b>Proposals must have unique names</b>, so that they can be
--   identified.
data Cycle a

-- | Create a <a>Cycle</a> from a list of <a>Proposal</a>s.
fromList :: [Proposal a] -> Cycle a

-- | Set the order of <a>Proposal</a>s in a <a>Cycle</a>.
setOrder :: Order -> Cycle a -> Cycle a

-- | Replicate <a>Proposal</a>s according to their weights and possibly
--   shuffle them.
getNCycles :: Cycle a -> Int -> GenIO -> IO [[Proposal a]]

-- | Tune <a>Proposal</a>s in the <a>Cycle</a>. See <a>tune</a>.
tuneCycle :: Map (Proposal a) Double -> Cycle a -> Cycle a

-- | Calculate acceptance ratios and auto tune the <a>Proposal</a>s in the
--   <a>Cycle</a>. For now, a <a>Proposal</a> is enlarged when the
--   acceptance ratio is above 0.44, and shrunk otherwise. Do not change
--   <a>Proposal</a>s that are not tuneable.
autotuneCycle :: Acceptance (Proposal a) -> Cycle a -> Cycle a

-- | Summarize the <a>Proposal</a>s in the <a>Cycle</a>. Also report
--   acceptance ratios.
summarizeCycle :: Acceptance (Proposal a) -> Cycle a -> ByteString

-- | For each key <tt>k</tt>, store the number of accepted and rejected
--   proposals.
data Acceptance k

-- | In the beginning there was the Word.
--   
--   Initialize an empty storage of accepted/rejected values.
emptyA :: Ord k => [k] -> Acceptance k

-- | For key <tt>k</tt>, prepend an accepted (True) or rejected (False)
--   proposal.
pushA :: (Ord k, Show k) => k -> Bool -> Acceptance k -> Acceptance k

-- | Reset acceptance storage.
resetA :: Ord k => Acceptance k -> Acceptance k

-- | Transform keys using the given lists. Keys not provided will not be
--   present in the new <a>Acceptance</a> variable.
transformKeysA :: (Ord k1, Ord k2) => [k1] -> [k2] -> Acceptance k1 -> Acceptance k2

-- | Acceptance ratios for all proposals.
acceptanceRatios :: Acceptance k -> Map k Double
instance GHC.Show.Show Mcmc.Proposal.Order
instance GHC.Classes.Eq Mcmc.Proposal.Order
instance Data.Aeson.Types.ToJSON.ToJSONKey k => Data.Aeson.Types.ToJSON.ToJSON (Mcmc.Proposal.Acceptance k)
instance (GHC.Classes.Ord k, Data.Aeson.Types.FromJSON.FromJSONKey k) => Data.Aeson.Types.FromJSON.FromJSON (Mcmc.Proposal.Acceptance k)
instance Data.Default.Class.Default Mcmc.Proposal.Order
instance GHC.Show.Show (Mcmc.Proposal.Proposal a)
instance GHC.Classes.Eq (Mcmc.Proposal.Proposal a)
instance GHC.Classes.Ord (Mcmc.Proposal.Proposal a)


-- | Creation date: Thu May 14 20:26:27 2020.
module Mcmc.Proposal.Generic

-- | Generic function to create proposals for continuous parameters
--   (<a>Double</a>).
proposalGenericContinuous :: (ContDistr d, ContGen d) => d -> (a -> Double -> a) -> Maybe (Double -> Double) -> ProposalSimple a

-- | Generic function to create proposals for discrete parameters
--   (<a>Int</a>).
proposalGenericDiscrete :: (DiscreteDistr d, DiscreteGen d) => d -> (a -> Int -> a) -> Maybe (Int -> Int) -> ProposalSimple a


-- | Creation date: Wed May 6 10:59:13 2020.
module Mcmc.Proposal.Slide

-- | Additive proposal with normally distributed kernel.
slide :: String -> Int -> Double -> Double -> Bool -> Proposal Double

-- | Additive proposal with normally distributed kernel with mean zero.
--   This proposal is very fast, because the Metropolis-Hastings ratio does
--   not include calculation of the forwards and backwards kernels.
slideSymmetric :: String -> Int -> Double -> Bool -> Proposal Double

-- | Additive proposal with uniformly distributed kernel. This proposal is
--   very fast, because the Metropolis-Hastings ratio does not include
--   calculation of the forwards and backwards kernels.
slideUniform :: String -> Int -> Double -> Bool -> Proposal Double


-- | Creation date: Thu May 14 21:49:23 2020.
module Mcmc.Proposal.Scale

-- | Multiplicative proposal with Gamma distributed kernel.
scale :: String -> Int -> Double -> Double -> Bool -> Proposal Double

-- | Multiplicative proposal with Gamma distributed kernel. The scale of
--   the Gamma distributions is set to (shape)^{-1}, so that the mean of
--   the Gamma distribution is 1.0.
scaleUnbiased :: String -> Int -> Double -> Bool -> Proposal Double


-- | Creation date: Thu Jun 25 15:49:48 2020.
--   
--   See <a>https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3845170/</a>.
module Mcmc.Proposal.Bactrian

-- | Additive symmetric proposal with kernel similar to the silhouette of a
--   Bactrian camel. The <a>Bactrian kernel</a> is a mixture of two
--   symmetrically arranged normal distributions. The spike parameter
--   loosely determines the standard deviations of the individual humps
--   while the other parameter refers to the standard deviation of the
--   complete Bactrian kernel.
--   
--   See <a>https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3845170/</a>.
slideBactrian :: String -> Int -> Double -> Double -> Bool -> Proposal Double

-- | Multiplicative proposal with kernel similar to the silhouette of a
--   Bactrian camel. See <a>slideBactrian</a>.
scaleBactrian :: String -> Int -> Double -> Double -> Bool -> Proposal Double


-- | Creation date: Wed May 20 09:11:25 2020.
module Mcmc.Trace

-- | A <a>Trace</a> passes through a list of states with associated
--   likelihoods which are called <a>Item</a>s. New <a>Item</a>s are
--   prepended, and the path of the Markov chain is stored in reversed
--   order.
data Trace a

-- | The empty trace.
singletonT :: Item a -> Trace a

-- | Prepend an <a>Item</a> to a <a>Trace</a>.
pushT :: Item a -> Trace a -> Trace a

-- | Get the most recent item of the trace.
headT :: Trace a -> Item a

-- | Get the N most recent items of the trace.
takeItems :: Int -> Trace a -> [Item a]

-- | Shorten the trace to given length.
takeT :: Int -> Trace a -> Trace a
instance GHC.Classes.Eq a => GHC.Classes.Eq (Mcmc.Trace.Trace a)
instance GHC.Read.Read a => GHC.Read.Read (Mcmc.Trace.Trace a)
instance GHC.Show.Show a => GHC.Show.Show (Mcmc.Trace.Trace a)
instance GHC.Base.Semigroup (Mcmc.Trace.Trace a)
instance GHC.Base.Monoid (Mcmc.Trace.Trace a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (Mcmc.Trace.Trace a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (Mcmc.Trace.Trace a)


-- | Creation date: Sat Jun 27 10:49:28 2020.
module Mcmc.Verbosity

-- | Not much to say here.
data Verbosity
Quiet :: Verbosity
Warn :: Verbosity
Info :: Verbosity
Debug :: Verbosity

-- | Perform action if <a>Verbosity</a> is <a>Warn</a> or higher.
warn :: Applicative m => Verbosity -> m () -> m ()

-- | Perform action if <a>Verbosity</a> is <a>Info</a> or higher.
info :: Applicative m => Verbosity -> m () -> m ()

-- | Perform action if <a>Verbosity</a> is <a>Debug</a>.
debug :: Applicative m => Verbosity -> m () -> m ()
instance Data.Aeson.Types.ToJSON.ToJSON Mcmc.Verbosity.Verbosity
instance Data.Aeson.Types.FromJSON.FromJSON Mcmc.Verbosity.Verbosity
instance GHC.Classes.Ord Mcmc.Verbosity.Verbosity
instance GHC.Classes.Eq Mcmc.Verbosity.Verbosity
instance GHC.Show.Show Mcmc.Verbosity.Verbosity


-- | Creation date: Thu May 21 14:35:11 2020.
module Mcmc.Monitor

-- | A <a>Monitor</a> describes which part of the Markov chain should be
--   logged and where. Further, they allow output of summary statistics per
--   iteration in a flexible way.
data Monitor a
Monitor :: MonitorStdOut a -> [MonitorFile a] -> [MonitorBatch a] -> Monitor a

-- | Monitor writing to standard output.
[mStdOut] :: Monitor a -> MonitorStdOut a

-- | Monitors writing to files.
[mFiles] :: Monitor a -> [MonitorFile a]

-- | Monitors calculating batch means and writing to files.
[mBatches] :: Monitor a -> [MonitorBatch a]

-- | Monitor to standard output; constructed with <a>monitorStdOut</a>.
data MonitorStdOut a

-- | Monitor to standard output.
monitorStdOut :: [MonitorParameter a] -> Int -> MonitorStdOut a

-- | Monitor to a file; constructed with <a>monitorFile</a>.
data MonitorFile a

-- | Monitor parameters to a file.
monitorFile :: String -> [MonitorParameter a] -> Int -> MonitorFile a

-- | Monitor to a file, but calculate batch means for the given batch size;
--   constructed with <a>monitorBatch</a>.
--   
--   Batch monitors are slow at the moment because the monitored parameter
--   has to be extracted from the state for each iteration.
data MonitorBatch a

-- | Monitor parameters to a file, see <a>MonitorBatch</a>.
monitorBatch :: String -> [MonitorParameterBatch a] -> Int -> MonitorBatch a

-- | Open the files associated with the <a>Monitor</a>.
mOpen :: String -> Bool -> Monitor a -> IO (Monitor a)

-- | Open the files associated with the <a>Monitor</a> in append mode.
mAppend :: String -> Monitor a -> IO (Monitor a)

-- | Get header line of <a>MonitorStdOut</a>.
mHeader :: Monitor a -> ByteString

-- | Execute monitors; print status information to files and return text to
--   be printed to standard output and log file.
mExec :: Verbosity -> Int -> Int -> UTCTime -> Trace a -> Int -> Monitor a -> IO (Maybe ByteString)

-- | Close the files associated with the <a>Monitor</a>.
mClose :: Monitor a -> IO (Monitor a)


-- | Creation date: Tue May 5 18:01:15 2020.
module Mcmc.Status

-- | The <a>Status</a> contains all information to run an MCMC chain. It is
--   constructed using the function <a>status</a>.
data Status a
Status :: String -> Item a -> Int -> Trace a -> Acceptance (Proposal a) -> Maybe Int -> Maybe Int -> Int -> Bool -> Maybe Int -> Verbosity -> GenIO -> Maybe (Int, UTCTime) -> Maybe Handle -> (a -> Log Double) -> (a -> Log Double) -> Cycle a -> Monitor a -> Status a

-- | The name of the MCMC chain; used as file prefix.
[name] :: Status a -> String

-- | The current <a>Item</a> of the chain combines the current state and
--   the current likelihood.
[item] :: Status a -> Item a

-- | The iteration is the number of completed cycles.
[iteration] :: Status a -> Int

-- | The <a>Trace</a> of the Markov chain in reverse order, the most recent
--   <a>Item</a> is at the head of the list.
[trace] :: Status a -> Trace a

-- | For each <a>Proposal</a>, store the list of accepted (True) and
--   rejected (False) proposals; for reasons of efficiency, the list is
--   also stored in reverse order.
[acceptance] :: Status a -> Acceptance (Proposal a)

-- | Number of burn in iterations; deactivate burn in with <a>Nothing</a>.
[burnInIterations] :: Status a -> Maybe Int

-- | Auto tuning period (only during burn in); deactivate auto tuning with
--   <a>Nothing</a>.
[autoTuningPeriod] :: Status a -> Maybe Int

-- | Number of normal iterations excluding burn in. Note that auto tuning
--   only happens during burn in.
[iterations] :: Status a -> Int

-- | Overwrite output files? Default is <a>False</a>, change with
--   <a>force</a>.
[forceOverwrite] :: Status a -> Bool

-- | Save the chain with trace of given length at the end of the run?
--   Default is no save (<a>Nothing</a>). Change with <a>saveWith</a>.
[save] :: Status a -> Maybe Int

-- | Verbosity.
[verbosity] :: Status a -> Verbosity

-- | The random number generator.
[generator] :: Status a -> GenIO

-- | Starting time and starting iteration of chain; used to calculate run
--   time and ETA.
[start] :: Status a -> Maybe (Int, UTCTime)

-- | Handle to log file.
[logHandle] :: Status a -> Maybe Handle

-- | The prior function. The un-normalized posterior is the product of the
--   prior and the likelihood.
[priorF] :: Status a -> a -> Log Double

-- | The likelihood function. The un-normalized posterior is the product of
--   the prior and the likelihood.
[likelihoodF] :: Status a -> a -> Log Double

-- | A set of <a>Proposal</a>s form a <a>Cycle</a>.
[cycle] :: Status a -> Cycle a

-- | A <a>Monitor</a> observing the chain.
[monitor] :: Status a -> Monitor a

-- | Initialize the <a>Status</a> of a Markov chain Monte Carlo run.
status :: String -> (a -> Log Double) -> (a -> Log Double) -> Cycle a -> Monitor a -> a -> Maybe Int -> Maybe Int -> Int -> GenIO -> Status a

-- | Save the Markov chain with trace of given length.
saveWith :: Int -> Status a -> Status a

-- | Overwrite existing files; it is not necessary to use <a>force</a>,
--   when a chain is continued.
force :: Status a -> Status a

-- | Do not print anything to standard output. Do not create log file. File
--   monitors and batch monitors are executed normally.
quiet :: Status a -> Status a

-- | Be verbose.
debug :: Status a -> Status a


-- | Creation date: Tue Jun 16 10:18:54 2020.
--   
--   Save and load an MCMC run. It is easy to save and restore the current
--   state and likelihood (or the trace), but it is not feasible to store
--   all the proposals and so on, so they have to be provided again when
--   continuing a run.
module Mcmc.Save

-- | Save a <a>Status</a> to file.
--   
--   Saved information: - state - iteration - trace - acceptance ratios -
--   generator
--   
--   Important information that cannot be saved and has to be provided
--   again when a chain is restored: - prior function - likelihood function
--   - cycle - monitor
saveStatus :: ToJSON a => FilePath -> Status a -> IO ()

-- | Load a <a>Status</a> from file.
--   
--   Important information that cannot be saved and has to be provided
--   again when a chain is restored: - prior function - likelihood function
--   - cycle - monitor
--   
--   To avoid incomplete continued runs, the <tt>mcmc</tt> file is removed
--   after load.
loadStatus :: FromJSON a => (a -> Log Double) -> (a -> Log Double) -> Cycle a -> Monitor a -> FilePath -> IO (Status a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (Mcmc.Save.Save a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (Mcmc.Save.Save a)


-- | Creation date: Fri May 29 10:19:45 2020.
module Mcmc.Mcmc

-- | An Mcmc state transformer; usually fiddling around with this type is
--   not required, but it is used by the different inference algorithms.
type Mcmc a = StateT (Status a) IO

-- | Write to standard output and log file.
mcmcOutT :: ByteString -> Mcmc a ()

-- | Write to standard output and log file.
mcmcOutS :: String -> Mcmc a ()

-- | Print warning message.
mcmcWarnT :: ByteString -> Mcmc a ()

-- | Print warning message.
mcmcWarnS :: String -> Mcmc a ()

-- | Print info message.
mcmcInfoT :: ByteString -> Mcmc a ()

-- | Print info message.
mcmcInfoS :: String -> Mcmc a ()

-- | Print debug message.
mcmcDebugT :: ByteString -> Mcmc a ()

-- | Print debug message.
mcmcDebugS :: String -> Mcmc a ()

-- | Auto tune the <a>Proposal</a>s in the <a>Cycle</a> of the chain. Reset
--   acceptance counts. See <a>autotuneCycle</a>.
mcmcAutotune :: Mcmc a ()

-- | Reset acceptance counts.
mcmcResetA :: Mcmc a ()

-- | Print short summary of <a>Proposal</a>s in <a>Cycle</a>. See
--   <a>summarizeCycle</a>.
mcmcSummarizeCycle :: Mcmc a ByteString

-- | Report what is going to be done.
mcmcReport :: ToJSON a => Mcmc a ()

-- | Print header line of standard output monitor.
mcmcMonitorStdOutHeader :: Mcmc a ()

-- | Execute the <a>Monitor</a>s of the chain. See <a>mExec</a>.
mcmcMonitorExec :: ToJSON a => Mcmc a ()

-- | Run an MCMC algorithm.
mcmcRun :: ToJSON a => Mcmc a () -> Status a -> IO (Status a)


-- | Creation date: Tue May 5 20:11:30 2020.
module Mcmc.Metropolis

-- | Run a Markov chain for a given number of Metropolis-Hastings steps.
mh :: ToJSON a => Status a -> IO (Status a)

-- | Continue a Markov chain for a given number of Metropolis-Hastings
--   steps.
mhContinue :: ToJSON a => Int -> Status a -> IO (Status a)


-- | Creation date: Tue May 5 18:01:15 2020.
--   
--   A short introduction to update mechanisms using the
--   Metropolis-Hastings algorithm (see Geyer, C. J., 2011; Introduction to
--   Markov Chain Monte Carlo. In Handbook of Markov Chain Monte Carlo (pp.
--   45), Chapman &amp; Hall/CRC).
--   
--   For examples, please see <a>mcmc-examples</a>.
--   
--   <b>The import of this module alone should cover most use cases.</b>
module Mcmc

-- | A <a>Proposal</a> is an instruction about how the Markov chain will
--   traverse the state space <tt>a</tt>. Essentially, it is a probability
--   mass or probability density conditioned on the current state (i.e., a
--   kernel).
--   
--   A <a>Proposal</a> may be tuneable in that it contains information
--   about how to enlarge or shrink the step size to tune the acceptance
--   ratio.
data Proposal a

-- | Convert a proposal from one data type to another using a lens.
--   
--   For example:
--   
--   <pre>
--   scaleFirstEntryOfTuple = scale &gt;&gt;&gt; _1
--   </pre>
(@~) :: Lens' b a -> Proposal a -> Proposal b

-- | Multiplicative proposal with Gamma distributed kernel.
scale :: String -> Int -> Double -> Double -> Bool -> Proposal Double

-- | Multiplicative proposal with Gamma distributed kernel. The scale of
--   the Gamma distributions is set to (shape)^{-1}, so that the mean of
--   the Gamma distribution is 1.0.
scaleUnbiased :: String -> Int -> Double -> Bool -> Proposal Double

-- | Additive proposal with normally distributed kernel.
slide :: String -> Int -> Double -> Double -> Bool -> Proposal Double

-- | Additive symmetric proposal with kernel similar to the silhouette of a
--   Bactrian camel. The <a>Bactrian kernel</a> is a mixture of two
--   symmetrically arranged normal distributions. The spike parameter
--   loosely determines the standard deviations of the individual humps
--   while the other parameter refers to the standard deviation of the
--   complete Bactrian kernel.
--   
--   See <a>https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3845170/</a>.
slideBactrian :: String -> Int -> Double -> Double -> Bool -> Proposal Double

-- | Additive proposal with normally distributed kernel with mean zero.
--   This proposal is very fast, because the Metropolis-Hastings ratio does
--   not include calculation of the forwards and backwards kernels.
slideSymmetric :: String -> Int -> Double -> Bool -> Proposal Double

-- | Additive proposal with uniformly distributed kernel. This proposal is
--   very fast, because the Metropolis-Hastings ratio does not include
--   calculation of the forwards and backwards kernels.
slideUniform :: String -> Int -> Double -> Bool -> Proposal Double

-- | In brief, a <a>Cycle</a> is a list of proposals. The state of the
--   Markov chain will be logged only after all <a>Proposal</a>s in the
--   <a>Cycle</a> have been completed, and the iteration counter will be
--   increased by one. The order in which the <a>Proposal</a>s are executed
--   is specified by <a>Order</a>. The default is <a>RandomO</a>.
--   
--   <b>Proposals must have unique names</b>, so that they can be
--   identified.
data Cycle a

-- | Create a <a>Cycle</a> from a list of <a>Proposal</a>s.
fromList :: [Proposal a] -> Cycle a

-- | Define the order in which <a>Proposal</a>s are executed in a
--   <a>Cycle</a>. The total number of <a>Proposal</a>s per <a>Cycle</a>
--   may differ between <a>Order</a>s (e.g., compare <a>RandomO</a> and
--   <a>RandomReversibleO</a>).
data Order

-- | Shuffle the <a>Proposal</a>s in the <a>Cycle</a>. The <a>Proposal</a>s
--   are replicated according to their weights and executed in random
--   order. If a <a>Proposal</a> has weight <tt>w</tt>, it is executed
--   exactly <tt>w</tt> times per iteration.
RandomO :: Order

-- | The <a>Proposal</a>s are executed sequentially, in the order they
--   appear in the <a>Cycle</a>. <a>Proposal</a>s with weight
--   <tt>w&gt;1</tt> are repeated immediately <tt>w</tt> times (and not
--   appended to the end of the list).
SequentialO :: Order

-- | Similar to <a>RandomO</a>. However, a reversed copy of the list of
--   shuffled <a>Proposal</a>s is appended such that the resulting Markov
--   chain is reversible. Note: the total number of <a>Proposal</a>s
--   executed per cycle is twice the number of <a>RandomO</a>.
RandomReversibleO :: Order

-- | Similar to <a>SequentialO</a>. However, a reversed copy of the list of
--   sequentially ordered <a>Proposal</a>s is appended such that the
--   resulting Markov chain is reversible.
SequentialReversibleO :: Order

-- | Set the order of <a>Proposal</a>s in a <a>Cycle</a>.
setOrder :: Order -> Cycle a -> Cycle a

-- | Initialize the <a>Status</a> of a Markov chain Monte Carlo run.
status :: String -> (a -> Log Double) -> (a -> Log Double) -> Cycle a -> Monitor a -> a -> Maybe Int -> Maybe Int -> Int -> GenIO -> Status a

-- | Save the Markov chain with trace of given length.
saveWith :: Int -> Status a -> Status a

-- | Overwrite existing files; it is not necessary to use <a>force</a>,
--   when a chain is continued.
force :: Status a -> Status a

-- | Do not print anything to standard output. Do not create log file. File
--   monitors and batch monitors are executed normally.
quiet :: Status a -> Status a

-- | Be verbose.
debug :: Status a -> Status a

-- | A <a>Monitor</a> describes which part of the Markov chain should be
--   logged and where. Further, they allow output of summary statistics per
--   iteration in a flexible way.
data Monitor a
Monitor :: MonitorStdOut a -> [MonitorFile a] -> [MonitorBatch a] -> Monitor a

-- | Monitor to standard output; constructed with <a>monitorStdOut</a>.
data MonitorStdOut a

-- | Monitor to standard output.
monitorStdOut :: [MonitorParameter a] -> Int -> MonitorStdOut a

-- | Monitor to a file; constructed with <a>monitorFile</a>.
data MonitorFile a

-- | Monitor parameters to a file.
monitorFile :: String -> [MonitorParameter a] -> Int -> MonitorFile a

-- | Monitor to a file, but calculate batch means for the given batch size;
--   constructed with <a>monitorBatch</a>.
--   
--   Batch monitors are slow at the moment because the monitored parameter
--   has to be extracted from the state for each iteration.
data MonitorBatch a

-- | Monitor parameters to a file, see <a>MonitorBatch</a>.
monitorBatch :: String -> [MonitorParameterBatch a] -> Int -> MonitorBatch a

-- | Run a Markov chain for a given number of Metropolis-Hastings steps.
mh :: ToJSON a => Status a -> IO (Status a)

-- | Continue a Markov chain for a given number of Metropolis-Hastings
--   steps.
mhContinue :: ToJSON a => Int -> Status a -> IO (Status a)

-- | Load a <a>Status</a> from file.
--   
--   Important information that cannot be saved and has to be provided
--   again when a chain is restored: - prior function - likelihood function
--   - cycle - monitor
--   
--   To avoid incomplete continued runs, the <tt>mcmc</tt> file is removed
--   after load.
loadStatus :: FromJSON a => (a -> Log Double) -> (a -> Log Double) -> Cycle a -> Monitor a -> FilePath -> IO (Status a)