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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2296
 LTFAT - Filterbanks

  Peter L. Soendergaard, 2011 - 2023.

  Transforms and basic routines
    FILTERBANK             - Filter bank
    UFILTERBANK            - Uniform Filter bank
    IFILTERBANK            - Inverse normal/uniform filter bank
    IFILTERBANKITER        - Iteratively inverse filter bank 
    FILTERBANKWIN          - Evaluate filter bank window
    FILTERBANKLENGTH       - Length of filter bank to expand signal
    FILTERBANKLENGTHCOEF   - Length of filter bank to expand coefficients

  Filter generators
    CQTFILTERS             - Logarithmically spaced filters
    ERBFILTERS             - ERB-spaced filters
    WARPEDFILTERS          - Frequency-warped filters 
    AUDFILTERS             - Filters based on auditory scales
    GABFILTERS             - Linearly spaced Gabor filters
    WAVELETFILTERS         - Waveletfilters
  
  Window construction and bounds
    FILTERBANKDUAL         - Canonical dual filters
    FILTERBANKTIGHT        - Canonical tight filters
    FILTERBANKREALDUAL     - Canonical dual filters for real-valued signals
    FILTERBANKREALTIGHT    - Canonical tight filters for real-valued signals
    FILTERBANKBOUNDS       - Frame bounds of filter bank
    FILTERBANKREALBOUNDS   - Frame bounds of filter bank for real-valued signals
    FILTERBANKRESPONSE     - Total frequency response (a frame property)

  Auxilary
    FILTERBANKFREQZ        - Frequency responses of filters
    FILTERBANKSCALE        - Scaling and normalization of filters
    NONU2UFILTERBANK       - Non-uni. to uniform filter bank transformation
    U2NONUCFMT             - Change format of coefficients
    NONU2UCFMT             - Change format of coefficients back

  Plots
    PLOTFILTERBANK         - Plot normal/uniform filter bank coefficients

  Reassignment and phase gradient
    FILTERBANKPHASEGRAD      - Instantaneous time/frequency from signal
    FILTERBANKREASSIGN       - Reassign filterbank spectrogram
    FILTERBANKSYNCHROSQUEEZE - Synchrosqueeze filterbank spectrogram  

  Phase reconstruction
    FILTERBANKCONSTPHASE     - Construct suitable phase from the coefficient magnitude
    

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

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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
 LTFAT - Filterbanks



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9185
 -- Function: audfilters
     AUDFILTERS Generates filters equidistantly spaced on auditory frequency scales
        Usage:  [g,a,fc,L]=audfilters(fs,Ls);
                [g,a,fc,L]=audfilters(fs,Ls,...);
     
        Input parameters:
           fs    : Sampling rate (in Hz).
           Ls    : Signal length.
        Output parameters:
           g     : Cell array of filters.
           a     : Downsampling rate for each channel.
           fc    : Center frequency of each channel.
           L     : Next admissible length suitable for the generated filters.
     
        [g,a,fc,L]=AUDFILTERS(fs,Ls) constructs a set of filters g that are
        equidistantly spaced on a perceptual frequency scale (see FREQTOAUD) between
        0 and the Nyquist frequency. The filter bandwidths are proportional to the 
        critical bandwidth of the auditory filters AUDFILTBW. The filters are intended 
        to work with signals with a sampling rate of fs. The signal length Ls is 
        mandatory, since we need to avoid too narrow frequency windows.
     
        By default the ERB scale is chosen but other frequency scales are
        possible. Currently supported scales are 'erb', 'erb83', 'bark', 'mel'
        and 'mel1000', and can be changed by passing the associated string as 
        an optional parameter. See FREQTOAUD for more information on the
        supported frequency scales.
     
        By default, a Hann window shape is chosen as prototype frequency 
        response for all filters. The prototype frequency response can be 
        changed by passing any of the window types from FIRWIN or FREQWIN 
        as an optional parameter.
     
        [g,a,fc,L]=AUDFILTERS(fs,Ls,fmin,fmax) constructs a set of filters 
        between fmin and fmax. The filters are equidistantly spaced on the 
        selected frequency scale. One additional filter will be positioned at 
        the 0 and Nyquist frequencies each, so as to cover the full range of 
        positive frequencies. 
        The values of fmin and fmax can be instead specified using a 
        key/value pair as:
     
            [g,a,fc,L]=audfilters(fs,Ls,...,'fmin',fmin,'fmax',fmax)
     
        Default values are fmin=0 and fmax=fs/2. 
     
        For more details on the construction of the filters, please see the
        given references.
     
        Downsampling factors
        --------------------
     
        The integer downsampling rates of the channels must all divide the
        signal length, FILTERBANK will only work for input signal lengths
        being multiples of the least common multiple of the downsampling rates.
        See the help of FILTERBANKLENGTH. 
        The fractional downsampling rates restrict the filterbank to a single
        length L=Ls.
     
        [g,a]=AUDFILTERS(...,'regsampling') constructs a non-uniform
        filterbank with integer subsampling factors.
     
        [g,a]=AUDFILTERS(...,'uniform') constructs a uniform filterbank
        where the integer downsampling rate is the same for all the channels. This
        results in most redundant representation which produces nice plots.
     
        [g,a]=AUDFILTERS(...,'fractional') constructs a filterbank with
        fractional downsampling rates a. 
        This results in the least redundant system.
     
        [g,a]=AUDFILTERS(...,'fractionaluniform') constructs a filterbank with
        fractional downsampling rates a, which are uniform for all filters
        except the "filling" low-pass and high-pass filters which can have different
        fractional downsampling rates. This is useful when uniform subsampling
        and low redundancy at the same time are desirable.
     
        Additional parameters
        ---------------------
     
        AUDFILTERS accepts the following optional parameters:
     
          'spacing',b        Specify the spacing between the filters, measured in
                             scale units. Default value is b=1 for the scales
                             'erb', 'erb83' and 'bark'; the default is b=100 for
                             'mel' and 'mel1000'.
     
          'bwmul',bwmul      Bandwidth of the filters relative to the bandwidth
                             returned by AUDFILTBW. Default value is bwmul=1 for 
                             the scales 'erb', 'erb83' and 'bark'; the default is 
                             b=100 for 'mel' and 'mel1000'.
     
          'redmul',redmul    Redundancy multiplier. Increasing the value of this
                             will make the system more redundant by lowering the
                             channel downsampling rates. Default
                             value is 1. If the value is less than one, the
                             system may no longer be painless.
      
          'redtar',redtar    Target redundancy. The downsampling factors will be
                             adjusted to achieve a redundancy as close as possible
                             to 'redtar'.
     
          'M',M              Specify the total number of filters between fmin and 
                             fmax. If this parameter is specified, it overwrites the
                             'spacing' parameter.
     
          'symmetric'        Create filters that are symmetric around their centre
                             frequency. This is the default.
     
          'warped'           Create asymmetric filters that are symmetric on the
                             auditory scale. 
     
          'complex'          Construct a filterbank that covers the entire
                             frequency range instead of just the positive 
                             frequencies this allows the analysis of complex
                             valued signals.
     
          'nosubprec'        Disable subsample window positions.
     
          'trunc_at'         When using a prototype defined in FREQWIN, a hard 
                             thresholding of the filters at the specified threshold 
                             value is performed to reduce their support size. 
                             The default value is trunc_at=10e-5. When no 
                             truncation is desired, trunc_at=0 should be chosen.
                             This value is ignored when a prototype shape from
                             FIRWIN was chosen.
     
          'min_win',min_win  Minimum admissible window length (in samples).
                             Default is 4. This restrict the windows not
                             to become too narrow when L is low.
     
        Examples:
        ---------
     
        In the first example, we construct a highly redudant uniform
        filterbank on the ERB scale and visualize the result:
     
          [f,fs]=greasy;  % Get the test signal
          [g,a,fc,L]=audfilters(fs,length(f),'uniform','M',100);
          c=filterbank(f,g,a);
          plotfilterbank(c,a,fc,fs,90,'audtick');
     
        In the second example, we construct a non-uniform filterbank with
        fractional sampling that works for this particular signal length, and
        test the reconstruction. The plot displays the response of the
        filterbank to verify that the filters are well-behaved both on a
        normal and an ERB-scale. The second plot shows frequency responses of
        filters used for analysis (top) and synthesis (bottom). :
     
          [f,fs]=greasy;  % Get the test signal
          L=length(f);
          [g,a,fc]=audfilters(fs,L,'fractional');
          c=filterbank(f,{'realdual',g},a);
          r=2*real(ifilterbank(c,g,a));
          norm(f-r)
     
          % Plot the response
          figure(1);
          subplot(2,1,1);
          R=filterbankresponse(g,a,L,fs,'real','plot');
     
          subplot(2,1,2);
          semiaudplot(linspace(0,fs/2,L/2+1),R(1:L/2+1));
          ylabel('Magnitude');
     
          % Plot frequency responses of individual filters
          gd=filterbankrealdual(g,a,L);
          figure(2);
          subplot(2,1,1);
          filterbankfreqz(gd,a,L,fs,'plot','linabs','posfreq');
     
          subplot(2,1,2);
          filterbankfreqz(g,a,L,fs,'plot','linabs','posfreq');
     
     
     
        References:
          T. Necciari, P. Balazs, N. Holighaus, and P. L. Soendergaard. The ERBlet
          transform: An auditory-based time-frequency representation with perfect
          reconstruction. In Proceedings of the 38th International Conference on
          Acoustics, Speech, and Signal Processing (ICASSP 2013), pages 498--502,
          Vancouver, Canada, May 2013. IEEE.
          
          T. Necciari, N. Holighaus, P. Balazs, Z. Průša, P. Majdak, and
          O. Derrien. Audlet filter banks: A versatile analysis/synthesis
          framework using auditory frequency scales. Applied Sciences, 8(1),
          2018. [1]http ]
          
          References
          
          1. http://www.mdpi.com/2076-3417/8/1/96
          
     *Url*: <http://ltfat.github.io/doc/filterbank/audfilters.html>

     See also: filterbank, ufilterbank, ifilterbank, ceil23.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
