[Pomp-commits] r765 - in pkg/pomp: . inst/doc
noreply at r-forge.r-project.org
noreply at r-forge.r-project.org
Wed Aug 8 17:22:18 CEST 2012
Author: kingaa
Date: 2012-08-08 17:22:18 +0200 (Wed, 08 Aug 2012)
New Revision: 765
Added:
pkg/pomp/inst/doc/bsmc-ricker-normal-prior.rda
pkg/pomp/inst/doc/complex-sir-def.rda
pkg/pomp/inst/doc/gompertz-pfilter-guess.rda
pkg/pomp/inst/doc/plugin-C-code.rda
pkg/pomp/inst/doc/plugin-R-code.rda
pkg/pomp/inst/doc/ricker-comparison.rda
pkg/pomp/inst/doc/ricker-first-probe.rda
pkg/pomp/inst/doc/ricker-probe.rda
pkg/pomp/inst/doc/sim-sim.rda
pkg/pomp/inst/doc/sir-pomp-def.rda
pkg/pomp/inst/doc/vectorized-C-code.rda
pkg/pomp/inst/doc/vectorized-R-code.rda
Modified:
pkg/pomp/DESCRIPTION
pkg/pomp/inst/doc/advanced_topics_in_pomp.Rnw
pkg/pomp/inst/doc/advanced_topics_in_pomp.pdf
pkg/pomp/inst/doc/intro_to_pomp.Rnw
pkg/pomp/inst/doc/intro_to_pomp.pdf
Log:
- store more intermediate results in the building of the vignettes to make vignette-checking quicker
Modified: pkg/pomp/DESCRIPTION
===================================================================
--- pkg/pomp/DESCRIPTION 2012-08-08 13:54:57 UTC (rev 764)
+++ pkg/pomp/DESCRIPTION 2012-08-08 15:22:18 UTC (rev 765)
@@ -2,7 +2,7 @@
Type: Package
Title: Statistical inference for partially observed Markov processes
Version: 0.43-4
-Date: 2012-08-03
+Date: 2012-08-08
Author: Aaron A. King, Edward L. Ionides, Carles Breto, Steve Ellner, Bruce Kendall, Helen Wearing, Matthew J. Ferrari, Michael Lavine, Daniel C. Reuman
Maintainer: Aaron A. King <kingaa at umich.edu>
URL: http://pomp.r-forge.r-project.org
Modified: pkg/pomp/inst/doc/advanced_topics_in_pomp.Rnw
===================================================================
--- pkg/pomp/inst/doc/advanced_topics_in_pomp.Rnw 2012-08-08 13:54:57 UTC (rev 764)
+++ pkg/pomp/inst/doc/advanced_topics_in_pomp.Rnw 2012-08-08 15:22:18 UTC (rev 765)
@@ -94,7 +94,7 @@
\subsection{An unvectorized implementation using \R\ code only}
Before we set about vectorizing the codes, let's have a look at what a plug-in based implementation written entirely in \R\ might look like.
-<<plugin-R-code,echo=T>>=
+<<plugin-R-code,echo=T,eval=T>>=
data(ou2)
ou2.dat <- as.data.frame(ou2)
@@ -118,10 +118,17 @@
) -> ou2.Rplug
@
<<plugin-R-code-sim,echo=F>>=
-tic <- Sys.time()
+binary.file <- "plugin-R-code.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+ tic <- Sys.time()
simdat.Rplug <- simulate(ou2.Rplug,params=coef(ou2),nsim=1000,states=T)
toc <- Sys.time()
etime.Rplug <- toc-tic
+n.Rplug <- dim(simdat.Rplug)[2]
+save(etime.Rplug,n.Rplug,file=binary.file,compress='xz')
+}
@
Notice how we specify the process model simulator using the \code{rprocess} plug-in \code{discrete.time.sim}.
The latter function's \code{step.fun} argument is itself a function that simulates one realization of the process for one timestep and one set of parameters.
@@ -145,7 +152,7 @@
This function must return a rank-3 array, which has the realized values of the state process at the requested times.
This array must have rownames.
Here is one implementation of such a simulator.
-<<vectorized-R-code>>=
+<<vectorized-R-code,eval=F>>=
ou2.Rvect.rprocess <- function (xstart, times, params, ...) {
nrep <- ncol(xstart) # number of realizations
ntimes <- length(times) # number of timepoints
@@ -180,12 +187,12 @@
}
@
We can put this into a pomp object that is the same as \code{ou2.Rplug} in every way except in its \code{rprocess} slot by doing
-<<vectorized-R-pomp>>=
+<<vectorized-R-pomp,eval=F>>=
ou2.Rvect <- pomp(ou2.Rplug,rprocess=ou2.Rvect.rprocess)
@
Let's pick some parameters and simulate some data to see how long it takes this code to run.
-<<theta>>=
+<<theta,eval=F>>=
theta <- c(
x1.0=-3, x2.0=4,
tau=1,
@@ -193,69 +200,29 @@
sigma.1=3, sigma.2=-0.5, sigma.3=2
)
@
-<<vectorized-R-code-sim>>=
+<<vectorized-R-code-sim,eval=F>>=
tic <- Sys.time()
simdat.Rvect <- simulate(ou2.Rvect,params=theta,states=T,nsim=1000)
toc <- Sys.time()
etime.Rvect <- toc-tic
@
-<<echo=F>>=
+<<vectorized-R-code-eval,eval=T>>=
+binary.file <- "vectorized-R-code.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+<<vectorized-R-code>>
+<<vectorized-R-pomp>>
+<<theta>>
+<<vectorized-R-code-sim>>
units(etime.Rvect) <- units(etime.Rplug)
+n.Rvect <- dim(simdat.Rvect)[2]
+save(etime.Rvect,n.Rvect,file=binary.file,compress='xz')
+}
@
-Doing \Sexpr{dim(simdat.Rvect)[2]} simulations of \code{ou2.Rvect} took \Sexpr{round(etime.Rvect,2)}~\Sexpr{units(etime.Rvect)}.
-Compared to the \Sexpr{round(etime.Rplug,2)}~\Sexpr{units(etime.Rplug)} it took to run \Sexpr{dim(simdat.Rplug)[2]} simulations of \code{ou2.Rplug}, this is a \Sexpr{round(as.numeric(etime.Rplug)/as.numeric(etime.Rvect))}-fold speed-up.
+Doing \Sexpr{n.Rvect} simulations of \code{ou2.Rvect} took \Sexpr{round(etime.Rvect,2)}~\Sexpr{units(etime.Rvect)}.
+Compared to the \Sexpr{round(etime.Rplug,2)}~\Sexpr{units(etime.Rplug)} it took to run \Sexpr{n.Rplug} simulations of \code{ou2.Rplug}, this is a \Sexpr{round(as.numeric(etime.Rplug)*n.Rvect/as.numeric(etime.Rvect)/n.Rplug)}-fold speed-up.
-\subsection{Using \R's byte compiler}
-
-From version {2.13}, \R\ has provided byte-compilation facilities, in the base package \code{compiler}.
-Let's see to what extent we can speed up our codes by byte-compiling the components of our \code{pomp} object.
-<<plugin-byte-code,echo=T>>=
-require(compiler)
-pomp(
- ou2.Rplug,
- rprocess=discrete.time.sim(
- step.fun=cmpfun(
- function (x, t, params, ...) {
- eps <- rnorm(n=2,mean=0,sd=1) # noise terms
- xnew <- c(
- x1=params["alpha.1"]*x["x1"]+params["alpha.3"]*x["x2"]+
- params["sigma.1"]*eps[1],
- x2=params["alpha.2"]*x["x1"]+params["alpha.4"]*x["x2"]+
- params["sigma.2"]*eps[1]+params["sigma.3"]*eps[2]
- )
- names(xnew) <- c("x1","x2")
- xnew
- },
- options=list(optimize=3)
- )
- )
- ) -> ou2.Bplug
-@
-<<plugin-byte-code-sim,echo=F>>=
-tic <- Sys.time()
-simdat.Bplug <- simulate(ou2.Bplug,params=coef(ou2),nsim=1000,states=T)
-toc <- Sys.time()
-etime.Bplug <- toc-tic
-@
-Doing these \Sexpr{dim(simdat.Bplug)[2]} simulations of \code{ou2.Bplug} took \Sexpr{round(etime.Bplug,2)}~\Sexpr{units(etime.Bplug)}.
-This is a \Sexpr{round(as.numeric(etime.Rplug)/as.numeric(etime.Bplug),1)}-fold speed-up relative to the plug-in code written in \R.
-
-We can byte-compile the vectorized \R\ code, too, and compare its performance:
-<<vectorized-byte-code>>=
-ou2.Bvect <- pomp(ou2.Rplug,rprocess=cmpfun(ou2.Rvect.rprocess,options=list(optimize=3)))
-@
-<<vectorized-byte-code-sim>>=
-tic <- Sys.time()
-simdat.Bvect <- simulate(ou2.Bvect,params=theta,states=T,nsim=1000)
-toc <- Sys.time()
-etime.Bvect <- toc-tic
-@
-<<echo=F>>=
-units(etime.Bvect) <- units(etime.Rplug)
-@
-This code shows a \Sexpr{round(as.numeric(etime.Rplug)/as.numeric(etime.Bvect))}-fold speed-up relative to the plug-in code written in \R.
-
-
\subsection{Accelerating the code using C: a plug-in based implementation}
As we've seen, we can usually acheive big accelerations using compiled native code.
@@ -270,7 +237,7 @@
file.show(file=system.file("include/pomp.h",package="pomp"))
@
We can put the one-step simulator into the \code{pomp} object and simulate as before by doing
-<<plugin-C-code>>=
+<<plugin-C-code,eval=F>>=
ou2.Cplug <- pomp(
ou2.Rplug,
rprocess=discrete.time.sim("ou2_step"),
@@ -282,19 +249,26 @@
statenames=c("x1","x2"),
obsnames=c("y1","y2")
)
-@
-<<plugin-C-sim>>=
+<<plugin-C-sim,eval=F>>=
tic <- Sys.time()
simdat.Cplug <- simulate(ou2.Cplug,params=theta,states=T,nsim=100000)
toc <- Sys.time()
etime.Cplug <- toc-tic
-@
-Note that \code{ou2\_step} is written in such a way that we must specify \code{paramnames}, \code{statenames}, and \code{obsnames}.
-These \Sexpr{dim(simdat.Cplug)[2]} simulations of \code{ou2.Cplug} took \Sexpr{round(etime.Cplug,2)}~\Sexpr{units(etime.Cplug)}.
-<<echo=F>>=
+<<plugin-C-sim-eval,eval=T,echo=F>>=
+binary.file <- "plugin-C-code.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+<<plugin-C-code>>
+<<plugin-C-sim>>
+ n.Cplug <- dim(simdat.Cplug)[2]
units(etime.Cplug) <- units(etime.Rplug)
-speedup <- as.numeric(etime.Rplug/dim(simdat.Rplug)[2])/as.numeric(etime.Cplug/dim(simdat.Cplug)[2])
+speedup <- as.numeric(etime.Rplug/n.Rplug)/as.numeric(etime.Cplug/n.Cplug)
+save(n.Cplug,etime.Cplug,speedup,file=binary.file,compress='xz')
+}
@
+Note that \code{ou2\_step} is written in such a way that we must specify \code{paramnames}, \code{statenames}, and \code{obsnames}.
+These \Sexpr{n.Cplug} simulations of \code{ou2.Cplug} took \Sexpr{round(etime.Cplug,2)}~\Sexpr{units(etime.Cplug)}.
This is a \Sexpr{round(speedup)}-fold speed-up relative to \code{ou2.Rplug}.
@@ -306,7 +280,7 @@
<<view-ou2-source>>
@
This function is called in the following \code{rprocess} function.
-Notice that the call to \code{ou2\_adv} uses the \verb+.C+ convention.
+Notice that the call to \code{ou2\_adv} uses the \verb+.C+ interface.
<<vectorized-C-code>>=
ou2.Cvect.rprocess <- function (xstart, times, params, ...) {
nvar <- nrow(xstart)
@@ -334,7 +308,7 @@
rprocess=ou2.Cvect.rprocess
)
@
-<<vectorized-C-code-sim,echo=T>>=
+<<vectorized-C-code-sim,echo=T,eval=F>>=
tic <- Sys.time()
paramnames <- c(
"alpha.1","alpha.2","alpha.3","alpha.4",
@@ -345,13 +319,21 @@
simdat.Cvect <- simulate(ou2.Cvect,params=theta[paramnames],nsim=100000,states=T)
toc <- Sys.time()
etime.Cvect <- toc-tic
-@
-Note that we've had to rearrange the order of parameters here to ensure that they arrive at the native codes in the right order.
-<<echo=F>>=
+@
+<<vectorized-C-code-eval,echo=F,eval=T>>=
+binary.file <- "vectorized-C-code.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+<<vectorized-C-code-sim>>
+ n.Cvect <- dim(simdat.Cvect)[2]
units(etime.Cvect) <- units(etime.Rplug)
-speedup <- as.numeric(etime.Rplug/dim(simdat.Rplug)[2])/as.numeric(etime.Cvect/dim(simdat.Cvect)[2])
+speedup <- as.numeric(etime.Rplug/n.Rplug)/as.numeric(etime.Cvect/n.Cvect)
+save(n.Cvect,etime.Cvect,speedup,file=binary.file,compress='xz')
+}
@
-Doing \Sexpr{dim(simdat.Cvect)[2]} simulations of \code{ou2.Cvect} took \Sexpr{round(etime.Cvect,2)}~\Sexpr{units(etime.Cvect)}, a \Sexpr{round(speedup)}-fold speed-up relative to \code{ou2.Rplug}.
+Note that we've had to rearrange the order of parameters here to ensure that they arrive at the native codes in the right order.
+Doing \Sexpr{n.Cvect} simulations of \code{ou2.Cvect} took \Sexpr{round(etime.Cvect,2)}~\Sexpr{units(etime.Cvect)}, a \Sexpr{round(speedup)}-fold speed-up relative to \code{ou2.Rplug}.
\subsection{More on native codes and plug-ins}
@@ -440,7 +422,7 @@
See the source code to see how this is done.
Let's specify some parameters, simulate, and compute a deterministic trajectory:
-<<sir-sim>>=
+<<sir-sim,eval=F>>=
params <- c(
gamma=26,mu=0.02,iota=0.01,
beta1=400,beta2=480,beta3=320,
@@ -453,6 +435,14 @@
sir <- simulate(sir,params=c(params,nbasis=3,degree=3,period=1),seed=3493885L)
sims <- simulate(sir,nsim=10,obs=T)
traj <- trajectory(sir,hmax=1/52)
+<<sir-sim-eval,echo=F,eval=T>>=
+binary.file <- "sim-sim.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+<<sir-sim>>
+ save(sir,sims,traj,file=binary.file,compress='xz')
+}
@
\section{Accumulator variables}
Modified: pkg/pomp/inst/doc/advanced_topics_in_pomp.pdf
===================================================================
(Binary files differ)
Added: pkg/pomp/inst/doc/bsmc-ricker-normal-prior.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/bsmc-ricker-normal-prior.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/complex-sir-def.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/complex-sir-def.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/gompertz-pfilter-guess.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/gompertz-pfilter-guess.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Modified: pkg/pomp/inst/doc/intro_to_pomp.Rnw
===================================================================
--- pkg/pomp/inst/doc/intro_to_pomp.Rnw 2012-08-08 13:54:57 UTC (rev 764)
+++ pkg/pomp/inst/doc/intro_to_pomp.Rnw 2012-08-08 15:22:18 UTC (rev 765)
@@ -388,8 +388,14 @@
loglik.guess <- logLik(pf)
@
<<gompertz-pfilter-guess-eval,echo=F>>=
+binary.file <- "gompertz-pfilter-guess.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
set.seed(457645443L)
<<gompertz-pfilter-guess>>
+save(theta.true,theta.guess,loglik.guess,file=binary.file,compress='xz')
+}
@
\begin{textbox}
@@ -891,10 +897,18 @@
Each of these functions can be applied to the \code{ricker}'s data or to simulated data sets.
A call to \pkg{pomp}'s function \code{probe} results in the application of these functions to the data, their application to each of some large number, \code{nsim}, of simulated data sets, and finally to a comparison of the two.
To see this, we'll apply probe to the Ricker model at the true parameters and at a wild guess.
-<<first-probe>>=
+<<first-probe,eval=F,echo=T>>=
pb.truth <- probe(ricker,probes=plist,nsim=1000,seed=1066L)
guess <- c(r=20,sigma=1,phi=20,N.0=7,e.0=0)
pb.guess <- probe(ricker,params=guess,probes=plist,nsim=1000,seed=1066L)
+<<first-probe-eval,eval=T,echo=F>>=
+binary.file <- "ricker-first-probe.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+<<first-probe>>
+ save(pb.truth,pb.guess,guess,file=binary.file,compress='xz')
+}
@
Results summaries and diagnostic plots showing the model-data agreement and correlations among the probes can be obtained by
<<first-probe-plot,eval=F>>=
@@ -909,17 +923,23 @@
\begin{figure}
<<ricker-probe-plot,echo=F,fig=T,png=T,results=hide>>=
+binary.file <- "ricker-probe.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
pb <- probe(ricker,
probes=list(
probe.marginal("y",ref=obs(ricker),transform=sqrt),
probe.acf("y",lags=c(0,1,3),transform=sqrt),
mean=probe.mean("y",transform=sqrt)
- ),
+ ),
transform=TRUE,
nsim=1000,
seed=1066L
)
- plot(pb)
+ save(pb,file=binary.file,compress='xz')
+}
+plot(pb)
@
\caption{
Results of \code{plot} on a \code{probed.pomp}-class object.
@@ -994,7 +1014,7 @@
\item the MLE from \code{mif}, and
\item the maximum synthetic likelihood estimate from \code{probe.match}.
\end{inparaenum}
-<<>>=
+<<ricker-comparison,eval=F,echo=T>>=
pf.truth <- pfilter(ricker,Np=1000,max.fail=50,seed=1066L)
pf.guess <- pfilter(ricker,params=guess,Np=1000,max.fail=50,seed=1066L)
pf.mf <- pfilter(mf,Np=1000,seed=1066L)
@@ -1015,7 +1035,16 @@
summary(pm)$synth.loglik
)
)
-
+<<ricker-comparison-eval,echo=F,eval=T>>=
+binary.file <- "ricker-comparison.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+<<ricker-comparison>>
+ save(res,file=binary.file,compress='xz')
+}
+@
+<<ricker-comparison-show>>=
print(res,digits=3)
@
@@ -1030,7 +1059,7 @@
As a simple example we can use \code{nlf} to estimate the parameters \code{K} and \code{r} of the Gompertz model.
An example of a minimal call, accepting the defaults for all optional arguments, is
-<<eval=F>>=
+<<first-nlf,eval=F>>=
data(gompertz)
out <- nlf(
gompertz,
@@ -1080,7 +1109,7 @@
}
fits <- t(sapply(out,function(x)c(x$params[c("r","K")],value=x$value)))
@
-<<echo=F,eval=T,results=hide>>=
+<<nlf-fits-eval,echo=F,eval=T,results=hide>>=
binary.file <- "nlf-fits.rda"
if (file.exists(binary.file)) {
load(binary.file)
@@ -1431,7 +1460,7 @@
\end{figure}
To repeat the procedure with log-normal priors on $r$ and $\sigma$, one might do the following.
-<<bsmc-example-normal-prior>>=
+<<bsmc-example-normal-prior,eval=F,echo=T>>=
set.seed(90348704L)
Np <- 10000
prior2 <- parmat(coef(ricker),nrep=Np)
@@ -1441,10 +1470,18 @@
prior2["sigma",] <- rlnorm(n=Np,meanlog=log(0.5),sdlog=5)
fit2 <- bsmc(ricker,params=prior2,transform=TRUE,
est=c("r","sigma"),smooth=0.2)
+<<bsmc-example-normal-prior-eval,eval=T,echo=F>>=
+binary.file <- "bsmc-ricker-normal-prior.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+<<bsmc-example-normal-prior>>
+ save(fit2,file=binary.file,compress="xz")
+}
+<<bsmc-example-normal-prior-show,echo=T,eval=T>>=
signif(coef(fit2),digits=2)
@
-
\clearpage
\section{Particle Markov chain Monte Carlo: \code{pmcmc}}
@@ -1610,7 +1647,7 @@
We can enforce this constraint by customizing the parameterization of our initial conditions.
We do this in by specializing a custom \code{initializer} in the call to \code{pomp} that constructs the \code{pomp} object.
Let's construct it now and fill it with simulated data.
-<<sir-pomp-def>>=
+<<sir-pomp-def,eval=F,echo=T>>=
simulate(
pomp(
data=data.frame(
@@ -1643,7 +1680,14 @@
),
seed=677573454L
) -> sir
-@
+<<sir-pomp-def-eval,eval=T,echo=F>>=
+binary.file <- "sir-pomp-def.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+<<sir-pomp-def>>
+ save(sir,file=binary.file,compress='xz')
+}
<<sir-pomp-def-with-skel,eval=F,echo=F>>=
sir <- pomp(
sir,
@@ -1726,7 +1770,7 @@
\citet{Breto2011} develop the theory of infinitesimally overdispersed processes.
Let's modify the process-model simulator to incorporate these three complexities.
-<<complex-sir-def>>=
+<<complex-sir-def,echo=T,eval=F>>=
complex.sir.proc.sim <- function (x, t, params, delta.t, covars, ...) {
## unpack the parameters
N <- params["N"] # population size
@@ -1782,6 +1826,14 @@
),
seed=8274355L
) -> complex.sir
+<<complex-sir-def-eval,echo=F,eval=T>>=
+binary.file <- "complex-sir-def.rda"
+if (file.exists(binary.file)) {
+ load(binary.file)
+} else {
+<<complex-sir-def>>
+ save(complex.sir,file=binary.file,compress='xz')
+}
@
Note that the seasonal basis functions are passed to \code{complex.sir.proc.sim} via the \code{covars} argument.
Whenever \code{complex.sir.proc.sim} is called, this argument will contain values of the covariates obtained from the look-up table.
Modified: pkg/pomp/inst/doc/intro_to_pomp.pdf
===================================================================
(Binary files differ)
Added: pkg/pomp/inst/doc/plugin-C-code.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/plugin-C-code.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/plugin-R-code.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/plugin-R-code.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/ricker-comparison.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/ricker-comparison.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/ricker-first-probe.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/ricker-first-probe.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/ricker-probe.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/ricker-probe.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/sim-sim.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/sim-sim.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/sir-pomp-def.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/sir-pomp-def.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/vectorized-C-code.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/vectorized-C-code.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
Added: pkg/pomp/inst/doc/vectorized-R-code.rda
===================================================================
(Binary files differ)
Property changes on: pkg/pomp/inst/doc/vectorized-R-code.rda
___________________________________________________________________
Added: svn:mime-type
+ application/octet-stream
More information about the pomp-commits
mailing list