# doc-cache created by Octave 10.2.0
# name: cache
# type: cell
# rows: 3
# columns: 71
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
Contents


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

   Zdenek Prusa, 2013 - 2023.

   If you use the wavelets module for a scientific work, please cite:

   Z. Průša, P. L. Soendergaard, and P. Rajmic. “Discrete Wavelet Transforms in the Large
   Time-Frequency Analysis Toolbox for MATLAB/GNU Octave.” ACM Trans. Math. Softw. 42, 4,
   Article 32, 2016. DOI: 10.1145/2839298
   
   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 coefficient subbands

   Advanced analysis/synthesis
      WFBT              - Transform using general Wavelet Filter Bank Tree 
      IWFBT             - Inverse transform using general Wavelet Filter Bank Tree
      UWFBT             - Undecimated transform using general Wavelet Filter Bank Tree 
      IUWFBT            - Inverse Undecimated transform using general Wavelet Filter Bank Tree
      WPFBT             - Wavelet Packet Transform using general Wavelet Filter Bank Tree 
      IWPFBT            - Inverse Wavelet Packet Transform using general Wavelet Filter Bank Tree
      UWPFBT            - Undecimated Wavelet Packet Transform using general Wavelet Filter Bank Tree 
      IUWPFBT           - Inverse Undecimated Wavelet Packet Transform using general Wavelet Filter Bank Tree
      WPBEST            - Best Tree selection
      WFBTLENGTH        - Length of Wavelet filter bank system to expand a signal
      WFBTCLENGTH       - Lengths of Wavelet filter bank coefficient subbands
      WPFBTCLENGTH      - Lengths of Wavelet Packet transform coefficient subbands

   Dual-tree complex wavelet transform
      DTWFB             - Dual-Tree Wavelet Filter Bank
      IDTWFB            - Inverse Dual-Tree Wavelet Filter Bank
      DTWFBREAL         - Dual-Tree Wavelet Filter Bank for real-valued signals
      IDTWFBREAL        - Inverse Dual-Tree Wavelet Filter Bank for real-valued signals

   Wavelet Filterbank trees manipulation
      WFBTINIT          - Wavelet Filter Bank tree structure initialization
      DTWFBINIT         - Dual-Tree wavelet filter bank structure initialization
      WFBTPUT           - Puts node (basic filter bank) to the specific  tree coordinates
      WFBTREMOVE        - Removes node (basic filter bank) from the specific tree coordinates
      WFBT2FILTERBANK   - WFBT or FWT non-iterated filter bank using the multi-rate identity
      WPFBT2FILTERBANK  - WPFBT non-iterated filter bank using the multi-rate identity
      DTWFB2FILTERBANK  - DTWFB or DTWFBREAL non-iterated filter bank
      FWTINIT           - Basic Wavelet Filters structure initialization

   Frame properties of wavelet filter banks:
      WFBTBOUNDS        - Frame bounds of WFBT and FWT (or UWFBT and UFWT)
      WPFBTBOUNDS       - Frame bounds of WPFBT or UWPFBT
      DTWFBBOUNDS       - Frame bounds of DTWFB
  
   Plots
      PLOTWAVELETS      - Plot wavelet coefficients
      WFILTINFO         - Plot wavelet filters impulse and frequency responses and approximation of scaling and wavelet functions
      WFILTDTINFO       - Plot the same as WFILTINFO but for dual-tree wavelet transform

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

   Wavelet Filters defined in the time-domain
      WFILT_ALGMBAND    - An ALGebraic construction of orthonormal M-BAND wavelets with perfect reconstruction
      WFILT_CMBAND      - M-Band cosine modulated wavelet filters
      WFILT_COIF        - Coiflets
      WFILT_DB          - DauBechies orthogonal filters (ortonormal base)
      WFILT_DDEN        - Double-DENsity dwt filters (tight frame)
      WFILT_DGRID       - Dense GRID framelets (tight frame, symmetric)
      WFILT_HDEN        - Higher DENsity dwt filters (tight frame, frame)  
      WFILT_LEMARIE       - Battle and Lemarie quadrature filters
      WFILT_MATLABWRAPPER - Wrapper of the wfilters function from the Matlab Wavelet Toolbox 
      WFILT_MBAND           - M-band filters
      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
      WFILT_SYMDDEN         - Symmetric Double-DENsity dwt filters (tight frame)
      WFILT_SYMORTH         - Symmetric nearly-orthogonal and orthogonal nearly-symmetric wav. filters
      WFILT_SYMTIGHT        - Symmetric nearly shift-invariant tight frame wavelets
      WFILT_QSHIFTA         - First tree filters from WFILTDT_QSHIFT 
      WFILT_QSHIFTB         - Second tree filters from WFILTDT_QSHIFT 
      WFILT_ODDEVENA        - First tree filters from WFILTDT_ODDEVEN 
      WFILT_ODDEVENB        - Second tree filters from WFILTDT_ODDEVEN 
      WFILT_OPTSYMA         - First tree filters from WFILTDT_OPTSYM 
      WFILT_OPTSYMB         - Second tree filters from WFILTDT_OPTSYM 
      WFILT_DDENA           - First tree filters from WFILTDT_DDEN 
      WFILT_DDENB           - Second tree filters from WFILTDT_DDEN 

   Dual-Tree Filters
      WFILTDT_QSHIFT        - Kingsbury's quarter-shift filters
      WFILTDT_OPTSYM        - Optimizatized Symmetric Self-Hilbertian Filters
      WFILTDT_ODDEVEN       - Kingsbury's symmetric odd and even biorthogonal filters
      WFILTDT_DDEN          - Double-density dual-tree filters

  For help, bug reports, suggestions etc. please visit 
  http://github.com/ltfat/ltfat/issues

   Url: http://ltfat.github.io/doc/wavelets/Contents.html



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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6846
 -- Function: dtwfb
     DTWFB Dual-Tree Wavelet Filter Bank
        Usage:  c=dtwfb(f,dualwt);
                c=dtwfb(f,{dualw,J});
                [c,info]=dtwfb(...);
     
        Input parameters:
              f      : Input data.
              dualwt : Dual-tree Wavelet Filter bank definition.
     
        Output parameters:
              c    : Coefficients stored in a cell-array.
              info : Additional transform parameters struct.
     
        c=DTWFBt(f,dualwt) computes dual-tree complex wavelet coefficients 
        of the signal f. The representation is approximately 
        time-invariant and provides analytic behaviour. Due to these facts, 
        the resulting subbands are nearly aliasing free making them suitable 
        for severe coefficient modifications. The representation is two times
        redundant, provided critical subsampling of all involved filter banks.
     
        The shape of the filterbank tree and filters used is controlled by 
        dualwt (for possible formats see below). The output c is a 
        cell-array with each element containing a single subband. The subbands 
        are ordered with the increasing subband centre frequency. 
     
        In addition, the function returns struct. info containing transform 
        parameters. It can be conveniently used for the inverse transform
        IDTWFB e.g. fhat = iDTWFB(c,info). It is also required by
        the PLOTWAVELETS function.
     
        If f is a matrix, the transform is applied to each column.
     
        Two formats of dualwt are accepted:
      
        1) Cell array of parameters. First two elements of the array are 
           mandatory {dualw,J}. 
      
           dualw   
             Basic dual-tree filters
           J*
             Number of levels of the filter bank tree
     
           Possible formats of dualw are the same as in FWTINIT except the
           wfiltdt_ prefix is used when searching for function specifying
           the actual impulse responses. These filters were designed specially
           for the dual-tree filter bank to achieve the half-sample shift 
           ultimately resulting in analytic (complex) behaviour of the 
           transform.
           
           The default shape of the filter bank tree is DWT i.e. only low-pass
           output is decomposed further (*J times in total).
     
           Different filter bank tree shapes can be obtained by passing
           additional flag in the cell array. Supported flags (mutually
           exclusive) are:
     
           'dwt'
              Plain DWT tree (default). This gives one band per octave freq. 
              resolution when using 2 channel basic wavelet filter bank.
     
           'full'
              Full filter bank tree. Both (all) basic filter bank outputs are
              decomposed further up to depth J achieving linear frequency band
              division.
     
           'doubleband','quadband','octaband'
              The filter bank is designed such that it mimics 4-band, 8-band or
              16-band complex wavelet transform provided the basic filter bank
              is 2 channel. In this case, J is treated such that it defines
              number of levels of 4-band, 8-band or 16-band transform.
     
           The dual-tree wavelet filter bank can use any basic wavelet
           filter bank in the first stage of both trees, provided they are 
           shifted by 1 sample (done internally). A custom first stage 
           filter bank can be defined by passing the following
           key-value pair in the cell array:
     
           'first',w 
              w defines a regular basic filter bank. Accepted formats are the
              same as in FWTINIT assuming the wfilt_ prefix.
     
           Similarly, when working with a filter bank tree containing
           decomposition of high-pass outputs, some filters in both trees must
           be replaced by a regular basic filter bank in order to achieve the
           approximately analytic behaviour. A custom filter bank can be
           specified by passing another key-value pair in the cell array:
     
           'leaf',w 
              w defines a regular basic filter bank. Accepted formats are the
              same as in FWTINIT assuming the wfilt_ prefix.      
     
        2) Another possibility is to pass directly a struct. returned by 
           DTWFBINIT and possibly modified by WFBTREMOVE. 
     
        Optional args.:
        ---------------
     
        In addition, the following flag groups are supported:
     
        'freq','nat'
           Frequency or natural (Paley) ordering of coefficient subbands.
           By default, subbands are ordered according to frequency. The natural
           ordering is how the subbands are obtained from the filter bank tree
           without modifications. The ordering differs only in non-plain DWT
           case.
     
        Boundary handling:
        ------------------
     
        In contrast with FWT, WFBT and WPFBT, this function supports
        periodic boundary handling only.
     
        Examples:
        ---------
        
        A simple example of calling the DTWFB function using the regular
        DWT iterated filter bank. The second figure shows a magnitude frequency
        response of an identical filter bank.:
      
          [f,fs] = greasy;
          J = 6;
          [c,info] = dtwfb(f,{'qshift3',J});
          figure(1);
          plotwavelets(c,info,fs,'dynrange',90);
          figure(2);
          [g,a] = dtwfb2filterbank({'qshift3',J});
          filterbankfreqz(g,a,1024,'plot','linabs');
     
        The second example shows a decomposition using a full filter bank tree
        of depth J*:
     
          [f,fs] = greasy;
          J = 5;
          [c,info] = dtwfb(f,{'qshift4',J,'full'});
          figure(1);
          plotwavelets(c,info,fs,'dynrange',90);
          figure(2);
          [g,a] = dtwfb2filterbank({'qshift4',J,'full'});
          filterbankfreqz(g,a,1024,'plot','linabs');
     
     
        References:
          I. Selesnick, R. Baraniuk, and N. Kingsbury. The dual-tree complex
          wavelet transform. Signal Processing Magazine, IEEE, 22(6):123 -- 151,
          nov. 2005.
          
          N. Kingsbury. Complex wavelets for shift invariant analysis and
          filtering of signals. Applied and Computational Harmonic Analysis,
          10(3):234 -- 253, 2001.
          
          I. Bayram and I. Selesnick. On the dual-tree complex wavelet packet and
          m-band transforms. Signal Processing, IEEE Transactions on,
          56(6):2298--2310, June 2008.
          
     *Url*: <http://ltfat.github.io/doc/wavelets/dtwfb.html>

     See also: dtwfbreal, idtwfb, plotwavelets, dtwfb2filterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DTWFB Dual-Tree Wavelet Filter Bank
   Usage:  c=dtwfb(f,dualwt);
           ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
