kzs                   package:kzs                   R Documentation

_K_o_l_m_o_g_o_r_o_v-_Z_u_r_b_e_n_k_o _S_p_l_i_n_e

_D_e_s_c_r_i_p_t_i_o_n:

     This is a one-dimensional iterative smoothing algorithm based on
     convolutions of rectangular kernels.

_U_s_a_g_e:

     kzs(y, x, smooth, scale, k = 1, edges = TRUE, plot = TRUE)

_A_r_g_u_m_e_n_t_s:

       y: a one-dimensional vector of real values representing the
          response variable to be smoothed. 

       x: a one-dimensional vector of real values representing the
          input variable. 

  smooth: a real number defining the width of the smoothing window,
          i.e., the width of the rectangular kernel.    

   scale: for an irregularly spaced 'x', 'scale' is a positive real
          number that will define a uniform scale along 'x'. 

       k: an integer specifying the number of iterations 'kzs' will
          execute; 'k' may also be  interpreted as the order of
          smoothness (as a polynomial of degree 'k-1'). By default, 'k
          = 1'. 

   edges: a logical indicating whether or not to display the outcome
          data beyond the initial range of 'x'. By  default, 'edges =
          TRUE'.  

    plot: a logical indicating whether or not to produce a plot of the
          'kzs' outcome. This is 'TRUE' by default. 

_D_e_t_a_i_l_s:

     The relation between variables Y and X as a function of a current
     value of X = x [namely, Y(x)] is  often desired as a result of
     practical research. Usually we search for some simple function,
     Y(x),  when given a data set of pairs (Xi, Yi). When plotted,
     these pairs frequently resemble a noisy plot,  and thus Y(x) is
     desired to be a smooth outcome that captures patterns or long-term
     trends in the  original data, while suppressing the noise. The
     'kzs' function is based on convolutions of the rectangular kernel,
     which is equilvalent to repeated applications of a moving average.
     According to  the Central Limit Theorem, repeated convolutions
     with rectangular kernels will converge to the Gaussian kernel; the
     resulting kernel will have finite support equal to 'smooth*k',
     which will result in a  smooth outcome with diminished noise
     leakage, which is a feature that the standard Gaussian kernel does
     not exhibit.

_V_a_l_u_e:

     a two-column data frame of paired values '(xk, yk)': 

     xk : 'x' values in increments of 'scale' 

     yk : smoothed response values resulting from 'k' iterations of
          'kzs' 

_N_o_t_e:

     Data set (Xi, Yi) must be provided, usually as some observations
     that occur at certain times; 'kzs' is designed for the general
     situation, including time series data. In many applications where
     the input  variable, 'x', can be time, 'kzs' is resolving the
     problem of missing values in time series or  irregularly observed
     values in longitudinal data analysis.


     'kzs' may take time to completely run depending on the size of the
     data set used and the number of  iterations specified.

     For more information on the restrictions imposed on 'delta' and
     'd', consult 'kzs.params'.

_A_u_t_h_o_r(_s):

     Derek Cyr cyr.derek@gmail.com and Igor Zurbenko
     igorg.zurbenko@gmail.com

_R_e_f_e_r_e_n_c_e_s:

     Zurbenko, I.G. (1986). _The Spectral Analysis of Time Series_.
     North Holland Series in  Statistics and Probability, Elsevier
     Science, Amsterdam.

_S_e_e _A_l_s_o:

     'kzs.params', 'kzs.2d', 'kzs.md'

_E_x_a_m_p_l_e_s:

     # Total time t
     t <- seq(from = -round(400*pi), to = round(400*pi), by = .25) 

     # Construct the signal over time
     ts <- 0.5*sin(sqrt((2*pi*abs(t))/200))
     signal <- ifelse(t < 0, -ts, ts)

     # Bury the signal in noise [randomly, from N(0, 1)]
     et <- rnorm(length(t), mean = 0, sd = 1)
     yt <- et + signal

     # Data frame of (t, yt) 
     pts <- data.frame(cbind(t, yt))

     ### EXAMPLE 1 - Apply kzs to the signal buried in noise                 

     # Plot of the true signal
     plot(signal ~ t, xlab = "t", ylab = "Signal", main = "True Signal",
     type = "l")

     # Plot of signal + noise
     plot(yt ~ t, ylab = "yt", main = "Signal buried in noise", type = "p")

     # Apply 3 iterations of kzs
     kzs(y = pts[,2], x = pts[,1], smooth = 80, scale = .2, k = 3, edges = TRUE,
     plot = TRUE)
     lines(signal ~ t, col = "red")
     title(main = "kzs(smooth = 80, scale = .2, k = 3, edges = TRUE)")
     legend("topright", c("True signal","kzs estimate"), cex = 0.8,
     col = c("red", "black"), lty = 1:1, lwd = 2, bty = "n")

     ### EXAMPLE 2 - Irregularly observed data over time

     # Cancel a random 20 percent of (t, yt) leaving irregularly observed time points
     obs <- seq(1:length(t))
     t20 <- sample(obs, size = length(obs)/5)
     pts20 <- pts[-t20,]        

     # Plot of (t,yt) with 20 percent of the data removed
     plot(pts20$yt ~ pts20$t, main = "Signal buried in noise\n20 percent of 
     (t, yt) deleted", xlab = "t", ylab = "yt", type = "p")

     # Apply 3 iterations of kzs
     kzs(y = pts20[,2], x = pts20[,1], smooth = 80, scale = .2, k = 3, edges = TRUE, 
     plot = TRUE)
     lines(signal ~ t, col = "red")
     title(main = "kzs(smooth = 80, scale = .2, k = 3, edges = TRUE)")
     legend("topright", c("True signal","kzs estimate"), cex = 0.8, 
     col = c("red", "black"), lty = 1:1, lwd = 2, bty = "n")  

