tsbootstrap             package:tseries             R Documentation

_B_o_o_t_s_t_r_a_p _f_o_r _G_e_n_e_r_a_l _S_t_a_t_i_o_n_a_r_y _D_a_t_a

_D_e_s_c_r_i_p_t_i_o_n:

     'tsbootstrap' generates bootstrap samples for general stationary
     data and computes the bootstrap estimate of standard error and
     bias if a statistic is given.

_U_s_a_g_e:

     tsbootstrap(x, nb = 1, statistic = NULL, m = 1, b = NULL,
                 type = c("stationary","block"), ...)

_A_r_g_u_m_e_n_t_s:

       x: a numeric vector or time series giving the original data.

      nb: the number of bootstrap series to compute.

statistic: a function which when applied to a time series returns a
          vector containing the statistic(s) of interest.

       m: the length of the basic blocks in the block of blocks
          bootstrap.

       b: if 'type' is '"stationary"', then 'b' is the mean block
          length. If 'type' is '"block"', then 'b' is the fixed block
          length.

    type: the type of bootstrap to generate the simulated time series.
          The possible input values are '"stationary"' (stationary
          bootstrap with mean block length 'b') and '"block"'
          (blockwise bootstrap with block length 'b'). Default to
          '"stationary"'.

     ...: additional arguments for 'statistic' which are passed
          unchanged each time 'statistic' is called.

_D_e_t_a_i_l_s:

     If 'type' is '"stationary"', then the stationary bootstrap scheme
     with mean block length 'b' according to Politis and Romano (1994)
     is computed. For 'type' equals '"block"', the blockwise bootstrap
     with block length 'b' according to Kuensch (1989) is used. 

     If 'm > 1', then the block of blocks bootstrap is computed (see
     Kuensch, 1989). The basic sampling scheme is the same as for  the
     case 'm = 1', except that the bootstrap is applied to a series 'y'
     containing blocks of length 'm', where each block of 'y' is
     defined as y[t] = (x[t], ..., x[t-m+1]). Therefore, for the block
     of blocks bootstrap the first argument of 'statistic' is given by
     a 'n x m' matrix 'yb', where each row of 'yb' contains one
     bootstrapped basic block observation y[t] ('n' is the number of
     observations in 'x'). 

     Note, that for statistics which are functions of the empirical
     'm'-dimensional marginal ('m > 1') only this procedure yields
     asymptotically valid bootstrap estimates. The  case 'm = 1' may
     only be used for symmetric statistics (i.e., for statistics which
     are invariant under permutations of 'x'). 'tsboot' does not
     implement the block of blocks bootstrap, and, therefore, the first
     example in 'tsboot' yields inconsistent estimates.

     For consistency, the (mean) block length 'b' should grow with 'n'
     at an appropriate rate. If 'b' is not given, then a default growth
     rate of 'const * n^(1/3)' is used. This rate is "optimal" under
     certain conditions (see the references for more details). However,
     in general the growth rate depends on the specific properties of
     the data generation process. A default value for 'const' has been
     determined by a Monte Carlo simulation using a Gaussian AR(1)
     process (AR(1)-parameter of 0.5, 500 observations). 'const' has
     been chosen such that the mean square error for the bootstrap
     estimate of the variance of the empirical mean is minimized.  

     Note, that the computationally intensive parts are fully
     implemented in 'C' which makes 'tsbootstrap' about 10 to 30 times
     faster than 'tsboot'.  

     Missing values are not allowed.

     There is a special print method for objects of class
     '"resample.statistic"' which by default uses 'max(3,
     getOption("digits") - 3)' digits to format real numbers.

_V_a_l_u_e:

     If 'statistic' is 'NULL', then it returns a matrix or time series
     with 'nb' columns and 'length(x)' rows containing the bootstrap
     data. Each column contains one bootstrap sample.

     If 'statistic' is given, then a list of class
     '"resample.statistic"' with the following elements is returned: 

statistic: the results of applying 'statistic' to each of the simulated
          time series.

orig.statistic: the results of applying 'statistic' to the original
          series.

    bias: the bootstrap estimate of the bias of 'statistic'.

      se: the bootstrap estimate of the standard error of 'statistic'.

    call: the original call of 'tsbootstrap'.

_A_u_t_h_o_r(_s):

     A. Trapletti

_R_e_f_e_r_e_n_c_e_s:

     H. R. Kuensch (1989): The Jackknife and the Bootstrap for General
     Stationary Observations. _The Annals of Statistics_ *17*,
     1217-1241.

     D. N. Politis and J. P. Romano (1994): The Stationary Bootstrap.
     _Journal of the American Statistical Association_ *89*, 1303-1313.

_S_e_e _A_l_s_o:

     'sample', 'surrogate', 'tsboot'

_E_x_a_m_p_l_e_s:

     n <- 500  # Generate AR(1) process
     a <- 0.6
     e <- rnorm(n+100)  
     x <- double(n+100)
     x[1] <- rnorm(1)
     for(i in 2:(n+100)) {
       x[i] <- a * x[i-1] + e[i]
     }
     x <- ts(x[-(1:100)])

     tsbootstrap(x, nb=500, statistic=mean)

     # Asymptotic formula for the std. error of the mean
     sqrt(1/(n*(1-a)^2))

     acflag1 <- function(x)
     {
       xo <- c(x[,1], x[1,2])
       xm <- mean(xo)
       return(mean((x[,1]-xm)*(x[,2]-xm))/mean((xo-xm)^2))
     }

     tsbootstrap(x, nb=500, statistic=acflag1, m=2)

     # Asymptotic formula for the std. error of the acf at lag one
     sqrt(((1+a^2)-2*a^2)/n)

