R bootstrap replicates of a statistic applied to a
time series. The replicate time series can be generated using fixed
or random block lengths or can be model based replicates.
tsboot(tseries, statistic, R, l = NULL, sim = "model", endcorr = TRUE, n.sim = NROW(tseries), orig.t = TRUE, ran.gen, ran.args = NULL, norm = TRUE, ..., parallel = c("no", "multicore", "snow"), ncpus = getOption("boot.ncpus", 1L), cl = NULL)tseries returns a vector
containing the statistic(s) of interest. Each time statistic is
called it is passed a time series of length n.sim which is of the
same class as the original tseries. Any other arguments which
statistic takes must remain constant for each bootstrap replicate
and should be supplied through the ... argument to tsboot.
"model" (model based resampling),
"fixed" (block resampling with fixed block lengths of
l), "geom" (block resampling with block lengths
having a geometric distribution with mean l) or
"scramble" (phase scrambling).
sim is "fixed" then l is the fixed block
length used in generating the replicate time series. If sim is
"geom" then l is the mean of the geometric distribution
used to generate the block lengths. l should be a positive
integer less than the length of tseries. This argument is not
required when sim is "model" but it is required for all
other simulation types.
sim is "fixed". When sim is
"geom", endcorr is automatically set to TRUE;
endcorr is not used when sim is "model" or
"scramble".
n.sim is larger than the original
length is if tseries is a residual time series from fitting some
model to the original time series. In this case, n.sim would
usually be the length of the original time series.
statistic should be
applied to tseries itself as well as the bootstrap replicate
series. If statistic is expecting a longer time series than
tseries or if applying statistic to tseries will
not yield any useful information then orig.t should be set to
FALSE.
sim is "model" then it will always be
tseries that is passed. For other simulation types it is the
result of selecting n.sim observations from tseries by
some scheme and converting the result back into a time series of the
same form as tseries (although of length n.sim). The
second argument to ran.gen is always the value n.sim, and
the third argument is ran.args, which is used to supply any other
objects needed by ran.gen. If sim is "model" then
the generation of the replicate time series will be done in
ran.gen (for example through use of arima.sim).
For the other simulation types ran.gen is used for
‘post-blackening’. The default is that the function simply returns
the time series passed to it.
ran.gen each time it is called. If
ran.gen needs any extra arguments then they should be
supplied as components of ran.args. Multiple arguments may be
passed by making ran.args a list. If ran.args is
NULL then it should not be used within ran.gen but
note that ran.gen must still have its third argument.
norm is FALSE then margins
corresponding to the exact empirical margins are used.
statistic may be supplied here.
Beware of partial matching to the arguments of tsboot listed above.
boot.
"boot" with the following components.orig.t is TRUE then t0 is the result of
statistic(tseries,...{}) otherwise it is NULL.
statistic to the replicate time series.
R as supplied to tsboot.
statistic as supplied.
endcorr used. The value is meaningful only when
sim is "fixed"; it is ignored for model based simulation
or phase scrambling and is always set to TRUE if sim is
"geom".
n.sim used.
l used for block based resampling. This will be
NULL if block based resampling was not used.
ran.gen function used for generating the series or for
‘post-blackening’.
ran.gen.
tsboot.
sim is "fixed" then each replicate time series is
found by taking blocks of length l, from the original time
series and putting them end-to-end until a new series of length
n.sim is created. When sim is "geom" a similar
approach is taken except that now the block lengths are generated from
a geometric distribution with mean l. Post-blackening can be
carried out on these replicate time series by including the function
ran.gen in the call to tsboot and having tseries
as a time series of residuals.Model based resampling is very similar to the parametric bootstrap and all simulation must be in one of the user specified functions. This avoids the complicated problem of choosing the block length but relies on an accurate model choice being made.
Phase scrambling is described in Section 8.2.4 of Davison and Hinkley
(1997). The types of statistic for which this method produces
reasonable results is very limited and the other methods seem to do
better in most situations. Other types of resampling in the frequency
domain can be accomplished using the function boot with the
argument sim = "parametric".
Kunsch, H.R. (1989) The jackknife and the bootstrap for general stationary observations. Annals of Statistics, 17, 1217--1241.
Politis, D.N. and Romano, J.P. (1994) The stationary bootstrap. Journal of the American Statistical Association, 89, 1303--1313.
boot, arima.sim
lynx.fun <- function(tsb) {
ar.fit <- ar(tsb, order.max = 25)
c(ar.fit$order, mean(tsb), tsb)
}
# the stationary bootstrap with mean block length 20
lynx.1 <- tsboot(log(lynx), lynx.fun, R = 99, l = 20, sim = "geom")
# the fixed block bootstrap with length 20
lynx.2 <- tsboot(log(lynx), lynx.fun, R = 99, l = 20, sim = "fixed")
# Now for model based resampling we need the original model
# Note that for all of the bootstraps which use the residuals as their
# data, we set orig.t to FALSE since the function applied to the residual
# time series will be meaningless.
lynx.ar <- ar(log(lynx))
lynx.model <- list(order = c(lynx.ar$order, 0, 0), ar = lynx.ar$ar)
lynx.res <- lynx.ar$resid[!is.na(lynx.ar$resid)]
lynx.res <- lynx.res - mean(lynx.res)
lynx.sim <- function(res,n.sim, ran.args) {
# random generation of replicate series using arima.sim
rg1 <- function(n, res) sample(res, n, replace = TRUE)
ts.orig <- ran.args$ts
ts.mod <- ran.args$model
mean(ts.orig)+ts(arima.sim(model = ts.mod, n = n.sim,
rand.gen = rg1, res = as.vector(res)))
}
lynx.3 <- tsboot(lynx.res, lynx.fun, R = 99, sim = "model", n.sim = 114,
orig.t = FALSE, ran.gen = lynx.sim,
ran.args = list(ts = log(lynx), model = lynx.model))
# For "post-blackening" we need to define another function
lynx.black <- function(res, n.sim, ran.args) {
ts.orig <- ran.args$ts
ts.mod <- ran.args$model
mean(ts.orig) + ts(arima.sim(model = ts.mod,n = n.sim,innov = res))
}
# Now we can run apply the two types of block resampling again but this
# time applying post-blackening.
lynx.1b <- tsboot(lynx.res, lynx.fun, R = 99, l = 20, sim = "fixed",
n.sim = 114, orig.t = FALSE, ran.gen = lynx.black,
ran.args = list(ts = log(lynx), model = lynx.model))
lynx.2b <- tsboot(lynx.res, lynx.fun, R = 99, l = 20, sim = "geom",
n.sim = 114, orig.t = FALSE, ran.gen = lynx.black,
ran.args = list(ts = log(lynx), model = lynx.model))
# To compare the observed order of the bootstrap replicates we
# proceed as follows.
table(lynx.1$t[, 1])
table(lynx.1b$t[, 1])
table(lynx.2$t[, 1])
table(lynx.2b$t[, 1])
table(lynx.3$t[, 1])
# Notice that the post-blackened and model-based bootstraps preserve
# the true order of the model (11) in many more cases than the others.
Run the code above in your browser using DataLab