Package 'boot' reference manual

Title:	Bootstrap Functions (Originally by Angelo Canty for S)
Description:	Functions and datasets for bootstrapping from the book "Bootstrap Methods and Their Application" by A. C. Davison and D. V. Hinkley (1997, CUP), originally written by Angelo Canty for S.
Authors:	Angelo Canty [aut] (author of original code for S), Brian Ripley [aut, trl] (conversion to R, maintainer 1999--2022, author of parallel support), Alessandra R. Brazzale [ctb, cre] (minor bug fixes)
Maintainer:	Alessandra R. Brazzale <[email protected]>
License:	Unlimited
Version:	1.3-30
Built:	2024-03-27 22:43:02 UTC
Source:	CRAN

Bootstrap Resampling

Description

Generate R bootstrap replicates of a statistic applied to data. Both parametric and nonparametric resampling are possible. For the nonparametric bootstrap, possible resampling methods are the ordinary bootstrap, the balanced bootstrap, antithetic resampling, and permutation. For nonparametric multi-sample problems stratified resampling is used: this is specified by including a vector of strata in the call to boot. Importance resampling weights may be specified.

Usage

boot(data, statistic, R, sim = "ordinary", stype = c("i", "f", "w"), 
     strata = rep(1,n), L = NULL, m = 0, weights = NULL, 
     ran.gen = function(d, p) d, mle = NULL, simple = FALSE, ...,
     parallel = c("no", "multicore", "snow"),
     ncpus = getOption("boot.ncpus", 1L), cl = NULL)

Arguments

`data`	The data as a vector, matrix or data frame. If it is a matrix or data frame then each row is considered as one multivariate observation.
`statistic`	A function which when applied to data returns a vector containing the statistic(s) of interest. When `sim = "parametric"`, the first argument to `statistic` must be the data. For each replicate a simulated dataset returned by `ran.gen` will be passed. In all other cases `statistic` must take at least two arguments. The first argument passed will always be the original data. The second will be a vector of indices, frequencies or weights which define the bootstrap sample. Further, if predictions are required, then a third argument is required which would be a vector of the random indices used to generate the bootstrap predictions. Any further arguments can be passed to `statistic` through the `...` argument.
`R`	The number of bootstrap replicates. Usually this will be a single positive integer. For importance resampling, some resamples may use one set of weights and others use a different set of weights. In this case `R` would be a vector of integers where each component gives the number of resamples from each of the rows of weights.
`sim`	A character string indicating the type of simulation required. Possible values are `"ordinary"` (the default), `"parametric"`, `"balanced"`, `"permutation"`, or `"antithetic"`. Importance resampling is specified by including importance weights; the type of importance resampling must still be specified but may only be `"ordinary"` or `"balanced"` in this case.
`stype`	A character string indicating what the second argument of `statistic` represents. Possible values of stype are `"i"` (indices - the default), `"f"` (frequencies), or `"w"` (weights). Not used for `sim = "parametric"`.
`strata`	An integer vector or factor specifying the strata for multi-sample problems. This may be specified for any simulation, but is ignored when `sim = "parametric"`. When `strata` is supplied for a nonparametric bootstrap, the simulations are done within the specified strata.
`L`	Vector of influence values evaluated at the observations. This is used only when `sim` is `"antithetic"`. If not supplied, they are calculated through a call to `empinf`. This will use the infinitesimal jackknife provided that `stype` is `"w"`, otherwise the usual jackknife is used.
`m`	The number of predictions which are to be made at each bootstrap replicate. This is most useful for (generalized) linear models. This can only be used when `sim` is `"ordinary"`. `m` will usually be a single integer but, if there are strata, it may be a vector with length equal to the number of strata, specifying how many of the errors for prediction should come from each strata. The actual predictions should be returned as the final part of the output of `statistic`, which should also take an argument giving the vector of indices of the errors to be used for the predictions.
`weights`	Vector or matrix of importance weights. If a vector then it should have as many elements as there are observations in `data`. When simulation from more than one set of weights is required, `weights` should be a matrix where each row of the matrix is one set of importance weights. If `weights` is a matrix then `R` must be a vector of length `nrow(weights)`. This parameter is ignored if `sim` is not `"ordinary"` or `"balanced"`.
`ran.gen`	This function is used only when `sim = "parametric"` when it describes how random values are to be generated. It should be a function of two arguments. The first argument should be the observed data and the second argument consists of any other information needed (e.g. parameter estimates). The second argument may be a list, allowing any number of items to be passed to `ran.gen`. The returned value should be a simulated data set of the same form as the observed data which will be passed to `statistic` to get a bootstrap replicate. It is important that the returned value be of the same shape and type as the original dataset. If `ran.gen` is not specified, the default is a function which returns the original `data` in which case all simulation should be included as part of `statistic`. Use of `sim = "parametric"` with a suitable `ran.gen` allows the user to implement any types of nonparametric resampling which are not supported directly.
`mle`	The second argument to be passed to `ran.gen`. Typically these will be maximum likelihood estimates of the parameters. For efficiency `mle` is often a list containing all of the objects needed by `ran.gen` which can be calculated using the original data set only.
`simple`	logical, only allowed to be `TRUE` for `sim = "ordinary", stype = "i", n = 0` (otherwise ignored with a warning). By default a `n` by `R` index array is created: this can be large and if `simple = TRUE` this is avoided by sampling separately for each replication, which is slower but uses less memory.
`...`	Other named arguments for `statistic` which are passed unchanged each time it is called. Any such arguments to `statistic` should follow the arguments which `statistic` is required to have for the simulation. Beware of partial matching to arguments of `boot` listed above, and that arguments named `X` and `FUN` cause conflicts in some versions of boot (but not this one).
`parallel`	The type of parallel operation to be used (if any). If missing, the default is taken from the option `"boot.parallel"` (and if that is not set, `"no"`).
`ncpus`	integer: number of processes to be used in parallel operation: typically one would chose this to the number of available CPUs.
`cl`	An optional parallel or snow cluster for use if `parallel = "snow"`. If not supplied, a cluster on the local machine is created for the duration of the `boot` call.

Details

The statistic to be bootstrapped can be as simple or complicated as desired as long as its arguments correspond to the dataset and (for a nonparametric bootstrap) a vector of indices, frequencies or weights. statistic is treated as a black box by the boot function and is not checked to ensure that these conditions are met.

The first order balanced bootstrap is described in Davison, Hinkley and Schechtman (1986). The antithetic bootstrap is described by Hall (1989) and is experimental, particularly when used with strata. The other non-parametric simulation types are the ordinary bootstrap (possibly with unequal probabilities), and permutation which returns random permutations of cases. All of these methods work independently within strata if that argument is supplied.

For the parametric bootstrap it is necessary for the user to specify how the resampling is to be conducted. The best way of accomplishing this is to specify the function ran.gen which will return a simulated data set from the observed data set and a set of parameter estimates specified in mle.