AUDFILTERS Generates filters equidistantly spaced on auditory frequency scale...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1358
 -- Function: cent_freqs
     CENT_FREQS   Determine relative center frequencies
        Usage:  cfreq = cent_freqs(g);
                cfreq = cent_freqs(g,L);
                cfreq = cent_freqs(fs,fc);
                cfreq = cent_freqs(g,fc);
     
        Input parameters:
           g     : Set of filters.
           L     : Signal length.
           fs    : Sampling rate (in Hz).
           fc    : Vector of center frequencies (in Hz).
        Output parameters:
           cfreq : Vector of relative center frequencies in ]-1,1].
     
        CENT_FREQS(g) will compute the center frequencies of the filters 
        contained in g by determining their circular center of gravity. To
        that purpose, the transfer function of each filter will be computed for
        a default signal length on 10000 samples. For improved accuracy, the 
        factual signal length L can be supplied as an optional parameter.
        Alternatively, the center frequencies can be obtained from a set of
        center frequencies fc (in Hz) and the sampling rate fs. The
        sampling rate can also be determined from the field fs of the filter
        set g.
     
        Note: If g.H contains full-length, numeric transfer functions, L*
        must be specified for correct results.
     *Url*: <http://ltfat.github.io/doc/filterbank/cent_freqs.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
CENT_FREQS   Determine relative center frequencies
   Usage:  cfreq = cent_fr...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7382
 -- Function: cqtfilters
     CQTFILTERS   CQT-spaced filters
        Usage:  [g,a,fc]=cqtfilters(fs,fmin,fmax,bins,Ls,varargin);
               
     
        Input parameters:
           fs    : Sampling rate (in Hz).
           fmin  : Minimum frequency (in Hz)
           fmax  : Maximum frequency (in Hz)
           bins  : Vector or scalar consisting of the number of bins per octave.
           Ls    : Signal length.
        Output parameters:
           g     : Cell array of filters.
           a     : Downsampling rate for each channel.
           fc    : Center frequency of each channel (in Hz).
           L     : Next admissible length suitable for the generated filters.
     
        [g,a,fc]=CQTFILTERS(fs,fmin,fmax,bins,Ls) constructs a set of
        band-limited filters g which cover the required frequency range
        fmin-fmax with bins filters per octave starting at fmin. All
        filters have (approximately) equal Q=f_c/f_b, hence constant-Q. The
        remaining frequency intervals not covered by these filters are captured
        by two additional filters (low-pass, high-pass). The signal length Ls*
        is mandatory, since we need to avoid too narrow frequency windows.
     
        By default, a Hann window on the frequency side is chosen, but the
        window can be changed by passing any of the window types from
        FIRWIN as an optional parameter.
        Run getfield(getfield(arg_firwin,'flags'),'wintype') to get a cell
        array of window types available.
     
        Because the downsampling rates of the channels must all divide the
        signal length, FILTERBANK will only work for multiples of the
        least common multiple of the downsampling rates. See the help of
        FILTERBANKLENGTH.
     
        [g,a]=CQTFILTERS(...,'regsampling') constructs a non-uniform
        filter bank. The downsampling rates are constant in the octaves but
        can differ among octaves. This approach was chosen in order to minimize
        the least common multiple of a, which determines a granularity of
        admissible input signal lengths.
     
        [g,a]=CQTFILTERS(...,'uniform') constructs a uniform filter bank
        where the downsampling rate is the same for all the channels. This
        results in the most redundant representation, which produces nice plots.
     
        [g,a]=CQTFILTERS(...,'fractional') constructs a filter bank with
        fractional downsampling rates a. The rates are constructed such
        that the filter bank can handle signal lengths that are multiples of
        L, so the benefit of the fractional downsampling is that you get to
        choose the value returned by FILTERBANKLENGTH. This results in the
        least redundant system.
     
        [g,a]=CQTFILTERS(...,'fractionaluniform') constructs a filter bank with
        fractional downsampling rates a, which are uniform for all filters
        except the "filling" low-pass and high-pass filters can have different
        fractional downsampling rates. This is useful when uniform subsampling
        and low redundancy at the same time are desirable.
     
        The filters are intended to work with signals with a sampling rate of
        fs.
     
        CQTFILTERS accepts the following optional parameters:
     
          'Qvar',Qvar           Bandwidth scaling factor. Inversely proportional
                                to Q as it multiplies the calculated bandwidth
                                (which divides Q). The default value is 1.
                                If the value is larger than one, the
                                system may no longer be painless.
     
          'nosubprec'           Disable subsample window positions.
     
          'complex'             Construct a filter bank that covers the entire
                                frequency range. When missing, only positive
                                frequencies are covered.
     
          'min_win',min_win     Minimum admissible window length (in samples).
                                Default is 4. This restrict the windows not
                                to become too narrow when L is low. This
                                however brakes the constant-Q property for such
                                windows and creates rippling in the overall
                                frequency response.
     
          'redmul',redmul       Redundancy multiplier. Increasing the value of
                                this will make the system more redundant by
                                lowering the channel downsampling rates. Default
                                value is 1. If the value is less than one,
                                the system may no longer be painless.
     
        Examples:
        ---------
     
        In the first example, we construct a highly redundant uniform
        filter bank and visualize the result:
     
          [f,fs]=greasy;  % Get the test signal
          [g,a,fc]=cqtfilters(fs,100,fs,32,length(f),'uniform');
          c=filterbank(f,g,a);
          plotfilterbank(c,a,fc,fs,90,'audtick');
     
        In the second example, we construct a non-uniform filter bank with
        fractional sampling that works for this particular signal length, and
        test the reconstruction. The plot displays the response of the
        filter bank to verify that the filters are well-behaved both on a
        normal and an log scale. The second plot shows frequency responses of
        filters used for analysis (top) and synthesis (bottom). :
     
          [f,fs]=greasy;  % Get the test signal
          L=length(f);
          [g,a,fc]=cqtfilters(fs,100,fs,8,L,'fractional');
          c=filterbank(f,{'realdual',g},a);
          r=2*real(ifilterbank(c,g,a));
          norm(f-r)
     
          % Plot the response
          figure(1);
          subplot(2,1,1);
          R=filterbankresponse(g,a,L,fs,'real','plot');
     
          subplot(2,1,2);
          semiaudplot(linspace(0,fs/2,L/2+1),R(1:L/2+1));
          ylabel('Magnitude');
     
          % Plot frequency responses of individual filters
          gd=filterbankrealdual(g,a,L);
          figure(2);
          subplot(2,1,1);
          filterbankfreqz(gd,a,L,fs,'plot','linabs','posfreq');
     
          subplot(2,1,2);
          filterbankfreqz(g,a,L,fs,'plot','linabs','posfreq');
     
     
        References:
          N. Holighaus, M. Doerfler, G. A. Velasco, and T. Grill. A framework for
          invertible, real-time constant-Q transforms. IEEE Transactions on
          Audio, Speech and Language Processing, 21(4):775 --785, 2013.
          
          G. A. Velasco, N. Holighaus, M. Doerfler, and T. Grill. Constructing an
          invertible constant-Q transform with non-stationary Gabor frames.
          Proceedings of DAFX11, 2011.
          
          C. Schoerkhuber, A. Klapuri, N. Holighaus, and M. Doerfler. A Matlab
          Toolbox for Efficient Perfect Reconstruction Time-Frequency Transforms
          with Log-Frequency Resolution. In Audio Engineering Society Conference:
          53rd International Conference: Semantic Audio. Audio Engineering
          Society, 2014.
          
     *Url*: <http://ltfat.github.io/doc/filterbank/cqtfilters.html>

     See also: erbfilters, cqt, firwin, filterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