dtwfb2filterbank


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2260
 -- Function: dtwfb2filterbank
     DTWFB2FILTERBANK DTWFB equivalent non-iterated filterbank
        Usage: [g,a] = dtwfb2filterbank(dualwt)
               [g,a,info] = dtwfb2filterbank(...)
     
        Input parameters:
           dualwt : Dual-tree wavelet filterbank specification.
     
        Output parameters:
           g      : Cell array of filters.
           a      : Downsampling rate for each channel.
           info   : Additional information.
     
        [g,a] = DTWFB2FILTERBANK(dualwt) constructs a set of filters g and
        subsampling factors a of a non-iterated filterbank, which is 
        equivalent to the dual-tree wavelet filterbank defined by dualwt. 
        The returned parameters can be used directly in FILTERBANK and other
        routines. The format of dualwt is the same as in DTWFB and 
        DTWFBREAL.  
     
        The function internally calls DTWFBINIT and passes dualwt and all
        additional parameters to it.
     
        [g,a,info] = DTWFB2FILTERBANK(...) additionally outputs a info*
        struct containing equivalent filterbanks of individual real-valued
        trees as fields info.g1 and info.g2.
     
        Additional parameters:
        ----------------------
     
        'real'
           By default, the function returns a filtebank equivalent to DTWFB.
           The filters can be restricted to cover only the positive frequencies
           and to be equivivalent to DTWFBREAL by passing a 'real' flag. 
     
        'freq'(default),'nat'
          The filters are ordered to produce subbands in the same order as 
          DTWFB or DTWFBREAL with the same flag.
     
        Examples:
        ---------
     
        The following two examples create a multirate identity filterbank
        using a duel-tree of depth 3:
     
           [g,a] = dtwfb2filterbank({'qshift3',3},'real');
           filterbankfreqz(g,a,1024,'plot','linabs');
     
        In the second example, the filterbank is identical to the full
        wavelet tree:
     
           [g,a] = dtwfb2filterbank({'qshift3',3,'full'},'real');
           filterbankfreqz(g,a,1024,'plot','linabs');
     
     *Url*: <http://ltfat.github.io/doc/wavelets/dtwfb2filterbank.html>

     See also: dtwfbinit.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DTWFB2FILTERBANK DTWFB equivalent non-iterated filterbank
   Usage: [g,a] = d...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 860
 -- Function: dtwfbbounds
     DTWFBBOUNDS Frame bounds of DTWFB
        Usage: fcond=dtwfbbounds(dualwt,L);
               [A,B]=dtwfbbounds(dualwt,L);
               [...]=dtwfbbounds(dualwt);
     
        DTWFBBOUNDS(dualwt,L) calculates the ratio B/A of the frame bounds
        of the dual-tree filterbank specified by dualwt for a system of 
        length L. The ratio is a measure of the stability of the system.
     
        DTWFBBOUNDS(dualwt) does the same thing, but L is the next compatible 
        length bigger than the longest filter in the identical filterbank.
     
        [A,B]=DTWFBBOUNDS(...) returns the lower and upper frame bounds
        explicitly.
     
        See DTWFB for explanation of parameter dualwt.
     
     
     *Url*: <http://ltfat.github.io/doc/wavelets/dtwfbbounds.html>

     See also: dtwfb, filterbankbounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DTWFBBOUNDS Frame bounds of DTWFB
   Usage: fcond=dtwfbbounds(dualwt,L);
    ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1811
 -- Function: dtwfbinit
     DTWFBINIT Dual-Tree Wavelet Filterbank Initialization
        Usage:  dualwt=dtwfbinit(dualwtdef);
     
        Input parameters:
              dualwtdef : Dual-tree filterbank definition.
     
        Output parameters:
              dualwt    : Dual-tree filtarbank structure.
     
        dtwfinit() (a call without aguments) creates an empty structure. It
        has the same fields as the struct. returned from WFBTINIT plus a field
        to hold nodes from the second tree:
     
           .nodes      Filterbank nodes of the first tree
      
           .dualnodes  Filterbank nodes of the second tree
     
           .children   Indexes of children nodes
     
           .parents    Indexes of a parent node
     
           .forder     Frequency ordering of the resultant frequency bands.   
     
        dtwfinit({dualw,J,flag}) creates a structure representing a dual-tree
        wavelet filterbank of depth J, using dual-tree wavelet filters 
        specified by dualw. The shape of the tree is controlled by flag.
        Please see help on DTWFB or DTWFBREAL for description of the
        parameters.
     
        [dualwt,info]=dtwfinit(...) additionally returns info struct which
        provides some information about the computed window:
     
        info.tight
           True if the overall tree construct a tight frame.
     
        info.dw
           A structure containing basic dual-tree filters as returned from
           fwtinit(dualwtdef,'wfiltdt_').
        
        Additional optional flags
        -------------------------
     
        'freq','nat'
           Frequency or natural ordering of the resulting coefficient subbands.
           Default ordering is 'freq'.
     *Url*: <http://ltfat.github.io/doc/wavelets/dtwfbinit.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DTWFBINIT Dual-Tree Wavelet Filterbank Initialization
   Usage:  dualwt=dtwfb...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6989
 -- Function: dtwfbreal
     DTWFBREAL Dual-Tree Wavelet FilterBank for real-valued signals
        Usage:  c=dtwfbreal(f,dualwt);
                c=dtwfbreal(f,{dualw,J});
                [c,info]=dtwfbreal(...);
     
        Input parameters:
              f      : Input data.
              dualwt : Dual-tree Wavelet Filterbank definition.
     
        Output parameters:
              c    : Coefficients stored in a cell-array.
              info : Additional transform parameters struct.
     
        c=dtwfbtreal(f,dualwt) computes dual-tree complex wavelet coefficients 
        of the real-valued signal f. The representation is approximately 
        time-invariant and provides analytic behavior. Due to these facts, 
        the resulting subbands are nearly aliasing free making them suitable 
        for severe coefficient modifications. The representation is two times
        redundant, provided critical subsampling of all involved filterbanks,
        but one half of the coefficients is complex conjugate of the other.
     
        The shape of the filterbank tree and filters used is controlled by 
        dualwt (for possible formats see below). The output c is a 
        cell-array with each element containing a single subband. The subbands 
        are ordered with increasing subband center frequency. 
     
        In addition, the function returns struct. info containing transform 
        parameters. It can be conviniently used for the inverse transform
        IDTWFBREAL e.g. fhat = iDTWFBREAL(c,info). It is also required by
        the PLOTWAVELETS function.
     
        If f is a matrix, the transform is applied to each column.
     
        Two formats of dualwt are accepted:
      
        1) Cell array of parameters. First two elements of the array are 
           mandatory {dualw,J}. 
      
           dualw
              Basic dual-tree filters
           J*
              Number of levels of the filterbank tree
     
           Possible formats of dualw are the same as in FWTINIT except the
           wfiltdt_ prefix is used when searching for function specifying
           the actual impulse responses. These filters were designed specially
           for the dual-tree filterbank to achieve the half-sample shift 
           ultimatelly resulting in analytic (complex) behavior of the 
           transform.
           
           The default shape of the filterbank tree is DWT i.e. only low-pass
           output is decomposed further (*J times in total).
     
           Different filterbank tree shapes can be obtained by passing
           additional flag in the cell array. Supported flags (mutually
           exclusive) are:
     
           'dwt'
              Plain DWT tree (default). This gives one band per octave freq. 
              resolution when using 2 channel basic wavelet filterbank.
     
           'full'
              Full filterbank tree. Both (all) basic filterbank outputs are
              decomposed further up to depth J achieving linear frequency band
              division.
     
           'doubleband','quadband','octaband'
              The filterbank is designed such that it mimics 4-band, 8-band or
              16-band complex wavelet transform provided the basic filterbank
              is 2 channel. In this case, J is treated such that it defines 
              number of levels of 4-band, 8-band or 16-band transform.
     
           The dual-tree wavelet filterbank can use any basic wavelet
           filterbank in the first stage of both trees, provided they are 
           shifted by 1 sample (done internally). A custom first stage 
           filterbank can be defined by passing the following
           key-value pair in the cell array:
     
           'first',w 
              w defines a regular basic filterbank. Accepted formats are the
              same as in FWTINIT assuming the wfilt_ prefix.
     
           Similarly, when working with a filterbank tree containing
           decomposition of high-pass outputs, some filters in both trees must
           be replaced by a regular basic filterbank in order to achieve the
           aproximatelly analytic behavior. A custom filterbank can be
           specified by passing another key-value pair in the cell array:
     
           'leaf',w 
              w defines a regular basic filterbank. Accepted formats are the
              same as in FWTINIT assuming the wfilt_ prefix.      
     
        2) Another possibility is to pass directly a struct. returned by 
           DTWFBINIT and possibly modified by WFBTREMOVE. 
     
        Optional args.:
        ---------------
     
        In addition, the following flag groups are supported:
     
        'freq','nat'
           Frequency or natural (Paley) ordering of coefficient subbands.
           By default, subbands are ordered according to frequency. The natural
           ordering is how the subbands are obtained from the filterbank tree
           without modifications. The ordering differ only in non-plain DWT
           case.
     
        Boundary handling:
        ------------------
     
        In contrast with FWT, WFBT and WPFBT, this function supports
        periodic boundary handling only.
     
        Examples:
        ---------
        
        A simple example of calling the DTWFBREAL function using the regular
        DWT iterated filterbank. The second figure shows a magnitude frequency
        response of an identical filterbank.:
      
          [f,fs] = greasy;
          J = 6;
          [c,info] = dtwfbreal(f,{'qshift3',J});
          figure(1);
          plotwavelets(c,info,fs,'dynrange',90);
          figure(2);
          [g,a] = dtwfb2filterbank({'qshift3',J},'real');
          filterbankfreqz(g,a,1024,'plot','linabs');
     
        The second example shows a decomposition using a full filterbank tree
        of depth J*:
     
          [f,fs] = greasy;
          J = 5;
          [c,info] = dtwfbreal(f,{'qshift4',J,'full'});
          figure(1);
          plotwavelets(c,info,fs,'dynrange',90);
          figure(2);
          [g,a] = dtwfb2filterbank({'qshift4',J,'full'},'real');
          filterbankfreqz(g,a,1024,'plot','linabs');
     
     
        References:
          I. Selesnick, R. Baraniuk, and N. Kingsbury. The dual-tree complex
          wavelet transform. Signal Processing Magazine, IEEE, 22(6):123 -- 151,
          nov. 2005.
          
          N. Kingsbury. Complex wavelets for shift invariant analysis and
          filtering of signals. Applied and Computational Harmonic Analysis,
          10(3):234 -- 253, 2001.
          
          I. Bayram and I. Selesnick. On the dual-tree complex wavelet packet and
          m-band transforms. Signal Processing, IEEE Transactions on,
          56(6):2298--2310, June 2008.
          
     *Url*: <http://ltfat.github.io/doc/wavelets/dtwfbreal.html>

     See also: dtwfb, idtwfbreal, plotwavelets, dtwfb2filterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DTWFBREAL Dual-Tree Wavelet FilterBank for real-valued signals
   Usage:  c=d...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5569
 -- 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.
     
        FWT(f,w,J) returns discrete wavelet coefficients of the input signal 
        f using J iterations of the basic wavelet filterbank defined by
        w using the fast wavelet transform algorithm (Mallat's algorithm).
        The coefficients 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 filterbanks
        with any number of the channels. In such case, the transform have a
        different name.
     
        Several formats of the basic filterbank definition w are recognized.
        One of them is a text string formed by a concatenation of a function 
        name with the wfilt_ prefix followed by a list of numerical arguments
        delimited by :. For example 'db10' will result in a call to 
        wfilt_db(10) or 'spline4:4' in call to wfilt_spline(4,4) etc.
        All filter defining functions can be listed by running
        dir([ltfatbasepath,filesep,'wavelets',filesep,'wfilt_*']);
        Please see help of the respective functions and follow references
        therein.
     
        For other recognized formats of w please see FWTINIT.
     
        [c,info]=FWT(f,w,J) additionally returns struct. info containing 
        transform parameters. It can be conviniently used for the inverse 
        transform IFWT e.g. as fhat = iFWT(c,info). It is also required 
        by the PLOTWAVELETS function.
     
        If f is row/column vector, the subbands c are stored
        in a single row/column in a consecutive order with respect to the
        inceasing central frequency. 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 when used.
     
        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:
     
          '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 using 'db8' wavelet
        filters.:
     
          [f,fs] = greasy;
          J = 10;
          [c,info] = fwt(f,'db8',J);
          plotwavelets(c,info,fs,'dynrange',90);
     
        Frequency bands of the transform with x-axis in a log scale and band
        peaks normalized to 1. Only positive frequency band is shown. :
     
          [g,a] = wfbt2filterbank({'db8',10,'dwt'});
          filterbankfreqz(g,a,20*1024,'linabs','posfreq','plot','inf','flog');
     
     
        References:
          S. Mallat. A wavelet tour of signal processing. Academic Press, San
          Diego, CA, 1998.
          
     *Url*: <http://ltfat.github.io/doc/wavelets/fwt.html>

     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,...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2139
 -- 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 filter bank definition.
              J     : Number of filter bank 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 filter bank defined by w.
        Please see FWT for description of w and J.
     
        FWT2 supports just the non-expansive boundary condition 'per' and
        critically subsampled filter banks 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'  
              Standard behaviour of the JPEG 2000 standard.
              This is the default.
     
           'tensor'
              This corresponds to doing a full 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,'db8',4);
          imagesc(dynlimit(20*log10(abs(c)),70));
          axis('image'); colormap(gray);
     
        The second example uses the tensor product layout:
     
          c = fwt2(cameraman,'db8',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.github.io/doc/wavelets/fwt2.html>

     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 = f...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 716
 -- Function: fwtclength
     FWTCLENGTH FWT subbands lengths from a signal length
        Usage: Lc=fwtclength(Ls,w,J);
               [Lc,L]=fwtclength(...);
     
        Lc=FWTCLENGTH(Ls,w,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 w and J.
     
        [Lc,L]=FWTCLENGTH(...) additianally 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.github.io/doc/wavelets/fwtclength.html>

     See also: fwt, fwtlength.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5090
 -- Function: fwtinit
     FWTINIT  Wavelet Filterbank Structure Initialization
        Usage:  w = fwtinit(wdef);
                w = fwtinit(wdef,prefix);
                [w,info]=fwtinit(...)
     
        Input parameters:
              wdef   : Wavelet filters specification.
              prefix : Function name prefix
     
        Output parameters:
              w    : Structure defining the filterbank.
        
        FWTINIT(wdef) produces a structure describing the analysis 
        (field w.h) and synthesis (field w.g) filterbanks and a hop factors 
        (field w.a) of a basic wavelet-type filterbank defined by wdef.
     
        The analysis filterbank w.h is by default used in FWT and the
        synthesis filterbank w.g in IFWT.
     
        Both w.h and w.g are cell arrays of structs defining FIR filters
        compatible with FILTERBANK, IFILTERBANK and related functions.
        More preciselly, each elemement of either cell array is a struct with
        fields .h and .offset defining impulse response and the initial 
        shift respectivelly.
        
        [w,info]=FWTINIT(...) additionally returns a info struct which 
        provides some information about the wavelet filterbank:
     
           info.istight
              Wavelet filterbank forms a tight frame. In such case, w.h and
              w.g are identical.
     
        The function is a wrapper for calling all the functions with the 
        wfilt_ prefix defined in the LTFAT wavelets directory.
     
        The possible formats of the wdef are the following:
     
        1) Cell array with first element being the name of the function defining
           the basic wavelet filters (wfilt_ prefix) and the other elements
           are the parameters of the function. 
     
        2) Character string as concatenation of the name of the wavelet
           filters defining function (as above) and the numeric parameters
           delimited by ':' character. Examples:
     
           {'db',10} or 'db10'   
              Daubechies with 10 vanishing moments. It calls wfilt_db(10) 
              internally.
           
           {'spline',4,4} or 'spline4:4'  
              Biorthogonal spline wavelet filters with 4 vanishing moments. 
              Calls wfilt_spline(4,4) internally.
           
           {'dden',1} or 'dden1'
              Double density wavelet filters. Calls wfilt_dden(1) where
              the filters are stored as numerical vectors.
     
        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 a dual of whatever
           is passed as the second argument.
     
        6) Two element cell array. First element is the string 'strict' and the
           second one is in format 1), 2), 4) or 5). This in the non tight case
           the filters has to be defined explicitly using 'ana' and 'syn'
           identifiers. See below.
     
        7) Two element cell array. First element is a cell array of structures
           defining FIR filterbank (.h and .offset fields) as in FILTERBANKWIN
           and the second element is a numeric vector of subsampling factors.
        
        One can interchange the filter in w.h and w.g and use the
        filterbank indended for synthesis in FWT and vice versa by
        re-using 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'.
     
        This only makes difference if the filterbanks are biorthogonal 
        (e.g. wfilt_spline) or a general frame (e.g. 'symds2'), in other 
        cases, the analysis and synthesis filters are identical. 
     
        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 additional field:
     
           w.origArgs 
               Original parameters in format 1).
     
     
        References:
          S. Mallat. A Wavelet Tour of Signal Processing, Third Edition: The
          Sparse Way. Academic Press, 3rd edition, 2008.
          
     *Url*: <http://ltfat.github.io/doc/wavelets/fwtinit.html>

     See also: fwt, ifwt, wfilt_db.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 753
 -- Function: fwtlength
     FWTLENGTH  FWT length from signal
        Usage: 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 w and J.
     
        If the returned length is longer than the signal length, the signal
        will be zero-padded by FWT to length L.
     
        In addition, the function accepts flags defining boundary extension
        technique as in FWT. The returned length can be longer than the
        signal length only in case of 'per' (periodic extension).
     
     *Url*: <http://ltfat.github.io/doc/wavelets/fwtlength.html>

     See also: fwt.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1600
 -- Function: idtwfb
     IDTWFB Inverse Dual-tree Filterbank
        Usage:  f=idtwfb(c,info);
                f=idtwfb(c,dualwt,Ls);
     
        Input parameters:
              c       : Input coefficients.
              info    : Transform params. struct
              dualwt  : Dual-tree Wavelet Filterbank definition
              Ls      : Length of the reconstructed signal.
     
        Output parameters:
              f     : Reconstructed data.
     
        f = IDTWFB(c,info) reconstructs signal f from the coefficients c*
        using parameters from info struct. both returned by DTWFB function.
     
        f = IDTWFB(c,dualwt,Ls) reconstructs signal f from the coefficients
        c using dual-tree filterbank defined by dualwt. Plese see DTWFB 
        for supported formats. The Ls parameter is mandatory due to the
        ambiguity of reconstruction lengths introduced by the subsampling
        operation. 
        Note that the same flag as in the DTWFB function have to be used, 
        otherwise perfect reconstruction cannot be obtained. Please see help 
        for DTWFB for description of the flags.
     
        Examples:
        ---------
     
        A simple example showing perfect reconstruction using IDTWFB:
     
           f = gspi;
           J = 7;
           wtdef = {'qshift3',J};
           c = dtwfb(f,wtdef);
           fhat = idtwfb(c,wtdef,length(f));
           % The following should give (almost) zero
           norm(f-fhat)
     
     
     
     *Url*: <http://ltfat.github.io/doc/wavelets/idtwfb.html>

     See also: dtwfb, dtwfbinit.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IDTWFB Inverse Dual-tree Filterbank
   Usage:  f=idtwfb(c,info);
           f...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1723
 -- Function: idtwfbreal
     IDTWFBREAL Inverse Dual-tree Filterbank for real-valued signals
        Usage:  f=idtwfbreal(c,info);
                f=idtwfbreal(c,dualwt,Ls);
     
        Input parameters:
              c           : Input coefficients.
              info        : Transform params. struct
              dualwt      : Dual-tree Wavelet Filterbank definition
              Ls          : Length of the reconstructed signal.
     
        Output parameters:
              f     : Reconstructed data.
     
        f = IDTWFBREAL(c,info) reconstructs real-valued signal f from the 
        coefficients c using parameters from info struct. both returned by 
        DTWFBREAL function.
     
        f = IDTWFBREAL(c,dualwt,Ls) reconstructs real-valued signal f from the
        coefficients c using dual-tree filterbank defined by dualwt. Plese 
        see DTWFBREAL for supported formats. The Ls parameter is mandatory 
        due to the ambiguity of reconstruction lengths introduced by the 
        subsampling operation. 
        Note that the same flag as in the DTWFBREAL function have to be used, 
        otherwise perfect reconstruction cannot be obtained. Please see help 
        for DTWFBREAL for description of the flags.
     
        Examples:
        ---------
     
        A simple example showing perfect reconstruction using IDTWFBREAL:
     
           f = gspi;
           J = 7;
           wtdef = {'qshift3',J};
           c = dtwfbreal(f,wtdef);
           fhat = idtwfbreal(c,wtdef,length(f));
           % The following should give (almost) zero
           norm(f-fhat)
     
     *Url*: <http://ltfat.github.io/doc/wavelets/idtwfbreal.html>

     See also: dtwfbreal, dtwfbinit.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IDTWFBREAL Inverse Dual-tree Filterbank for real-valued signals
   Usage:  f=...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2107
 -- 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 filterbank 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.github.io/doc/wavelets/ifwt.html>

     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)
           ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1298
 -- 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.
              w     : Wavelet filters definition.
              J     : Number of filterbank iterations.
              Ls    : Size of the reconstructed signal.
     
        Output parameters:
              f     : Reconstructed data.
     
        f = IFWT2(c,w,J) reconstructs signal f from the wavelet coefficients
        c using a J*-iteration synthesis filterbank build from the basic 
        synthesis filterbank defined by w. f is a matrix with 
        size(f)==size(c).
     
        f = IFWT2(c,w,J,Ls) works as above but the result f is cut or
        extended to size Ls if Ls is a two-element vector or to [Ls,Ls]
        if Ls is a scalar.
     
        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.github.io/doc/wavelets/ifwt2.html>

     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)
         ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2283
 -- 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 w 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.
     
        Filter scaling
        --------------
     
        As in UFWT, 3 flags defining scaling of filters are recognized:
     
           'sqrt'
                    Each filter is scaled by 1/sqrt(a), there a is the hop
                    factor associated with it. If the original filterbank is
                    orthonormal, the overall undecimated transform is a tight
                    frame.
                    This is the default.
     
           'noscale'
                    Uses filters without scaling.
     
           'scale'
                    Each filter is scaled by 1/a.
     
        If 'noscale' is used, 'scale' must have been used in UFWT (and vice
        versa) in order to obtain a perfect reconstruction.
     
        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.github.io/doc/wavelets/iufwt.html>

     See also: ufwt, plotwavelets.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2037
 -- 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,wt : 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.
     
        Please see help for WFBT description of possible formats of wt.
     
        Filter scaling:
        ---------------
     
        As in UWFBT, the function recognizes three flags controlling scaling
        of the filters:
     
           'sqrt'
                    Each filter is scaled by 1/sqrt(a), there a is the hop
                    factor associated with it. If the original filterbank is
                    orthonormal, the overall undecimated transform is a tight
                    frame.
                    This is the default.
     
           'noscale'
                    Uses filters without scaling.
     
           'scale'
                    Each filter is scaled by 1/a.
     
        If 'noscale' is used, 'scale' must have been used in UWFBT (and vice
        versa) in order to obtain a perfect reconstruction.
     
        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.github.io/doc/wavelets/iuwfbt.html>

     See also: uwfbt, plotwavelets.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2999
 -- Function: iuwpfbt
     IUWPFBT Inverse Undecimated Wavelet Packet Filterbank Tree
        Usage:  f=iuwpfbt(c,info);
                f=iuwpfbt(c,wt);
     
        Input parameters:
              c       : Coefficients stored in L xM matrix.
              info,wt : Transform parameters struct/Wavelet tree definition.
     
        Output parameters:
              f     : Reconstructed data.
     
        f = IUWPFBT(c,info) reconstructs signal f from the wavelet packet
        coefficients c using parameters from info struct. both returned by
        the UWPFBT function.
     
        f = IUWPFBT(c,wt) reconstructs signal f from the wavelet packet 
        coefficients c using the undecimated wavelet filterbank tree 
        described by wt.
     
        Please see help for WFBT description of possible formats of wt.
     
        Filter scaling:
        ---------------
     
        As in UWPFBT, the function recognizes three flags controlling scaling
        of filters:
     
           'sqrt'
                    Each filter is scaled by 1/sqrt(a), there a is the hop
                    factor associated with it. If the original filterbank is
                    orthonormal, the overall undecimated transform is a tight
                    frame.
                    This is the default.
     
           'noscale'
                    Uses filters without scaling.
     
           'scale'
                    Each filter is scaled by 1/a.
     
        If 'noscale' is used, 'scale' must have been used in UWPFBT (and vice
        versa) in order to obtain a perfect reconstruction.
     
        Scaling of intermediate outputs:
        --------------------------------
     
        The following flags control scaling of the intermediate coefficients.
        The intermediate coefficients are outputs of nodes which ale also
        inputs to nodes further in the tree.
     
           'intsqrt'
                    Each intermediate output is scaled by 1/sqrt(2).
                    If the filterbank in each node is orthonormal, the overall
                    undecimated transform is a tight frame.
                    This is the default.
     
           'intnoscale'
                    No scaling of intermediate results is used.
     
           'intscale'
                    Each intermediate output is scaled by 1/2.
     
        If 'intnoscale' is used, 'intscale' must have been used in UWPFBT
        (and vice versa) in order to obtain a perfect reconstruction.
     
        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.github.io/doc/wavelets/iuwpfbt.html>

     See also: wfbt, wfbtinit.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1566
 -- 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 filterbank 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 IDTWFB:
     
          f = gspi;
          J = 7;
          wt = {'db6',J};
          c = wfbt(f,wt);
          fhat = iwfbt(c,wt,length(f));
          % The following should give (almost) zero
          norm(f-fhat)
     
     *Url*: <http://ltfat.github.io/doc/wavelets/iwfbt.html>

     See also: wfbt, wfbtinit.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2456
 -- 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.
     
        Please see help for WFBT description of possible formats of wt and
        of the additional flags.
     
        Scaling of intermediate outputs:
        --------------------------------
     
        The following flags control scaling of the intermediate coefficients.
        The intermediate coefficients are outputs of nodes which ale also
        inputs to nodes further in the tree.
     
           'intsqrt'
                    Each intermediate output is scaled by 1/sqrt(2).
                    If the filterbank in each node is orthonormal, the overall
                    undecimated transform is a tight frame.
                    This is the default.
     
           'intnoscale'
                    No scaling of intermediate results is used.
     
           'intscale'
                    Each intermediate output is scaled by 1/2.
     
        If 'intnoscale' is used, 'intscale' must have been used in WPFBT
        (and vice versa) in order to obtain a perfect reconstruction.
     
        Examples:
        ---------
     
        A simple example showing perfect reconstruction using the "full
        decomposition" wavelet tree:
     
          f = gspi;
          J = 7;
          wt = {'db10',J,'full'};
          c = wpfbt(f,wt);
          fhat = iwpfbt(c,wt,length(f));
          % The following should give (almost) zero
          norm(f-fhat)
     
     
     *Url*: <http://ltfat.github.io/doc/wavelets/iwpfbt.html>

     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: 12