Value

The returned value is an object of class "boot", containing the following components:

`t0`	The observed value of `statistic` applied to `data`.
`t`	A matrix with `sum(R)` rows each of which is a bootstrap replicate of the result of calling `statistic`.
`R`	The value of `R` as passed to `boot`.
`data`	The `data` as passed to `boot`.
`seed`	The value of `.Random.seed` when `boot` started work.
`statistic`	The function `statistic` as passed to `boot`.
`sim`	Simulation type used.
`stype`	Statistic type as passed to `boot`.
`call`	The original call to `boot`.
`strata`	The strata used. This is the vector passed to `boot`, if it was supplied or a vector of ones if there were no strata. It is not returned if `sim` is `"parametric"`.
`weights`	The importance sampling weights as passed to `boot` or the empirical distribution function weights if no importance sampling weights were specified. It is omitted if `sim` is not one of `"ordinary"` or `"balanced"`.
`pred.i`	If predictions are required (`m > 0`) this is the matrix of indices at which predictions were calculated as they were passed to statistic. Omitted if `m` is `0` or `sim` is not `"ordinary"`.
`L`	The influence values used when `sim` is `"antithetic"`. If no such values were specified and `stype` is not `"w"` then `L` is returned as consecutive integers corresponding to the assumption that data is ordered by influence values. This component is omitted when `sim` is not `"antithetic"`.
`ran.gen`	The random generator function used if `sim` is `"parametric"`. This component is omitted for any other value of `sim`.
`mle`	The parameter estimates passed to `boot` when `sim` is `"parametric"`. It is omitted for all other values of `sim`.

There are c, plot and print methods for this class.

Parallel operation

When parallel = "multicore" is used (not available on Windows), each worker process inherits the environment of the current session, including the workspace and the loaded namespaces and attached packages (but not the random number seed: see below).

More work is needed when parallel = "snow" is used: the worker processes are newly created R processes, and statistic needs to arrange to set up the environment it needs: often a good way to do that is to make use of lexical scoping since when statistic is sent to the worker processes its enclosing environment is also sent. (E.g. see the example for jack.after.boot where ancillary functions are nested inside the statistic function.) parallel = "snow" is primarily intended to be used on multi-core Windows machine where parallel = "multicore" is not available.

For most of the boot methods the resampling is done in the master process, but not if simple = TRUE nor sim = "parametric". In those cases (or where statistic itself uses random numbers), more care is needed if the results need to be reproducible. Resampling is done in the worker processes by censboot(sim = "wierd") and by most of the schemes in tsboot (the exceptions being sim == "fixed" and sim == "geom" with the default ran.gen).

Where random-number generation is done in the worker processes, the default behaviour is that each worker chooses a separate seed, non-reproducibly. However, with parallel = "multicore" or parallel = "snow" using the default cluster, a second approach is used if RNGkind("L'Ecuyer-CMRG") has been selected. In that approach each worker gets a different subsequence of the RNG stream based on the seed at the time the worker is spawned and so the results will be reproducible if ncpus is unchanged, and for parallel = "multicore" if parallel::mc.reset.stream() is called: see the examples for mclapply.

Note that loading the parallel namespace may change the random seed, so for maximum reproducibility this should be done before calling this function.

References

There are many references explaining the bootstrap and its variations. Among them are :

Booth, J.G., Hall, P. and Wood, A.T.A. (1993) Balanced importance resampling for the bootstrap. Annals of Statistics, 21, 286–298.

Davison, A.C. and Hinkley, D.V. (1997) Bootstrap Methods and Their Application. Cambridge University Press.

Davison, A.C., Hinkley, D.V. and Schechtman, E. (1986) Efficient bootstrap simulation. Biometrika, 73, 555–566.

Efron, B. and Tibshirani, R. (1993) An Introduction to the Bootstrap. Chapman & Hall.

Gleason, J.R. (1988) Algorithms for balanced bootstrap simulations. American Statistician, 42, 263–266.

Hall, P. (1989) Antithetic resampling for the bootstrap. Biometrika, 73, 713–724.

Hinkley, D.V. (1988) Bootstrap methods (with Discussion). Journal of the Royal Statistical Society, B, 50, 312–337, 355–370.

Hinkley, D.V. and Shi, S. (1989) Importance sampling and the nested bootstrap. Biometrika, 76, 435–446.

Johns M.V. (1988) Importance sampling for bootstrap confidence intervals. Journal of the American Statistical Association, 83, 709–714.

Noreen, E.W. (1989) Computer Intensive Methods for Testing Hypotheses. John Wiley & Sons.

Examples

# Usual bootstrap of the ratio of means using the city data
ratio <- function(d, w) sum(d$x * w)/sum(d$u * w)
boot(city, ratio, R = 999, stype = "w")


# Stratified resampling for the difference of means.  In this
# example we will look at the difference of means between the final
# two series in the gravity data.
diff.means <- function(d, f)
{    n <- nrow(d)
     gp1 <- 1:table(as.numeric(d$series))[1]
     m1 <- sum(d[gp1,1] * f[gp1])/sum(f[gp1])
     m2 <- sum(d[-gp1,1] * f[-gp1])/sum(f[-gp1])
     ss1 <- sum(d[gp1,1]^2 * f[gp1]) - (m1 *  m1 * sum(f[gp1]))
     ss2 <- sum(d[-gp1,1]^2 * f[-gp1]) - (m2 *  m2 * sum(f[-gp1]))
     c(m1 - m2, (ss1 + ss2)/(sum(f) - 2))
}
grav1 <- gravity[as.numeric(gravity[,2]) >= 7,]
boot(grav1, diff.means, R = 999, stype = "f", strata = grav1[,2])

# In this example we show the use of boot in a prediction from
# regression based on the nuclear data.  This example is taken
# from Example 6.8 of Davison and Hinkley (1997).  Notice also
# that two extra arguments to 'statistic' are passed through boot.
nuke <- nuclear[, c(1, 2, 5, 7, 8, 10, 11)]
nuke.lm <- glm(log(cost) ~ date+log(cap)+ne+ct+log(cum.n)+pt, data = nuke)
nuke.diag <- glm.diag(nuke.lm)
nuke.res <- nuke.diag$res * nuke.diag$sd
nuke.res <- nuke.res - mean(nuke.res)

# We set up a new data frame with the data, the standardized 
# residuals and the fitted values for use in the bootstrap.
nuke.data <- data.frame(nuke, resid = nuke.res, fit = fitted(nuke.lm))

# Now we want a prediction of plant number 32 but at date 73.00
new.data <- data.frame(cost = 1, date = 73.00, cap = 886, ne = 0,
                       ct = 0, cum.n = 11, pt = 1)
new.fit <- predict(nuke.lm, new.data)