CQTFILTERS   CQT-spaced filters
   Usage:  [g,a,fc]=cqtfilters(fs,fmin,fmax,b...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 210
 -- Function: economize_filters
      Compute 'econ' or 'asfreqfilter' type filter output from full length
      numerical filters
     *Url*:
     <http://ltfat.github.io/doc/filterbank/economize_filters.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 Compute 'econ' or 'asfreqfilter' type filter output from full length
 numeri...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3159
 -- Function: erbfilters
     ERBFILTERS   ERB-spaced filters
        Usage:  [g,a,fc,L]=erbfilters(fs,Ls);
                [g,a,fc,L]=erbfilters(fs,Ls,...);
     
        Input parameters:
           fs    : Sampling rate (in Hz).
           Ls    : Signal length.
        Output parameters:
           g     : Cell array of filters.
           a     : Downsampling rate for each channel.
           fc    : Center frequency of each channel.
           L     : Next admissible length suitable for the generated filters.
     
        [g,a,fc]=ERBFILTERS(fs,Ls) constructs a set of filters g that are
        equidistantly spaced on the ERB-scale (see FREQTOERB) with bandwidths
        that are proportional to the width of the auditory filters
        AUDFILTBW. The filters are intended to work with signals with a
        sampling rate of fs.
     
        Note that this function just forwards the arguments to AUDFILTERS.
        Please see the help of AUDFILTERS for more details.
     
        Examples:
        ---------
     
        In the first example, we construct a highly redudant uniform
        filterbank and visualize the result:
     
          [f,fs]=greasy;  % Get the test signal
          [g,a,fc]=erbfilters(fs,length(f),'uniform','M',100);
          c=filterbank(f,g,a);
          plotfilterbank(c,a,fc,fs,90,'audtick');
     
        In the second example, we construct a non-uniform filterbank with
        fractional sampling that works for this particular signal length, and
        test the reconstruction. The plot displays the response of the
        filterbank to verify that the filters are well-behaved both on a
        normal and an ERB-scale. The second plot shows frequency responses of
        filters used for analysis (top) and synthesis (bottom). :
     
          [f,fs]=greasy;  % Get the test signal
          L=length(f);
          [g,a,fc]=erbfilters(fs,L,'fractional');
          c=filterbank(f,{'realdual',g},a);
          r=2*real(ifilterbank(c,g,a));
          norm(f-r)
     
          % Plot the response
          figure(1);
          subplot(2,1,1);
          R=filterbankresponse(g,a,L,fs,'real','plot');
     
          subplot(2,1,2);
          semiaudplot(linspace(0,fs/2,L/2+1),R(1:L/2+1));
          ylabel('Magnitude');
     
          % Plot frequency responses of individual filters
          gd=filterbankrealdual(g,a,L);
          figure(2);
          subplot(2,1,1);
          filterbankfreqz(gd,a,L,fs,'plot','linabs','posfreq');
     
          subplot(2,1,2);
          filterbankfreqz(g,a,L,fs,'plot','linabs','posfreq');
     
     
     
        References:
          T. Necciari, P. Balazs, N. Holighaus, and P. L. Soendergaard. The ERBlet
          transform: An auditory-based time-frequency representation with perfect
          reconstruction. In Proceedings of the 38th International Conference on
          Acoustics, Speech, and Signal Processing (ICASSP 2013), pages 498--502,
          Vancouver, Canada, May 2013. IEEE.
          
     *Url*: <http://ltfat.github.io/doc/filterbank/erbfilters.html>

     See also: audfilters, filterbank, ufilterbank, ifilterbank, ceil23.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
ERBFILTERS   ERB-spaced filters
   Usage:  [g,a,fc,L]=erbfilters(fs,Ls);
    ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1536
 -- Function: filterbank
     FILTERBANK   Apply filterbank
        Usage:  c=filterbank(f,g,a);
     
        FILTERBANK(f,g,a) applies the filters given in g to the signal
        f. Each subband will be subsampled by a factor of a (the
        hop-size). In contrast to UFILTERBANK, a can be a vector so the
        hop-size can be channel-dependant. If f is a matrix, the
        transformation is applied to each column.
     
        The filters g must be a cell-array, where each entry in the cell
        array corresponds to an FIR filter.
     
        The output coefficients are stored a cell array. More precisely, the
        n'th cell of c, c{m}, is a 2D matrix of size M(n) xW and
        containing the output from the m'th channel subsampled at a rate of
        a(m).  c{m}(n,l) is thus the value of the coefficient for time index
        n, frequency index m and signal channel l.
     
        The coefficients c computed from the signal f and the filterbank
        with windows g_m are defined by
     
                      L-1
           c_m(n+1) = sum f(l+1) * g_m (a(m)n-l+1)
                      l=0
     
        where an-l is computed modulo L.
     
     
        References:
          H. Boelcskei, F. Hlawatsch, and H. G. Feichtinger. Frame-theoretic
          analysis of oversampled filter banks. Signal Processing, IEEE
          Transactions on, 46(12):3256--3268, 2002.
          
     *Url*: <http://ltfat.github.io/doc/filterbank/filterbank.html>

     See also: ufilterbank, ifilterbank, pfilt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
FILTERBANK   Apply filterbank
   Usage:  c=filterbank(f,g,a);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 954
 -- Function: filterbankbounds
     FILTERBANKBOUNDS  Frame bounds of a filterbank
        Usage: fcond=filterbankbounds(g,a,L);
               [A,B]=filterbankbounds(g,a,L);
               [...]=filterbankbounds(g,a);
     
        FILTERBANKBOUNDS(g,a,L) calculates the ratio B/A of the frame bounds
        of the filterbank specified by g and a for a system of length
        L. The ratio is a measure of the stability of the system.
     
        FILTERBANKBOUNDS(g,a) does the same, but the filters must be FIR
        filters, as the transform length is unspecified. L will be set to 
        next suitable length equal or bigger than the longest impulse response
        such that L=filterbanklength(gl_longest,a).
     
        [A,B]=FILTERBANKBOUNDS(...) returns the lower and upper frame bounds
        explicitly.
     
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbankbounds.html>

     See also: filterbank, filterbankdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKBOUNDS  Frame bounds of a filterbank
   Usage: fcond=filterbankboun...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
filterbankconstphase


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5843
 -- Function: filterbankconstphase
     FILTERBANKCONSTPHASE Construct phase from FILTERBANK or UFILTERBANK magnitude 
        Usage:  c=filterbankconstphase(s,a,fc,tfr);
                c=filterbankconstphase(c,a,fc,tfr,mask);
                c=filterbankconstphase(s,a,fc,tfr,mask,usephase);
                c=filterbankconstphase(s,a,fc,{tgrad,fgrad},...);
                [c,newphase,usedmask,tgrad,fgrad] = filterbankconstphase(...);
     
        Input parameters:
              s        : Initial coefficients.
              a        : Downsampling factor(s).
              fc       : Center frequencies (normalized to the Nyquist rate)
              tfr      : ERB of the filters (normalized to the Nyquist rate)
              mask     : Mask for selecting known phase.
              usephase : Explicit known phase.
        Output parameters:
              c        : Coefficients with the constructed phase.
              newphase : Just the (unwrapped) phase.
              usedmask : Mask for selecting coefficients with the new phase.
              tgrad    : Relative time phase derivative.
              fgrad    : Relative frequency phase derivative.
     
        FILTERBANKCONSTPHASE(s,a,tfr,fc) will construct a suitable phase for 
        the positive valued coefficients s. 
     
        If s is the absolute value of filterbank coefficients comming from
        a filterbank with filters with center frequencies fc and time-frequency
        ratios tfr and subsampling factors a i.e.:
     
            [g,a,~,~,info] = ...filters(...);
            c = filterbank(f,g,a);
            s = abs(c);
     
        then FILTERBANKCONSTPHASE(s,a,info.fc,info.tfr) will attempt to 
        reconstruct c.
     
        FILTERBANKCONSTPHASE(c,a,fc,tfr,mask) accepts real or complex valued
        c and real valued mask of the same size. Values in mask which can
        be converted to logical true (anything other than 0) determine
        coefficients with known phase which is used in the output. Only the
        phase of remaining coefficients (for which mask==0) is computed.
     
        FILTERBANKCONSTPHASE(c,a,fc,tfr,mask,usephase) does the same as before
        but uses the known phase values from usephase rather than from c.
     
        FILTERBANKCONSTPHASE(s,a,fc,{tgrad,fgrad},...) accepts the phase 
        gradient {tgrad,fgrad} explicitly instead of computing it from
        the magnitude using tfr and the phase-magnitude relationship.
        This is directly compatible with FILTERBANKPHASEGRAD.
     
        Addition parameters
        -------------------
     
        The function accepts the following additional paramaters:
     
        'tol',tol 
                The phase is computed only for coefficients above tol. The
                rest is set to random values.
                In addition, tol can be a vector containing decreasing values. 
                In that case, the algorithm is run numel(tol) times, 
                initialized with the result from the previous step in the 2nd 
                and the further steps. 
                The default value is tol=[1e-1, 1e-10].
     
        'real' (default) or 'complex'
                By default, the coefficients are expected to come from a real
                filterbank i.e. the filters cover only the positive
                frequencies. For filterbanks which cover the whole frequency
                range, pass 'complex' instead.
     
        'naturalscaling' (default) or 'peakscaling' or 'custscaling',scal
                Relative scaling of the filter frequency responses. 
                'naturalscaling' deduces the scaling of the filters from the
                subsampling factors a. 
                'peakscaling' assumes all frequency responses were notmalized 
                to have peaks of equal height.
                'custscaling',scal allows passing a custom scaling vector scal. 
     
        'gabor' (default) or 'wavelet'
                Version of the phase-magnitude relationship to be used. In
                contrast to 'gabor', the 'wavelet' option does not contain the
                term involving the derivative of sqrt(tfr). 
                See the references for more details.
                
        This function requires a computational subroutine that is only
        available in C. Use LTFATMEX to compile it.
     
        Example
        -------
     
        We construct a constant-Q filterbank with fractional downsampling and a reasonably high redundancy.
        Then, we apply filterbankconstphase on the absolute values of the resulting coefficients to test the
        reconstruction accuracy of filterbankconstphase.
     
         [f,fs] = gspi;
         [g,a,fc,L,info]=cqtfilters(fs,100,fs/2 - 100,48,numel(f),'fractional', 'redmul', 8, 'Qvar',4,'subprec');
         corig = filterbank(f,g,a);
     
         c=filterbankconstphase(cellfun(@abs,corig,'UniformOutput',0),a,info.fc,info.tfr,'tol',1e-10);
         cproj = filterbank(ifilterbankiter(c,g,a,'pcg','tol',1e-6),g,a);
         Cdb = 20*log10( norm(abs(cell2mat(corig)) - abs(cell2mat(cproj)) )/norm( abs(cell2mat(corig))) );
           
     
            
     
     
     
        References:
          N. Holighaus, G. Koliander, and Z. Průša. On the derivatives of the
          continuous wavelet transform - with application to phaseless
          reconstruction. Submitted., 2018.
          
          Z. Průša and N. Holighaus. Non-iterative filter bank phase
          (re)construction. In Proc. 25th European Signal Processing Conference
          (EUSIPCO--2017), pages 952--956, Aug 2017.
          
     
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbankconstphase.html>

     See also: ltfatmex, filterbank, ufilterbank, audfilters,
     cqtfilters, gabfilters.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKCONSTPHASE Construct phase from FILTERBANK or UFILTERBANK magnitude...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1515
 -- Function: filterbankdual
     FILTERBANKDUAL  Dual filters
        Usage:  gd=filterbankdual(g,a,L);
                gd=filterbankdual(g,a);           
     
        FILTERBANKDUAL(g,a,L) computes the canonical dual filters of g for a
        channel subsampling rate of a (hop-size) and system length L.
        L must be compatible with subsampling rate a as 
        L==filterbanklength(L,a). This will create a dual frame valid for 
        signals of length L. 
     
        filterabankrealdual(g,a) does the same, but the filters must be FIR
        filters, as the transform length is unspecified. L will be set to 
        next suitable length equal or bigger than the longest impulse response
        such that L=filterbanklength(gl_longest,a).
     
        The input and output format of the filters g are described in the
        help of FILTERBANK.
     
        In addition, the funtion recognizes a 'forcepainless' flag which
        forces treating the filterbank g and a as a painless case
        filterbank.  
     
        To actually invert the output of a filterbank, use the dual filters
        together with the IFILTERBANK function.
     
        REMARK: In general, perfect reconstruction can be obtained for signals 
        of length L. In some cases, using dual system calculated for shorter
        L might work but check the reconstruction error.
     
     *Url*: <http://ltfat.github.io/doc/filterbank/filterbankdual.html>

     See also: filterbank, ufilterbank, ifilterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKDUAL  Dual filters
   Usage:  gd=filterbankdual(g,a,L);
           ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 582
 -- Function: filterbankfreqz
     FILTERBANKFREQZ  Filterbank frequency responses
        Usage: gf = filterbankfreqz(g,a,L)
     
        gf = FILTERBANKFREQZ(g,a,L) calculates length L frequency responses
        of filters in g and returns them as columns of gf.
     
        If an optional parameters 'plot' is passed to FILTERBANKFREQZ,
        the frequency responses will be plotted using PLOTFFT. Any
        optional parameter undestood by PLOTFFT can be passed in addition
        to 'plot'.
     
     *Url*: <http://ltfat.github.io/doc/filterbank/filterbankfreqz.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKFREQZ  Filterbank frequency responses
   Usage: gf = filterbankfreq...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 655
 -- Function: filterbanklength
     FILTERBANKLENGTH  Filterbank length from signal
        Usage: L=filterbanklength(Ls,a);
     
        FILTERBANKLENGTH(Ls,a) returns the length of a filterbank with
        time shifts a, such that it is long enough to expand a signal of
        length Ls.
     
        If the filterbank length is longer than the signal length, the signal
        will be zero-padded by FILTERBANK or UFILTERBANK.
     
        If instead a set of coefficients are given, call FILTERBANKLENGTHCOEF.
     
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbanklength.html>

     See also: filterbank, filterbanklengthcoef.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKLENGTH  Filterbank length from signal
   Usage: L=filterbanklength(...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
filterbanklengthcoef


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 533
 -- Function: filterbanklengthcoef
     FILTERBANKLENGTHCOEF  Filterbank length from coefficients
        Usage: L=filterbanklengthcoef(coef,a);
     
        FILTERBANKLENGTHCOEF(coef,a) returns the length of a filterbank with
        time-shifts a, such that the filterbank is long enough to expand the
        coefficients coef.
     
        If instead a signal is given, call FILTERBANKLENGTH.
     
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbanklengthcoef.html>

     See also: filterbank, filterbanklength.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKLENGTHCOEF  Filterbank length from coefficients
   Usage: L=filterb...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2624
 -- Function: filterbankphasegrad
     FILTERBANKPHASEGRAD   Phase gradient of a filterbank representation
        Usage:  [tgrad,fgrad,s,c] = filterbankphasegrad(f,g,a,L,minlvl);
                [tgrad,fgrad,s,c] = filterbankphasegrad(f,g,a,L);
                [tgrad,fgrad,s,c] = filterbankphasegrad(f,g,a,minlvl);
                [tgrad,fgrad,s,c] = filterbankphasegrad(f,g,a);
                [tgrad,fgrad,s] = filterbankphasegrad(...)
                [tgrad,fgrad]  = filterbankphasegrad(...)
      
        Input parameters:
           f     : Signal to be analyzed.
           g     : Cell array of filters
           a     : Vector of time steps.
           L     : Signal length (optional).
           minlvl: Regularization parameter (optional, required < 1).
        Output parameters:
           tgrad : Instantaneous frequency relative to original position.
           fgrad : The negative of the local group delay. 
           cs    : Filterbank spectrogram.
           c     : Filterbank coefficients.
     
        [tgrad,fgrad,s,c] = FILTERBANKPHASEGRAD(f,g,a,L) computes the 
        relative instantaneous frequency tgrad and the negative of the group
        delay fgrad of the filterbank spectrogram s obtained from the 
        signal f and filterbank parameters g and a. 
        Both tgrad and fgrad are specified relative to the original 
        coefficient position entirely similar to GABPHASEGRAD.
        fgrad is given in samples, while tgrad is given in normalised
        frequencies such that the absolute frequencies are in the range of ]-1,1]. 
     
        This routine uses the equivalence of the filterbank coefficients in 
        each channel with coefficients obtained from an STFT obtained with a
        certain window (possibly different for every channel). As a consequence
        of this equivalence, the formulas derived in the reference apply. 
     
     
        References:
          F. Auger and P. Flandrin. Improving the readability of time-frequency
          and time-scale representations by the reassignment method. IEEE Trans.
          Signal Process., 43(5):1068--1089, 1995.
          
          N. Holighaus, Z. Průša, and P. L. Soendergaard. Reassignment and
          synchrosqueezing for general time-frequency filter banks, subsampling
          and processing. Signal Processing, 125:1--8, 2016. [1]http ]
          
          References
          
          1. http://www.sciencedirect.com/science/article/pii/S0165168416000141
          
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbankphasegrad.html>

     See also: gabphasegrad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKPHASEGRAD   Phase gradient of a filterbank representation
   Usage:...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