plotwavelets


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1169
 -- Function: plotwavelets
     PLOTWAVELETS  Plot wavelet coefficients
        Usage:  plotwavelets(c,info,fs) 
                plotwavelets(c,info,fs,'dynrange',dynrange,...)
     
        PLOTWAVELETS(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.
     
        PLOTWAVELETS(c,info,fs) does the same plot assuming a sampling rate
        fs Hz of the original signal.
     
        plowavelets(c,info,fs,'dynrange',dynrange) additionally limits the 
        dynamic range.
     
        C=PLOTWAVELETS(...) 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.
     
        PLOTWAVELETS supports optional parameters of TFPLOT. Please see
        the help of TFPLOT for an exhaustive list.
     
     *Url*: <http://ltfat.github.io/doc/wavelets/plotwavelets.html>

     See also: fwt, tfplot,
     complainif_notenoughargs(nargin,2,'plotwavelets');.


# 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: 3876
 -- 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 x(J+1) matrix.
              info  : Transform paramaters struct.
     
        UFWT(f,w,J) computes redundant time (or shift) invariant
        wavelet representation of the input signal f using wavelet filters
        defined by w in the "a-trous"  algorithm. 
     
        For all accepted formats of the parameter w see the FWTINIT function.
     
        [c,info]=UFWT(f,w,J) additionally returns the info struct. 
        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 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 respective subbands.
     
        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.
     
        Filter scaling
        --------------
     
        When compared to FWT, UFWT subbands are gradually more and more 
        redundant with increasing level of the subband. If no scaling of the 
        filters is introduced, the energy of subbands tends to grow with increasing
        level.
        There are 3 flags defining filter scaling:
     
           'sqrt'
                    Each filter is scaled by 1/sqrt(a), where a is the hop
                    factor associated with it. If the original filterbank is
                    orthonormal, the overall undecimated transform is a tight
                    frame.
                    This is the default.
     
           'noscale'
                    Uses filters without scaling.
     
           'scale'
                    Each filter is scaled by 1/a.
     
        If 'noscale' is used, 'scale' has to be used in IUFWT (and vice
        versa) in order to obtain a perfect reconstruction.
     
        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,fs] = greasy;
          J = 8;
          [c,info] = ufwt(f,'db8',J);
          plotwavelets(c,info,fs,'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.github.io/doc/wavelets/ufwt.html>

     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: 2558
 -- 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.
     
        UWFBT(f,wt) computes redundant time (or shift) invariant 
        representation 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 nodes of the tree.
     
        [c,info]=UWFBT(f,wt) additionally 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.
     
        Filter scaling
        --------------
     
        When compared to WFBT, the subbands produced by UWFBT are
        gradually more and more redundant with increasing depth in the tree.
        This results in energy grow of the coefficients. There are 3 flags
        defining filter scaling:
     
           'sqrt'
                    Each filter is scaled by 1/sqrt(a), there a is the hop
                    factor associated with it. If the original filterbank is
                    orthonormal, the overall undecimated transform is a tight
                    frame.
                    This is the default.
     
           'noscale'
                    Uses filters without scaling.
     
           'scale'
                    Each filter is scaled by 1/a.
     
        If 'noscale' is used, 'scale' has to be used in IUWFBT (and vice
        versa) in order to obtain a perfect reconstruction.
     
        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.github.io/doc/wavelets/uwfbt.html>

     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: 3637
 -- Function: uwpfbt
     UWPFBT Undecimated Wavelet Packet FilterBank Tree
        Usage:  c=uwpfbt(f,wt);
                [c,info]=uwpfbt(...);
     
        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.
     
        [c,info]=UWPFBT(f,wt) additionally 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.
     
        Scaling of intermediate outputs:
        --------------------------------
     
        The following flags control scaling of intermediate outputs and
        therefore the energy relations between coefficient subbands. An 
        intermediate output is an output of a node which is further used as an
        input to a descendant node.
     
           'intsqrt'
                    Each intermediate output is scaled by 1/sqrt(2).
                    If the filterbank in each node is orthonormal, the overall
                    undecimated transform is a tight frame.
                    This is the default.
     
           'intnoscale'
                    No scaling of intermediate results is used. This is
                    necessaty for the WPBEST function to correctly work with
                    the cost measures.
     
           'intscale'
                    Each intermediate output is scaled by 1/2.
     
        If 'intnoscale' is used, 'intscale' must be used in IUWPFBT (and vice
        versa) in order to obtain a perfect reconstruction.
     
        Scaling of filters:
        -------------------
     
        When compared to WPFBT, the subbands produced by UWPFBT are
        gradually more and more redundant with increasing depth in the tree.
        This results in energy grow of the coefficients. There are 3 flags
        defining filter scaling:
     
           'sqrt'
                    Each filter is scaled by 1/sqrt(a), there a is the hop
                    factor associated with it. If the original filterbank is
                    orthonormal, the overall undecimated transform is a tight
                    frame.
                    This is the default.
     
           'noscale'
                    Uses filters without scaling.
     
           'scale'
                    Each filter is scaled by 1/a.
     
        If 'noscale' is used, 'scale' must be used in IUWPFBT (and vice
        versa) in order to obtain a perfect reconstruction.
     
        Examples:
        ---------
     
        A simple example of calling the UWPFBT function using the "full
        decomposition" wavelet tree:
     
          [f,fs] = greasy;
          J = 6;
          [c,info] = uwpfbt(f,{'db10',J,'full'});
          plotwavelets(c,info,fs,'dynrange',90);
     
     *Url*: <http://ltfat.github.io/doc/wavelets/uwpfbt.html>

     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: 1105
 -- 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.github.io/doc/wavelets/wavcell2pack.html>

     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: 6
wavfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1808
 -- 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+1 set to 1. xvals*
        contains correct x-axis values. All but last columns 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.github.io/doc/wavelets/wavfun.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1678
 -- 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 columns 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.github.io/doc/wavelets/wavpack2cell.html>

     See also: wavcell2pack, fwt, wfbt, wpfbt.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3621
 -- Function: wfbt
     WFBT   Wavelet FilterBank Tree
        Usage:  c=wfbt(f,wt);
                c=wfbt(f,wt,ext);
                [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.
     
        WFBT(f,wt) returns coefficients c obtained by applying a wavelet
        filterbank tree defined by wt to the input data f. 
     
        [c,info]=WFBT(f,wt) additionally 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'
              Plain DWT tree (default). This gives one band per octave freq. 
              resolution when using 2 channel basic wavelet filterbank and
              produces coefficients identical to the ones in FWT.
     
           'full'
              Full filterbank tree. Both (all) basic filterbank outputs are
              decomposed further up to depth J achieving linear frequency band
              division.
     
           'doubleband','quadband','octaband'
              The filterbank is designed such that it mimics 4-band, 8-band or
              16-band complex wavelet transform provided the basic filterbank
              is 2 channel. In this case, J is treated such that it defines
              number of levels of 4-band, 8-band or 16-band transform.
     
        2) Structure returned by the WFBTINIT function and possibly
           modified by WFBTPUT and WFBTREMOVE.
     
        Please see WFBTINIT for a detailed description and more options.
     
        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'(default),'zero','odd','even'
          Type of the boundary handling. Please see the help on FWT for a 
          description of the boundary condition flags.
     
        'freq'(default),'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).
     
        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.github.io/doc/wavelets/wfbt.html>

     See also: iwfbt, wfbtinit.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2121
 -- Function: wfbt2filterbank
     WFBT2FILTERBANK  WFBT equivalent non-iterated filterbank
        Usage: [g,a] = wfbt2filterbank(wt)
     
        Input parameters:
              wt : Wavelet filter tree definition
     
        Output parameters:
              g   : Cell array containing filters
              a   : Vector of sub-/upsampling factors
     
        [g,a]=WFBT2FILTERBANK(wt) calculates the impulse responses g and the
        subsampling factors a of non-iterated filterbank, which is equivalent
        to the wavelet filterbank tree described by wt used in WFBT. The 
        returned parameters can be used directly in FILTERBANK and other routines.
     
        [g,a]=WFBT2FILTERBANK({w,J,'dwt'}) does the same for the DWT (|FWT|)
        filterbank tree.
     
        Please see help on WFBT for description of wt and help on FWT for
        description of w and J. 
     
        The function additionally support the following flags:
     
        'freq'(default),'nat'
          The filters are ordered to produce subbands in the same order as 
          WFBT with the same flag.
     
        'scaling_notset'(default),'noscale','scale','sqrt'
          Support for scaling flags as described in UWFBT. By default,
          the returned filterbank g and a is equivalent to WFBT,
          passing any of the non-default flags results in a filterbank 
          equivalent to UWFBT i.e. scaled and with a(:)=1.
     
        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'});
           filterbankfreqz(g,a,1024,'plot','linabs','posfreq');
     
        In the second example, the filterbank is identical to the full
        wavelet tree:
     
           [g,a] = wfbt2filterbank({'db10',3,'full'});
           filterbankfreqz(g,a,1024,'plot','linabs','posfreq');
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfbt2filterbank.html>

     See also: wfbtinit.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1390
 -- Function: wfbtbounds
     WFBTBOUNDS Frame bounds of WFBT
        Usage: fcond=wfbtbounds(wt,L);
               [A,B]=wfbtbounds(wt,L);
               [...]=wfbtbounds(wt);
     
        WFBTBOUNDS(wt,L) calculates the ratio B/A of the frame bounds
        of the filterbank tree specified by wt for a system of length
        L. The ratio is a measure of the stability of the system.
     
        WFBTBOUNDS({w,J,'dwt'},L) calculates the ratio B/A of the frame
        bounds of the DWT (|FWT|) filterbank specified by w and J for a
        system of length L.
     
        WFBTBOUNDS(wt) does the same thing, but L is assumed to be the
        next compatible length bigger than the longest filter in the identical
        filterbank.
     
        [A,B]=WFBTBOUNDS(...) returns the lower and upper frame bounds
        explicitly.
     
        See WFBT for explanation of parameter wt and FWT for explanation
        of parameters w and J.
     
        The function supports the following flag groups:
     
        'scaling_notset'(default),'noscale','scale','sqrt'
          Support for scaling flags as described in UWFBT. By default,
          the bounds are computed for WFBT, passing any of the non-default
          flags results in framebounds for UWFBT.
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfbtbounds.html>

     See also: wfbt, fwt, filterbankbounds.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 717
 -- Function: wfbtclength
     WFBTCLENGTH  WFBT subband lengths from a signal length
        Usage: Lc=wfbtclength(Ls,wt);
               [Lc,L]=wfbtclength(...);
     
        Lc=WFBTCLENGTH(Ls,wt) returns the lengths of coefficient subbands 
        obtained from WFBT for a signal of length Ls. Please see the help 
        on WFBT for an explanation of the parameters wt. 
     
        [Lc,L]=WFBTCLENGTH(...) additionally 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.github.io/doc/wavelets/wfbtclength.html>

     See also: wfbt, wfbtlength.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFBTCLENGTH  WFBT subband lengths from a signal length
   Usage: Lc=wfbtcleng...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1989
 -- 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({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','doubleband','quadband','octaband'
          Type of the tree to be created.
     
        WFBTINIT({w,J,flag,'mod',mod}) creates a filterbank tree as before,
        but modified according to the value of mod.
        Recognized options:
     
        'powshiftable'
           Changes subsampling factors of the root to 1. This results in redundant
           near-shift invariant representation.
     
        The returned structure wt has the following fields:
     
        .nodes     
           Cell-array of structures obtained from FWTINIT. Each element
           define a basic wavelet filterbank.
     
        .children  
           Indexes of children nodes
     
        .parents   
           Indexes of a parent node
     
        .forder 
           Frequency ordering of the resultant frequency bands.
     
        The structure together with functions from the wfbtmanip 
        subdirectory acts as an abstract data structure tree. 
     
        Regular WFBTINIT 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.github.io/doc/wavelets/wfbtinit.html>

     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: 760
 -- Function: wfbtlength
     WFBTLENGTH  WFBT length from signal
        Usage: 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.
     
        In addition, the function accepts flags defining boundary extension
        technique as in WFBT. The returned length can be longer than the
        signal length only in case of 'per' (periodic extension).
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfbtlength.html>

     See also: wfbt, fwt.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2767
 -- 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 w to the filter
        tree structure wt at level d and index(es) 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.
     
        Examples:
        ---------
     
        This example shows magnitude frequency responses of a tree build from
        the root:
     
           % Initialize empty struct
           wt = wfbtinit();
           % Put root node to the empty struct
           wt1 = wfbtput(0,0,'db8',wt);
           % Connect a different nodes to both outputs of the root
           wt2 = wfbtput(1,[0,1],'db10',wt1);
           % Connect another nodes just to high-pass outputs of nodes just added
           wt3 = wfbtput(2,[1,3],'db10',wt2);
           % Add another node at level 3
           wt4 = wfbtput(3,1,'db16',wt3);
           
           % Create identical filterbanks
           [g1,a1] = wfbt2filterbank(wt1,'freq');
           [g2,a2] = wfbt2filterbank(wt2,'freq');
           [g3,a3] = wfbt2filterbank(wt3,'freq');
           [g4,a4] = wfbt2filterbank(wt4,'freq');
     
           % Plot frequency responses of the growing tree. Linear scale 
           % (both axis) is used and positive frequencies only are shown.
           subplot(4,1,1);
           filterbankfreqz(g1,a1,1024,'plot','linabs','posfreq');
           subplot(4,1,2);
           filterbankfreqz(g2,a2,1024,'plot','linabs','posfreq');
           subplot(4,1,3);
           filterbankfreqz(g3,a3,1024,'plot','linabs','posfreq');
           subplot(4,1,4);
           filterbankfreqz(g4,a4,1024,'plot','linabs','posfreq');
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfbtput.html>


# 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: 1836
 -- Function: wfbtremove
     WFBTREMOVE Remove node(s) 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 (it is not a leaf node).
     
        WFBTREMOVE(d,k,wt,'force') does the same, but any childern of the
        node are removed too.
     
        Examples:
        ---------
     
        The following example shows magnitude frequency responses of filterbank
        tree before and after prunning.:
     
           % Create a full filterbank tree usinf 'db10' basic filterbank.
           wt1 = wfbtinit({'db10',4,'full'});
           % Remove a subtree starting by root's high-pass filter. Force flag
           % is used because we are removing a non-leaf node.
           wt2 = wfbtremove(1,1,wt1,'force');
           
           % Create identical filterbanks
           [g1,a1] = wfbt2filterbank(wt1,'freq');
           [g2,a2] = wfbt2filterbank(wt2,'freq');
     
           % Plot the frequency responses
           subplot(2,1,1);
           filterbankfreqz(g1,a1,1024,'plot','posfreq','linabs');
           subplot(2,1,2);
           filterbankfreqz(g2,a2,1024,'plot','posfreq','linabs');
           
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfbtremove.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 835
 -- Function: wfilt_algmband
     WFILT_ALGMBAND  An ALGebraic construction of orthonormal M-BAND wavelets with perfect reconstruction
        Usage: [h,g,a] = wfilt_algmband(K);
     
        [h,g,a]=WFILT_ALGMBAND(K) with K in {1,2} returns wavelet filters
        from the reference paper. The filters are 3-band (K==1) and 4-band 
        (K==2) with critical subsampling.
     
        Examples:
        ---------
        :
          wfiltinfo('algmband1');  
     
        :
          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.github.io/doc/wavelets/wfilt_algmband.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 885
 -- 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) with Min {2,3,dots} returns smooth, 
        1-regular cosine modulated M*-band wavelet filters according to the 
        reference paper.
        The length of the filters is 4M.
     
        Examples:
        ---------
        :
          wfiltinfo('cmband3');
     
        :
          wfiltinfo('cmband4');
     
        :
          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.github.io/doc/wavelets/wfilt_cmband.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 780
 -- Function: wfilt_coif
     WFILT_COIF Coiflets
     
        Usage: [h,g,a] = wfilt_coif(K);
     
        [h,g,a]=WFILT_COIF(K) with K in {1,2,3,4,5} returns a Coiflet
        filters of order 2K the number of vanishing moments of both the
        scaling and the wavelet functions.
     
        Values are taken from table 8.1 from the reference. REMARK: There is 
        a typo in 2nd element for K==1.
     
        Examples:
        ---------
        :
          wfiltinfo('coif2');
     
        :
          wfiltinfo('coif5');
      
        References:
          I. Daubechies. Ten Lectures on Wavelets. Society for Industrial and
          Applied Mathematics, Philadelphia, PA, USA, 1992.
          
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_coif.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
WFILT_COIF Coiflets



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1879
 -- Function: wfilt_db
     WFILT_DB    Daubechies FIR filterbank
        Usage:  [h, g, a, info] = wfilt_db(N, compat = 1);
     
        Input parameters:
              N      : Order of Daubechies filters.
              compat : 0 is precomputed LUT for N <= 38,
                       1 is runtime calculation (default).
        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
              info   : info.istight=1 indicates the wavelet system is a can. tight frame
     
        [H, G] = WFILT_DB(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 inside of the unit circle):
     
           H_l(z) = (1 + z^-1)^N * R(z),
     
        where R(z) is a spectral factor of the Lagrange interpolator P(z) = 2 R(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 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.github.io/doc/wavelets/wfilt_db.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_DB    Daubechies FIR filterbank
   Usage:  [h, g, a, info] = wfilt_db(N...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 691
 -- 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 of the basic filterbank is equal to 1.5.
     
        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.github.io/doc/wavelets/wfilt_dden.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 607
 -- Function: wfilt_ddena
     WFILT_DDENA  Double-Density Dual-Tree DWT filters 
     
        Usage: [h,g,a] = wfilt_ddena(N);
     
        [h,g,a]=wfil_ddena(N) with N in {1,2} returns filters suitable
        for dual-tree double density complex wavelet transform tree A. 
     
        Examples:
        ---------
        :
          wfiltinfo('ddena1');
     
        References:
          I. Selesnick. The double-density dual-tree DWT. Signal Processing, IEEE
          Transactions on, 52(5):1304--1314, May 2004.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_ddena.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
WFILT_DDENA  Double-Density Dual-Tree DWT filters 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 608
 -- Function: wfilt_ddenb
     WFILT_DDENB  Double-Density Dual-Tree DWT filters 
     
        Usage: [h,g,a] = wfilt_ddenb(N);
     
        [h,g,a]=WFILT_DDENB(N) with N in {1,2} returns filters suitable
        for dual-tree double density complex wavelet transform tree A. 
     
        Examples:
        ---------
        :
          wfiltinfo('ddena1');
     
        References:
          I. Selesnick. The double-density dual-tree DWT. Signal Processing, IEEE
          Transactions on, 52(5):1304--1314, May 2004.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_ddenb.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
WFILT_DDENB  Double-Density Dual-Tree DWT filters 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 667
 -- 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.github.io/doc/wavelets/wfilt_dgrid.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 747
 -- Function: wfilt_hden
     WFILT_HDEN  Higher DENsity dwt filters (tight frame, frame)
        Usage: [h,g,a] = wfilt_hden(K);
     
        [h,g,a]=WFILT_HDEN(K) with K in {1,2,3,4} returns Higher DENsity 
        dwt filters (tight frame, frame) from the reference. The filterbanks 
        have 3 channels and unusual non-uniform subsamplig factors [2,2,1].
     
        Examples:
        ---------
        :
          wfiltinfo('hden3');
     
        :
          wfiltinfo('ana:hden4');
     
        References:
          I. Selesnick. A higher density discrete wavelet transform. IEEE
          Transactions on Signal Processing, 54(8):3039--3048, 2006.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_hden.html>


# 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: 1131
 -- Function: wfilt_lemarie
     WFILT_LEMARIE  Battle and Lemarie filters
        Usage: [h,g,a]=wfilt_lemarie(N)
     
        Input parameters:
              N     : Filter length, must be even.
     
        [h,g,a]=WFILT_LEMARIE(N) calculates N (even) truncated coeficients 
        of orthonormal Battle-Lemarie wavelets. Filter coefficients are obtained 
        by frequency domain sampling and trunctating the impulse response.
        Due to the truncation, the filterbank might not achieve a perfect 
        reconstruction. The filetrs are included nevertheless since they were
        the original ones used in the first MRA paper.  
     
        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.github.io/doc/wavelets/wfilt_lemarie.html>


# 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: 19
wfilt_matlabwrapper


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 461
 -- Function: wfilt_matlabwrapper
     WFILT_MATLABWRAPPER Wrapper of the Matlab Wavelet Toolbox wfilters function
        Usage: [h,g,a] = wfilt_matlabwrapper(wname);
     
        [h,g,a]=WFILT_MATLABWRAPPER(wname) calls Matlab Wavelet Toolbox
        function wfilters and passes the parameter wname to it. 
     
        This function requires the Matlab Wavelet Toolbox.
     
     *Url*:
     <http://ltfat.github.io/doc/wavelets/wfilt_matlabwrapper.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 846
 -- Function: wfilt_mband
     WFILT_MBAND  Generates 4-band coder
        Usage: [h,g,a] = wfilt_mband(N);
     
        [h,g,a]=WFILT_MBAND(1) returns linear-phase 4-band filters
        from the reference.
     
        The filters are not actually proper wavelet filters, because the
        scaling filter is not regular, therefore it is not stable under 
        iterations (does not converge to a scaling function). 
        
     
        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.github.io/doc/wavelets/wfilt_mband.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
WFILT_MBAND  Generates 4-band coder
   Usage: [h,g,a] = wfilt_mband(N);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 699
 -- Function: wfilt_oddevena
     WFILT_ODDEVENA  Kingsbury's symmetric even filters
     
        Usage: [h,g,a] = wfilt_oddevena(N);
     
        [h,g,a]=WFILT_ODDEVENA(N) with N in {1} returns Kingsbury's
        even filters.
     
        Examples:
        ---------
        :
          figure(1);
          wfiltinfo('ana:oddevena1');
     
          figure(2);
          wfiltinfo('syn:oddevena1');
      
        References:
          N. Kingsbury. Complex wavelets for shift invariant analysis and
          filtering of signals. Applied and Computational Harmonic Analysis,
          10(3):234 -- 253, 2001.
          
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_oddevena.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
WFILT_ODDEVENA  Kingsbury's symmetric even filters



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 697
 -- Function: wfilt_oddevenb
     WFILT_ODDEVENB  Kingsbury's symmetric odd filters
     
        Usage: [h,g,a] = wfilt_oddevenb(N);
     
        [h,g,a]=WFILT_ODDEVENB(N) with N in {1} returns Kingsbury's
        odd filters.
     
        Examples:
        ---------
        :
          figure(1);
          wfiltinfo('ana:oddevenb1');
     
          figure(2);
          wfiltinfo('syn:oddevenb1');
      
        References:
          N. Kingsbury. Complex wavelets for shift invariant analysis and
          filtering of signals. Applied and Computational Harmonic Analysis,
          10(3):234 -- 253, 2001.
          
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_oddevenb.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
WFILT_ODDEVENB  Kingsbury's symmetric odd filters



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 748
 -- Function: wfilt_optsyma
     WFILT_OPTSYMA  Optimizatized Symmetric Self-Hilbertian Filters 
     
        Usage: [h,g,a] = wfilt_optsyma(N);
     
        [h,g,a]=wfiltdt_optsyma(N) with N in {1,2,3} returns filters
        suitable with optimized symmetry suitable for for dual-tree complex 
        wavelet transform tree A.
     
        Examples:
        ---------
        :
          wfiltinfo('optsyma3');
      
        References:
          B. Dumitrescu, I. Bayram, and I. W. Selesnick. Optimization of
          symmetric self-hilbertian filters for the dual-tree complex wavelet
          transform. IEEE Signal Process. Lett., 15:146--149, 2008.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_optsyma.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
WFILT_OPTSYMA  Optimizatized Symmetric Self-Hilbertian Filters 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 748
 -- Function: wfilt_optsymb
     WFILT_OPTSYMB  Optimizatized Symmetric Self-Hilbertian Filters 
     
        Usage: [h,g,a] = wfilt_optsymb(N);
     
        [h,g,a]=wfiltdt_optsymb(N) with N in {1,2,3} returns filters
        suitable with optimized symmetry suitable for for dual-tree complex 
        wavelet transform tree B.
     
        Examples:
        ---------
        :
          wfiltinfo('optsymb3');
      
        References:
          B. Dumitrescu, I. Bayram, and I. W. Selesnick. Optimization of
          symmetric self-hilbertian filters for the dual-tree complex wavelet
          transform. IEEE Signal Process. Lett., 15:146--149, 2008.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_optsymb.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
WFILT_OPTSYMB  Optimizatized Symmetric Self-Hilbertian Filters 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 946
 -- Function: wfilt_qshifta
     WFILT_QSHIFTA  Improved Orthogonality and Symmetry properties 
     
        Usage: [h,g,a] = wfilt_qshifta(N);
     
        [h,g,a]=wfilt_qshift(N) with N in {1,2,3,4,5,6,7} returns
        Kingsbury's Q-shift wavelet filters for tree A.
     
        Examples:
        ---------
        :
          figure(1);
          wfiltinfo('qshifta3');
      
        References:
          N. G. Kingsbury. A dual-tree complex wavelet transform with improved
          orthogonality and symmetry properties. In ICIP, pages 375--378, 2000.
          
          N. Kingsbury. Design of q-shift complex wavelets for image processing
          using frequency domain energy minimization. In Image Processing, 2003.
          ICIP 2003. Proceedings. 2003 International Conference on, volume 1,
          pages I--1013--16 vol.1, Sept 2003.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_qshifta.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
WFILT_QSHIFTA  Improved Orthogonality and Symmetry properties 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 947
 -- Function: wfilt_qshiftb
     WFILT_QSHIFTB  Improved Orthogonality and Symmetry properties 
     
        Usage: [h,g,a] = wfilt_qshiftb(N);
     
        [h,g,a]=WFILT_QSHIFTB(N) with N in {1,2,3,4,5,6,7} returns
        Kingsbury's Q-shift wavelet filters for tree B.
     
        Examples:
        ---------
        :
          figure(1);
          wfiltinfo('qshiftb3');
      
        References:
          N. G. Kingsbury. A dual-tree complex wavelet transform with improved
          orthogonality and symmetry properties. In ICIP, pages 375--378, 2000.
          
          N. Kingsbury. Design of q-shift complex wavelets for image processing
          using frequency domain energy minimization. In Image Processing, 2003.
          ICIP 2003. Proceedings. 2003 International Conference on, volume 1,
          pages I--1013--16 vol.1, Sept 2003.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_qshiftb.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
WFILT_QSHIFTB  Improved Orthogonality and Symmetry properties 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1106
 -- 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 (regularity) at z=-1. 
              B     : Normalized transition bandwidth.
     
        [h,g,a]=WFILT_REMEZ(L,K,B) calculates a set of wavelet filters. 
        Regularity, frequency selectivity, and length of the filters can be
        controlled by K, B and L parameters respectivelly.
     
        The filter desigh algorithm is based on a Remez algorithm and a 
        factorization of 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.github.io/doc/wavelets/wfilt_remez.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 634
 -- Function: wfilt_spline
      WFILT_SPLINE  Biorthogonal 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}
     
        [h,g,a]=WFILT_SPLINE(m,n) with m+n being even returns biorthogonal
        spline wavelet filters.  
     
        Examples:
        ---------
        :
          wfiltinfo('ana:spline4:2');
     
        :
          wfiltinfo('syn:spline4:2');
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_spline.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 WFILT_SPLINE  Biorthogonal spline wavelets
   Usage: [h,g,a]=wfilt_spline(m,...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 936
 -- 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'
        orthogonal wavelets or "symlets" with N vanishing moments and 
        length 2N.  
        Zeros of the trigonometrical polynomial the filters consist of in the 
        Z-plane are selected alternatingly inside and outside the unit circle.
     
        Remark: Filters generated by this routine differ slightly from the
        ones in the reference (table 6.3, figure. 6.4) because of the ambiguity
        in the algorithm.
     
        Examples:
        ---------
        :
          wfiltinfo('sym8');
        
        References:
          I. Daubechies. Ten Lectures on Wavelets. Society for Industrial and
          Applied Mathematics, Philadelphia, PA, USA, 1992.
          
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_sym.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 727
 -- Function: wfilt_symdden
     WFILT_SYMDDEN  Symmetric Double-Density DWT filters (tight frame)
        Usage: [h,g,a] = wfilt_symdden(K);
     
        [h,g,a]=WFILT_SYMDDEN(K) with K in {1,2} returns oversampled
        symmetric double-density DWT filters. 
        The redundancy of the basic filterbank is equal to 1.5.
     
        Examples:
        ---------
        :
          wfiltinfo('symdden1');
     
        :
          wfiltinfo('symdden2');
     
        References:
          I. Selesnick and A. Abdelnour. Symmetric wavelet tight frames with two
          generators. Appl. Comput. Harmon. Anal., 17(2):211--225, 2004.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_symdden.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WFILT_SYMDDEN  Symmetric Double-Density DWT filters (tight frame)
   Usage: [...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 881
 -- Function: wfilt_symds
     WFILT_SYMDS  Symmetric wavelets dyadic sibling
        Usage: [h,g,a] = wfilt_symds(K);
     
        [h,g,a]=WFILT_SYMDS(K) with K in {1,2,3,4,5} returns symmetric 
        dyadic sibling wavelet frame filters from the reference.
     
        The returned filterbank has redundancy equal to 2 and it does not form
        a tight frame.
     
        Examples:
        ---------
        :
          wfiltinfo('ana:symds3');
     
        :
          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.github.io/doc/wavelets/wfilt_symds.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 927
 -- Function: wfilt_symorth
     WFILT_SYMORTH  Symmetric nearly-orthogonal and orthogonal nearly-symmetric
     
        Usage: [h,g,a] = wfilt_symorth(N);
     
        [h,g,a]=WFILT_SYMORTH(N) with Nin {1,2,3} returns orthogonal
        near-symmetric (N==1) and symmetric near-orthogonal (N==[2,3])
        wavelet filters from the reference.
     
        The filters exhibit a coiflet-like behavior i.e. the scaling filter
        has vanishing moments too.    
     
        Examples:
        ---------
        :
          wfiltinfo('ana:symorth2');
     
        :
          wfiltinfo('syn:symorth2');
      
        References:
          F. Abdelnour and I. W. Selesnick. Symmetric nearly orthogonal and
          orthogonal nearly symmetric wavelets. The Arabian Journal for Science
          and Engineering, 29(2C):3 -- 16, 2004.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_symorth.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
WFILT_SYMORTH  Symmetric nearly-orthogonal and orthogonal nearly-symmetric



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 728
 -- Function: wfilt_symtight
     WFILT_SYMTIGHT Symmetric Nearly Shift-Invariant Tight Frame Wavelets
     
        Usage: [h,g,a] = wfilt_symtight(K);
     
        [h,g,a]=WFILT_SYMTIGHT(K) with K in {1,2} returns 4-band 
        symmetric nearly shift-invariant tight framelets.
     
     
     
        Examples:
        ---------
        :
          wfiltinfo('symtight1');
     
        :
          wfiltinfo('symtight2');
      
        References:
          A. F. Abdelnour and I. W. Selesnick. Symmetric nearly shift-invariant
          tight frame wavelets. IEEE Transactions on Signal Processing,
          53(1):231--239, 2005.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfilt_symtight.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
WFILT_SYMTIGHT Symmetric Nearly Shift-Invariant Tight Frame Wavelets



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 656
 -- Function: wfiltdt_dden
     WFILTDT_DDEN  Double-Density Dual-Tree DWT filters 
     
        Usage: [h,g,a] = wfiltdt_dden(N);
     
        [h,g,a]=WFILTDT_DDEN(N) with N in {1,2} returns filters suitable
        for dual-tree double density complex wavelet transform. 
     
        Examples:
        ---------
        :
          wfiltdtinfo('dden1');
     
        :
          wfiltdtinfo('dden2');
      
        References:
          I. Selesnick. The double-density dual-tree DWT. Signal Processing, IEEE
          Transactions on, 52(5):1304--1314, May 2004.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfiltdt_dden.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
WFILTDT_DDEN  Double-Density Dual-Tree DWT filters 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 757
 -- Function: wfiltdt_oddeven
     WFILTDT_ODDEVEN  Kingsbury's symmetric odd and even filters
     
        Usage: [h,g,a] = wfiltdt_oddeven(N);
     
        [h,g,a]=wfilt_oddeven(N) with N in {1} returns the original odd
        and even symmetric filters suitable for dual-tree complex wavelet
        transform. The filters in individual trees are biorthogonal.
     
        Examples:
        ---------
        :
          wfiltdtinfo('ana:oddeven1');
      
        References:
          N. Kingsbury. Complex wavelets for shift invariant analysis and
          filtering of signals. Applied and Computational Harmonic Analysis,
          10(3):234 -- 253, 2001.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfiltdt_oddeven.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
WFILTDT_ODDEVEN  Kingsbury's symmetric odd and even filters



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 732
 -- Function: wfiltdt_optsym
     WFILTDT_OPTSYM  Optimizatized Symmetric Self-Hilbertian Filters 
     
        Usage: [h,g,a] = wfiltdt_optsym(N);
     
        [h,g,a]=WFILTDT_OPTSYM(N) with N in {1,2,3} returns filters
        suitable for dual-tree complex wavelet transform with optimized 
        symmetry.
     
        Examples:
        ---------
        :
          wfiltdtinfo('optsym3');
      
        References:
          B. Dumitrescu, I. Bayram, and I. W. Selesnick. Optimization of
          symmetric self-hilbertian filters for the dual-tree complex wavelet
          transform. IEEE Signal Process. Lett., 15:146--149, 2008.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfiltdt_optsym.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
WFILTDT_OPTSYM  Optimizatized Symmetric Self-Hilbertian Filters 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1253
 -- Function: wfiltdt_qshift
     WFILTDT_QSHIFT  Improved Orthogonality and Symmetry properties 
     
        Usage: [h,g,a] = wfiltdt_qshift(N);
     
        [h,g,a]=WFILTDT_QSHIFT(N) with N in {1,2,3,4,5,6,7} returns 
        Kingsbury's Q-shift filters suitable for dual-tree complex wavelet 
        transform.
        Filters in both trees are orthogonal and based on a single prototype
        low-pass filter with a quarter sample delay. Other filters are
        derived by modulation and time reversal such that they fulfil the
        half-sample delay difference between the trees.   
     
        Examples:
        ---------
        :
          wfiltdtinfo('qshift3');
      
        References:
          N. G. Kingsbury. A dual-tree complex wavelet transform with improved
          orthogonality and symmetry properties. In ICIP, pages 375--378, 2000.
          
          N. Kingsbury. Design of q-shift complex wavelets for image processing
          using frequency domain energy minimization. In Image Processing, 2003.
          ICIP 2003. Proceedings. 2003 International Conference on, volume 1,
          pages I--1013--16 vol.1, Sept 2003.
          
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wfiltdt_qshift.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
WFILTDT_QSHIFT  Improved Orthogonality and Symmetry properties 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1371
 -- Function: wfiltdtinfo
     WFILTDTINFO Plots dual-tree filters info
        Usage: wfiltdtinfo(dw);
     
        Input parameters:
              dw     : Wavelet dual-tree filterbank
     
        WFILTDTINFO(w) plots impulse responses, frequency responses and 
        approximation of the scaling and of the wavelet function(s) associated
        with the dual-tree wavelet filters defined by w in a single figure. 
        Format of dw is the same as in DTWFB.
     
        The figure is organized as follows:
     
        First row shows impulse responses of the first (real) tree.
     
        Second row shows impulse responses of the second (imag) tree.
     
        Third row contains plots of real (green), imaginary (red) and absolute 
        (blue) parts of approximation of scaling and wavelet function(s).
     
        Fourth and fifth row show magnitude and phase frequency responses 
        respectivelly of filters from rows 1 and 2 with matching colors.
     
        Optionally it is possible to define scaling of the y axis of the
        frequency seponses. Supported are:
     
        'db','lin'   
            dB or linear scale respectivelly. By deault a dB scale is used.
     
        Examples:
        ---------
        :
           wfiltdtinfo('qshift4');
        
     *Url*: <http://ltfat.github.io/doc/wavelets/wfiltdtinfo.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
WFILTDTINFO Plots dual-tree filters info
   Usage: wfiltdtinfo(dw);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1039
 -- Function: wfiltinfo
     WFILTINFO Plots filters info
        Usage: wfiltinfo(w);
     
        Input parameters:
              w     : Basic wavelet filterbank.
     
        WFILTINFO(w) plots impulse responses, frequency responses and 
        approximation of the scaling and of the wavelet function(s) associated
        with the wavelet filters defined by w in a single figure. Format of 
        w is the same as in FWT.
     
        Optionally it is possible to define scaling of the y axis of the
        frequency seponses. Supported are:
     
        'db','lin'   
            dB or linear scale respectivelly. By deault a dB scale is used.
     
        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.github.io/doc/wavelets/wfiltinfo.html>

     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: 6
wpbest


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5594
 -- 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.
     
        Please note that w should define orthonormal wavelet filters.
     
        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.github.io/doc/wavelets/wpbest.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2863
 -- 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. 
         
        [c,info]=WPFBT(f,wt) additionally 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 WFBT, the cell array c contain every intermediate 
        output of each node in the tree. c{jj} are ordered according to
        nodes taken in the breadth-first order.
     
        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.
     
        Scaling of intermediate outputs:
        --------------------------------
     
        The following flags control scaling of intermediate outputs and
        therefore the energy relations between coefficient subbands. An 
        intermediate output is an output of a node which is further used as an
        input to a descendant node.
     
           'intsqrt'
                    Each intermediate output is scaled by 1/sqrt(2).
                    If the filterbank in each node is orthonormal, the overall
                    undecimated transform is a tight frame.
                    This is the default.
     
           'intnoscale'
                    No scaling of intermediate results is used. This is
                    necessaty for the WPBEST function to correctly work with
                    the cost measures.
     
           'intscale'
                    Each intermediate output is scaled by 1/2.
     
        If 'intnoscale' is used, 'intscale' must be used in IWPFBT (and vice
        versa) in order to obtain a perfect reconstruction.
     
        Please see help for WFBT description of possible formats of wt and
        of the additional flags defining boundary handling.
     
        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.github.io/doc/wavelets/wpfbt.html>

     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);
           [...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
wpfbt2filterbank


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2165
 -- Function: wpfbt2filterbank
     WPFBT2FILTERBANK  WPFBT equivalent non-iterated filterbank
        Usage: [g,a] = wpfbt2filterbank(wt)
     
        Input parameters:
              wt : Wavelet filter tree definition
     
        Output parameters:
              g   : Cell array containing filters
              a   : Vector of sub-/upsampling factors
     
        WPFBT2FILTERBANK(wt) calculates the impulse responses g and the
        subsampling factors a of non-iterated filterbank, which is equivalent
        to the wavelet packet filterbank tree described by wt. The returned
        parameters can be used directly in FILTERBANK, UFILTERBANK or
        FILTERBANK.
     
        Please see help on WFBT for description of wt. The function
        additionally support the following flags:
     
        'freq'(default),'nat'
           The filters are ordered to produce subbands in the same order as 
           WPFBT with the same flag.
     
        'intsqrt'(default),'intnoscale', 'intscale'
           The filters in the filterbank tree are scaled to reflect the
           behavior of WPFBT and IWPFBT with the same flags.
     
        'scaling_notset'(default),'noscale','scale','sqrt'
          Support for scaling flags as described in UWPFBT. By default,
          the returned filterbank g and a is equivalent to WPFBT,
          passing any of the non-default flags results in a filterbank 
          equivalent to UWPFBT i.e. scaled and with a(:)=1.
     
        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] = wpfbt2filterbank({'db10',3,'dwt'});
          filterbankfreqz(g,a,1024,'plot','linabs','posfreq');
     
     
        In the second example, the filterbank is identical to the full
        wavelet tree:
     
          [g,a] = wpfbt2filterbank({'db10',3,'full'});
          filterbankfreqz(g,a,1024,'plot','linabs','posfreq');
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wpfbt2filterbank.html>

     See also: wfbtinit.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1374
 -- Function: wpfbtbounds
     WPFBTBOUNDS Frame bounds of WPFBT
        Usage: fcond=wpfbtbounds(wt,L);
               [A,B]=wpfbtbounds(wt,L);
               [...]=wpfbtbounds(wt);
     
        WPFBTBOUNDS(wt,L) calculates the ratio B/A of the frame bounds
        of the wavelet packet filterbank specified by wt for a system of length
        L. The ratio is a measure of the stability of the system.
     
        WPFBTBOUNDS(wt) does the same, except L is chosen to be the next 
        compatible length bigger than the longest filter from the identical
        filterbank.
     
        [A,B]=WPFBTBOUNDS(...) returns the lower and upper frame bounds
        explicitly.
     
        See WFBT for explanation of parameter wt. 
     
        Additionally, the function accepts the following flags:
     
        'intsqrt'(default),'intnoscale', 'intscale'
            The filters in the filterbank tree are scaled to reflect the
            behavior of WPFBT and IWPFBT with the same flags.
     
        'scaling_notset'(default),'noscale','scale','sqrt'
          Support for scaling flags as described in UWPFBT. By default,
          the bounds are caltulated for WPFBT, passing any of the non-default
          flags results in bounds for UWPFBT.
     
     *Url*: <http://ltfat.github.io/doc/wavelets/wpfbtbounds.html>

     See also: wpfbt, filterbankbounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WPFBTBOUNDS Frame bounds of WPFBT
   Usage: fcond=wpfbtbounds(wt,L);
        ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 716
 -- Function: wpfbtclength
     WPFBTCLENGTH  WPFBT subband length from a signal length
        Usage: Lc=wpfbtclength(Ls,wt);
               [Lc,L]=wpfbtclength(Ls,wt);
     
        Lc=WPFBTCLENGTH(Ls,wt) returns the lengths of coefficient subbands 
        obtained from WPFBT for a signal of length Ls. Please see the help 
        on WPFBT for an explanation of the parameter wt. 
     
        [Lc,L]=WPFBTCLENGTH(...) additionally 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.github.io/doc/wavelets/wpfbtclength.html>

     See also: wpfbt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WPFBTCLENGTH  WPFBT subband length from a signal length
   Usage: Lc=wpfbtcle...