nuke.fun <- function(dat, inds, i.pred, fit.pred, x.pred)
{
     lm.b <- glm(fit+resid[inds] ~ date+log(cap)+ne+ct+log(cum.n)+pt,
                 data = dat)
     pred.b <- predict(lm.b, x.pred)
     c(coef(lm.b), pred.b - (fit.pred + dat$resid[i.pred]))
}

nuke.boot <- boot(nuke.data, nuke.fun, R = 999, m = 1, 
                  fit.pred = new.fit, x.pred = new.data)
# The bootstrap prediction squared error would then be found by
mean(nuke.boot$t[, 8]^2)
# Basic bootstrap prediction limits would be
new.fit - sort(nuke.boot$t[, 8])[c(975, 25)]


# Finally a parametric bootstrap.  For this example we shall look 
# at the air-conditioning data.  In this example our aim is to test 
# the hypothesis that the true value of the index is 1 (i.e. that 
# the data come from an exponential distribution) against the 
# alternative that the data come from a gamma distribution with
# index not equal to 1.
air.fun <- function(data) {
     ybar <- mean(data$hours)
     para <- c(log(ybar), mean(log(data$hours)))
     ll <- function(k) {
          if (k <= 0) 1e200 else lgamma(k)-k*(log(k)-1-para[1]+para[2])
     }
     khat <- nlm(ll, ybar^2/var(data$hours))$estimate
     c(ybar, khat)
}

air.rg <- function(data, mle) {
    # Function to generate random exponential variates.
    # mle will contain the mean of the original data
    out <- data
    out$hours <- rexp(nrow(out), 1/mle)
    out
}

air.boot <- boot(aircondit, air.fun, R = 999, sim = "parametric",
                 ran.gen = air.rg, mle = mean(aircondit$hours))

# The bootstrap p-value can then be approximated by
sum(abs(air.boot$t[,2]-1) > abs(air.boot$t0[2]-1))/(1+air.boot$R)

Bootstrapping of Time Series

Description

Generate 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.

Usage

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)

Arguments