filterbankrealbounds


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1134
 -- Function: filterbankrealbounds
     FILTERBANKREALBOUNDS  Frame bounds of filter bank for real signals only
        Usage: fcond=filterbankrealbounds(g,a,L);
               [A,B]=filterbankrealbounds(g,a,L);
               [...]=filterbankrealbounds(g,a);
     
        FILTERBANKREALBOUNDS(g,a,L) calculates the ratio B/A of the frame
        bounds of the filterbank specified by g and a for a system of length
        L. The ratio is a measure of the stability of the system.  Use this
        function on the common construction where the filters in g only covers
        the positive frequencies.
     
        FILTERBANKREALBOUNDS(g,a) does the same, but the filters must be FIR
        filters, as the transform length is unspecified. L will be set to 
        next suitable length equal or bigger than the longest impulse response
        such that L=filterbanklength(gl_longest,a).
     
        [A,B]=FILTERBANKREALBOUNDS(g,a) returns the lower and upper frame
        bounds explicitly.
     
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbankrealbounds.html>

     See also: filterbank, filterbankdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKREALBOUNDS  Frame bounds of filter bank for real signals only
   Us...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
filterbankrealdual


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1588
 -- Function: filterbankrealdual
     FILTERBANKREALDUAL  Dual filters of filterbank for real signals only 
        Usage:  gd=filterbankrealdual(g,a,L);
                gd=filterbankrealdual(g,a);
     
        FILTERBANKREALDUAL(g,a,L) computes the canonical dual filters of g*
        for a channel subsampling rate of a (hop-size) and a system length L.
        L must be compatible with subsampling rate a as 
        L==filterbanklength(L,a). The dual filters work only for real-valued
        signals. Use this function on the common construction where the filters
        in g only covers the positive frequencies.
     
        filterabankrealdual(g,a) does the same, but the filters must be FIR
        filters, as the transform length is unspecified. L will be set to 
        next suitable length equal or bigger than the longest impulse response.
     
        The format of the filters g are described in the help of FILTERBANK.
     
        In addition, the function recognizes a 'forcepainless' flag which
        forces treating the filterbank g and a as a painless case
        filterbank.  
     
        To actually invert the output of a filterbank, use the dual filters
        together with 2*real(ifilterbank(...)).
     
        REMARK: Perfect reconstruction can be obtained for signals of length
        L. In some cases, using dual system calculated for shorter L might
        work but check the reconstruction error.
     
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbankrealdual.html>

     See also: filterbank, ufilterbank, ifilterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKREALDUAL  Dual filters of filterbank for real signals only 
   Usag...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1454
 -- Function: filterbankrealtight
     FILTERBANKREALTIGHT  Tight filters of filterbank for real signals only 
        Usage:  gt=filterbankrealtight(g,a,L);
                gt=filterbankrealtight(g,a);
     
        filterabankrealtight(g,a,L) computes the canonical tight filters of 
        g for a channel subsampling rate of a (hop-size) and a system 
        length L. L must be compatible with subsampling rate a as 
        L==filterbanklength(L,a). The tight filters work only for real-valued
        signals. Use this function on the common construction where the filters
        in g only covers the positive frequencies.
     
        filterabankrealtight(g,a) does the same, but the filters must be FIR
        filters, as the transform length is unspecified. L will be set to 
        next suitable length equal or bigger than the longest impulse response.  
     
        The format of the filters g are described in the help of FILTERBANK.
     
        In addition, the function recognizes a 'forcepainless' flag which
        forces treating the filterbank g and a as a painless case
        filterbank.  
     
        REMARK: The resulting system is tight for length L. In some cases, 
        using tight system calculated for shorter L might work but check the
        reconstruction error.
     
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbankrealtight.html>

     See also: filterbank, ufilterbank, ifilterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKREALTIGHT  Tight filters of filterbank for real signals only 
   Us...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
filterbankreassign


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3380
 -- Function: filterbankreassign
     FILTERBANKREASSIGN  Reassign filterbank spectrogram
        Usage:  sr = filterbankreassign(s,tgrad,fgrad,a,cfreq);
                sr = filterbankreassign(s,tgrad,fgrad,a,g);
                [sr,repos,Lc] = filterbankreassign(...);
     
        Input parameters:
           s     : Spectrogram to be reassigned.
           tgrad : Instantaneous frequency relative to original position.
           fgrad : Group delay relative to original position.
           a     : Vector of time steps.
           cfreq : Vector of relative center frequencies in ]-1,1].
           g     : Set of filters.
        Output parameters:
           sr    : Reassigned filterbank spectrogram.
           repos : Reassigned positions.
           Lc    : Subband lengths.
     
        FILTERBANKREASSIGN(s,tgrad,fgrad,a,cfreq) will reassign the values of
        the filterbank spectrogram s using the group delay fgrad and
        instantaneous frequency tgrad. The time-frequency sampling
        pattern is determined from the time steps a and the center
        frequencies cfreq.
     
        FILTERBANKREASSIGN(s,tgrad,fgrad,a,g) will do the same thing except
        the center frequencies are estimated from a set of filters g.
     
        [sr,repos,Lc]=FILTERBANKREASSIGN(...) does the same thing, but in addition
        returns a vector of subband lengths Lc (Lc = cellfun(@numel,s))
        and cell array repos with sum(Lc) elements. Each element corresponds
        to a single coefficient obtained by cell2mat(sr) and it is a vector
        of indices identifying coefficients from cell2mat(s) assigned to
        the particular time-frequency position.
     
        The arguments s, tgrad and fgrad must be cell-arrays of vectors
        of the same lengths. Arguments a and cfreq or g must have the
        same number of elements as the cell arrays with coefficients.
     
        Examples:
        ---------
     
        This example shows how to reassign a ERB filterbank spectrogram:
     
          % Genrate 3 chirps 1 second long
          L = 44100; fs = 44100; l = 0:L-1;
     
          f = sin(2*pi*(l/35+(l/300).^2)) + ...
              sin(2*pi*(l/10+(l/300).^2)) + ...
              sin(2*pi*(l/5-(l/450).^2));
          f = 0.7*f';
     
          % Create ERB filterbank
          [g,a,fc]=erbfilters(fs,L,'fractional','spacing',1/12,'warped');
     
          % Compute phase gradient
          [tgrad,fgrad,cs,c]=filterbankphasegrad(f,g,a);
          % Do the reassignment
          sr=filterbankreassign(cs,tgrad,fgrad,a,cent_freqs(fs,fc));
          figure(1); subplot(211);
          plotfilterbank(cs,a,fc,fs,60);
          title('ERBlet spectrogram of 3 chirps');
          subplot(212);
          plotfilterbank(sr,a,fc,fs,60);
          title('Reassigned ERBlet spectrogram of 3 chirps');
     
     
        References:
          N. Holighaus, Z. Průša, and P. L. Soendergaard. Reassignment and
          synchrosqueezing for general time-frequency filter banks, subsampling
          and processing. Signal Processing, 125:1--8, 2016. [1]http ]
          
          References
          
          1. http://www.sciencedirect.com/science/article/pii/S0165168416000141
          
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbankreassign.html>

     See also: filterbankphasegrad, gabreassign.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKREASSIGN  Reassign filterbank spectrogram
   Usage:  sr = filterban...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
