# Created by Octave 3.8.2, Sat Sep 27 14:09:40 2014 UTC <root@rama>
# name: cache
# type: cell
# rows: 3
# columns: 54
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
Contents


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4115
 LTFAT - Wavelets

   Zdenek Prusa, 2013 - 2014.

   Basic analysis/synthesis
      FWT               - Fast Wavelet Transform 
      IFWT              - Inverse Fast Wavelet Transform
      FWT2              - 2D Fast Wavelet Transform 
      IFWT2             - 2D Inverse Fast Wavelet Transform
      UFWT              - Undecimated Fast Wavelet Transform
      IUFWT             - Inverse Undecimated Fast Wavelet Transform 
      FWTLENGTH         - Length of Wavelet system to expand a signal
      FWTCLENGTH        - Lengths of the wavelet coefficients subbands

   Advanced analysis/synthesis
      WFBT              - Transform using general Wavelet Filterbank Tree 
      IWFBT             - Inverse transform using general Wavelet Filterbank Tree
      UWFBT             - Undecimated transform using general Wavelet Filterbank Tree 
      IUWFBT            - Inverse Undecimated transform using general Wavelet Filterbank Tree
      WPFBT             - Wavelet Packet Transform using general Wavelet Filterbank Tree 
      IWPFBT            - Inverse Wavelet Packet Transform using general Wavelet Filterbank Tree
      UWPFBT            - Undecimated Wavelet Packet Transform using general Wavelet Filterbank Tree 
      IUWPFBT           - Inverse Undecimated Wavelet Packet Transform using general Wavelet Filterbank Tree
      WPBEST            - Best Tree selection
      WFBTLENGTH        - Length of Wavelet filterbank system to expand a signal

   Wavelet Filterbank trees manipulation
      WFBTINIT          - Wavelet Filterbank tree structure initialization
      WFBTPUT           - Puts node (basic filterbank) to the specific  tree coordinates
      WFBTREMOVE        - Removes node (basic filterbank) from the specific tree coordinates
      WFBT2FILTERBANK   - Creates a non-iterated filterbank using the multirate identity
      FWT2FILTERBANK    - Creates a non-iterated filterbank using the multirate identity
      FWTINIT           - Basic Wavelet Filters structure initialization
  
   Plots
      PLOTWAVELETS      - Plot wavelet coefficients
      WFILTINFO         - Plot wavelet filters impulse and frequency responses and approximation of scaling and wavelet functions

   Auxilary
      WAVFUN            - Aproximate of the continuous scaling and wavelet functions
      WAVCELL2PACK      - Changes wavelet coefficient storing format
      WAVPACK2CELL      - Changes wavelet coefficient storing format back

   Filters defined in the time-domain
      WFILT_ALGMBAND    - An ALGebraic construction of orthonormal M-BAND wavelets with perfect reconstruction
      WFILT_APR         - Almost Perfect Reconstruction Filter Bank for Non-redundant, Approximately Shift-Invariant, ComplexWavelet Transforms
      WFILT_DB          - DauBechies orthogonal filters (ortonormal base)
      WFILT_DDEN        - Double-DENsity dwt filters (tight frame)
      WFILT_DGRID       - Dense GRID framelets (tight frame, symmetric)
      WFILT_DTREE       - Dual-TREE complex wavelet transform filters (two orthonormal bases)
      WFILT_HDEN        - Higher DENsity dwt filters (tight frame, frame)  
      WFILT_LEMARIE         - Battle and Lemarie quadrature filters
      WFILT_MATLABWTWRAPPER - Wrapper of the wfilters function from the Matlab Wavelet Toolbox 
      WFILT_MAXFLAT         - Maximally flat FIR filters
      WFILT_MBAND           - M-band filters
      WFILT_OPTFS           - Optimized orthogonal filters with improved Frequency Selectivity (ortonormal base)
      WFILT_REMEZ           - Wavelet orthonogal filters based on the Remez Exchange algorithm
      WFILT_SYMDS           - SYMmetric wavelet Dyadic Siblings (frames)
      WFILT_SPLINE          - Biorthogonal spline wavelet filters
      WFILT_SYM             - Least asymmetric Daubechies wavelet filters
      
   Wavelet filters defined in the frequency-domain
      WFREQ_LEMARIE         - Battle and Lemarie filters sampled freq. resp.

  For help, bug reports, suggestions etc. please send an email to
  ltfat-help@lists.sourceforge.net

   Url: http://ltfat.sourceforge.net/doc/wavelets/Contents.php



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
 LTFAT - Wavelets



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
fwt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5962
 -- Function: fwt
     FWT   Fast Wavelet Transform
        Usage:  c = fwt(f,w,J);
                c = fwt(f,w,J,dim);
                [c,info] = fwt(...);

        Input parameters:
              f     : Input data.
              w     : Wavelet definition.
              J     : Number of filterbank iterations.
              dim   : Dimension to along which to apply the transform.

        Output parameters:
              c      : Coefficient vector.
              info   : Transform parameters struct.

        c=FWT(f,w,J) returns wavelet coefficients c of the input signal f*
        using J iterations of the basic wavelet filterbank defined by w*
        i.e. the fast wavelet transform algorithm (Mallat's algorithm) is used.
        In addition, the function returns struct. info containing transform
        parameters. It can be conviniently used for the inverse transform
        IFWT e.g. fhat = iFWT(c,info). It is also required by the
        PLOTWAVELETS function.

        The coefficents c are the Discrete Wavelet transform (DWT) of the input
        signal f, if w defines two-channel wavelet filterbank. The following
        figure shows DWT with J=3.

        The function can apply the Mallat's algorithm using basic filter banks
        with any number of the channels. In such case, the transform have a
        different name.

        The basic analysis wavelet filterbank w can be passed in several
        formats. The formats are the same as for the FWTINIT function.

        1) Cell array whose first element is the name of the function defining
           the basic wavelet filters (wfilt_ prefix) and the other elements
           are the parameters of the function. e.g. {'db',10} calls
           wfilt_db(10) internally.

        2) Character string as concatenation of the name of the wavelet
           filters defining function (as above) and the numeric parameters
           delimited by ':' character, e.g. 'db10' has the same effect as above,
           'spline4:4' calls wfilt_spline(4,4) internally.

        3) Cell array of one dimensional numerical vectors directly defining
           the wavelet filter impulse responses.  By default, outputs of the
           filters are subsampled by a factor equal to the number of the
           filters. One can pass additional key-value pair 'a',a (still inside
           of the cell array) to define the custom subsampling factors, e.g.:
           {h1,h2,'a',[2,2]}.

        4) The fourth option is to pass the structure obtained from the
           FWTINIT function. The structure is checked whether it has a valid
           format.

        If f is row/collumn vector, the subbands c are stored
        in a single row/collumn in a consecutive order with respect to the
        inceasing central frequency of the corresponding effective filter
        frequency responses or equivalently with decreasing wavelet scale. The
        lengths of subbands are stored in info.Lc so the subbands can be easily
        extracted using WAVPACK2CELL. Moreover, one can pass an additional
        flag 'cell' to obtain the coefficient directly in a cell array. The
        cell array can be again converted to a packed format using WAVCELL2PACK.

        If the input f is a matrix, the transform is applied to each column
        if dim==1 (default) and [Ls, W]=size(f). If dim==2
        the transform is applied to each row [W, Ls]=size(f).
        The output is then a matrix and the input orientation is preserved in
        the orientation of the output coefficients. The dim paramerer has to
        be passed to the WAVPACK2CELL and WAVCELL2PACK.

        Boundary handling:
        ------------------

        FWT(f,w,J,'per') (default) uses the periodic extension which considers
        the input signal as it was a one period of some infinite periodic signal
        as is natural for transforms based on the FFT. The resulting wavelet
        representation is non-expansive, that is if the input signal length is a
        multiple of a J-th power of the subsampling factor and the filterbank
        is critically subsampled, the total number of coefficients is equal to
        the input signal length. The input signal is padded with zeros to the
        next legal length L internally.

        The default periodic extension can result in "false" high wavelet
        coefficients near the boundaries due to the possible discontinuity
        introduced by the zero padding and periodic boundary treatment.

        FWT(f,w,J,ext) with ext other than 'per' computes a slightly
        redundant wavelet representation of the input signal f with the chosen
        boundary extension ext. The redundancy (expansivity) of the
        represenation is the price to pay for using general filterbank and
        custom boundary treatment.  The extensions are done at each level of the
        transform internally rather than doing the prior explicit padding.

        The supported possibilities are:

          'per'    Zero padding to the next legal length and periodic boundary
                   extension. This is the default.

          'zero'   Zeros are considered outside of the signal (coefficient)
                   support.

          'even'   Even symmetric extension.

          'odd'    Odd symmetric extension.

        Note that the same flag has to be used in the call of the inverse transform
        function IFWT if the info struct is not used.

        Examples:
        ---------

        A simple example of calling the FWT function:

          f = greasy;
          J = 10;
          [c,info] = fwt(f,'db8',J);
          plotwavelets(c,info,44100,'dynrange',90);


        References:
          S. Mallat. A wavelet tour of signal processing. Academic Press, San
          Diego, CA, 1998.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/fwt.php>

     See also: ifwt, plotwavelets, wavpack2cell, wavcell2pack, thresh.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FWT   Fast Wavelet Transform
   Usage:  c = fwt(f,w,J);
           c = fwt(f,w,J



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
fwt2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1991
 -- Function: fwt2
     FWT2   Fast Wavelet Transform 2D
        Usage:  c = fwt2(f,w,J);
                c = fwt2(f,w,J,...);

        Input parameters:
              f     : Input data.
              w     : Wavelet Filterbank definition.
              J     : Number of filterbank iterations.

        Output parameters:
              c      : Coefficients stored in a matrix.

        c=FWT2(f,w,J) returns wavelet coefficients c of the input matrix f*
        using J iterations of the basic wavelet filterbank defined by h.

        FWT2 supports just the non-expansive boundary condition 'per' and
        critically subsampled filterbanks in order to be able to pack the
        coefficients in a matrix. Also the J is limited to some maximum value
        for the same reason.

        Additional flags make it possible to specify how the algorithm
        should subdivide the matrix:

          'standard'  (default) This is the standard behaviour of the JPEG 2000
                      standard

          'tensor'    This corresponds to doing a FWT along each dimension
                      of the matrix.

        Examples:
        ---------

        Some simple example of calling the FWT2 function, compare with the
        CAMERAMAN image. Only the 70 dB largest coefficients are shown, to
        make the structures more visible.

        The first example uses the standard layout:

          c = fwt2(cameraman,{'db',8},4);
          imagesc(dynlimit(20*log10(abs(c)),70));
          axis('image'); colormap(gray);

        The second example uses the tensor product layout:

          c = fwt2(cameraman,{'db',8},4,'tensor');
          imagesc(dynlimit(20*log10(abs(c)),70));
          axis('image'); colormap(gray);



        References:
          S. Mallat. A wavelet tour of signal processing. Academic Press, San
          Diego, CA, 1998.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/fwt2.php>

     See also: ifwt2, fwtinit, demo_imagecompression.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FWT2   Fast Wavelet Transform 2D
   Usage:  c = fwt2(f,w,J);
           c = fwt2



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
fwt2filterbank


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 938
 -- Function: fwt2filterbank
     FWT2FILTERBANK  FWT equivalent non-iterated filterbank
        Usage: [g,a] = fwt2filterbank(wtdef)

        Input parameters:
               w : Wavelet filters definition
               J : Number of filterbank iterations.

        Output parameters:
              g   : Cell array containing filters
              a   : Vector of sub-/upsampling factors

        FWT2FILTERBANK( w, J) calculates the impulse responses g and the
        subsampling factors a of non-iterated filterbank, which is equivalent
        to the wavelet filterbank tree described by w and J. The returned
        parameters can be used directly in FILTERBANK, UFILTERBANK.

        The filters are scaled if a is not returned.

        The function is wrapper for calling WFBT2FILTERBANK.

     *Url*:
     <http://ltfat.sourceforge.net/doc/wavelets/fwt2filterbank.php>

     See also: wfbtinit, wfbt2filterbank, filterbank.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FWT2FILTERBANK  FWT equivalent non-iterated filterbank
   Usage: [g,a] = fwt2fil



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
fwtbounds


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 604
 -- Function: fwtbounds
     FWTBOUNDS Frame bounds of DWT
        Usage: fcond=fwtbounds(w,J,L);
               [A,B]=fwtbounds(w,J,L);

        FWTBOUNDS(w,a,L) calculates the ratio B/A of the frame bounds
        of the filterbank specified by w and J for a system of length
        L. The ratio is a measure of the stability of the system.

        [A,B]=FWTBOUNDS(w,J,L) returns the lower and upper frame bounds
        explicitly.

        See FWT for explanation of parameters w and J.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/fwtbounds.php>

     See also: fwt, filterbankbounds.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FWTBOUNDS Frame bounds of DWT
   Usage: fcond=fwtbounds(w,J,L);
          [A,B]=



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
fwtclength


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 685
 -- Function: fwtclength
     FWTCLENGTH FWT subbands lengths from a signal length
        Usage: L=fwtclength(Ls,h,J);
               L=fwtclength(Ls,h,J,ext,'ext');

        Lc=FWTCLENGTH(Ls,h,J) returns the lengths of the wavelet coefficient
        subbands for a signal of length Ls. Please see the help on FWT for
        an explanation of the parameters h and J. In addition, the function
        returns the next legal length of the input signal for the given extension
        type.

        The function support the same boundary-handling flags as the FWT
        does.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/fwtclength.php>

     See also: fwt, fwtlength.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FWTCLENGTH FWT subbands lengths from a signal length
   Usage: L=fwtclength(Ls,h



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
fwtinit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4454
 -- Function: fwtinit
     FWTINIT  Wavelet Filterbank Structure Initialization
        Usage:  w = fwtinit(wdef);

        Input parameters:
              wdef : Wavelet filters specification.

        Output parameters:
              w    : Structure defining the filterbank.

        w=FWTINIT(wdef) produces a structure describing the analysis
        (field .h) synthesis (field .g) parts of a one level wavelet-type
        filterbank. The function is a wrapper for calling all the functions
        starting with wfilt_ defined in the LTFAT wavelets directory.

        The possible formats of the wdef are the following:

        1) Cell array whose first element is the name of the function defining
           the basic wavelet filters (wfilt_ prefix) and the other elements
           are the parameters of the function. e.g. {'db',10} calls
           wfilt_db(10) internally.

        2) Character string as concatenation of the name of the wavelet
           filters defining function (as above) and the numeric parameters
           delimited by ':' character, e.g. 'db10' has the same effect as above,
           'spline4:4' calls wfilt_spline(4,4) internally.

        3) Cell array of one dimensional numerical vectors directly defining
           the wavelet filter impulse responses.  By default, outputs of the
           filters are subsampled by a factor equal to the number of the
           filters. Pass additional key-value pair 'a',a (still inside of the
           cell array) to define the custom subsampling factors, e.g.:
           {h1,h2,'a',[2,2]}.

        4) The fourth option is to pass again the structure obtained from the
           FWTINIT function. The structure is checked whether it has a valid
           format.

        5) Two element cell array. First element is the string 'dual' and the
           second one is in format 1), 2) or 4). This returns dual of whatever
           is passed.

        6) Two element cell array. First element is the string 'strict' and the
           second one is in format 1), 2), 4) or 5). This ensures the wavelet
           filters not forming a tight frame has to be explicitly defined.

        Using synthesis filters for analysis and vice versa makes a difference
        in case of birtoghonal filters (e.g. 'spline4:4') and filters which
        constructs a general frame (e.g. 'symds2'), in other cases, the analysis
        filters are just time-reversed version of synthesis filters. To specify
        which filters should be used, one can re-use the items 1) and 2) in the
        following way:

        1) Add 'ana' or 'syn' as the first element in the cell array e.g.
           {'ana','spline',4,4} or {'syn','spline',4,4}.

        2) Add 'ana:' or 'syn:' to the beginning of the string e.g.
           'ana:spline4:4' or 'syn:spline4:4'.

        Please note that using e.g. c=fwt(f,'ana:spline4:4',J) and
        fhat=ifwt(c,'ana:spline4:4',J,size(f,1)) will not give a perfect
        reconstruction.

        The output structure has the following fields:

          w.h  Cell array of structures defining the original analysis filter bank.

          w.g  Cell array of structures defining the original synthesis filter bank.

          w.a  Subsampling factors.

          w.origArgs
               Original parameters in format 1).

        w.h, w.g are cell-arrays of structures. Each structure represents
        one filter in the filterbank and it has the following fields:

          .offset  Filter delay in samples.

          .h       Actual filter impulse response values.

        *Remark:* Function names with the wfilt_ prefix cannot contain numbers
        and cannot start with 'ana' or 'syn'!

        Choosing wavelet filters
        ------------------------

        TO DO: Write something meaningfull.
        Determining which wavelet filters to use depends strongly on the type
        of the analyzed signal. There are several properties which should be
        taken into account.

        orthogonality/biorthogonality/frame
        number of vanishing moments of psi
        symmetry/linear phase

        support of psi
        smoothnes/regularity of psi



        References:
          S. Mallat. A Wavelet Tour of Signal Processing, Third Edition: The
          Sparse Way. Academic Press, 3rd edition, 2008.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/fwtinit.php>

     See also: fwt, ifwt, wfilt_db.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FWTINIT  Wavelet Filterbank Structure Initialization
   Usage:  w = fwtinit(wdef



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
fwtlength


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 565
 -- Function: fwtlength
     FWTLENGTH  FWT length from signal
        Usage: L=fwtlength(Ls,w,J);
               L=fwtlength(Ls,w,J,...);

        FWTLENGTH(Ls,w,J) returns the length of a Wavelet system that is long
        enough to expand a signal of length Ls. Please see the help on
        FWT for an explanation of the parameters h and J.

        If the returned length is longer than the signal length, the signal
        will be zero-padded by FWT to length L.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/fwtlength.php>

     See also: fwt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FWTLENGTH  FWT length from signal
   Usage: L=fwtlength(Ls,w,J);
          L=fwt



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
ifwt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2051
 -- Function: ifwt
     IFWT   Inverse Fast Wavelet Transform
        Usage:  f = ifwt(c,info)
                f = ifwt(c,w,J,Ls)
                f = ifwt(c,w,J,Ls,dim)

        Input parameters:
              c      : Wavelet coefficients.
              info,w : Transform parameters struct/Wavelet filters definition.
              J      : Number of filterbank iterations.
              Ls     : Length of the reconstructed signal.
              dim    : Dimension to along which to apply the transform.

        Output parameters:
              f     : Reconstructed data.

        f = IFWT(c,info) reconstructs signal f from the wavelet coefficients
        c using parameters from info struct. both returned by FWT
        function.

        f = IFWT(c,w,J,Ls) reconstructs signal f from the wavelet coefficients
        c using J*-iteration synthesis filter bank build from the basic
        filterbank defined by w. The Ls parameter is mandatory due to the
        ambiguity of lengths introduced by the subsampling operation and by
        boundary treatment methods. Note that the same flag as in the FWT
        function have to be used, otherwise perfect reconstruction cannot be
        obtained.

        In both cases, the fast wavelet transform algorithm (Mallat's algorithm)
        is employed. The format of c can be either packed, as returned by the
        FWT function or cell-array as returned by WAVPACK2CELL function.

        Please see the help on FWT for a detailed description of the parameters.

        Examples:
        ---------

        A simple example showing perfect reconstruction:

          f = gspi;
          J = 8;
          c = fwt(f,'db8',J);
          fhat = ifwt(c,'db8',J,length(f));
          % The following should give (almost) zero
          norm(f-fhat)


        References:
          S. Mallat. A wavelet tour of signal processing. Academic Press, San
          Diego, CA, 1998.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/ifwt.php>

     See also: fwt, wavpack2cell, wavcell2pack.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IFWT   Inverse Fast Wavelet Transform
   Usage:  f = ifwt(c,info)
           f =



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ifwt2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1038
 -- Function: ifwt2
     IFWT2   Inverse Fast Wavelet Transform
        Usage:  f = ifwt2(c,w,J)
                f = ifwt2(c,w,J,Ls,...)

        Input parameters:
              c     : Coefficients stored in a matrix.
              g     : Wavelet filters definition.
              J     : Number of filterbank iterations.
              Ls    : Length of the reconstructed signal.

        Output parameters:
              f     : Reconstructed data.

        f = IFWT2(c,g,J) reconstructs signal f from the wavelet coefficients
        c using a J*-iteration synthesis filter bank build from the basic synthesis
        filterbank defined by g.

        This function takes the same optional parameters as FWT2. Please see
        the help on FWT2 for a description of the parameters.



        References:
          S. Mallat. A wavelet tour of signal processing. Academic Press, San
          Diego, CA, 1998.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/ifwt2.php>

     See also: fwt2, fwtinit, demo_imagecompression.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IFWT2   Inverse Fast Wavelet Transform
   Usage:  f = ifwt2(c,w,J)
           f 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
iufwt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1484
 -- Function: iufwt
     IUFWT   Inverse Undecimated Fast Wavelet Transform
        Usage:  f = iufwt(c,info)
                f = iufwt(c,w,J);

        Input parameters:
              c      : Coefficients stored in L xJ+1 matrix.
              info,w : Transform parameters struct/Wavelet filters definition.
              J      : Number of filterbank iterations.

        Output parameters:
              f     : Reconstructed data.

        f = IUFWT(c,info) reconstructs signal f from the wavelet
        coefficients c using parameters from info struct. both returned by
        UFWT function.

        f = IUFWT(c,w,J) reconstructs signal f from the wavelet
        coefficients c using the wavelet filterbank consisting of the J
        levels of the basic synthesis filterbank defined by g using the "a-trous"
        algorithm. Node that the same flag as in the ufwt function have to be used.

        Please see the help on UFWT for a description of the parameters.

        Examples:
        ---------

        A simple example showing perfect reconstruction:

          f = gspi;
          J = 8;
          c = ufwt(f,'db8',J);
          fhat = iufwt(c,'db8',J);
          % The following should give (almost) zero
          norm(f-fhat)


        References:
          S. Mallat. A wavelet tour of signal processing. Academic Press, San
          Diego, CA, 1998.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/iufwt.php>

     See also: ufwt, plotwavelets.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IUFWT   Inverse Undecimated Fast Wavelet Transform
   Usage:  f = iufwt(c,info)




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
iuwfbt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1166
 -- Function: iuwfbt
     IUWFBT   Inverse Undecimated Wavelet Filterbank Tree
        Usage: f = iuwfbt(c,info)
               f = iuwfbt(c,wt)

        Input parameters:
              c      : Coefficients stored in L xM matrix.
              info,w : Transform parameters struct/Wavelet tree definition.

        Output parameters:
              f     : Reconstructed data.

        f = IUWFBT(c,info) reconstructs signal f from the coefficients c
        using parameters from info struct. both returned by the UWFBT function.

        f = IUWFBT(c,wt) reconstructs signal f from the wavelet coefficients
        c using the undecimated wavelet filterbank tree described by wt using
        the "a-trous" algorithm.

        Examples:
        ---------

        A simple example showing perfect reconstruction using the "full decomposition" wavelet tree:

          f = greasy;
          J = 6;
          c = uwfbt(f,{'db8',J,'full'});
          fhat = iuwfbt(c,{'db8',J,'full'});
          % The following should give (almost) zero
          norm(f-fhat)

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/iuwfbt.php>

     See also: uwfbt, plotwavelets.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IUWFBT   Inverse Undecimated Wavelet Filterbank Tree
   Usage: f = iuwfbt(c,info



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
iuwpfbt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1311
 -- Function: iuwpfbt
     IUWPFBT Inverse Undecimated Wavelet Packet Filterbank Tree
        Usage:  f=iuwpfbt(c,info);
                f=iuwpfbt(c,wt,...);

        Input parameters:
              c     : Coefficients stored in a cell-array.
              wt    : Wavelet Filterbank tree

        Output parameters:
              f     : Reconstructed data.

        f=IUWPFBT(c,wt) reconstructs signal f from coefficients c using the
        wavelet filterbank tree wt.

        The following flags are supported:

        'per','zpd','sym','symw','asym','asymw','ppd','sp0'
               Type of the boundary handling.

        'full','dwt'
               Type of the tree to be used.

        'freq','nat'
               Frequency or natural order of the coefficient subbands.

        Please see the help on FWT for a description of the flags.

        Examples:
        ---------

        A simple example showing perfect reconstruction using the "full decomposition" wavelet tree:

          f = greasy;
          J = 7;
          wtdef = {'db10',J,'full'};
          c = uwpfbt(f,wtdef);
          fhat = iuwpfbt(c,wtdef);
          % The following should give (almost) zero
          norm(f-fhat)


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/iuwpfbt.php>

     See also: wfbt, wfbtinit.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IUWPFBT Inverse Undecimated Wavelet Packet Filterbank Tree
   Usage:  f=iuwpfbt(



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
iwfbt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1581
 -- Function: iwfbt
     IWFBT   Inverse Wavelet Filterbank Tree
        Usage:  f=iwfbt(c,info);
                f=iwfbt(c,wt,Ls);

        Input parameters:
              c       : Coefficients stored in a cell-array.
              info,wt : Transform parameters struct/Wavelet Filterbank tree
              Ls      : Length of the reconstructed signal.

        Output parameters:
              f     : Reconstructed data.

        f = IWFBT(c,info) reconstructs signal f from the coefficients c
        using parameters from info struct. both returned by WFBT function.

        f = IWFBT(c,wt,Ls) reconstructs signal f from the coefficients c*
        using filter bank tree defined by wt. Plese see WFBT function for
        possible formats of wt. The Ls parameter is mandatory due to the
        ambiguity of reconstruction lengths introduced by the subsampling
        operation and by boundary treatment methods. Note that the same flag as
        in the WFBT function have to be used, otherwise perfect reconstruction
        cannot be obtained. Please see help for WFBT for description of the
        flags.

        Examples:
        ---------

        A simple example showing perfect reconstruction using the "full decomposition" wavelet tree:

          f = gspi;
          J = 7;
          wtdef = {'db10',J,'full'};
          c = wfbt(f,wtdef);
          fhat = iwfbt(c,wtdef,length(f));
          % The following should give (almost) zero
          norm(f-fhat)

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/iwfbt.php>

     See also: wfbt, wfbtinit.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IWFBT   Inverse Wavelet Filterbank Tree
   Usage:  f=iwfbt(c,info);
           f



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
iwpfbt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1600
 -- Function: iwpfbt
     IWPFBT   Inverse Wavelet Packet Filterbank Tree
        Usage:  f=iwpfbt(c,info);
                f=iwpfbt(c,wt,Ls);

        Input parameters:
              c       : Coefficients stored in a cell-array.
              info,wt : Transform parameters struct/Wavelet Filterbank tree.
              Ls      : Length of the reconstructed signal.

        Output parameters:
              f     : Reconstructed data.

        f = IWPFBT(c,info) reconstructs signal f from the coefficients c
        using parameters from info struct. both returned by WFBT function.

        f = IWPFBT(c,wt,Ls) reconstructs signal f from the coefficients c*
        using filter bank tree defined by wt. Plese see WFBT function for
        possible formats of wt. The Ls parameter is mandatory due to the
        ambiguity of reconstruction lengths introduced by the subsampling
        operation and by boundary treatment methods. Note that the same flag as
        in the WFBT function have to be used, otherwise perfect reconstruction
        cannot be obtained. Please see help for WFBT for description of the
        flags.

        Examples:
        ---------

        A simple example showing perfect reconstruction using the "full decomposition" wavelet tree:

          f = gspi;
          J = 7;
          wtdef = {'db10',J,'full'};
          c = wpfbt(f,wtdef);
          fhat = iwpfbt(c,wtdef,length(f));
          % The following should give (almost) zero
          norm(f-fhat)


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/iwpfbt.php>

     See also: wpfbt, wfbtinit.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IWPFBT   Inverse Wavelet Packet Filterbank Tree
   Usage:  f=iwpfbt(c,info);
   



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
iwtfft


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 281
 -- Function: iwtfft
     IWTFFT  Inverse Wavelet Transform in the frequency-domain
        Usage: f=iwtfft(c,G,a);
               f=iwtfft(c,G,a,...);

        IWTFFT(c,G,a) computes XXX.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/iwtfft.php>

     See also: wtfft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IWTFFT  Inverse Wavelet Transform in the frequency-domain
   Usage: f=iwtfft(c,G



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
plotwavelets


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1078
 -- Function: plotwavelets
     PLOTWAVELETS  Plot wavelet coefficients
        Usage:  plotwavelets(c,info,fs)
                plotwavelets(c,info,fs,'dynrange',dynrange,...)

        plowavelets(c,info) plots the wavelet coefficients c using
        additional parameters from struct. info. Both parameters are returned
        by any forward transform function in the wavelets directory.

        plowavelets(c,info,fs) does the same plot assuming a sampling rate of fs Hz
        of the original signal.

        plowavelets(c,info,fs,'dynrange',dynrange) additionally limits the dynamic range.

        C=plowavelets(...) returns the processed image data used in the
        plotting. Inputting this data directly to imagesc or similar functions
        will create the plot. This is usefull for custom post-processing of the
        image data.

        plowavelets supports optional parameters of TFPLOT. Please see
        the help of TFPLOT for an exhaustive list.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/plotwavelets.php>

     See also: fwt, tfplot.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTWAVELETS  Plot wavelet coefficients
   Usage:  plotwavelets(c,info,fs)
     



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
ufwt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2850
 -- Function: ufwt
     UFWT  Undecimated Fast Wavelet Transform
        Usage:  c = ufwt(f,w,J);
                [c,info] = ufwt(...);

        Input parameters:
              f     : Input data.
              w     : Wavelet Filterbank.
              J     : Number of filterbank iterations.

        Output parameters:
              c     : Coefficients stored in L xJ+1 matrix.
              info  : Transform paramaters struct.

        c=UFWT(f,w,J) computes redundant time (or shift) invariant
        wavelet representation c of the input signal f using the "a-trous"
        algorithm. In addition, the function returns struct. info containing
        the transform parameters. It can be conviniently used for the inverse
        transform IUFWT e.g. fhat = iUFWT(c,info). It is also required by
        the PLOTWAVELETS function.

        The coefficents c are so called Undecimated Discrete Wavelet transform
        of the input signal f, if w defines two-channel wavelet filterbank.
        Other names for this version of the wavelet transform are: the
        time-invariant wavelet transform, the stationary wavelet transform,
        maximal overlap discrete wavelet transform or even the "continuous"
        wavelet transform (as the time step is one sample). However, the
        function accepts any number filters (referred to as M) in the basic
        wavelet filterbank and the number of columns of c is then J(M-1)+1.

        For all accepted formats of the parameter w see the FWT function.

        For one-dimensional input f of length L, the coefficients c are
        stored as columns of a matrix. The columns are ordered with inceasing
        central frequency of the corresponding effective filter frequency
        response or equivalently with decreasing wavelet scale.

        If the input f is L xW matrix, the transform is applied
        to each column and the outputs are stacked along third dimension in the
        L xJ(M-1)+1 xW data cube.

        Boundary handling:
        ------------------

        c=UFWT(f,w,J) uses periodic boundary extension. The extensions are
        done internally at each level of the transform, rather than doing the
        prior explicit padding.

        Examples:
        ---------

        A simple example of calling the UFWT function:

          f = greasy;
          J = 8;
          [c,info] = ufwt(f,'db8',J);
          %plotwavelets(c,info,16000,'dynrange',90);


        References:
          M. Holschneider, R. Kronland-Martinet, J. Morlet, and P. Tchamitchian.
          A real-time algorithm for signal analysis with the help of the wavelet
          transform. In Wavelets. Time-Frequency Methods and Phase Space,
          volume 1, page 286, 1989.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/ufwt.php>

     See also: iufwt, plotwavelets.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
UFWT  Undecimated Fast Wavelet Transform
   Usage:  c = ufwt(f,w,J);
           



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
uwfbt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1574
 -- Function: uwfbt
     UWFBT   Undecimated Wavelet FilterBank Tree
        Usage:  c=uwfbt(f,wt);
                [c,info]=uwfbt(...);

        Input parameters:
              f   : Input data.
              wt  : Wavelet Filterbank tree

        Output parameters:
              c     : Coefficients stored in L xM matrix.

        c=UWFBT(f,wt) computes redundant time (or shift) representation c
        of the input signal f using the filterbank tree definition in wt and
        using the "a-trous" algorithm. Number of columns in c (*M*) is defined
        by the total number of outputs of the leaf nodes of the tree.
        In addition, the function returns struct. info containing the transform
        parameters. It can be conviniently used for the inverse transform IUWFBT
        e.g. fhat = iUWFBT(c,info). It is also required by the PLOTWAVELETS
        function.

        If f is a matrix, the transformation is applied to each of W columns
        and the coefficients in c are stacked along the third dimension.

        Please see help for WFBT description of possible formats of wt and
        description of frequency and natural ordering of the coefficient subbands.

        Examples:
        ---------

        A simple example of calling the UWFBT function using the "full decomposition" wavelet tree:

          f = greasy;
          J = 8;
          [c,info] = uwfbt(f,{'sym10',J,'full'});
          plotwavelets(c,info,16000,'dynrange',90);

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/uwfbt.php>

     See also: iuwfbt, wfbtinit.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
UWFBT   Undecimated Wavelet FilterBank Tree
   Usage:  c=uwfbt(f,wt);
          



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
uwpfbt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1562
 -- Function: uwpfbt
     UWPFBT Undecimated Wavelet Packet FilterBank Tree
        Usage:  c=uwpfbt(f,wt);
                c=uwpfbt(f,wt,...);

        Input parameters:
              f   : Input data.
              wt  : Wavelet Filterbank tree

        Output parameters:
              c   : Coefficients in a L xM matrix.

        c=UWPFBT(f,wt) returns coefficients c obtained by applying the
        undecimated wavelet filterbank tree defined by wt to the input data
        f using the "a-trous" algorithm. Number of columns in c (*M*) is
        defined by the total number of outputs of each node. The outputs c(:,jj)
        are ordered in the breadth-first node order manner.
        In addition, the function returns struct. info containing the transform
        parameters. It can be conviniently used for the inverse transform IUWPFBT
        e.g. fhat = iUWPFBT(c,info). It is also required by the PLOTWAVELETS
        function.

        If f is a matrix, the transformation is applied to each of W columns
        and the coefficients in c are stacked along the third dimension.

        Please see help for WFBT description of possible formats of wt.

        Examples:
        ---------

        A simple example of calling the UWPFBT function using the "full
        decomposition" wavelet tree:

          f = greasy;
          J = 6;
          [c,info] = uwpfbt(f,{'db10',J,'full'});
          plotwavelets(c,info,44100,'dynrange',90);

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/uwpfbt.php>

     See also: iuwpfbt, wfbtinit.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
UWPFBT Undecimated Wavelet Packet FilterBank Tree
   Usage:  c=uwpfbt(f,wt);
   



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
wavcell2pack


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1076
 -- Function: wavcell2pack
     WAVCELL2PACK Changes wavelet coefficients storing format
        Usage:  [cvec,Lc] = wavcell2pack(ccell);
                [cvec,Lc] = wavcell2pack(ccell,dim);

        Input parameters:
              ccell    : Coefficients stored in a collumn cell-array.
              dim      : Dimension along which the data were transformed.

        Output parameters:
              cvec     : Coefficients in packed format.
              Lc       : Vector containing coefficients lengths.

        [cvec,Lc] = WAVCELL2PACK(ccell) assembles a column vector or a matrix
        cvec using elements of the cell-array ccell in the following
        manner:

           cvec(1+sum(Lc(1:j-1)):sum(Lc(1:j),:)=ccell{j};

        where Lc is a vector of length numel(ccell) containing number of
        rows of each element of ccell.

        [cvec,Lc] = WAVCELL2PACK(ccell,dim) with dim==2 returns a
        transposition of the previous.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wavcell2pack.php>

     See also: wavpack2cell, fwt, wfbt, wpfbt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WAVCELL2PACK Changes wavelet coefficients storing format
   Usage:  [cvec,Lc] = 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
waveletsinit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 101
 -- Function: waveletsinit
     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/waveletsinit.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
   *Url*: <http://ltfat.sourceforge.net/doc/wavelets/waveletsinit.php>



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wavfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1743
 -- Function: wavfun
      WAVFUN  Wavelet Function
        Usage: [w,s,xvals] = wavfun(g)
                [w,s,xvals] = wavfun(g,N)

        Input parameters:
              w     : Wavelet filterbank
              N     : Number of iterations
        Output parameters:
              wfunc : Approximation of wavelet function(s)
              sfunc : Approximation of the scaling function
              xvals : Correct x-axis values

        Iteratively generate (*N iterations) a discrete approximation of wavelet
        and scaling functions using filters obtained from w. The possible formats of w*
        are the same as for the FWT function. The algorithm is equal to the
        DWT reconstruction of a single coefficient at level N set to 1. xvals*
        contains correct x-axis values. All but alst collumns belong to the
        wfunc, last one to the sfunc.

        The following flags are supported (first is default):

        'fft', 'conv'
          How to do the computations. Whatever is faster depends on
          the speed of the conv2 function.

        *WARNING**: The output array lengths L depend on N exponentially like:

           L=(m-1)*(a^N-1)/(a-1) + 1

        where a is subsamling factor after the lowpass filter in the wavelet
        filterbank and m is length of the filters. Expect issues for
        high N e.g. 'db10' (m=20) and N=20 yields a ~150MB array.

        Examples:
        ---------

        Approximation of a Daubechies wavelet and scaling functions from the
        12 tap filters:

          [wfn,sfn,xvals] = wavfun('db6');
          plot(xvals,[wfn,sfn]);
          legend('wavelet function','scaling function');

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wavfun.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 WAVFUN  Wavelet Function
   Usage: [w,s,xvals] = wavfun(g)
           [w,s,xval



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
wavpack2cell


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1644
 -- Function: wavpack2cell
     WAVPACK2CELL Changes wavelet coefficients storing format
        Usage:
               ccell = wavpack2cell(cvec,Lc);
               ccell = wavpack2cell(cvec,Lc,dim);

        Input parameters:
              cvec     : Coefficients in packed format.
              Lc       : Vector containing coefficients lengths.
              dim      : Dimension along which the data were transformed.

        Output parameters:
              ccell    : Coefficients stored in a cell-array. Each element is
                         a column vector or a matrix.
              dim      : Return used dim. Usefull as an input of the
                         complementary function WAVCELL2PACK.

        ccell = WAVPACK2CELL(cvec,Lc) copies coefficients from a single column
        vector or collumns of a matrix cvec of size [sum(Lc), W] to the cell
        array ccell of length length(Lc). Size of j*-th element of ccell*
        is [Lc(j), W] and it is obtained by:

           ccell{j}=cvec(1+sum(Lc(1:j-1)):sum(Lc(1:j),:);

        ccell = WAVPACK2CELL(cvec,Lc,dim) allows specifying along which
        dimension the coefficients are stored in cvec. dim==1 (default)
        considers columns (as above) and dim==2 rows to be coefficients
        belonging to separate channels. Other values are not supported. For
        dim=2, cvec size is [W, sum(Lc)], Size of j*-th element of ccell*
        is [Lc(j), W] and it is obtained by:

           ccell{j}=cvec(:,1+sum(Lc(1:j-1)):sum(Lc(1:j)).';

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wavpack2cell.php>

     See also: wavcell2pack, fwt, wfbt, wpfbt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WAVPACK2CELL Changes wavelet coefficients storing format
   Usage:
          cce



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
wfbt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2770
 -- Function: wfbt
     WFBT   Wavelet FilterBank Tree
        Usage:  c=wfbt(f,wt);
                [c,info]=wfbt(...);

        Input parameters:
              f     : Input data.
              wt    : Wavelet Filterbank tree definition.

        Output parameters:
              c    : Coefficients stored in a cell-array.
              info : Transform parameters struct.

        c=WFBT(f,wt) returns coefficients c obtained by applying a wavelet
        filterbank tree defined by wt to the input data f. In addition, the
        function returns struct. info containing transform parameters. It can
        be conviniently used for the inverse transform IWFBT e.g.
        fhat = iWFBT(c,info). It is also required by the PLOTWAVELETS function.

        wt defines a tree shaped filterbank structure build from the
        elementary two (or more) channel wavelet filters. The tree can have any
        shape and thus provide a flexible frequency covering. The outputs of the
        tree leaves are stored in c.

        The wt parameter can have two formats:

        1) Cell array containing 3 elements {w,J,treetype}, where w is
           the basic wavelet filterbank definition as in FWT function, J*
           stands for the depth of the tree and the flag treetype defines
           the type of the tree to be used. Supported options are:

           'dwt'
             DWT tree. Just the low-pass output is decomposed further.

           'full'
             Full decomposition tree. Each output is decomposed up to level J.

        2) Structure returned by the WFBTINIT function and possibly
           modified by WFBTPUT and WFBTREMOVE.

        If f is row/column vector, the coefficient vectors c{jj} are columns.

        If f is a matrix, the transformation is by default applied to each of
        W columns [Ls, W]=size(f).

        In addition, the following flag groups are supported:

        'per','zero','odd','even'
          Type of the boundary handling.

        'freq','nat'
          Frequency or natural ordering of the coefficient subbands. The direct
          usage of the wavelet tree ('nat' option) does not produce coefficient
          subbans ordered according to the frequency. To achieve that, some
          filter shuffling has to be done ('freq' option).

        Please see the help on FWT for a description of the boundary condition flags.

        Examples:
        ---------

        A simple example of calling the WFBT function using the "full decomposition" wavelet tree:

          f = gspi;
          J = 7;
          [c,info] = wfbt(f,{'sym10',J,'full'});
          plotwavelets(c,info,44100,'dynrange',90);

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfbt.php>

     See also: iwfbt, wfbtinit.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFBT   Wavelet FilterBank Tree
   Usage:  c=wfbt(f,wt);
           [c,info]=wfbt



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
wfbt2filterbank


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1357
 -- Function: wfbt2filterbank
     WFBT2FILTERBANK  WFBT equivalent non-iterated filterbank
        Usage: [g,a] = wfbt2filterbank(wtdef)

        Input parameters:
              wtdef : Wavelet filter tree definition

        Output parameters:
              g   : Cell array containing filters
              a   : Vector of sub-/upsampling factors

        wfbtmultid(wtdef) calculates the impulse responses g and the
        subsampling factors a of non-iterated filterbank, which is equivalent
        to the wavelet filterbank tree described by wtdef. The returned
        parameters can be used directly in FILTERBANK, UFILTERBANK or
        FILTERBANK.

        The filters are scaled if a is not returned.

        The function internally calls WFBTINIT and passes wtdef and all
        additional parameters to it.

        Examples:
        ---------

        The following two examples create a multirate identity filterbank
        using a tree of depth 3. In the first example, the filterbank is
        identical to the DWT tree:

          [g,a] = wfbt2filterbank({'db10',3,'dwt'});


        In the second example, the filterbank is identical to the full
        wavelet tree:

          [g,a] = wfbt2filterbank({'db10',3,'full'});

     *Url*:
     <http://ltfat.sourceforge.net/doc/wavelets/wfbt2filterbank.php>

     See also: wfbtinit.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFBT2FILTERBANK  WFBT equivalent non-iterated filterbank
   Usage: [g,a] = wfbt2



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
wfbtbounds


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 599
 -- Function: wfbtbounds
     WFBTBOUNDS Frame bounds of WFBT
        Usage: fcond=wfbtbounds(wt,L);
               [A,B]=wfbtbounds(wt,L);

        WFBTBOUNDS(wt,L) calculates the ratio B/A of the frame bounds
        of the filterbank specified by wt for a system of length
        L. The ratio is a measure of the stability of the system.

        [A,B]=WFBTBOUNDS(wt,L) returns the lower and upper frame bounds
        explicitly.

        See WFBT for explanation of parameter wt.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfbtbounds.php>

     See also: wfbt, filterbankbounds.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFBTBOUNDS Frame bounds of WFBT
   Usage: fcond=wfbtbounds(wt,L);
          [A,B



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
wfbtclength


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 591
 -- Function: wfbtclength
     WFBTLENGTH  WFBT subband lengthf from a signal length
        Usage: L=wfbtlength(Ls,wt);
               L=wfbtlength(Ls,wt,...);

        wfbtlength(Ls,wt) returns the length of a Wavelet system that is long
        enough to expand a signal of length Ls. Please see the help on
        WFBT for an explanation of the parameter wt.

        If the returned length is longer than the signal length, the signal
        will be zero-padded by WFBT to length L.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfbtclength.php>

     See also: wfbt, fwt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFBTLENGTH  WFBT subband lengthf from a signal length
   Usage: L=wfbtlength(Ls,



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
wfbtinit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1375
 -- Function: wfbtinit
     WFBTINIT Initialize Filterbank Tree
        Usage:  wt = wfbtinit(wtdef);

        Input parameters:
              wtdef : Filterbank tree definition.

        Output parameters:
              wt    : Structure describing the filter tree.

        WFBTINIT() creates empty structure. The structure describing the
        tree has the following fields:

          .nodes     Actual impulse responses

          .children  Indexes of children nodes

          .parents   Indexes of a parent node

          .forder    Frequency ordering of the resultant frequency bands.

        wfbt=WFBTINIT({w,J,flag}) creates a filterbank tree of depth J. The
        parameter w defines a basic wavelet filterbank. For all possible formats
        see FWT.  The following optional flags (still inside of the
        cell-array) are recognized:

        'dwt','full'
          Type of the tree to be created.

        Additional flags:

        'freq','nat'
          Frequency or natural ordering of the coefficient subbands. The direct
          usage of the wavelet tree ('nat' option) does not produce coefficient
          subbans ordered according to the frequency. To achieve that, some
          filter shuffling has to be done ('freq' option).

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfbtinit.php>

     See also: wfbtput, wfbtremove.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
WFBTINIT Initialize Filterbank Tree
   Usage:  wt = wfbtinit(wtdef);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
wfbtlength


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 571
 -- Function: wfbtlength
     WFBTLENGTH  WFBT length from signal
        Usage: L=wfbtlength(Ls,wt);
               L=wfbtlength(Ls,wt,...);

        WFBTLENGTH(Ls,wt) returns the length of a Wavelet system that is long
        enough to expand a signal of length Ls. Please see the help on
        WFBT for an explanation of the parameter wt.

        If the returned length is longer than the signal length, the signal
        will be zero-padded by WFBT to length L.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfbtlength.php>

     See also: wfbt, fwt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFBTLENGTH  WFBT length from signal
   Usage: L=wfbtlength(Ls,wt);
          L=w



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
wfbtput


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1340
 -- Function: wfbtput
     WFBTPUT  Put node to the filterbank tree
        Usage:  wt = wfbtput(d,k,w,wt);
                wt = wfbtput(d,k,w,wt,'force');

        Input parameters:
                d   : Level in the tree (0 - root).
                k   : Index (array of indexes) of the node at level d (starting at 0).
                w   : Node, basic wavelet filterbank.
                wt  : Wavelet filterbank tree structure (as returned from
                      WFBTINIT).

        Output parameters:
                wt : Modified filterbank structure.

        WFBTPUT(d,k,w,wt) puts the basic filterbank filt to the filter
        tree structure wt at level d and index k. The output is a
        modified tree structure. d and k have to specify unconnected output
        of the leaf node. Error is issued if d and k points to already
        existing node. For possible formats of parameter w see help of FWT.
        Parameter wt has to be a structure returned by WFBTINIT.

        WFBTPUT(d,k,w,wt,'force') does the same but replaces node at d and k*
        if it already exists. If the node to be replaced has any children,
        the number of outputs of the replacing node have to be equal to number of
        outputs of the node beeing replaced.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfbtput.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFBTPUT  Put node to the filterbank tree
   Usage:  wt = wfbtput(d,k,w,wt);
    



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
wfbtremove


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 925
 -- Function: wfbtremove
     WFBTREMOVE Remove node from the filterbank tree
        Usage:  wt = wbftremove(d,kk,wt);
                wt = wfbtremove(d,kk,wt,'force');

        Input parameters:
                d   : Level in the tree (0 - root).
                kk  : Index of the node at level d (starting at 0) or array
                      of indexes.
                wt  : Wavelet filterbank tree structure (as returned from
                      WFBTINIT).

        Output parameters:
                wt : Modified filterbank structure.

        WFBTREMOVE(d,kk,wt) removes existing node at level d and index kk*
        from the filterbank tree structure wt. The function fails if the
        node has any children (is not a leaf node).

        WFBTREMOVE(d,k,wt,'force') does the same, but any childern of the
        node are removed too.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfbtremove.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFBTREMOVE Remove node from the filterbank tree
   Usage:  wt = wbftremove(d,kk,



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
wfilt_algmband


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 743
 -- Function: wfilt_algmband
     WFILT_ALGMBAND  An ALGebraic construction of orthonormal M-BAND wavelets with perfect reconstruction
        Usage: [h,g,a] = wfilt_algmband(N);

        [h,g,a]=WFILT_ALGMBAND(N) computes an algebraic construction of
        orthonormal m-band wavelets with perfect reconstruction. Critically
        subsampled.

        Examples:
        ---------
        :

          wfiltinfo('algmband2');

        References:
          T. Lin, S. Xu, Q. Shi, and P. Hao. An algebraic construction of
          orthonormal M-band wavelets with perfect reconstruction. Applied
          mathematics and computation, 172(2):717-730, 2006.

     *Url*:
     <http://ltfat.sourceforge.net/doc/wavelets/wfilt_algmband.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_ALGMBAND  An ALGebraic construction of orthonormal M-BAND wavelets with pe



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
wfilt_apr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 742
 -- Function: wfilt_apr
     WFILT_APR Almost Perfect Reconstruction Filter Bank for Non-redundant, Approximately Shift-Invariant, ComplexWavelet Transforms
        Usage: [h,g,a] = wfilt_apr(N);

        [h,g,a] = WFILT_APR(N) computes an almost perfect reconstruction
        filter bank for non-redundant, approximately shift-invariant,
        Complex Wavelet Transforms. Critically subsampled.

        References:
          R. Hosseini and M. Vafadust. Almost perfect reconstruction filter bank
          for non-redundant, approximately shift-invariant, complex wavelet
          transforms. Journal of Wavelet Theory and Applications, 2(1):1-14,
          2008.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_apr.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_APR Almost Perfect Reconstruction Filter Bank for Non-redundant, Approxima



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
wfilt_cmband


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 689
 -- Function: wfilt_cmband
     WFILT_CMBAND  Generates M-Band cosine modulated wavelet filters
        Usage: [h,g,a] = wfilt_cmband(M);

        Input parameters:
              M     : Number of channels.

        [h,g,a]=WFILT_CMBAND(M,K) returns smooth, 1*-regular Cosine modulated
        M*-band wavelet filters. The length of the filters is 4M.

        Examples:
        ---------
        :

          wfiltinfo('cmband5');


        References:
          R. Gopinath and C. Burrus. On cosine-modulated wavelet orthonormal
          bases. Image Processing, IEEE Transactions on, 4(2):162-176, Feb 1995.



     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_cmband.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_CMBAND  Generates M-Band cosine modulated wavelet filters
   Usage: [h,g,a



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
wfilt_db


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1585
 -- Function: wfilt_db
     WFILT_DB    Daubechies FIR filterbank
        Usage:  [h,g] = wfilt_db(N);

        Input parameters:
              N     : Order of Daubechies filters.
        Output parameters:
              H     : cell array of analysing filters impulse reponses
              G     : cell array of synthetizing filters impulse reponses
              a     : array of subsampling (or hop) factors accociated with
                      corresponding filters

        [H,G] = dbfilt(N) computes a two-channel Daubechies FIR filterbank
        from prototype maximum-phase analysing lowpass filter obtained by
        spectral factorization of the Lagrange interpolator filter.  N also
        denotes the number of zeros at z=-1 of the lowpass filters of length
        2N.  The prototype lowpass filter has the following form (all roots of
        R(z) are outside of the unit circle):

           H_l(z)=(1+z^-1)^N*R(z),

        where R(z) is a spectral factor of the Legrange interpolator P(z)=2R(z)*R(z^{-1})
        All subsequent filters of the two-channel filterbank are derived as
        follows:

           H_h(z)=H_l((-z)^-1)
           G_l(z)=H_l(z^-1)
           G_h(z)=-H_l(-z)

        making them an orthogonal causal perfect-reconstruction QMF.

        Examples:
        ---------
        :

          wfiltinfo('db8');

        References:
          I. Daubechies. Ten Lectures on Wavelets. Society for Industrial and
          Applied Mathematics, Philadelphia, PA, USA, 1992.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_db.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
WFILT_DB    Daubechies FIR filterbank
   Usage:  [h,g] = wfilt_db(N);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
wfilt_dden


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 627
 -- Function: wfilt_dden
     WFILT_DDEN  Double-DENsity DWT filters (tight frame)
        Usage: [h,g,a] = wfilt_dden(N);

        [h,g,a]=WFILT_DDEN(N) computes oversampled dyadic double-density DWT
        filters. The redundancy is equal to 2.

        Examples:
        ---------
        :

          wfiltinfo('dden5');

        References:
          A. A. Petrosian and F. G. Meyer, editors. Wavelets in Signal and Image
          Analysis: From Theory to Practice, chapter The Double Density DWT,
          pages 39-66. Kluwer, 1 edition, 2001.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_dden.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_DDEN  Double-DENsity DWT filters (tight frame)
   Usage: [h,g,a] = wfilt_d



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
wfilt_dgrid


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 633
 -- Function: wfilt_dgrid
     WFILT_DGRID  Dense GRID framelets (tight frame, symmetric)
        Usage: [h,g,a] = wfilt_dgrid(N);

        [h,g,a]=WFILT_DGRID(N) computes Dense GRID framelets. Redundancy
        equal to 2.

        Examples:
        ---------
        :

          wfiltinfo('dgrid3');

        References:
          A. Abdelnour. Dense grid framelets with symmetric lowpass and bandpass
          filters. In Signal Processing and Its Applications, 2007. ISSPA 2007.
          9th International Symposium on, volume 172, pages 1-4, 2007.



     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_dgrid.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_DGRID  Dense GRID framelets (tight frame, symmetric)
   Usage: [h,g,a] = w



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
wfilt_dtree


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 501
 -- Function: wfilt_dtree
     WFILT_DTREE  Dual-TREE complex wavelet transform filters
        Usage: [h,g,a] = wfilt_dtree(N);

        [h,g,a]=WFILT_DTREE(N) computes filters used in the dual-tree complex wavelet transform.

        References:
          I. Selesnick, R. Baraniuk, and N. Kingsbury. The dual-tree complex
          wavelet transform. Signal Processing Magazine, IEEE, 22(6):123 - 151,
          nov. 2005.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_dtree.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_DTREE  Dual-TREE complex wavelet transform filters
   Usage: [h,g,a] = wfi



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
wfilt_hden


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 535
 -- Function: wfilt_hden
     WFILT_HDEN  Higher DENsity dwt filters (tight frame, frame)
        Usage: [h,g,a] = wfilt_hden(N);

        [h,g,a]=WFILT_HDEN(N) computes Higher DENsity dwt filters (tight frame, frame).

        Examples:
        ---------
        :

          wfiltinfo('hden3');

        References:
          I. Selesnick. A higher density discrete wavelet transform. IEEE
          Transactions on Signal Processing, 54(8):3039-3048, 2006.



     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_hden.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_HDEN  Higher DENsity dwt filters (tight frame, frame)
   Usage: [h,g,a] = 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
wfilt_lemarie


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 849
 -- Function: wfilt_lemarie
     WFILT_LEMARIE  Battle and Lemarie filters
        Usage: [h,g,a]=wfilt_lemarie(N)

        Input parameters:
              N     : Filter length.

        [h,g,a]=WFILT_LEMARIE(N) calculates coeficients of orthonormal
        Battle-Lemarie wavelets. Filter coefficients are obtainded by
        frequency domain sampling and trunctating the impulse response.

        Examples:
        ---------
        :

          wfiltinfo('lemarie50');

        References:
          S. G. Mallat. A theory for multiresolution signal decomposition: The
          wavelet representation. IEEE Trans. Pattern Anal. Mach. Intell.,
          11(7):674-693, July 1989. [1]http ]

          References

          1. http://dx.doi.org/10.1109/34.192463

     *Url*:
     <http://ltfat.sourceforge.net/doc/wavelets/wfilt_lemarie.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
WFILT_LEMARIE  Battle and Lemarie filters
   Usage: [h,g,a]=wfilt_lemarie(N)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
wfilt_matlabwtwrapper


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 455
 -- Function: wfilt_matlabwtwrapper
     WFILT_MATLABWTWRAPPER Wrapper of the Matlab Wavelet Toolbox wfilters function
        Usage: [h,g,a] = wfilt_matlabwtwrapper(wname);

        [h,g,a]=WFILT_MATLABWTWRAPPER(wname) calls Matlab Wavelet Toolbox
        function wfilters and passes the parameter wname. This function
        requires the Matlab Wavelet Toolbox.

     *Url*:
     <http://ltfat.sourceforge.net/doc/wavelets/wfilt_matlabwtwrapper.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_MATLABWTWRAPPER Wrapper of the Matlab Wavelet Toolbox wfilters function
  



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
wfilt_maxflat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 580
 -- Function: wfilt_maxflat
     WFILT_MAXFLAT Generates maximally flat FIR filters
        Usage: [h,g,a] = wfilt_maxflat(N);

        [h,g,a]=WFILT_MAXFLAT(N) calculates half-band maximally flat FIR filters,
        where (N-1) is the degree of flatness at w=0 and w=pi radians.

        Examples:
        ---------
        :

          wfiltinfo('maxflat6');

        References:
          P. Vaidyanathan. Multirate Systems ans Filter Banks. Prentise-Hall,
          Englewood Clifs, NJ, 1993.


     *Url*:
     <http://ltfat.sourceforge.net/doc/wavelets/wfilt_maxflat.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_MAXFLAT Generates maximally flat FIR filters
   Usage: [h,g,a] = wfilt_max



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
wfilt_mband


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 575
 -- Function: wfilt_mband
     WFILT_MBAND  Generates M-Band coders
        Usage: [h,g,a] = wfilt_mband(N);

        [h,g,a]=WFILT_MBAND(N) returns linear-phase M-band wavelet filters.

        Examples:
        ---------
        :

          wfiltinfo('mband1');

        References:
          O. Alkin and H. Caglar. Design of efficient M-band coders with
          linear-phase and perfect-reconstruction properties. Signal Processing,
          IEEE Transactions on, 43(7):1579 -1590, jul 1995.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_mband.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
WFILT_MBAND  Generates M-Band coders
   Usage: [h,g,a] = wfilt_mband(N);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
wfilt_optfs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 801
 -- Function: wfilt_optfs
     WFILT_OPTFS Improved frequency separation filters
        Usage: [h,g,a] = wfilt_optfs(N);

        [h,g,a]=WFILT_OPTFS(N) returns wavelet filters with better frequency
        band sepparation (compared to Daubeschies filters of the same length)
        having at least two vanishing moments.

        Examples:
        ---------
        :

          wfiltinfo('optfs4');

        References:
          H. M. Paiva and R. K. H. Galvao. Optimized orthonormal wavelet filters
          with improved frequency separation. Digital Signal Processing,
          22(4):622 - 627, 2012. [1]http ]

          References

          1. http://www.sciencedirect.com/science/article/pii/S1051200412000735



     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_optfs.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_OPTFS Improved frequency separation filters
   Usage: [h,g,a] = wfilt_optf



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
wfilt_remez


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 971
 -- Function: wfilt_remez
     WFILT_REMEZ Filters designed using Remez exchange algorithm
        Usage: [h,g,a]=wfilt_remez(L,K,B)

        Input parameters:
              L     : Length of the filters.
              K     : Degree of flatness at z=-1.
              B     : Normalized transition bandwidth.

        [h,g,a]=WFILT_REMEZ(L,K,B) calculates a set of wavelet filters. You
        can control regularity, frequency selectivity, and length of the
        filters.  It works performing a factorization based on the complex
        cepstrum of the polynomial.

        Examples:
        ---------
        :

          wfiltinfo('remez50:2:0.1');

        References:
          O. Rioul and P. Duhamel. A remez exchange algorithm for orthonormal
          wavelets. Circuits and Systems II: Analog and Digital Signal
          Processing, IEEE Transactions on, 41(8):550 -560, aug 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_remez.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_REMEZ Filters designed using Remez exchange algorithm
   Usage: [h,g,a]=wf



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
wfilt_spline


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 751
 -- Function: wfilt_spline
      WFILT_SPLINE  Birthogonal spline wavelets
        Usage: [h,g,a]=wfilt_spline(m,n);

        Input parameters:
              m     : Number of zeros at z=-1 of the lowpass filter in g{1}
              n     : Number of zeros at z=-1 of the lowpass filter in
                      h{1}. m+n must be even.

        [h,g,a]=WFILT_SPLINE(m,n) returns the analysis and synthesis filters
        corresponding to a biortoghonal scheme with spline wavelets of compact
        support.

        Examples:
        ---------
        :
          figure(1);
          wfiltinfo('ana:spline4:4');
          figure(2);
          wfiltinfo('syn:spline4:4');

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_spline.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 79
 WFILT_SPLINE  Birthogonal spline wavelets
   Usage: [h,g,a]=wfilt_spline(m,n);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
wfilt_sym


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 641
 -- Function: wfilt_sym
     WFILT_SYM Symlet filters
        Usage: [h,g,a]=wfilt_sym(N);

        [h,g,a]=WFILT_SYM(N) generates the "least asymmetric" Daubechies'
        wavelets or "symlets".  Zeros of the trigonometrical polynomial the
        filters of are selected alternatingly inside and outside the unit
        circle.

        Examples:
        ---------
        :

          wfiltinfo('sym8');

        References:
          I. Daubechies. Ten Lectures on Wavelets. Society for Industrial and
          Applied Mathematics, Philadelphia, PA, USA, 1992.


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_sym.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
WFILT_SYM Symlet filters
   Usage: [h,g,a]=wfilt_sym(N);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
wfilt_symds


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 737
 -- Function: wfilt_symds
     WFILT_SYMDS  Symmetric wavelets dyadic sibling
        Usage: [h,g,a] = wfilt_symds(N);

        [h,g,a]=WFILT_SYMDS(N) Returns symmetric dyadic sibling wavelet filters.
        The redundancy is equal to 2.

        Examples:
        ---------
        :
          figure(1);
          wfiltinfo('ana:symds3');
          figure(2);
          wfiltinfo('syn:symds3');

        References:
          F. Abdelnour. Symmetric wavelets dyadic sibling and dual frames. Signal
          Processing, 92(5):1216 - 1229, 2012. [1]http ]


          References

          1. http://www.sciencedirect.com/science/article/pii/S0165168411003963


     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfilt_symds.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_SYMDS  Symmetric wavelets dyadic sibling
   Usage: [h,g,a] = wfilt_symds(N



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
wfiltinfo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 736
 -- Function: wfiltinfo
     WFILTINFO Plots filters info
        Usage: wfiltinfo(w);

        Input parameters:
              w     : Wavelet filterbank

        Plots impulse responses, frequency responses and approximation of
        the scaling of the wavelet function(s) associated withthe wavelet filters
        defined by w in a single figure. Format of w is the same as in FWT.

        Examples:
        ---------

        Details of the 'syn:spline8:8' wavelet filters (see WFILT_SPLINE):

           wfiltinfo('syn:spline8:8');

        Details of the 'ana:spline8:8' wavelet filters:

           wfiltinfo('ana:spline8:8');

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wfiltinfo.php>

     See also: wfilt_db.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
WFILTINFO Plots filters info
   Usage: wfiltinfo(w);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
wfreq_lemarie


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 724
 -- Function: wfreq_lemarie
     WFREQ_LEMARIE  Battle and Lemarie filters frequency resp. sampling
        Usage: [H,G]=wfreq_lemarie(L)

        Input parameters:
              N     : Number of samples of the frequency response.

        [H,G]=wfreq_lemaire(L) calculates L samples of the Battle and
        Lemarie filters frequency responses.

        References:
          S. G. Mallat. A theory for multiresolution signal decomposition: The
          wavelet representation. IEEE Trans. Pattern Anal. Mach. Intell.,
          11(7):674-693, July 1989. [1]http ]

          References

          1. http://dx.doi.org/10.1109/34.192463



     *Url*:
     <http://ltfat.sourceforge.net/doc/wavelets/wfreq_lemarie.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
WFREQ_LEMARIE  Battle and Lemarie filters frequency resp.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wpbest


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5226
 -- Function: wpbest
     WPBEST  Best Tree selection
        Usage: c = wpbest(f,w,J,cost);
               [c,info] = wpbest(...);

        Input parameters:
              f   : Input data.
              w   : Wavelet Filterbank.
              J   : Maximum depth of the tree.

        Output parameters:
              c     : Coefficients stored in a cell-array.
              info  : Transform parameters struct.

        [c,info]=WPBEST(f,w,J,cost) selects the best sub-tree info.wt from
        the full tree with max. depth J, which minimizes the cost function.

        Only one-dimensional input f is accepted. The supported formats of
        the parameter w can be found in help for FWT. The format of the
        coefficients c and the info struct is the same as in WFBT.

        First, the depth J wavelet packet decomposition is performed using WPFBT.
        Then the nodes are traversed in the breadth-first and bottom-up order
        and the value of the cost function of the node input and cost of the
        combined node outputs is compared. If the node input cost function value
        is less than the combined output cost, the current node and all
        possible descendant nodes are marked to be deleted, if not, the input is
        assigned the combined output cost. At the end, the marked nodes are
        removed and the resulting tree is considered to be a best basis (or
        near-best basis) in the chosen cost function sense.

        The cost parameter can be a cell array or an user-defined function handle.
        accepting a single column vector. The cell array should consist of a
        string, followed by a numerical arguments.
        The possible formats are listed in the following text.

        Additive costs:
        ---------------

        The additive cost E of a vector x is a real valued cost function
        such that:


           E(x) = sum E(x(k)),
                   k

        and E(0)=0. Given a collection of vectors x_i being coefficients in
        orthonormal bases B_i, the best basis relative to E is the one for
        which the E(x_i) is minimal.

        Additive cost functions allows using the fast best-basis search algorithm
        since the costs can be precomputed and combined cost of two vectors is
        just a sum of their costs.

        {'shannon'}
           A cost function derived from the Shannon entropy:


              E_sh(x) = -sum |x(k)|^2 log(|x(k)|^2),
                      k:x(k)~=0

        {'log'}
           A logarithm of energy:


              E_log(x) = sum log(|x(k)|^2),
                       k:x(k)~=0

        {'lpnorm',p}
           Concentration in l^p norm:


              E_lp(x) = ( sum (|x(k)|^p) ),
                           k

        {'thre',th}
           Number of coefficients above a threshold th.


        Non-additive costs:
        -------------------

        Cost function, which is not additive cost but which is used for the
        basis selection is called a non-additive cost. The resulting basis for
        which the cost is minimal is called near-best, because the non-additive
        cost cannot guarantee the selection of a best basis relative to the
        cost function.

        {'wlpnorm',p}
           The weak-l^p norm cost function:


              E_wlp(x) = max k^{\frac{1}{p}}v_k(x),

           where 0<p<= 2 and v_k(x) denotes the k*-th largest absolute value
           of x.

        {'compn',p,f}
           Compression number cost:


              E_cn(x) = arg min |w_k(x,p) - f|,
                          k

           where 0<p<= 2, 0<f<1 and w_k(u,p) denotes decreasingly sorted,
           powered, cumulateively summed and renormalized vector:

                          k              N
              w_k(x,p) = sum v_j^p(x) / sum v_j^p(x)
                         j=1            j=1

           where v_k(x) denotes the k*-th largest absolute value of x and
           N is the number of elements of x.

        {'compa',p}
           Compression area cost:


              E_ca(x) = N - sum w_k(x,p),
                             k

           where 0<p<= 2 and w_k(u,p) and N as in the previous case.

        Examples:
        ---------

        A simple example of calling WPBEST :

          f = gspi;
          J = 8;
          [c,info] = wpbest(f,'sym10',J,'cost','shannon');

          % Use 2/3 of the space for the first plot, 1/3 for the second.
          subplot(3,3,[1 2 4 5 7 8]);
          plotwavelets(c,info,44100,90);

          subplot(3,3,[3 6 9]);
          N=cellfun(@numel,c); L=sum(N); a=L./N;
          plot(a,'o');
          xlim([1,numel(N)]);
          view(90,-90);
          xlabel('Channel no.');
          ylabel('Subsampling rate / samples');

        References:
          M. V. Wickerhauser. Lectures on wavelet packet algorithms. In INRIA
          Lecture notes. Citeseer, 1991.

          C. Taswell. Near-best basis selection algorithms with non-additive
          information cost functions. In Proceedings of the IEEE International
          Symposium on Time-Frequency and Time-Scale Analysis, pages 13-16. IEEE
          Press, 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wpbest.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WPBEST  Best Tree selection
   Usage: c = wpbest(f,w,J,cost);
          [c,info]



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
wpfbt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1958
 -- Function: wpfbt
     WPFBT   Wavelet Packet FilterBank Tree
        Usage:  c=wpfbt(f,wt);
                [c,info]=wpfbt(...);

        Input parameters:
              f   : Input data.
              wt  : Wavelet Filterbank tree definition.

        Output parameters:
              c    : Coefficients stored in a cell-array.
              info : Transform parameters struct.

        c=WPFBT(f,wt) returns wavelet packet coefficients c obtained by
        applying a wavelet filterbank tree defined by wt to the input data
        f. In addition, the function returns struct. info containing transform
        parameters. It can be conviniently used for the inverse transform IWPFBT
        e.g. fhat = iWPFBT(c,info). It is also required by the PLOTWAVELETS
        function.

        In contrast to the WFBT, the c contain every intermediate output
        of each node in the tree. The c{jj} are ordered in the breadth-first
        node order manner.

        If f is row/column vector, the coefficient vectors c{jj} are
        columns. If f is a matrix, the transformation is applied to each of
        column of the matrix.

        By default, the function scales all intermediate outputs in the tree
        which are not terminal ones in order to preserve energy. Passing a
        'noscale' flag overrides this behavior. This is necessary for the
        WPBEST function to correctly work with the cost measures.

        Please see help for WFBT description of possible formats of wt and
        of the additional flags.


        Examples:
        ---------

        A simple example of calling the WPFBT function using the "full
        decomposition" wavelet tree:

          f = gspi;
          J = 6;
          [c,info] = wpfbt(f,{'sym10',J,'full'});
          plotwavelets(c,info,44100,'dynrange',90);

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wpfbt.php>

     See also: wfbt, iwpfbt, wfbtinit, plotwavelets, wpbest.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WPFBT   Wavelet Packet FilterBank Tree
   Usage:  c=wpfbt(f,wt);
           [c,i



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
wpfbtclength


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 653
 -- Function: wpfbtclength
     WFBTLENGTH  WPFBT subband length from a signal length
        Usage: L=wfbtlength(Ls,wt);
               L=wfbtlength(Ls,wt,...);

        [Lc,L]=WPFBTCLENGTH(Ls,wt) returns the length L of a wavelet system
        that is long enough to expand a signal of length Ls and associated
        vector subband lengths Lc. Please see the help on
        WFBT for an explanation of the parameter wt.

        If the returned length is longer than the signal length, the signal
        will be zero-padded by WFBT to length L.

     *Url*: <http://ltfat.sourceforge.net/doc/wavelets/wpfbtclength.php>

     See also: wfbt, fwt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFBTLENGTH  WPFBT subband length from a signal length
   Usage: L=wfbtlength(Ls,





