prior_spec {pomp} | R Documentation |

## prior specification

### Description

Specification of prior distributions via the rprior and dprior components.

### Details

A prior distribution on parameters is specified by means of the `rprior`

and/or `dprior`

arguments to `pomp`

.
As with the other basic model components, it is preferable to specify these using C snippets.
In writing a C snippet for the prior sampler (`rprior`

), keep in mind that:

Within the context in which the snippet will be evaluated, only the parameters will be defined.

The goal of such a snippet is the replacement of parameters with values drawn from the prior distribution.

Hyperparameters can be included in the ordinary parameter list. Obviously, hyperparameters should not be replaced with random draws.

In writing a C snippet for the prior density function (`dprior`

), observe that:

Within the context in which the snippet will be evaluated, only the parameters and

`give_log`

will be defined.The goal of such a snippet is computation of the prior probability density, or the log of same, at a given point in parameter space. This scalar value should be returned in the variable

`lik`

. When`give_log == 1`

,`lik`

should contain the log of the prior probability density.Hyperparameters can be included in the ordinary parameter list.

General rules for writing C snippets can be found here.

Alternatively, one can furnish **R** functions for one or both of these arguments.
In this case, `rprior`

must be a function that makes a draw from
the prior distribution of the parameters and returns a named vector
containing all the parameters.
The only required argument of this function is `...`

.

Similarly, the `dprior`

function must evaluate the prior probability
density (or log density if `log == TRUE`

) and return that single
scalar value.
The only required arguments of this function are `...`

and `log`

.

### Default behavior

By default, the prior is assumed flat and improper.
In particular, `dprior`

returns `1`

(`0`

if `log = TRUE`

) for every parameter set.
Since it is impossible to simulate from a flat improper prior, `rprocess`

returns missing values (`NA`

s).

### Note for Windows users

Some Windows users report problems when using C snippets in parallel computations.
These appear to arise when the temporary files created during the C snippet compilation process are not handled properly by the operating system.
To circumvent this problem, use the `cdir`

and `cfile`

options to cause the C snippets to be written to a file of your choice, thus avoiding the use of temporary files altogether.

### See Also

More on implementing POMP models:
`Csnippet`

,
`accumvars`

,
`basic_components`

,
`betabinomial`

,
`covariates`

,
`dinit_spec`

,
`dmeasure_spec`

,
`dprocess_spec`

,
`emeasure_spec`

,
`eulermultinom`

,
`parameter_trans()`

,
`pomp-package`

,
`pomp_constructor`

,
`rinit_spec`

,
`rmeasure_spec`

,
`rprocess_spec`

,
`skeleton_spec`

,
`transformations`

,
`userdata`

,
`vmeasure_spec`

More on Bayesian methods:
`abc()`

,
`bsmc2()`

,
`dprior()`

,
`pmcmc()`

,
`rprior()`

### Examples

```
# takes too long for R CMD check
## Starting with an existing pomp object:
verhulst() |> window(end=30) -> po
## We add or change prior distributions using the two
## arguments 'rprior' and 'dprior'. Here, we introduce
## a Gamma prior on the 'r' parameter.
## We construct 'rprior' and 'dprior' using R functions.
po |>
bsmc2(
rprior=function (n_0, K0, K1, sigma, tau, r0, r1, ...) {
c(
n_0 = n_0,
K = rgamma(n=1,shape=K0,scale=K1),
r = rgamma(n=1,shape=r0,scale=r1),
sigma = sigma,
tau = tau
)
},
dprior=function(K, K0, K1, r, r0, r1, ..., log) {
p <- dgamma(x=c(K,r),shape=c(K0,r0),scale=c(K1,r1),log=log)
if (log) sum(p) else prod(p)
},
params=c(n_0=10000,K=10000,K0=10,K1=1000,
r=0.9,r0=0.9,r1=1,sigma=0.5,tau=0.3),
Np=1000
) -> B
## We can also pass them as C snippets:
po |>
bsmc2(
rprior=Csnippet("
K = rgamma(K0,K1);
r = rgamma(r0,r1);"
),
dprior=Csnippet("
double lik1 = dgamma(K,K0,K1,give_log);
double lik2 = dgamma(r,r0,r1,give_log);
lik = (give_log) ? lik1+lik2 : lik1*lik2;"
),
paramnames=c("K","K0","K1","r","r0","r1"),
params=c(n_0=10000,K=10000,K0=10,K1=1000,
r=0.9,r0=0.9,r1=1,sigma=0.5,tau=0.3),
Np=10000
) -> B
## The prior is plotted in grey; the posterior, in blue.
plot(B)
B |>
pmcmc(Nmcmc=100,Np=1000,proposal=mvn_diag_rw(c(r=0.01,K=10))) -> Bb
plot(Bb,pars=c("loglik","log.prior","r","K"))
```

*pomp*version 5.11.0.0 Index]