accessC.wd            package:wavethresh            R Documentation

_G_e_t _s_m_o_o_t_h_e_d _d_a_t_a _f_r_o_m _w_a_v_e_l_e_t _o_b_j_e_c_t (_w_d)

_D_e_s_c_r_i_p_t_i_o_n:

     The smoothed and original data from a wavelet decomposition
     structure (returned from 'wd') are packed into a single vector in
     that structure.  This function extracts the data corresponding to
     a particular resolution level.

_U_s_a_g_e:

     accessC.wd(wd, level = wd$nlevels, boundary=FALSE, aspect, ...)

_A_r_g_u_m_e_n_t_s:

      wd: wavelet decomposition structure from which you wish to
          extract the smoothed or original data if the structure is
          from a wavelet decomposition, or the reconstructed data if
          the structure is from a wavelet reconstruction. 

   level: the level that you wish to extract.  By default, this is the
          level with most detail (in the case of structures from a
          decomposition this is the original data, in the case of
          structures from a reconstruction this is the top-level
          reconstruction). 

boundary: logical; if 'TRUE' then all of the boundary correction values
          will be returned as well (note: the length of the returned
          vector may not be a power of 2).
           If 'boundary' is false, then just the coefficients will be
          returned.

          If the decomposition (or reconstruction) was done with
          periodic boundary conditions, this option has no effect.

  aspect: 

     ...: any other arguments

_D_e_t_a_i_l_s:

     The wd ('wr.wd') function produces a wavelet decomposition
     (reconstruction) structure.

     For decomposition, the top level contains the original data, and
     subsequent lower levels contain the successively smoothed data. So
     if there are 2^m original data points, there will be m+1 levels
     indexed 0,1,...{},m. So

     'accessC.wd(wdobj, level=m)'

     pulls out the original data, as does

     'accessC.wd(wdobj)'

     To get hold of lower levels just specify the level that you're
     interested in, e.g.

     'accessC.wd(wdobj, level=2)'

     gets hold of the second level.

     For reconstruction, the top level contains the ultimate step in
     the Mallat pyramid reconstruction algorithm, lower levels are
     intermediate steps.

     The need for this function is a consequence of the pyramidal
     structure of Mallat's algorithm and the memory efficiency gain
     achieved by storing the pyramid as a linear vector. AccessC
     obtains information about where the smoothed data appears from the
     fl.dbase component of an wd.object, in particular the array
     'fl.dbase$first.last.c' which gives a complete specification of
     index numbers and offsets for 'wd.object$C'.

     Note that this function is method for the generic function
     'accessC'. When the 'wd.object' is definitely a wd class object
     then you only need use the generic version of this function. 

     Note that this function only gets information from 'wd' class
     objects. To insert coefficients etc. into 'wd' structures you have
     to use the 'putC' function (or more precisely, the 'putC.wd'
     method).

_V_a_l_u_e:

     A vector of the extracted data.

_R_E_L_E_A_S_E:

     Version 3.5.3 Copyright Guy Nason 1994

_R_e_f_e_r_e_n_c_e_s:

     Mallat, S. G. (1989) A theory for multiresolution signal
     decomposition:  the wavelet representation. _IEEE Transactions on
     Pattern Analysis and Machine Intelligence. *11*, 674-693.

     Nason, G. P. and Silverman, B. W. (1994). The discrete wavelet
     transform in S.  _Journal of Computational and Graphical
     Statistics,_ *3*, 163-191.  _ \section{RELEASE}{Version 3.5.3
     Copyright Guy Nason 1994} \seealso{ 'wr', 'wd', 'accessD',
     'accessD.wd', 'filter.select', 'threshold', 'putC.wd', 'putD.wd'.}

_S_e_e _A_l_s_o:

     'wr', 'wd', 'accessD', 'accessD.wd', 'filter.select', 'threshold',
     'putC.wd', 'putD.wd'.

_E_x_a_m_p_l_e_s:

     ## Get the 3rd level of smoothed data from a decomposition
     #accessC(wd(data), level=3)
     #
     # Plot the time series from a reconstruction
     #ts.plot(accessC(reconstruction))

