threshold.irregwd         package:wavethresh         R Documentation

_h_o_l_d _i_r_r_e_g_u_l_a_r_l_y _s_p_a_c_e_d _w_a_v_e_l_e_t _d_e_c_o_m_p_o_s_i_t_i_o_n _o_b_j_e_c_t

_D_e_s_c_r_i_p_t_i_o_n:

     This function provides various ways to threshold a 'irregwd' class
     object.

_U_s_a_g_e:

     threshold.irregwd(irregwd, levels = 3:(wd$nlevels - 1), type = "hard",
             policy = "universal", by.level = FALSE, value = 0, dev = var, boundary =        FALSE, verbose = FALSE, return.threshold = FALSE, force.sure=FALSE, cvto        l = 0.01, Q = 0.05, alpha=0.05, ...)

_A_r_g_u_m_e_n_t_s:

 irregwd: The irregularly spaced wavelet decomposition object that you
          wish to threshold.

  levels: a vector of integers which determines which scale levels are
          thresholded in the decomposition. Each integer in the vector
          must refer to a valid level in the 'irregwd' object supplied.
          This is usually any integer from 0 to 'nlevels'(irregwd)-1
          inclusive. Only the levels in this vector contribute to the
          computation of the threshold and its application.

    type: determines the type of thresholding this can be "hard" or
          "soft".

  policy: selects the technique by which the threshold value is
          selected. Each policy corresponds to a method in the
          literature. At present the different policies are:
          '"universal"', '"LSuniversal"', '"sure"', '"cv"', '"fdr"',
          '"op1"', '"op2"', '"manual"', '"mannum"', '"probability"'. A
          description of the policies can be obtained by clicking on
          the above links.

by.level: If 'FALSE' then a global threshold is computed on and applied
          to all scale levels defined in levels. If 'TRUE' a threshold
          is computed and applied separately to each scale level.

   value: This argument conveys the user supplied threshold. If the
          'policy="manual"' then value is the actual threshold value.

     dev: this argument supplies the function to be used to compute the
          spread of the absolute values coefficients. The function
          supplied must return a value of spread on the variance scale
          (i.e. not standard deviation) such as the 'var()' function. A
          popular, useful and robust alternative is the 'madmad'
          function.

boundary: If this argument is 'TRUE' then the boundary bookeeping
          values are included for thresholding, otherwise they are not.

 verbose: if 'TRUE' then the function prints out informative messages
          as it progresses.

return.threshold: If this option is 'TRUE' then the actual _value_ of
          the threshold is returned. If this option is 'FALSE' then a
          thresholded version of the input is returned.

force.sure: If 'TRUE' then the 'SURE' threshold is computed on a vector
          even when that vector is very sparse. If 'FALSE' then the
          normal SUREshrink procedure is followed whereby the universal
          threshold is used for sparse vectors of coefficients.

   cvtol: Parameter for the cross-validation '"cv"' policy.

       Q: Parameter for the false discovery rate '"fdr"' policy.

   alpha: Parameter for Ogden and Parzen's first '"op1"' and '"op2"'
          policies.

     ...: other arguments

_D_e_t_a_i_l_s:

     This function thresholds or shrinks wavelet coefficients stored in
     a 'irregwd' object and returns the coefficients in a modified
     'irregwd' object. The thresholding step is an essential component
     of denoising. 

     The basic idea of thresholding is very simple. In a signal plus
     noise model the wavelet transform of signal is very sparse, the
     wavelet transform of noise is not (in particular, if the noise is
     iid Gaussian then so if the noise contained in the wavelet
     coefficients). Thus since the signal gets concentrated in the
     wavelet coefficients and the noise remains "spread" out it is
     "easy" to separate the signal from noise by keeping large
     coefficients (which correspond to signal) and delete the small
     ones (which correspond to noise). However, one has to have some
     idea of the noise level (computed using the dev option in
     threshold functions). If the noise level is very large then it is
     possible, as usual, that no signal "sticks up" above the noise. 

     For thresholding of an _irregularly spaced wavelet decomposition_
     things are a little different. The original data are irregularly
     spaced (i.e. [x,y] where the x_i are irregularly spaced) and even
     if one assumes iid error on the original data once this has been
     interpolated to a grid by the 'makegrid' function the interpolated
     data values are not independent. The 'irregwd' function computes
     the wavelet transform of the interpolated data but also computes
     the variance of each coefficient using a fast transform. This
     variance information is stored in the c component of 'irregwd'
     objects and this function, 'threshold.irregwd', makes use of this
     variance information when thresholding each coefficient. For more
     details see Kovac and Silverman, 2000 

     Some issues to watch for: 

_l_e_v_e_l_s The default of 'levels = 3:(wd$nlevels - 1)' for the 'levels'
     option most certainly does not work globally for all data problems
     and situations. The level at which thresholding begins (i.e. the
     given threshold and finer scale wavelets) is called the _primary
     resolution_ and is unique to a particular problem. In some ways
     choice of the primary resolution is very similar to choosing the
     bandwidth in kernel regression albeit on a logarithmic scale. See
     Hall and Patil, (1995) and Hall and Nason (1997) for more
     information. For each data problem you need to work out which is
     the best primary resolution. This can be done by gaining
     experience at what works best, or using prior knowledge. It is
     possible to "automatically" choose a "best" primary resolution
     using cross-validation (but not yet in WaveThresh).

     Secondly the levels argument computes and applies the threshold at
     the levels specified in the levels argument. It does this for all
     the levels specified. Sometimes, in wavelet shrinkage, the
     threshold is computed using only the finest scale coefficients (or
     more precisely the estimate of the overall noise level). If you
     want your threshold variance estimate only to use the finest scale
     coefficients (e.g. with universal thresholding) then you will have
     to apply the 'threshold.wd' function twice. Once (with levels set
     equal to 'nlevels'(wd)-1 and with 'return.threshold=TRUE' to
     return the threshold computed on the finest scale and then apply
     the threshold function with the manual option supplying the value
     of the previously computed threshold as the value options.

_b_y._l_e_v_e_l for a 'wd' object which has come from data with noise that is
     correlated then you should have a threshold computed for each
     resolution level. See the paper by Johnstone and Silverman, 1997.

_V_a_l_u_e:

     An object of class 'irregwd'. This object contains the thresholded
     wavelet coefficients. Note that if the 'return.threshold' option
     is set to 'TRUE' then the threshold values will be returned rather
     than the thresholded object.

_R_E_L_E_A_S_E:

     Version 3.6 Copyright Guy Nason 1997

_S_e_e _A_l_s_o:

     'makegrid', 'irregwd', 'irregwd' object, 'accessc',

_E_x_a_m_p_l_e_s:

     #
     # See main example of these functions in the help to makegrid
     #