filterbankresponse


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2191
 -- Function: filterbankresponse
     FILTERBANKRESPONSE  Response of filterbank as function of frequency
        Usage:  gf=filterbankresponse(g,a,L);
           
        gf=FILTERBANKRESPONSE(g,a,L) computes the total response in frequency
        of a filterbank specified by g and a for a signal length of
        L. This corresponds to summing up all channels. The output is a
        usefull tool to investigate the behaviour of the windows, as peaks
        indicate that a frequency is overrepresented in the filterbank, while
        a dip indicates that it is not well represented.
     
        CAUTION: This function computes a sum of squares of modulus of the 
        frequency responses, which is  also the diagonal of the Fourier 
        transform of the frame operator.
        Use FILTERBANKFREQZ for evaluation or plotting of frequency responses
        of filters.
     
        FILTERBANKRESPONSE(g,a,L,'real') does the same for a filterbank
        intended for positive-only filterbank.
     
        FILTERBANKRESPONSE(g,a,L,fs) specifies the sampling rate fs. This
        is only used for plotting purposes.
     
        gf=FILTERBANKRESPONSE(g,a,L,'individual') returns responses 
        in frequency of individual filters as columns of a matrix. The total
        response can be obtained by gf = sum(gf,2). 
     
        FILTERBANKRESPONSE takes the following optional parameters:
     
           'fs',fs    
                      Sampling rate, used only for plotting.
     
           'complex'  
                      Assume that the filters cover the entire frequency
                      range. This is the default.
     
           'real'     
                      Assume that the filters only cover the positive
                      frequencies (and is intended to work with real-valued
                      signals only).
     
           'noplot'   
                      Don't plot the response, just return it.
     
           'plot'     
                      Plot the response using PLOTFFTREAL or PLOTFFT.
     
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbankresponse.html>

     See also: filterbank, filterbankbounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKRESPONSE  Response of filterbank as function of frequency
   Usage:...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1547
 -- Function: filterbankscale
     FILTERBANKSCALE Scale filters in filterbank
        Usage:  g=filterbankscale(g,scal)
                g=filterbankscale(g,'flag')
                g=filterbankscale(g,L,'flag')
                [g,scal]=filterbankscale(...)
     
        g=FILTERBANKSCALE(g,scal) scales each filter in g by multiplying it
        with scal. scal can be either scalar or a vector of the same length
        as g. The function only works with filterbanks already instantiated
        (returned from a function with a filter (of filters) suffix or run
        trough FILTERBANKWIN) such that the elements of g must be either structs
        with .h or .H fields or be plain numeric vectors.
     
        g=FILTERBANKSCALE(g,'flag') instead normalizes each filter to have
        unit norm defined by 'flag'. It can be any of the flags recognized by
        SETNORM. The  normalization is done in the time domain by default.
        The normalization can be done in frequency by passing extra flag 'freq'.
     
        g=FILTERBANKSCALE(g,L,'flag') works as before, but some filters require
        knowing L to be instantialized to obtain their norm. The normalization
        will be valid for the lengh L only.
     
        [g,scal]=FILTERBANKSCALE(g,...) additionally returns a vector scal 
        which contains scaling factors used.
     
        In any case, the returned filters will be in exactly the same format as
        the input filters.
     
     *Url*: <http://ltfat.github.io/doc/filterbank/filterbankscale.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKSCALE Scale filters in filterbank
   Usage:  g=filterbankscale(g,sc...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
filterbanksynchrosqueeze


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3360
 -- Function: filterbanksynchrosqueeze
     FILTERBANKSYNCHROSQUEEZE  Synchrosqueeze filterbank spectrogram
        Usage:  cr = filterbanksynchrosqueeze(c,tgrad,cfreq);
                cr = filterbanksynchrosqueeze(c,tgrad,g);
                [cr,repos,Lc] = filterbanksynchrosqueeze(...);
     
        Input parameters:
           c     : Coefficients to be synchrosqueezed.
           tgrad : Instantaneous frequency relative to original position.
           cfreq : Vector of relative center frequencies in ]-1,1].
           g     : Set of filters.
        Output parameters:
           cr    : Synchrosqueezed filterbank coefficients.
           repos : Reassigned positions.
           Lc    : Subband lengths.
     
        FILTERBANKSYNCHROSQUEEZE(c,tgrad,cfreq) will reassign the values of 
        the filterbank coefficients c according to instantaneous frequency
        tgrad. The frequency center frequencies of filters are given by cfreq.
        The filterbank coefficients c are assumed to be obtained from a
        non-subsampled filterbank (a=1).
     
        FILTERBANKSYNCHROSQUEEZE(s,tgrad,g) will do the same thing except
        the center frequencies are estimated from a set of filters g.
     
        [sr,repos,Lc]=FILTERBANKSYNCHROSQUEEZE(...) does the same thing, but 
        in addition returns a vector of subband lengths Lc (Lc = cellfun(@numel,s))
        and cell array repos with sum(Lc) elements. Each element corresponds 
        to a single coefficient obtained by cell2mat(sr) and it is a vector 
        of indices identifying coefficients from cell2mat(s) assigned to 
        the particular time-frequency position.
     
        The arguments s, tgrad must be cell-arrays of vectors
        of the same lengths. Arguments cfreq or g must have the
        same number of elements as the cell arrays with coefficients.
     
        Examples:
        ---------
     
        This example shows how to synchrosqueeze a ERB filterbank spectrogram:
     
          % Genrate 3 chirps half a second long
          L = 22050; fs = 44100; l = 0:L-1;
      
          f = sin(2*pi*(l/35+(l/300).^2)) + ...
              sin(2*pi*(l/10+(l/300).^2)) + ...
              sin(2*pi*(l/5-(l/450).^2));
          f = 0.7*f';
          
          % Create ERB filterbank
          [g,~,fc]=erbfilters(fs,L,'uniform','spacing',1/12,'warped');
          
          % Compute phase gradient
          [tgrad,~,~,c]=filterbankphasegrad(f,g,1);
          % Do the reassignment
          sr=filterbanksynchrosqueeze(c,tgrad,cent_freqs(fs,fc));
          figure(1); subplot(211);
          plotfilterbank(c,1,fc,fs,60);
          title('ERBlet spectrogram of 3 chirps');
          subplot(212);  
          plotfilterbank(sr,1,fc,fs,60);
          title('Synchrosqueezed ERBlet spectrogram of 3 chirps');
     
     
        References:
          N. Holighaus, Z. Průša, and P. L. Soendergaard. Reassignment and
          synchrosqueezing for general time-frequency filter banks, subsampling
          and processing. Signal Processing, 125:1--8, 2016. [1]http ]
          
          References
          
          1. http://www.sciencedirect.com/science/article/pii/S0165168416000141
          
     *Url*:
     <http://ltfat.github.io/doc/filterbank/filterbanksynchrosqueeze.html>

     See also: filterbankphasegrad, gabreassign.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKSYNCHROSQUEEZE  Synchrosqueeze filterbank spectrogram
   Usage:  cr...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1249
 -- Function: filterbanktight
     FILTERBANKTIGHT  Tight filterbank
        Usage:  gt=filterbanktight(g,a,L);
                gt=filterbanktight(g,a);
     
        FILTERBANKTIGHT(g,a,L) computes the canonical tight filters of g 
        for a channel subsampling rate of a (hop-size) and a system length L.
        L must be compatible with subsampling rate a as 
        L==filterbanklength(L,a).
     
        FILTERBANKTIGHT(g,a,L) does the same, but the filters must be FIR
        filters, as the transform length is unspecified. L will be set to 
        next suitable length equal or bigger than the longest impulse response.
     
        The input and output format of the filters g are described in the
        help of FILTERBANK.
     
        In addition, the funtion recognizes a 'forcepainless' flag which
        forces treating the filterbank g and a as a painless case
        filterbank. 
     
        REMARK: The resulting system is tight for length L. In some cases, 
        using tight system calculated for shorter L might work but check the
        reconstruction error. 
     
     *Url*: <http://ltfat.github.io/doc/filterbank/filterbanktight.html>

     See also: filterbank, filterbankdual, ufilterbank, ifilterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKTIGHT  Tight filterbank
   Usage:  gt=filterbanktight(g,a,L);
     ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2535
 -- Function: filterbankwin
     FILTERBANKWIN  Compute set of filter bank windows from text or cell array
        Usage: [g,info] = filterbankwin(g,a,L);
     
        [g,info]=FILTERBANKWIN(g,a,L) computes a window that fits well with
        time shift a and transform length L. The window itself is as a cell
        array containing additional parameters.
     
        The window can be specified directly as a cell array of vectors of
        numerical values. In this case, FILTERBANKWIN only checks assumptions
        about transform sizes etc.
     
        [g,info]=FILTERBANKWIN(g,a) does the same, but the windows must be FIR
        windows, as the transform length is unspecified.
     
        FILTERBANKWIN(...,'normal') computes a window for regular
        filterbanks, while FILTERBANKWIN(...,'real') does the same for the
        positive-frequency only filterbanks.
     
        The window can also be specified as cell array. The possibilities are:
     
          {'dual',...}
              Canonical dual window of whatever follows. See the examples below.
     
          {'realdual',...}
              Canonical dual window for a positive-frequency filterbank
              of whatever follows. See the examples below.
     
          {'tight',...}
              Canonical tight window of whatever follows. See the examples below.
     
          {'realtight',...} 
              Canonical tight window for a real-valued for a positive
              frequency filterbank of whatever follows.
     
        The structure info provides some information about the computed
        window:
     
          info.M              Number of windows (equal to the number of channels)
     
          info.longestfilter  Length of the longest filter
     
          info.gauss          True if the windows are Gaussian.
     
          info.tfr            Time/frequency support ratios of the window. Set whenever it makes sense.
     
          info.isfir          Input is an FIR window
     
          info.isdual         Output is the dual window of the auxiliary window.
     
          info.istight        Output is known to be a tight window.
     
          info.auxinfo        Info about auxiliary window.
        
          info.gl             Length of windows.
     
          info.isfac          True if the frame generated by the window has a fast factorization.
     
     *Url*: <http://ltfat.github.io/doc/filterbank/filterbankwin.html>

     See also: filterbank, filterbankdual, filterbankrealdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKWIN  Compute set of filter bank windows from text or cell array
   ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1812
 -- Function: gabfilters
     GABFILTERS Constructs Gabor filters
        Usage:  [gout,aout,fc,L]=gabfilters(Ls,g,a,M);
     
        Input parameters:
           Ls    : Signal length.
           g     : Window
           a     : Hop factor
           M     : Number of channels
        Output parameters:
           gout  : Cell array of filters.
           aout  : Downsampling rate for each channel.
           fc    : Center frequencies normalized to the Nyquist rate
           L     : Next admissible length suitable for the generated filters. 
     
        GABFILTERS(Ls,g,a,M) constructs a linear frequency Gabor filters
        as modulations of a prototype window g using hop size a and number 
        of channels M. The filterbank is only valid for the system length 
        dgtlength(Ls,a,M). The filterbank acts exactly like DGTREAL 
        (there is M2=floor(M/2)+1 filters) with the 'timeinv' phase 
        convention i.e. the following should be close of zero:
     
            M = 512; a = 128; L = 10*512; g = 'hann';
            f = randn(L,1);
            c1 = dgtreal(f,g,a,M,'timeinv');
            [gfb,afb] = gabfilters(L,g,a,M);
            c2 = ufilterbank(f,gfb,afb);
            norm(c1 - c2.')  
     
        !!!Note!!! that the this function is not suitable for long signals. 
        Using DGTREAL and DGT directly will be much faster.
     
        Additional paramaters
        ---------------------
     
        'real' (default) or 'complex'
            'real' mimics DGTREAL, 'complex' mimics DGT
            
        'time' (default) or 'freq'
            The specified window g is applied either in the time domain 
            or in the frequency domain.
     
     
     *Url*: <http://ltfat.github.io/doc/filterbank/gabfilters.html>

     See also: dgtreal, dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABFILTERS Constructs Gabor filters
   Usage:  [gout,aout,fc,L]=gabfilters(Ls...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1322
 -- Function: ifilterbank
     IFILTERBANK  Filter bank inversion
        Usage:  f=ifilterbank(c,g,a);
     
        IFILTERBANK(c,g,a) synthesizes a signal f from the coefficients c*
        using the filters stored in g for a channel subsampling rate of a (the
        hop-size). The coefficients has to be in the format returned by
        either FILTERBANK or UFILTERBANK.
     
        The filter format for g is the same as for FILTERBANK.
     
        If perfect reconstruction is desired, the filters must be the duals
        of the filters used to generate the coefficients. See the help on
        FILTERBANKDUAL.
     
        Additional parameters
        ---------------------
     
        'complex' (default), 'real'
            The 'real' flag indicates that the filters g cover only the positive
            frequencies and does 2*real(f) to effectivelly mirror the filters to
            cover also the negative frequencies.
            
     
        References:
          H. Boelcskei, F. Hlawatsch, and H. G. Feichtinger. Frame-theoretic
          analysis of oversampled filter banks. Signal Processing, IEEE
          Transactions on, 46(12):3256--3268, 2002.
          
     *Url*: <http://ltfat.github.io/doc/filterbank/ifilterbank.html>

     See also: filterbank, ufilterbank, filterbankdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
IFILTERBANK  Filter bank inversion
   Usage:  f=ifilterbank(c,g,a);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3744
 -- Function: ifilterbankiter
     IFILTERBANKITER  Filter bank iterative inversion
        Usage:  f=ifilterbankiter(c,g,a);
     
        IFILTERBANKITER(c,g,a) iteratively synthesizes a signal f from the
        coefficients c which were obtained using the filters stored in g for
        a channel subsampling rate of a (the hop-size).
     
        The filter bank g and the subsampling rate a must be the same
        as used in FILTERBANK or UFILTERBANK.
     
        This function is useful if there is no way how to explicitly compute
        a dual system using FILTERBANKDUAL or FILTERBANKREALDUAL.
     
        Additional parameters
        ---------------------
     
        The function calls FRSYNITER and passes all the optional arguments to it.
        Please refer to help of FRSYNITER for further details.
     
        Please note that by default, the function expects filterbank g*
        to be created for real signals i.e. g cover only the positive frequencies.
        Additional flag 'complex' is required if the filterbank is defined for 
        positive and negative frequencies.
     
        Examples:
        ---------
     
        The following example compares convergence rates of CG and PCG for a
        filterbank which forms a frame, but it is neither uniform or painless:
     
            [f,fs] = greasy; L = size(f,1);
            [g,a,fc]=erbfilters(fs,L,'fractional','bwmul',0.6,'redmul',4/5,'complex');
            filterbankfreqz(g,a,L,'plot','linabs');
            % Filterbankdual does not work
            try
                gd=filterbankdual(g,a,L);
            catch
                disp('FILTERBANKDUAL exited with error.');
            end
     
            c = filterbank(f,g,a);
            [fpcg,~,iterpcg] = ifilterbankiter(c,g,a,'complex','pcg');
            [fcg,~,itercg] = ifilterbankiter(c,g,a,'complex','cg');
     
            fprintf('CG achieved error %e in %d iterations.n',norm(f-fcg), itercg);
            fprintf('PCG achieved error %e in %d iterations.n',norm(f-fpcg), iterpcg);
     
        Similar example with real filterbank:
     
            [f,fs] = greasy; L = size(f,1);
            [g,a,fc]=erbfilters(fs,L,'fractional','bwmul',0.6,'redmul',4/5);
            filterbankfreqz(g,a,L,'plot','linabs');
            % Filterbankrealdual does not work
            try
                gd=filterbankrealdual(g,a,L);
            catch
                disp('FILTERBANKREALDUAL exited with error.');
            end
     
            c = filterbank(f,g,a);
            [fpcg,~,iterpcg] = ifilterbankiter(c,g,a,'pcg');
            [fcg,~,itercg] = ifilterbankiter(c,g,a,'cg');
     
            fprintf('CG achieved error %e in %d iterations.n',norm(f-fcg), itercg);
            fprintf('PCG achieved error %e in %d iterations.n',norm(f-fpcg), iterpcg);
     
     
        References:
          T. Necciari, P. Balazs, N. Holighaus, and P. L. Soendergaard. The ERBlet
          transform: An auditory-based time-frequency representation with perfect
          reconstruction. In Proceedings of the 38th International Conference on
          Acoustics, Speech, and Signal Processing (ICASSP 2013), pages 498--502,
          Vancouver, Canada, May 2013. IEEE.
          
          T. Necciari, N. Holighaus, P. Balazs, Z. Průša, P. Majdak, and
          O. Derrien. Audlet filter banks: A versatile analysis/synthesis
          framework using auditory frequency scales. Applied Sciences, 8(1),
          2018. [1]http ]
          
          References
          
          1. http://www.mdpi.com/2076-3417/8/1/96
          
     *Url*: <http://ltfat.github.io/doc/filterbank/ifilterbankiter.html>

     See also: filterbank, ufilterbank, ifilterbank, filterbankdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IFILTERBANKITER  Filter bank iterative inversion
   Usage:  f=ifilterbankiter...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1134
 -- Function: nonu2ucfmt
     NONU2UCFMT Non-uniform to uniform filterbank coefficient format
        Usage:  cu=nonu2ucfmt(c,pk)
     
        Input parameters:
              c   : Non-uniform filterbank coefficients.
     
        Output parameters:
              cu  : Uniform filterbank coefficients.
              p   : Numbers of copies of each filter.
     
        cu = NONU2UCFMT(c,p) changes the coefficient format from
        non-uniform filterbank coefficients c (M=numel(p) channels) to
        uniform coefficients c (sum(p) channels)  such that each
        channel of cu consinst of de-interleaved samples of channels of c.
     
        The output cu is a cell-array in any case.
     
     
        References:
          S. Akkarakaran and P. Vaidyanathan. Nonuniform filter banks: New
          results and open problems. In P. M. C.K. Chui and L. Wuytack, editors,
          Studies in Computational Mathematics: Beyond Wavelets, volume 10, pages
          259 --301. Elsevier B.V., 2003.
          
     *Url*: <http://ltfat.github.io/doc/filterbank/nonu2ucfmt.html>

     See also: nonu2ufilterbank, u2nonucfmt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
NONU2UCFMT Non-uniform to uniform filterbank coefficient format
   Usage:  cu...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1764
 -- Function: nonu2ufilterbank
     NONU2UFILTERBANK   Non-uniform to uniform filterbank transform
        Usage:  [gu,au]=nonu2ufilterbank(g,a)
     
        Input parameters:
              g     : Filters as a cell array of structs.
              a     : Subsampling factors.
     
        Output parameters:
              gu    : Filters as a cell array of structs.
              au    : Uniform subsampling factor.
              pk    : Numbers of copies of each filter.
     
        [gu,au]=NONU2UFILTERBANK(g,a) calculates uniform filterbank gu, 
        au=lcm(a) which is identical to the (possibly non-uniform) filterbank
        g, a in terms of the equal output coefficients. Each filter g{k} 
        is replaced by p(k)=au/a(k) advanced versions of itself such that
        z^{ma(k)}G_k(z) for m=0,...,p-1.
     
        This allows using the factorisation algorithm when determining
        filterbank frame bounds in FILTERBANKBOUNDS and
        FILTERBANKREALBOUNDS and in the computation of the dual filterbank 
        in FILTERBANKDUAL and FILTERBANKREALDUAL which do not work 
        with non-uniform filterbanks.
     
        One can change between the coefficient formats of gu, au and 
        g, a using NONU2UCFMT and U2NONUCFMT in the reverse direction.
     
     
        References:
          S. Akkarakaran and P. Vaidyanathan. Nonuniform filter banks: New
          results and open problems. In P. M. C.K. Chui and L. Wuytack, editors,
          Studies in Computational Mathematics: Beyond Wavelets, volume 10, pages
          259 --301. Elsevier B.V., 2003.
          
     *Url*:
     <http://ltfat.github.io/doc/filterbank/nonu2ufilterbank.html>

     See also: ufilterbank, filterbank, filterbankbounds,
     filterbankdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
NONU2UFILTERBANK   Non-uniform to uniform filterbank transform
   Usage:  [gu...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2460
 -- Function: plotfilterbank
     PLOTFILTERBANK Plot filterbank and ufilterbank coefficients
        Usage:  plotfilterbank(coef,a);
                plotfilterbank(coef,a,fc);
                plotfilterbank(coef,a,fc,fs);
                plotfilterbank(coef,a,fc,fs,dynrange);
     
        PLOTFILTERBANK(coef,a) plots filterbank coefficients coef obtained from
        either the FILTERBANK or UFILTERBANK functions. The coefficients must
        have been produced with a time-shift of a. For more details on the
        format of the variables coef and a, see the help of the FILTERBANK
        or UFILTERBANK functions.
     
        PLOTFILTERBANK(coef,a,fc) makes it possible to specify the center
        frequency for each channel in the vector fc.
     
        PLOTFILTERBANK(coef,a,fc,fs) does the same assuming a sampling rate of
        fs Hz of the original signal.
     
        PLOTFILTERBANK(coef,a,fc,fs,dynrange) makes it possible to specify
        the dynamic range of the coefficients.
     
        C=PLOTFILTERBANK(...) 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.
     
        PLOTFILTERBANK supports all the optional parameters of TFPLOT. Please
        see the help of TFPLOT for an exhaustive list.
     
        In addition to the flags and key/values in TFPLOT, PLOTFILTERBANK
        supports the following optional arguments:
     
          'fc',fc       Centre frequencies of the channels. fc must be a vector with
                        the length equal to the number of channels. The
                        default value of [] means to plot the channel
                        no. instead of its frequency.
     
          'ntickpos',n  Number of tick positions along the y-axis. The
                        position of the ticks are determined automatically.
                        Default value is 10.
     
          'tick',t      Array of tick positions on the y-axis. Use this
                        option to specify the tick position manually.
     
          'audtick'     Use ticks suitable for visualizing an auditory
                        filterbank. Same as 'tick',[0,100,250,500,1000,...].
     
     *Url*: <http://ltfat.github.io/doc/filterbank/plotfilterbank.html>

     See also: filterbank, ufilterbank, tfplot, sgram.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTFILTERBANK Plot filterbank and ufilterbank coefficients
   Usage:  plotfi...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1117
 -- Function: u2nonucfmt
     U2NONUCFMT Uniform to non-uniform filterbank coefficient format
        Usage:  c=u2nonucfmt(cu,pk)
     
        Input parameters:
              cu   : Uniform filterbank coefficients.
     
        Output parameters:
              c    : Non-uniform filterbank coefficients.
              p    : Numbers of copies of each filter.
     
        c = U2NONUCFMT(cu,pk) changes the coefficient format from
        uniform filterbank coefficients cu (M=sum(p) channels) to
        non-uniform coefficients c (numel(p) channels)  such that each
        channel of c consinst of p(m) interleaved channels of cu.
     
        The output c is a cell-array in any case.
     
     
        References:
          S. Akkarakaran and P. Vaidyanathan. Nonuniform filter banks: New
          results and open problems. In P. M. C.K. Chui and L. Wuytack, editors,
          Studies in Computational Mathematics: Beyond Wavelets, volume 10, pages
          259 --301. Elsevier B.V., 2003.
          
     *Url*: <http://ltfat.github.io/doc/filterbank/u2nonucfmt.html>

     See also: nonu2ufilterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
U2NONUCFMT Uniform to non-uniform filterbank coefficient format
   Usage:  c=...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1347
 -- Function: ufilterbank
     UFILTERBANK   Apply Uniform filterbank
        Usage:  c=ufilterbank(f,g,a);
     
        UFILTERBANK(f,g,a) applies the filter given in g to the signal
        f. Each subband will be subsampled by a factor of a (the
        hop-size). If f is a matrix, the transformation is applied to each
        column.
     
        The filters g must be a cell-array, where each entry in the cell
        array corresponds to a filter.
     
        If f is a single vector, then the output will be a matrix, where each
        column in f is filtered by the corresponding filter in g. If f is
        a matrix, the output will be 3-dimensional, and the third dimension will
        correspond to the columns of the input signal.
     
        The coefficients c computed from the signal f and the filterbank
        with windows g_m are defined by
     
                        L-1
           c(n+1,m+1) = sum f(l+1) * g_m (an-l+1)
                        l=0
     
     
     
        References:
          H. Boelcskei, F. Hlawatsch, and H. G. Feichtinger. Frame-theoretic
          analysis of oversampled filter banks. Signal Processing, IEEE
          Transactions on, 46(12):3256--3268, 2002.
          
     *Url*: <http://ltfat.github.io/doc/filterbank/ufilterbank.html>

     See also: ifilterbank, filterbankdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
UFILTERBANK   Apply Uniform filterbank
   Usage:  c=ufilterbank(f,g,a);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9618
 -- Function: warpedfilters
     WARPEDFILTERS   Frequency-warped band-limited filters
        Usage:  [g,a,fc]=warpedfilters(freqtoscale,scaletofreq,fs,fmin,fmax,bins,Ls);
     
        Input parameters:
           freqtoscale  : Function converting frequency (Hz) to scale units
           scaletofreq  : Function converting scale units to frequency (Hz)
           fs           : Sampling rate (in Hz).
           fmin         : Minimum frequency (in Hz)
           fmax         : Maximum frequency (in Hz)
           bins         : Vector consisting of the number of bins per octave.
           Ls           : Signal length.
        Output parameters:
           g            : Cell array of filters.
           a            : Downsampling rate for each channel.
           fc           : Center frequency of each channel (in Hz).
           L            : Next admissible length suitable for the generated filters.
     
        [g,a,fc]=WARPEDFILTERS(freqtoscale,scaletofreq,fs,fmin,fmax,bins,Ls)
        constructs a set of band-limited filters g which cover the required 
        frequency range fmin-fmax with bins filters per scale unit. The 
        filters are always centered at full (fractional k/bins) scale units, 
        where the first filter is selected such that its center is lower than 
        fmin. 
     
        By default, a Hann window on the frequency side is choosen, but the
        window can be changed by passing any of the window types from
        FIRWIN as an optional parameter.
        Run getfield(getfield(arg_firwin,'flags'),'wintype') to get a cell
        array of window types available.
     
        With respect to the selected scale, all filters have equal bandwidth 
        and are uniformly spaced on the scale axis, e.g. if freqtoscale is 
        log(x), then we obtain constant-Q filters with geometric spacing. 
        The remaining frequency intervals not covered by these filters are 
        captured one or two additional filters (high-pass always, low-pass if 
        necessary). The signal length Ls is required in order to obtain the 
        optimal normalization factors.
        
        Attention: When using this function, the user needs to be aware of a 
        number of things: 
     
            a)  Although the freqtoscale and scaletofreq can be chosen
                freely, it is assumed that freqtoscale is an invertible,
                increasing function from {R} or {R}^+ onto
                {R} and that freqtoscale is the inverse function.
            b)  If freqtoscale is from {R}^+ onto {R}, then
                necessarily freqtoscale(0) = -infty.
            c)  If the slope of freqtoscale is (locally) too steep, then
                there is the chance that some filters are effectively 0 or
                have extremely low bandwidth (1-3 samples), and consequently
                very poor localization in time. If freqtoscale is from 
                {R}^+ onto {R} then this usually occurs close
                to the DC component and can be alleviated by increasing fmin.
            d)  Since the input parameter bins is supposed to be integer, 
                freqtoscale and scaletofreq have to be scaled
                appropriately. Note that freqtoscale(fs) is in some sense
                proportional to the resulting number of frequency bands and
                inversely proportional to the filter bandwidths. For example,
                the ERB scale defined by 21.4log_{10}(1+f/228.8) works
                nicely out of the box, while the similar mel scale
                2595log_{10}(1+f/700) most likely has to be rescaled in
                order not to provide a filter bank with 1000s of channels.
     
        If any of these guidelines are broken, this function is likely to break
        or give undesireable results.  
      
        By default, a Hann window is chosen as the transfer function prototype, 
        but the window can be changed by passing any of the window types from
        FIRWIN as an optional parameter.
     
        The integer downsampling rates of the channels must all divide the
        signal length, FILTERBANK will only work for input signal lengths
        being multiples of the least common multiple of the downsampling rates.
        See the help of FILTERBANKLENGTH. 
        The fractional downsampling rates restrict the filterbank to a single
        length L=Ls.
     
        [g,a]=WARPEDFILTERS(...,'regsampling') constructs a non-uniform
        filterbank with integer subsampling factors. 
     
        [g,a]=WARPEDFILTERS(...,'uniform') constructs a uniform filterbank
        where the the downsampling rate is the same for all the channels. This
        results in most redundant representation, which produces nice plots.
     
        [g,a]=WARPEDFILTERS(...,'fractional') constructs a filterbank with
        fractional downsampling rates a. This results in the
        least redundant system.
     
        [g,a]=WARPEDFILTERS(...,'fractionaluniform') constructs a filterbank
        with fractional downsampling rates a, which are uniform for all filters
        except the "filling" low-pass and high-pass filters can have different
        fractional downsampling rates. This is usefull when uniform subsampling
        and low redundancy at the same time are desirable.
     
        The filters are intended to work with signals with a sampling rate of
        fs.
     
        WARPEDFILTERS accepts the following optional parameters:
     
            'bwmul',bwmul 
                                Bandwidth variation factor. Multiplies the
                                calculated bandwidth. Default value is 1.
                                If the value is less than one, the
                                system may no longer be painless.
     
            'complex'            
                                Construct a filterbank that covers the entire
                                frequency range. When missing, only positive
                                frequencies are covered.
     
            'redmul',redmul      
                                Redundancy multiplier. Increasing the value of
                                this will make the system more redundant by
                                lowering the channel downsampling rates. Default
                                value is 1. If the value is less than one,
                                the system may no longer be painless.
     
        Examples:
        ---------
     
        In the first example, we use the ERB scale functions freqtoerb and
        erbtofreq to construct a filter bank and visualize the result:
     
          [s,fs] = gspi; % Get a test signal
          Ls = numel(gspi);
     
          % Fix some parameters
          fmax = fs/2;
          bins = 1;
     
          % Compute filters, using fractional downsampling
          [g,a,fc]=warpedfilters(@freqtoerb,@erbtofreq,fs,0,fmax,bins,...
                                 Ls,'bwmul',1.5,'real','fractional');
     
          % Plot the filter transfer functions
          figure(1); 
          filterbankfreqz(g,a,Ls,'plot','linabs','posfreq');
          title('ERBlet filter transfer functions');
     
          % Compute the frame bounds
          gf=filterbankresponse(g,a,Ls,'real'); framebound_ratio = max(gf)/min(gf);
          disp(['Painless system frame bound ratio of ERBlets: ',...
               num2str(framebound_ratio)]);
           
          % Plot the filter bank coefficients of the test signal
          figure(2);
          c=filterbank(s,g,a);
          plotfilterbank(c,a,fc,fs,60);
          title('ERBlet transform of the test signal');
     
        In the second example, we look at the same test signal using a 
        constant-Q filter bank with 4 bins per scale unit and the standard 
        (semi-regular) sampling scheme:
     
          [s,fs] = gspi; % Get a test signal
          Ls = numel(gspi);
     
          % Fix some parameters
          fmax = fs/2;
          bins = 1;
     
          % Define the frequency-to-scale and scale-to-frequency functions
          warpfun_log = @(x) 10*log(x);
          invfun_log = @(x) exp(x/10);
     
          bins_hi = 4; % Select bins/unit parameter
          fmin = 50; % The logarithm's derivative 1/x tends to Inf for x towards 0
     
          % Compute filters, using fractional downsampling
          [g,a,fc]=warpedfilters(warpfun_log,invfun_log,fs,fmin,fmax,bins_hi,Ls,'bwmul',1,'real');
     
          % Plot the filter transfer functions
          figure(1); 
          filterbankfreqz(g,a,Ls,'plot','linabs','posfreq');
          title('constant-Q filter transfer functions (4 bins)');
     
          % Compute the frame bounds
          gf=filterbankresponse(g,a,Ls,'real'); framebound_ratio = max(gf)/min(gf);
          disp(['Painless system frame bound ratio (constant-Q - 4 bins): ', num2str(framebound_ratio)]);
     
          % Plot the filter bank coefficients of the test signal
          figure(2); 
          c=filterbank(s,g,a);
          plotfilterbank(c,a,fc,fs,60);
          title('constant-Q transform of the test signal (4 bins)');
     
     
        References:
          N. Holighaus, Z. Průša, and C. Wiesmeyr. Designing tight filter bank
          frames for nonlinear frequency scales. Sampling Theory and Applications
          2015, submitted, 2015.
          
     
     *Url*: <http://ltfat.github.io/doc/filterbank/warpedfilters.html>

     See also: erbfilters, cqtfilters, firwin, filterbank,
     warpedblfilter.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WARPEDFILTERS   Frequency-warped band-limited filters
   Usage:  [g,a,fc]=war...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8880
 -- Function: waveletfilters
     WAVELETFILTERS Generates wavelet filters
        Usage: [gout,a,fc,L,info] = waveletfilters(Ls,scales)
               [gout,a,fc,L,info] = waveletfilters(Ls,'bins', fs, fmin, fmax, bins)
               [gout,a,fc,L,info] = waveletfilters(Ls,'linear', fs, fmin, fmax, channels)
     
        Input parameters:
              Ls     : System length
              scales : Vector of wavelet scales
        Output parameters:
              gout  : Cell arrary of wavelet filters
              a     : Downsampling rate for each channel.
              fc    : Center frequency of each channel.
              L     : Next admissible length suitable for the generated filters.
              info  : Struct with additional outputs
     
        WAVELETFILTERS(Ls,scales) constructs a system of wavelet filters covering 
        scales in the range scales for system length Ls. A scale of 1 corresponds 
        to a wavelet filter with peak positioned at the frequency 0.1 relative 
        to the Nyquist rate.
     
        [g,a,fc]=WAVELETFILTERS(Ls, 'bins', fs,fmin,fmax,bins) constructs a set of
        wavelets g which cover the required frequency range
        fmin-fmax with bins filters per octave starting at fmin. All
        filters have (approximately) equal Q=f_c/f_b. The
        frequency interval below fmin not covered by these is captured
        by additional lowpass filter(s) . The signal length Ls*
        is mandatory, since we need to avoid too narrow frequency windows
     
        [g,a,fc]=WAVELETFILTERS(Ls, 'linear', fs, fmin, fmax, channels) constructs 
         a set of wavelets g which cover the required frequency range
        fmin-fmax with channels equidistantly spaced filters starting at fmin.
     
        Wavelet types
        --------------------
     
        The following wavelets can be passed as a flag:
     
        'cauchy'     Cauchy wavelet (default parameters [alpha beta gamma] = [300 0 3])
     
        'morse'      Generalized morse wavelet (default parameters [alpha beta gamma] = [300 0 3])
     
        'morlet'     Morlet wavelet (default parameters sigma = [4])
     
        'fbsp'       Frequency B-spline wavelet (default parameters [order fb] = [4 2])
     
        'analyticsp' Analytic spline wavelet (default parameters [order fb] = [4 2])
     
        'cplxsp'     Complex spline wavelet (default parameters [order fb] = [4 2])
     
        A scale of 1 corresponds
        to a wavelet filter with peak positioned at the frequency 0.1 relative
        to the Nyquist rate. By default, this function does not allow center frequencies
        exceeding the Nyquist rate, except with the optional parameter 'analytic',
        see below. This implies that scales below 0.1 (or 0.05 for the 'analytic' scheme)
        are not supported.
        For more details on the construction of the wavelets and the available
        wavelet types, please see FREQWAVELET. 
     
        By default, wavelet filters are peak normalized before being adjusted
        to the proposed downsampling factor. The peak normalization can be 
        overridden by forwarding any norm flag accepted by SETNORM.
     
        Downsampling factors
        --------------------
     
        The integer downsampling rates of the channels must all divide the
        signal length, FILTERBANK will only work for input signal lengths
        being multiples of the least common multiple of the downsampling rates.
        See the help of FILTERBANKLENGTH. 
        The fractional downsampling rates restrict the filterbank to a single
        length L=Ls.
     
        [gout,a]=WAVELETFILTERS(...,'regsampling') constructs a non-uniform
        filterbank with integer subsampling factors. This is the default.
     
        [gout,a]=WAVELETFILTERS(...,'uniform') constructs a uniform filterbank
        where the integer downsampling rate is the same for all the channels. This
        results in the most redundant representation which produces nice plots.
     
        [gout,a]=WAVELETFILTERS(...,'fractional') constructs a filterbank with
        fractional downsampling rates a. 
        This results in the least redundant system.
     
        [gout,a]=WAVELETFILTERS(...,'fractionaluniform') constructs a filterbank 
        with fractional downsampling rates a, which are uniform for all filters
        except the "filling" low-pass filter which can have different
        fractional downsampling rates. This is useful when uniform subsampling
        and low redundancy at the same time are desirable.
     
        Lowpass filters
        --------------------
     
        [gout,a]=WAVELETFILTERS(...,'single') uses a single lowpass filter
        for covering the range from zero frequency to the center frequency of the
        largest scale specified. This is the default.
     
        [gout,a]=WAVELETFILTERS(...,'repeat') constructs frequency-shifted
        copies of the largest scale wavelet to cover the range from zero frequency 
        to the center frequency of the largest scale specified.
     
        [gout,a]=WAVELETFILTERS(...,'none') foregoes the construction of a
        lowpass filter. This option cannot be expected to yield an invertible 
        filterbank.
     
        Additional parameters
        ---------------------
     
        waveletfilter accepts the following optional parameters:
     
          'redmul',redmul    Redundancy multiplier. Increasing the value of this
                             will make the system more redundant by lowering the
                             channel downsampling rates. Default
                             value is 1. If the value is less than one, the
                             system may no longer be painless.
      
          'redtar',redtar    Target redundancy. The downsampling factors will be
                             adjusted to achieve a redundancy as close as possible
                             to 'redtar'.
     
          'trunc_at',trunc_at     Applies hard thresholding of the wavelet filters 
                                  at the specified threshold value to reduce their 
                                  support size. 
                                  The default value is trunc_at=10e-5. When no 
                                  truncation is desired, trunc_at=0 should be chosen.
     
          'delay',delay      A scalar, numeric vector of function handle that 
                             specifies delays for the wavelet filters. A
                             numeric vector must have at least as many entries
                             as there are filters in the filterbank. A function
                             handle must accept two inputs (k-1,a(k)), where 
                             k is the channel index and a are the
                             downsampling rates. If a function handle is given
                             and 'redtar' is specified, delays are computed
                             based on the final value of a.
     
          'real'             Allows positive scales with center frequencies up 
                             to Nyquist. This is the default.
     
          'complex'          Allows positive scales with center frequencies up 
                             to Nyquist, which are also mirrored to cover
                             negative scales.
     
          'analytic'         Allows positive scales with center frequencies up 
                             to twice the Nyquist frequency. This setting is
                             suitable for the analysis of analytic signals.
     
          'startfreq'        Allows to manually set a starting frequency for
                             the wavelet range. Can not be lower than fmin.
     
        Examples:
        ---------
     
        In the first example, we analyze a glockenspiel signal with a
        regularly sampled wavelet filterbank using a frequency B-spline
        wavelet of order 4 and with parameter fb=3 and visualize the result:
     
          [f,fs]=gspi;  % Get the test signal
          Ls = length(f);
          scales = 2.^linspace(5,-3.3,256);
          [g,a,fc,L]=waveletfilters(Ls,scales, {'fbsp', 4, 3}, 'repeat');
          c=filterbank(f,g,a);
          plotfilterbank(c,a,fc,fs,90);
     
        In the second example, we do a constant-Q style analysis, the default is
        a Cauchy wavelet, and plot its frequency bank response:
     
          fmin = 120;
          fmax = fs/2;
          bins = 8;
          [g, a, fc, L, info] = waveletfilters(Ls,'bins', fs, fmin, fmax, bins,'repeat');
          filterbankfreqz(g,a,Ls, 'plot', 'posfreq', 'dynrange', 60);
      
     *Url*: <http://ltfat.github.io/doc/filterbank/waveletfilters.html>

     See also: freqwavelet, filterbank, setnorm, demo_waveletfilters.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WAVELETFILTERS Generates wavelet filters
   Usage: [gout,a,fc,L,info] = wavel...