`tseries`	A univariate or multivariate time series.
`statistic`	A function which when applied to `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`.
`R`	A positive integer giving the number of bootstrap replicates required.
`sim`	The type of simulation required to generate the replicate time series. The possible input values are `"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).
`l`	If `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.
`endcorr`	A logical variable indicating whether end corrections are to be applied when `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`	The length of the simulated time series. Typically this will be equal to the length of the original time series but there are situations when it will be larger. One obvious situation is if prediction is required. Another situation in which `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.
`orig.t`	A logical variable which indicates whether `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`.
`ran.gen`	This is a function of three arguments. The first argument is a time series. If `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.args`	This will be supplied to `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`	A logical argument indicating whether normal margins should be used for phase scrambling. If `norm` is `FALSE` then margins corresponding to the exact empirical margins are used.
`...`	Extra named arguments to `statistic` may be supplied here. Beware of partial matching to the arguments of `tsboot` listed above.
`parallel`, `ncpus`, `cl`	See the help for `boot`.

Details

If 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".

Value

An object of class "boot" with the following components.

`t0`	If `orig.t` is `TRUE` then `t0` is the result of `statistic(tseries,...{})` otherwise it is `NULL`.
`t`	The results of applying `statistic` to the replicate time series.
`R`	The value of `R` as supplied to `tsboot`.
`tseries`	The original time series.
`statistic`	The function `statistic` as supplied.
`sim`	The simulation type used in generating the replicates.
`endcorr`	The value of `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`	The value of `n.sim` used.
`l`	The value of `l` used for block based resampling. This will be `NULL` if block based resampling was not used.
`ran.gen`	The `ran.gen` function used for generating the series or for ‘post-blackening’.
`ran.args`	The extra arguments passed to `ran.gen`.
`call`	The original call to `tsboot`.

References

Davison, A.C. and Hinkley, D.V. (1997) Bootstrap Methods and Their Application. Cambridge University Press.

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.

Examples

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.

`y`	A vector or matrix of data
`tmin`	The minimum value of the range over which the likelihood should be computed. This must be larger than `min(y)`.
`tmax`	The maximum value of the range over which the likelihood should be computed. This must be smaller than `max(y)`.
`n.t`	The number of points between `tmin` and `tmax` at which the value of the log-likelihood should be computed.
`u`	A function of the data and the parameter.

`boot.out`	A object of class `"boot"` generated by a call to `boot` or `tilt.boot`. Use of these functions makes sense only when the bootstrap resampling used unequal weights for the observations. If the importance weights `w` are not supplied then `boot.out` is a required argument. It is also required if `t` is not supplied.
`alpha`	The alpha levels for the required quantiles. The default is to calculate the 1%, 2.5%, 5%, 10%, 90%, 95%, 97.5% and 99% quantiles.
`index`	The index of the variable of interest in the output of `boot.out$statistic`. This is not used if the argument `t` is supplied.
`t0`	The values at which tail probability estimates are required. For each value `t0[i]` the function will estimate the bootstrap cdf evaluated at `t0[i]`. If `imp.prob` is called without the argument `t0` then the bootstrap cdf evaluated at the observed value of the statistic is found.
`t`	The bootstrap replicates of a statistic. By default these are taken from the bootstrap output object `boot.out` but they can be supplied separately if required (e.g. when the statistic of interest is a function of the calculated values in `boot.out`). Either `boot.out` or `t` must be supplied.
`w`	The importance resampling weights for the bootstrap replicates. If they are not supplied then `boot.out` must be supplied, in which case the importance weights are calculated by a call to `imp.weights`.
`def`	A logical value indicating whether a defensive mixture is to be used for weight calculation. This is used only if `w` is missing and it is passed unchanged to `imp.weights` to calculate `w`.
`q`	A vector of probabilities specifying the resampling distribution from which any estimates should be found. In general this would correspond to the usual bootstrap resampling distribution which gives equal weight to each of the original observations. The estimates depend on this distribution only through the importance weights `w` so this argument is ignored if `w` is supplied. If `w` is missing then `q` is passed as an argument to `imp.weights` and used to find `w`.

`alpha`	The `alpha` levels used for the quantiles, if `imp.quantile` is used.
`t0`	The values at which the tail probabilities are estimated, if `imp.prob` is used.
`raw`	The raw importance resampling estimates. For `imp.moments` this has length 2, the first component being the estimate of the mean and the second being the variance estimate. For `imp.prob`, `raw` is of the same length as `t0`, and for `imp.quantile` it is of the same length as `alpha`.
`rat`	The ratio importance resampling estimates. In this method the weights `w` are rescaled to have average value one before they are used. The format of this vector is the same as `raw`.
`reg`	The regression importance resampling estimates. In this method the weights which are used are derived from a regression of `t*w` on `w`. This choice of weights can be shown to minimize the variance of the weights and also the Euclidean distance of the weights from the uniform weights. The format of this vector is the same as `raw`.

`data`	A data set expressed as a vector, matrix or data frame.
`statistic`	A function which returns the statistic of interest. The function must take at least 2 arguments; the first argument should be the data and the second a vector of weights. The weights passed to `statistic` will be normalized to sum to 1 within each stratum. Any other arguments should be passed to `abc.ci` as part of the `...{}` argument.
`index`	If `statistic` returns a vector of length greater than 1, then this indicates the position of the variable of interest within that vector.
`strata`	A factor or numerical vector indicating to which sample each observation belongs in multiple sample problems. The default is the one-sample case.
`conf`	A scalar or vector containing the confidence level(s) of the required interval(s).
`eps`	The value of epsilon to be used for the numerical differentiation.
`...`	Any other arguments for `statistic`. These will be passed unchanged to `statistic` each time it is called within `abc.ci`.

`boot.out`	An object of class `"boot"` returned by one of the generation functions for such an object.
`indices`	A logical argument which specifies whether to return the frequency array or the raw index array. The default is `indices=FALSE` unless `boot.out` was created by `tsboot` in which case the default is `indices=TRUE`.

`boot.out`	An object of class `"boot"` containing the output of a bootstrap calculation.
`conf`	A scalar or vector containing the confidence level(s) of the required interval(s).
`type`	A vector of character strings representing the type of intervals required. The value should be any subset of the values `c("norm","basic", "stud", "perc", "bca")` or simply `"all"` which will compute all five types of intervals.
`index`	This should be a vector of length 1 or 2. The first element of `index` indicates the position of the variable of interest in `boot.out$t0` and the relevant column in `boot.out$t`. The second element indicates the position of the variance of the variable of interest. If both `var.t0` and `var.t` are supplied then the second element of `index` (if present) is ignored. The default is that the variable of interest is in position 1 and its variance is in position 2 (as long as there are 2 positions in `boot.out$t0`).
`var.t0`	If supplied, a value to be used as an estimate of the variance of the statistic for the normal approximation and studentized intervals. If it is not supplied and `length(index)` is 2 then `var.t0` defaults to `boot.out$t0[index[2]]` otherwise `var.t0` is undefined. For studentized intervals `var.t0` must be defined. For the normal approximation, if `var.t0` is undefined it defaults to `var(t)`. If a transformation is supplied through the argument `h` then `var.t0` should be the variance of the untransformed statistic.
`var.t`	This is a vector (of length `boot.out$R`) of variances of the bootstrap replicates of the variable of interest. It is used only for studentized intervals. If it is not supplied and `length(index)` is 2 then `var.t` defaults to `boot.out$t[,index[2]]`, otherwise its value is undefined which will cause an error for studentized intervals. If a transformation is supplied through the argument `h` then `var.t` should be the variance of the untransformed bootstrap statistics.
`t0`	The observed value of the statistic of interest. The default value is `boot.out$t0[index[1]]`. Specification of `t0` and `t` allows the user to get intervals for a transformed statistic which may not be in the bootstrap output object. See the second example below. An alternative way of achieving this would be to supply the functions `h`, `hdot`, and `hinv` below.
`t`	The bootstrap replicates of the statistic of interest. It must be a vector of length `boot.out$R`. It is an error to supply one of `t0` or `t` but not the other. Also if studentized intervals are required and `t0` and `t` are supplied then so should be `var.t0` and `var.t`. The default value is `boot.out$t[,index]`.
`L`	The empirical influence values of the statistic of interest for the observed data. These are used only for BCa intervals. If a transformation is supplied through the parameter `h` then `L` should be the influence values for `t`; the values for `h(t)` are derived from these and `hdot` within the function. If `L` is not supplied then the values are calculated using `empinf` if they are needed.
`h`	A function defining a transformation. The intervals are calculated on the scale of `h(t)` and the inverse function `hinv` applied to the resulting intervals. It must be a function of one variable only and for a vector argument, it must return a vector of the same length, i.e. `h(c(t1,t2,t3))` should return `c(h(t1),h(t2),h(t3))`. The default is the identity function.
`hdot`	A function of one argument returning the derivative of `h`. It is a required argument if `h` is supplied and normal, studentized or BCa intervals are required. The function is used for approximating the variances of `h(t0)` and `h(t)` using the delta method, and also for finding the empirical influence values for BCa intervals. Like `h` it should be able to take a vector argument and return a vector of the same length. The default is the constant function 1.
`hinv`	A function, like `h`, which returns the inverse of `h`. It is used to transform the intervals calculated on the scale of `h(t)` back to the original scale. The default is the identity function. If `h` is supplied but `hinv` is not, then the intervals returned will be on the transformed scale.
`...`	Any extra arguments that `boot.out$statistic` is expecting. These arguments are needed only if BCa intervals are required and `L` is not supplied since in that case `L` is calculated through a call to `empinf` which calls `boot.out$statistic`.

`R`	The number of bootstrap replicates on which the intervals were based.
`t0`	The observed value of the statistic on the same scale as the intervals.
`call`	The call to `boot.ci` which generated the object. It will also contain one or more of the following components depending on the value of `type` used in the call to `bootci`.
`normal`	A matrix of intervals calculated using the normal approximation. It will have 3 columns, the first being the level and the other two being the upper and lower endpoints of the intervals.
`basic`	The intervals calculated using the basic bootstrap method.
`student`	The intervals calculated using the studentized bootstrap method.
`percent`	The intervals calculated using the bootstrap percentile method.
`bca`	The intervals calculated using the adjusted bootstrap percentile (BCa) method. These latter four components will be matrices with 5 columns, the first column containing the level, the next two containing the indices of the order statistics used in the calculations and the final two the calculated endpoints themselves.

`data`	The data frame or matrix containing the data. It must have at least two columns, one of which contains the times and the other the censoring indicators. It is allowed to have as many other columns as desired (although efficiency is reduced for large numbers of columns) except for `sim = "weird"` when it should only have two columns - the times and censoring indicators. The columns of `data` referenced by the components of `index` are taken to be the times and censoring indicators.
`statistic`	A function which operates on the data frame and returns the required statistic. Its first argument must be the data. Any other arguments that it requires can be passed using the `...` argument. In the case of `sim = "weird"`, the data passed to `statistic` only contains the times and censoring indicator regardless of the actual number of columns in `data`. In all other cases the data passed to statistic will be of the same form as the original data. When `sim = "weird"`, the actual number of observations in the resampled data sets may not be the same as the number in `data`. For this reason, if `sim = "weird"` and `strata` is supplied, `statistic` should also take a numeric vector indicating the strata. This allows the statistic to depend on the strata if required.
`R`	The number of bootstrap replicates.
`F.surv`	An object returned from a call to `survfit` giving the survivor function for the data. This is a required argument unless `sim = "ordinary"` or `sim = "model"` and `cox` is missing.
`G.surv`	Another object returned from a call to `survfit` but with the censoring indicators reversed to give the product-limit estimate of the censoring distribution. Note that for consistency the uncensored times should be reduced by a small amount in the call to `survfit`. This is a required argument whenever `sim = "cond"` or when `sim = "model"` and `cox` is supplied.
`strata`	The strata used in the calls to `survfit`. It can be a vector or a matrix with 2 columns. If it is a vector then it is assumed to be the strata for the survival distribution, and the censoring distribution is assumed to be the same for all observations. If it is a matrix then the first column is the strata for the survival distribution and the second is the strata for the censoring distribution. When `sim = "weird"` only the strata for the survival distribution are used since the censoring times are considered fixed. When `sim = "ordinary"`, only one set of strata is used to stratify the observations, this is taken to be the first column of `strata` when it is a matrix.
`sim`	The simulation type. Possible types are `"ordinary"` (case resampling), `"model"` (equivalent to `"ordinary"` if `cox` is missing, otherwise it is model-based resampling), `"weird"` (the weird bootstrap - this cannot be used if `cox` is supplied), and `"cond"` (the conditional bootstrap, in which censoring times are resampled from the conditional censoring distribution).
`cox`	An object returned from `coxph`. If it is supplied, then `F.surv` should have been generated by a call of the form `survfit(cox)`.
`index`	A vector of length two giving the positions of the columns in `data` which correspond to the times and censoring indicators respectively.
`...`	Other named arguments which are passed unchanged to `statistic` each time it is called. Any such arguments to `statistic` must follow the arguments which `statistic` is required to have for the simulation. Beware of partial matching to arguments of `censboot` listed above, and that arguments named `X` and `FUN` cause conflicts in some versions of boot (but not this one).
`parallel`, `ncpus`, `cl`	See the help for `boot`.

`t0`	The value of `statistic` when applied to the original data.
`t`	A matrix of bootstrap replicates of the values of `statistic`.
`R`	The number of bootstrap replicates performed.
`sim`	The simulation type used. This will usually be the input value of `sim` unless that was `"model"` but `cox` was not supplied, in which case it will be `"ordinary"`.
`data`	The data used for the bootstrap. This will generally be the input value of `data` unless `sim = "weird"`, in which case it will just be the columns containing the times and the censoring indicators.
`seed`	The value of `.Random.seed` when `censboot` started work.
`statistic`	The input value of `statistic`.
`strata`	The strata used in the resampling. When `sim = "ordinary"` this will be a vector which stratifies the observations, when `sim = "weird"` it is the strata for the survival distribution and in all other cases it is a matrix containing the strata for the survival distribution and the censoring distribution.
`call`	The original call to `censboot`.

`boot.out`	A bootstrap output object returned from `boot`. The bootstrap replicates must have been generated using the usual nonparametric bootstrap.
`L`	The empirical influence values for the statistic of interest. If `L` is not supplied then `empinf` is called to calculate them from `boot.out`.
`distn`	If present this must be the output from `smooth.spline` giving the distribution function of the linear approximation. This is used only if `bias.adj` is `FALSE`. Normally this would be found using a saddlepoint approximation. If it is not supplied in that case then it is calculated by `saddle.distn`.
`index`	The index of the variable of interest in the output of `boot.out$statistic`.
`t0`	The observed value of the statistic of interest on the original data set `boot.out$data`. This argument is used only if `bias.adj` is `FALSE`. The input value is ignored if `t` is not also supplied. The default value is is `boot.out$t0[index]`.
`t`	The bootstrap replicate values of the statistic of interest. This argument is used only if `bias.adj` is `FALSE`. The input is ignored if `t0` is not supplied also. The default value is `boot.out$t[,index]`.
`bias.adj`	A logical variable which if `TRUE` specifies that the adjusted bias estimate using post-simulation balance is all that is required. If `bias.adj` is `FALSE` (default) then the linear approximation to the statistic is calculated and used as a control variate in estimates of the bias, variance and third cumulant as well as quantiles.
`alpha`	The alpha levels for the required quantiles if `bias.adj` is `FALSE`.
`...`	Any additional arguments that `boot.out$statistic` requires. These are passed unchanged every time `boot.out$statistic` is called. `boot.out$statistic` is called once if `bias.adj` is `TRUE`, otherwise it may be called by `empinf` for empirical influence calculations if `L` is not supplied.

`L`	The empirical influence values used. These are the input values if supplied, and otherwise they are the values calculated by `empinf`.
`tL`	The linear approximations to the bootstrap replicates `t` of the statistic of interest.
`bias`	The control estimate of bias using the linear approximation to `t` as a control variate.
`var`	The control estimate of variance using the linear approximation to `t` as a control variate.
`k3`	The control estimate of the third cumulant using the linear approximation to `t` as a control variate.
`quantiles`	A matrix with two columns; the first column are the alpha levels used for the quantiles and the second column gives the corresponding control estimates of the quantiles using the linear approximation to `t` as a control variate.
`distn`	An output object from `smooth.spline` describing the saddlepoint approximation to the bootstrap distribution of the linear approximation to `t`. If `distn` was supplied on input then this is the same as the input otherwise it is calculated by a call to `saddle.distn`.

`d`	A matrix with two columns corresponding to the two variables whose correlation we wish to calculate.
`w`	A vector of weights to be applied to each pair of observations. The default is equal weights for each pair. Normalization takes place within the function so `sum(w)` need not equal 1.

`a`	A vector of observations.
`b`	Another vector of observations, if not supplied it is set to the value of `a`. If supplied then it must be the same length as `a`.
`c`	Another vector of observations, if not supplied it is set to the value of `a`. If supplied then it must be the same length as `a`.
`unbiased`	A logical value indicating whether the unbiased estimator should be used.

`data`	A matrix or data frame containing the data. The rows should be cases and the columns correspond to variables, one of which is the response.
`glmfit`	An object of class `"glm"` containing the results of a generalized linear model fitted to `data`.
`cost`	A function of two vector arguments specifying the cost function for the cross-validation. The first argument to `cost` should correspond to the observed responses and the second argument should correspond to the predicted or fitted responses from the generalized linear model. `cost` must return a non-negative scalar value. The default is the average squared error function.
`K`	The number of groups into which the data should be split to estimate the cross-validation prediction error. The value of `K` must be such that all groups are of approximately equal size. If the supplied value of `K` does not satisfy this criterion then it will be set to the closest integer which does and a warning is generated specifying the value of `K` used. The default is to set `K` equal to the number of observations in `data` which gives the usual leave-one-out cross-validation.

`call`	The original call to `cv.glm`.
`K`	The value of `K` used for the K-fold cross validation.
`delta`	A vector of length two. The first component is the raw cross-validation estimate of prediction error. The second component is the adjusted cross-validation estimate. The adjustment is designed to compensate for the bias introduced by not using leave-one-out cross-validation.
`seed`	The value of `.Random.seed` when `cv.glm` was called.

`boot.out`	A bootstrap object created by the function `boot`. If `type` is `"reg"` then this argument is required. For any of the other types it is an optional argument. If it is included when optional then the values of `data`, `statistic`, `stype`, and `strata` are taken from the components of `boot.out` and any values passed to `empinf` directly are ignored.
`data`	A vector, matrix or data frame containing the data for which empirical influence values are required. It is a required argument if `boot.out` is not supplied. If `boot.out` is supplied then `data` is set to `boot.out$data` and any value supplied is ignored.
`statistic`	The statistic for which empirical influence values are required. It must be a function of at least two arguments, the data set and a vector of weights, frequencies or indices. The nature of the second argument is given by the value of `stype`. Any other arguments that it takes must be supplied to `empinf` and will be passed to `statistic` unchanged. This is a required argument if `boot.out` is not supplied, otherwise its value is taken from `boot.out` and any value supplied here will be ignored.
`type`	The calculation type to be used for the empirical influence values. Possible values of `type` are `"inf"` (infinitesimal jackknife), `"jack"` (usual jackknife), `"pos"` (positive jackknife), and `"reg"` (regression estimation). The default value depends on the other arguments. If `t` is supplied then the default value of `type` is `"reg"` and `boot.out` should be present so that its frequency array can be found. It `t` is not supplied then if `stype` is `"w"`, the default value of `type` is `"inf"`; otherwise, if `boot.out` is present the default is `"reg"`. If none of these conditions apply then the default is `"jack"`. Note that it is an error for `type` to be `"reg"` if `boot.out` is missing or to be `"inf"` if `stype` is not `"w"`.
`stype`	A character variable giving the nature of the second argument to `statistic`. It can take on three values: `"w"` (weights), `"f"` (frequencies), or `"i"` (indices). If `boot.out` is supplied the value of `stype` is set to `boot.out$stype` and any value supplied here is ignored. Otherwise it is an optional argument which defaults to `"w"`. If `type` is `"inf"` then `stype` MUST be `"w"`.
`index`	An integer giving the position of the variable of interest in the output of `statistic`.
`t`	A vector of length `boot.out$R` which gives the bootstrap replicates of the statistic of interest. `t` is used only when `type` is `reg` and it defaults to `boot.out$t[,index]`.
`strata`	An integer vector or a factor specifying the strata for multi-sample problems. If `boot.out` is supplied the value of `strata` is set to `boot.out$strata`. Otherwise it is an optional argument which has default corresponding to the single sample situation.
`eps`	This argument is used only if `type` is `"inf"`. In that case the value of epsilon to be used for numerical differentiation will be `eps` divided by the number of observations in `data`.
`...`	Any other arguments that `statistic` takes. They will be passed unchanged to `statistic` every time that it is called.

`boot.out`	An object of class `"boot"` for which `boot.out$t` contains the replicates of the curve at a number of fixed points.
`mat`	A matrix of bootstrap replicates of the values of the curve at a number of fixed points. This is a required argument if `boot.out` is not supplied and is set to `boot.out$t` otherwise.
`level`	The confidence level of the envelopes required. The default is to find 95% confidence envelopes. It can be a scalar or a vector of length 2. If it is scalar then both the pointwise and the overall envelopes are found at that level. If is a vector then the first element gives the level for the pointwise envelope and the second gives the level for the overall envelope.
`index`	The numbers of the columns of `mat` which contain the bootstrap replicates. This can be used to ensure that other statistics which may have been calculated in the bootstrap are not considered as values of the function.

`point`	A matrix with two rows corresponding to the values of the upper and lower pointwise confidence envelope at the same points as the bootstrap replicates were calculated.
`overall`	A matrix similar to `point` but containing the envelope which controls the overall error.
`k.pt`	The quantiles used for the pointwise envelope.
`err.pt`	A vector with two components, the first gives the pointwise error rate for the pointwise envelope, and the second the overall error rate for that envelope.
`k.ov`	The quantiles used for the overall envelope.
`err.ov`	A vector with two components, the first gives the pointwise error rate for the overall envelope, and the second the overall error rate for that envelope.
`err.nom`	A vector of length 2 giving the nominal error rates for the pointwise and the overall envelopes.

`L`	The empirical influence values for the statistic of interest based on the observed data. The length of `L` should be the same as the size of the original data set. Typically `L` will be calculated by a call to `empinf`.
`theta`	The value at which the tilted distribution is to be centred. This is not required if `lambda` is supplied but is needed otherwise.
`t0`	The current value of the statistic. The default is that the statistic equals 0.
`lambda`	The Lagrange multiplier(s). For each value of `lambda` a multinomial distribution is found with probabilities proportional to `exp(lambda * L)`. In general `lambda` is not known and so `theta` would be supplied, and the corresponding value of `lambda` found. If both `lambda` and `theta` are supplied then `lambda` is ignored and the multipliers for tilting to `theta` are found.
`strata`	A vector or factor of the same length as `L` giving the strata for the observed data and the empirical influence values `L`.

`p`	The tilted probabilities. There will be `m` distributions where `m` is the length of `theta` (or `lambda` if supplied). If `m` is 1 then `p` is a vector of `length(L)` probabilities. If `m` is greater than 1 then `p` is a matrix with `m` rows, each of which contain `length(L)` probabilities. In this case the vector `p[i,]` is the distribution tilted to `theta[i]`. `p` is in the form required by the argument `weights` of the function `boot` for importance resampling.
`lambda`	The Lagrange multiplier used in the equation to determine the tilted probabilities. `lambda` is a vector of the same length as `theta`.
`theta`	The values of `theta` to which the distributions have been tilted. In general this will be the input value of `theta` but if `lambda` was supplied then this is the vector of the corresponding `theta` values.

`res`	The vector of jackknife deviance residuals.
`rd`	The vector of standardized deviance residuals.
`rp`	The vector of standardized Pearson residuals.
`cook`	The vector of approximate Cook statistics.
`h`	The vector of leverages of the observations.
`sd`	The value used to standardize the residuals. This is the estimate of residual standard deviation in the Gaussian family and is the square root of the estimated shape parameter in the Gamma family. In all other cases it is 1.

`glmfit`	`glm.object` : the result of a call to `glm()`
`glmdiag`	Diagnostics of `glmfit` obtained from a call to `glm.diag`. If it is not supplied then it is calculated.
`subset`	Subset of `data` for which `glm` fitting performed: should be the same as the `subset` option used in the call to `glm()` which generated `glmfit`. Needed only if the `subset=` option was used in the call to `glm`.
`iden`	A logical argument. If `TRUE` then, after the plots are drawn, the user will be prompted for an integer between 0 and 4. A positive integer will select a plot and invoke `identify()` on that plot. After exiting `identify()`, the user is again prompted, this loop continuing until the user responds to the prompt with 0. If `iden` is `FALSE` (default) the user cannot interact with the plots.
`labels`	A vector of labels for use with `identify()` if `iden` is `TRUE`. If it is not supplied then the labels are derived from `glmfit`.
`ret`	A logical argument indicating if `glmdiag` should be returned. The default is `FALSE`.

`boot.out`	An object of class `"boot"` which would normally be created by a call to `boot`. It should represent a nonparametric bootstrap. For reliable results `boot.out$R` should be reasonably large.
`index`	The index of the statistic of interest in the output of `boot.out$statistic`.
`t`	A vector of length `boot.out$R` giving the bootstrap replicates of the statistic of interest. This is useful if the statistic of interest is a function of the calculated bootstrap output. If it is not supplied then the default is `boot.out$t[,index]`.
`L`	The empirical influence values for the statistic of interest. These are used only if `useJ` is `FALSE`. If they are not supplied and are needed, they are calculated by a call to `empinf`. If `L` is supplied then it is assumed that they are the infinitesimal jackknife values.
`useJ`	A logical variable indicating if the jackknife influence values calculated from the bootstrap replicates should be used. If `FALSE` the empirical influence values are used. The default is `TRUE`.
`stinf`	A logical variable indicating whether to standardize the jackknife values before plotting them. If `TRUE` then the jackknife values used are divided by their standard error.
`alpha`	The quantiles at which the plots are required. The default is `c(0.05, 0.1, 0.16, 0.5, 0.84, 0.9, 0.95)`.
`main`	A character string giving the main title for the plot.
`ylab`	The label for the Y axis. If the default values of `alpha` are used and `ylab` is not supplied then a label indicating which percentiles are plotted is used. If `alpha` is supplied then the default label will not say which percentiles were used.
`...`	Any extra arguments required by `boot.out$statistic`. These are required only if `useJ` is `FALSE` and `L` is not supplied, in which case they are passed to `empinf` for use in calculation of the empirical influence values.

`L`	Vector of the empirical influence values of a statistic. These will usually be calculated by a call to `empinf`.
`strata`	A numeric vector or factor specifying which observations (and hence which components of `L`) come from which strata.

`boot.out`	An object of class `"boot"` representing a nonparametric bootstrap. It will usually be created by the function `boot`.
`L`	A vector containing the empirical influence values for the statistic of interest. If it is not supplied then `L` is calculated through a call to `empinf`.
`index`	The index of the variable of interest within the output of `boot.out$statistic`.
`type`	This gives the type of empirical influence values to be calculated. It is not used if `L` is supplied. The possible types of empirical influence values are described in the help for `empinf`.
`t0`	The observed value of the statistic of interest. The input value is used only if one of `t` or `L` is also supplied. The default value is `boot.out$t0[index]`. If `t0` is supplied but neither `t` nor `L` are supplied then `t0` is set to `boot.out$t0[index]` and a warning is generated.
`t`	A vector of bootstrap replicates of the statistic of interest. If `t0` is missing then `t` is not used, otherwise it is used to calculate the empirical influence values (if they are not supplied in `L`).
`...`	Any extra arguments required by `boot.out$statistic`. These are needed if `L` is not supplied as they are used by `empinf` to calculate empirical influence values.

Package 'boot'

Help Index

Empirical Likelihoods

Description

Usage

Arguments

Details

Value

Author(s)

References

Importance Sampling Estimates

Description

Usage

Arguments

Value

References

See Also

Examples

Nonparametric ABC Confidence Intervals

Description

Usage

Arguments

Details

Value

References

See Also

Examples

Monthly Excess Returns

Description

Usage

Format

Source

References

Delay in AIDS Reporting in England and Wales

Description

Usage

Format

Source

References

Failures of Air-conditioning Equipment

Description

Usage

Format

Source

References

Car Speeding and Warning Signs

Description

Usage

Format

Source

References

Remission Times for Acute Myelogenous Leukaemia

Description

Usage

Format

Note

Source

References

Beaver Body Temperature Data

Description

Usage

Format

Source

References

Population of U.S. Cities

Description

Usage

Format

Source

References

Bootstrap Resampling

Description

Usage

Arguments

Details

Value

Parallel operation

References

See Also

Examples

`x`	An object of class `"saddle.distn"` (see `saddle.distn.object` representing a saddlepoint approximation to a distribution.
`dens`	A logical variable indicating whether the saddlepoint density (`TRUE`; the default) or the saddlepoint distribution function (`FALSE`) should be plotted.
`h`	Any transformation of the variable that is required. Its first argument must be the value at which the approximation is being performed and the function must be vectorized.
`J`	When `dens=TRUE` this function specifies the Jacobian for any transformation that may be necessary. The first argument of `J` must the value at which the approximation is being performed and the function must be vectorized. If `h` is supplied `J` must also be supplied and both must have the same argument list.
`npts`	The number of points to be used for the plot. These points will be evenly spaced over the range of points used in finding the saddlepoint approximation.
`lty`	The line type to be used.
`...`	Any additional arguments to `h` and `J`.

`x`	An object of class `"boot"` returned from one of the bootstrap generation functions.
`index`	The index of the variable of interest within the output of `boot.out`. This is ignored if `t` and `t0` are supplied.
`t0`	The original value of the statistic. This defaults to `boot.out$t0[index]` unless `t` is supplied when it defaults to `NULL`. In that case no vertical line is drawn on the histogram.
`t`	The bootstrap replicates of the statistic. Usually this will take on its default value of `boot.out$t[,index]`, however it may be useful sometimes to supply a different set of values which are a function of `boot.out$t`.
`jack`	A logical value indicating whether a jackknife-after-bootstrap plot is required. The default is not to produce such a plot.
`qdist`	The distribution against which the Q-Q plot should be drawn. At present `"norm"` (normal distribution - the default) and `"chisq"` (chi-squared distribution) are the only possible values.
`nclass`	An integer giving the number of classes to be used in the bootstrap histogram. The default is the integer between 10 and 100 closest to `ceiling(length(t)/25)`.
`df`	If `qdist` is `"chisq"` then this is the degrees of freedom for the chi-squared distribution to be used. It is a required argument in that case.
`...`	When `jack` is `TRUE` additional parameters to `jack.after.boot` can be supplied. See the help file for `jack.after.boot` for details of the possible parameters.

`x`	A bootstrap output object of class `"boot"` generated by one of the bootstrap functions.
`digits`	The number of digits to be printed in the summary statistics.
`index`	Indices indicating for which elements of the bootstrap output summary statistics are required.
`...`	further arguments passed to or from other methods.

`x`	The output from a call to `boot.ci`.
`hinv`	A transformation to be made to the interval end-points before they are printed.
`...`	further arguments passed to or from other methods.

`x`	An object of class `"saddle.distn"` created by a call to `saddle.distn`.
`...`	further arguments passed to or from other methods.

`x`	An object of class `"simplex"` created by calling the function `simplex` to solve a linear programming problem.
`...`	further arguments passed to or from other methods.

`A`	A vector or matrix of known coefficients of the linear combinations of W. It is a required argument unless `K.adj` and `K2` are supplied, in which case it is ignored.
`u`	The value at which it is desired to calculate the saddlepoint approximation to the distribution of the linear combination of W. It is a required argument unless `K.adj` and `K2` are supplied, in which case it is ignored.
`wdist`	The distribution of W. This can be one of `"m"` (multinomial), `"p"` (Poisson), `"b"` (binary) or `"o"` (other). If `K.adj` and `K2` are given `wdist` is set to `"o"`.
`type`	The type of saddlepoint approximation. Possible types are `"simp"` for simple saddlepoint and `"cond"` for the conditional saddlepoint. When `wdist` is `"o"` or `"m"`, `type` is automatically set to `"simp"`, which is the only type of saddlepoint currently implemented for those distributions.
`d`	This specifies the dimension of the whole statistic. This argument is required only when `wdist = "o"` and defaults to 1 if not supplied in that case. For other distributions it is set to `ncol(A)`.
`d1`	When `type` is `"cond"` this is the dimension of the statistic of interest which must be less than `length(u)`. Then the saddlepoint approximation to the conditional distribution of the first `d1` linear combinations given the values of the remaining combinations is found. Conditional distribution function approximations can only be found if the value of `d1` is 1.
`init`	Used if `wdist` is either `"m"` or `"o"`, this gives initial values to `nlmin` which is used to solve the saddlepoint equation.
`mu`	The values of the parameters of the distribution of W when `wdist` is `"m"`, `"p"` `"b"`. `mu` must be of the same length as W (i.e. `nrow(A)`). The default is that all values of `mu` are equal and so the elements of W are identically distributed.
`LR`	If `TRUE` then the Lugananni-Rice approximation to the cdf is used, otherwise the approximation used is based on Barndorff-Nielsen's r*.
`strata`	The strata for stratified data.
`K.adj`	The adjusted cumulant generating function used when `wdist` is `"o"`. This is a function of a single parameter, `zeta`, which calculates `K(zeta)-u%*%zeta`, where `K(zeta)` is the cumulant generating function of W.
`K2`	This is a function of a single parameter `zeta` which returns the matrix of second derivatives of `K(zeta)` for use when `wdist` is `"o"`. If `K.adj` is given then this must be given also. It is called only once with the calculated solution to the saddlepoint equation being passed as the argument. This argument is ignored if `K.adj` is not supplied.

`spa`	The saddlepoint approximations. The first value is the density approximation and the second value is the distribution function approximation.
`zeta.hat`	The solution to the saddlepoint equation. For the conditional saddlepoint this is the solution to the saddlepoint equation for the numerator.
`zeta2.hat`	If `type` is `"cond"` this is the solution to the saddlepoint equation for the denominator. This component is not returned for any other value of `type`.

`A`	This is a matrix of known coefficients or a function which returns such a matrix. If a function then its first argument must be the point `t` at which a saddlepoint is required. The most common reason for A being a function would be if the statistic is not itself a linear combination of the W but is the solution to a linear estimating equation.
`u`	If `A` is a function then `u` must also be a function returning a vector with length equal to the number of columns of the matrix returned by `A`. Usually all components other than the first will be constants as the other components are the values of the conditioning variables. If `A` is a matrix with more than one column (such as when `wdist = "cond"`) then `u` should be a vector with length one less than `ncol(A)`. In this case `u` specifies the values of the conditioning variables. If `A` is a matrix with one column or a vector then `u` is not used.
`alpha`	The alpha levels for the quantiles of the distribution which should be returned. By default the 0.1, 0.5, 1, 2.5, 5, 10, 20, 50, 80, 90, 95, 97.5, 99, 99.5 and 99.9 percentiles are calculated.
`wdist`	The distribution of W. Possible values are `"m"` (multinomial), `"p"` (Poisson), or `"b"` (binary).
`type`	The type of saddlepoint to be used. Possible values are `"simp"` (simple saddlepoint) and `"cond"` (conditional). If `wdist` is `"m"`, `type` is set to `"simp"`.
`npts`	The number of points at which the saddlepoint approximation should be calculated and then used to fit the spline.
`t`	A vector of points at which the saddlepoint approximations are calculated. These points should extend beyond the extreme quantiles required but still be in the possible range of the bootstrap distribution. The observed value of the statistic should not be included in `t` as the distribution function approximation breaks down at that point. The points should, however cover the entire effective range of the distribution including close to the centre. If `t` is supplied then `npts` is set to `length(t)`. When `t` is not supplied, the function attempts to find the effective range of the distribution and then selects points to cover this range.
`t0`	If `t` is not supplied then a vector of length 2 should be passed as `t0`. The first component of `t0` should be the centre of the distribution and the second should be an estimate of spread (such as a standard error). These two are then used to find the effective range of the distribution. The range finding mechanism does rely on an accurate estimate of location in `t0[1]`.
`init`	When `wdist` is `"m"`, this vector should contain the initial values to be passed to `nlmin` when it is called to solve the saddlepoint equations.
`mu`	The vector of parameter values for the distribution. The default is that the components of W are identically distributed.
`LR`	A logical flag. When `LR` is `TRUE` the Lugananni-Rice cdf approximations are calculated and used to fit the spline. Otherwise the cdf approximations used are based on Barndorff-Nielsen's r*.
`strata`	A vector giving the strata when the rows of A relate to stratified data. This is used only when `wdist` is `"m"`.
`...`	When `A` and `u` are functions any additional arguments are passed unchanged each time one of them is called.

`a`	A vector of length `n` which gives the coefficients of the objective function.
`A1`	An `m1` by `n` matrix of coefficients for the $\leq$ type of constraints.
`b1`	A vector of length `m1` giving the right hand side of the $\leq$ constraints. This argument is required if `A1` is given and ignored otherwise. All values in `b1` must be non-negative.
`A2`	An `m2` by `n` matrix of coefficients for the $\geq$ type of constraints.
`b2`	A vector of length `m2` giving the right hand side of the $\geq$ constraints. This argument is required if `A2` is given and ignored otherwise. All values in `b2` must be non-negative. Note that the constraints `x >= 0` are included automatically and so should not be repeated here.
`A3`	An `m3` by `n` matrix of coefficients for the equality constraints.
`b3`	A vector of length `m3` giving the right hand side of equality constraints. This argument is required if `A3` is given and ignored otherwise. All values in `b3` must be non-negative.
`maxi`	A logical flag which specifies minimization if `FALSE` (default) and maximization otherwise. If `maxi` is `TRUE` then the maximization problem is recast as a minimization problem by changing the objective function coefficients to their negatives.
`n.iter`	The maximum number of iterations to be conducted in each phase of the simplex method. The default is `n+2*(m1+m2+m3)`.
`eps`	The floating point tolerance to be used in tests of equality.