

filter {ts}                                  R Documentation

_L_i_n_e_a_r _F_i_l_t_e_r_i_n_g _o_n _a _T_i_m_e _S_e_r_i_e_s

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

     Applies linear filtering to a univariate time series or
     to each series separately of a multivariate time
     series.

_U_s_a_g_e_:

     filter(x, filter, method="convolution", sides=2,
           circular=FALSE, init)

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

       x: a univariate or multivariate time series.

  filter: a vector of filter coefficients in reverse time
          order (as for AR or MA coefficients).

  method: Either `"convolution"' or `"recursive"' (and can
          be abbreviated). If `"convolution"' a moving aver-
          age is used: if `"recursive"' an autoregression is
          used.

   sides: for convolution filters only. If `sides=1' the
          filter coefficients are for past values only; if
          `sides=2' they are centred around lag 0. In this
          case the length of the filter should be odd, but
          if it is even, more of the filter is forward in
          time than backward.

circular: for convolution filters only.  If `TRUE', wrap the
          filter around the ends of the series, otherwise
          assume external values are missing (`NA').

    init: for recursive filters only. Specifies the initial
          values of the time series just prior to the start
          value, in reverse time order. The default is a set
          of zeros.

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

     Missing values are allowed in `x' but not in `filter'
     (where they would lead to missing values everywhere in
     the output).

     Note that there is an implied coefficient 1 at lag 0 in
     the recursive filter, which gives

         `y[i] =
                 x[i] + f[1]*y[i-1] + ... + f[p]*y[i-p]'

     No check is made to see if recursive filter is invert-
     ible: the output may diverge if it is not.

     The convolution filter is

          `y[i] = f[1]*x[i+o] + ... + f[p]*x[i+o-p-1]'

     where `o' is the offset: see `sides' for how it is
     determined.

_V_a_l_u_e_:

     A time series object.

_N_o_t_e_:

     `convolve(, type="filter")' uses the FFT for computa-
     tions and so may be faster for long filters on univari-
     ate series, but it does not return a time series (and
     so the  time alignment is unclear), nor does it handle
     missing values.  `filter' is faster for a filter of
     length 100 on a series of length 1000, for example.

_A_u_t_h_o_r_(_s_)_:

     B.D. Ripley

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

     `convolve'

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

     x <- 1:100
     filter(x, rep(1,3))
     filter(x, rep(1,3), sides=1)
     filter(x, rep(1,3), sides=1, circular=T)
     data(presidents)
     filter(presidents, rep(1,3))

     ## A simple simulation function for ARMA processes
     arma.sim <- function(n, ar = NULL, ma = NULL, sigma = 1.0)
     {
         x <- ts(rnorm(n+100, 0, sigma), start = -99)
         if(length(ma)) x <- filter(x, c(1, ma), sides=1)
         if(length(ar)) x <- filter(x, ar, method="recursive")
         as.ts(x[-(1:100)])
     }
     arma.sim(63, c(0.8897,-0.4858), c(-0.2279, 0.2488), sigma=sqrt(0.1796))

