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


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

  Peter L. Soendergaard, 2011 - 2014

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

  Auditory inspired filterbanks
    CQT                    - Constant Q transform
    ICQT                   - Inverse constant Q transform
    ERBLETT                - Erb-let transform
    IERBLETT               - Inverse Erb-let transform
    INSDGFB                - Say what?

  Filter generators
    CQTFILTERS             - Logaritmically spaced filters
    ERBFILTERS             - ERB-spaced filters
  
  Window construction and bounds
    FILTERBANKDUAL         - Canonical dual filters
    FILTERBANKTIGHT        - Canonical tight filters
    FILTERBANKREALDUAL     - Canonical dual filters for real signals
    FILTERBANKREALTIGHT    - Canonical tight filters for real signals
    FILTERBANKBOUNDS       - Frame bounds of filter bank
    FILTERBANKREALBOUNDS   - Frame bounds of filter bank for real signals
    FILTERBANKRESPONSE     - Total frequency response (a frame property)

  Auxilary
    FILTERBANKFREQZ        - Frequency responses of filters
    NONU2UFILTERBANK       - Non-uni. to uniform filterbank transformation
    U2NONUCFMT             - Change format of coefficients
    NONU2UCFMT             - Change format of coefficients back

  Plots
    PLOTFILTERBANK         - Plot normal/uniform filter bank coefficients

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

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



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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3502
 -- Function: cqt
     CQT  Constant-Q nonstationary Gabor filterbank
        Usage: [c,Ls,g,shift,M] = cqt(f,fmin,fmax,bins,fs,M)
               [c,Ls,g,shift,M] = cqt(f,fmin,fmax,bins,fs)
               [c,Ls,g,shift] = cqt(...)
               [c,Ls] = cqt(...)
               c = cqt(...)

        Input parameters:
              f         : The signal to be analyzed (For multichannel
                          signals, input should be a matrix which each
                          column storing a channel of the signal).
              fmin      : Minimum frequency (in Hz)
              fmax      : Maximum frequency (in Hz)
              bins      : Vector consisting of the number of bins per octave
              fs        : Sampling rate (in Hz)
              M         : Number of time channels (optional)
                          If M is constant, the output is converted to a
                          matrix
        Output parameters:
              c         : Transform coefficients (matrix or cell array)
              Ls        : Original signal length (in samples)
              g         : Cell array of Fourier transforms of the analysis
                          windows
              shift     : Vector of frequency shifts
              M         : Number of time channels

        This function computes a constant-Q transform via nonstationary Gabor
        filterbanks. Given the signal f, the constant-Q parameters fmin,
        fmax and bins, as well as the sampling rate fs of f, the
        corresponding constant-Q coefficients c are given as output. For
        reconstruction, the length of f and the filterbank parameters can
        be returned also.

        The transform produces phase-locked coefficients in the
        sense that each filter is considered to be centered at
        0 and the signal itself is modulated accordingly.

        Optional input arguments arguments can be supplied like this:

            cqt(f,fmin,fmax,bins,fs,'min_win',min_win)

        The arguments must be character strings followed by an
        argument:

          'min_win',min_win        Minimum admissible window length
                                   (in samples)

          'Qvar',Qvar              Bandwidth variation factor

          'M_fac',M_fac            Number of time channels are rounded to
                                   multiples of this

          'winfun',winfun          Filter prototype (see FIRWIN for available
                                   filters)
          'fractional'             Allow fractional shifts and bandwidths


        Example:
        --------

        The following example shows analysis and synthesis with CQT and ICQT:

          [f,fs] = gspi;
          fmin = 200;
          fmax = fs/2;
          [c,Ls,g,shift,M] = cqt(f,fmin,fmax,48,fs);
          fr = icqt(c,g,shift,Ls);
          rel_err = norm(f-fr)/norm(f);
          plotfilterbank(c,Ls./M,[],fs,'dynrange',60);


        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.

     *Url*: <http://ltfat.sourceforge.net/doc/filterbank/cqt.php>

     See also: icqt, firwin.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
CQT  Constant-Q nonstationary Gabor filterbank
   Usage: [c,Ls,g,shift,M] = cqt(



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5683
 -- Function: cqtfilters
     CQTFILTERS   CQT-spaced filters
        Usage:  [g,a,fc]=cqtfilters(fs);
                [g,a,fc]=cqtfilters(fs,...);

        Input parameters:
           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.
           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
        remainding 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 choosen, but the
        window can be changed by passing any of the window types from
        FIRWIN as an optional parameter.

        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
        filterbank. 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 filterbank
        where the downsampling rate is the same for all the channels. This
        results in most redundant representation, which produces nice plots.

        [g,a]=CQTFILTERS(...,'fractional') constructs a filterbank with
        fractional downsampling rates a. The rates are constructed such
        that the filterbank 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 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.

        CQTFILTERS accepts the following optional parameters:

          'winfun',winfun       Filter prototype (see FIRWIN for available
                                filters). Default is 'hann'.

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

          'subprec'             Allow subsample window positions and
                                bandwidths to better approximate the constant-Q
                                property.

          'complex'             Construct a filterbank 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.


        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.sourceforge.net/doc/filterbank/cqtfilters.php>

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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6143
 -- Function: erbfilters
     ERBFILTERS   ERB-spaced filters
        Usage:  [g,a,fc]=erbfilters(fs,Ls);
                [g,a,fc]=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. 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 choosen, but the
        window can be changed by passing any of the window types from
        FIRWIN as an optional parameter.

        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]=ERBFILTERS(...,'regsampling') constructs a non-uniform
        filterbank with integer subsampling factors.

        [g,a]=ERBFILTERS(...,'uniform') constructs a uniform filterbank
        where the downsampling rate is the same for all the channels. This
        results in most redundant representation, which produces nice plots.

        [g,a]=ERBFILTERS(...,'fractional') constructs a filterbank with
        fractional downsampling rates a. The rates are constructed such
        that the filterbank 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]=ERBFILTERS(...,'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.

        ERBFILTERS accepts the following optional parameters:

          'spacing',b     Specify the spacing in ERBS between the
                          filters. Default value is b=1.

          'M',M           Specify the number of filters, M. If this
                          parameter is specified, it overwrites the
                          'spacing' parameter.

          'redmul',redmul  Redundancy multiplier. Increasing the value of this
                           will make the system more redundant by lowering the
                           channel downsampling rates. It is only used if the
                           filterbank is a non-uniform filterbank. Default
                           value is 1. If the value is less than one, the
                           system may no longer be painless.

          'symmetric'     Create filters that are symmetric around their centre
                          frequency. This is the default.

          'warped'        Create asymmetric filters that are symmetric on the
                          Erb-scale.

          'complex'       Construct a filterbank that covers the entire
                          frequency range.


          'bwmul',bwmul   Bandwidth of the filters relative to the bandwidth
                          returned by AUDFILTBW. Default is bwmul=1.

          '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 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.sourceforge.net/doc/filterbank/erbfilters.php>

     See also: filterbank, ufilterbank, ifilterbank, ceil23.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2969
 -- Function: erblett
     ERBLETT  ERBlet nonstationary Gabor filterbank
        Usage: [c,Ls,g,shift,M] = erblett(f,bins,fs,varargin)
               [c,Ls,g,shift] = erblett(...)
               [c,Ls] = erblett(...)
               c = erblett(...)

        Input parameters:
              f         : The signal to be analyzed (For multichannel
                          signals, input should be a matrix which each
                          column storing a channel of the signal)
              bins      : Desired bins per ERB
              fs        : Sampling rate of f (in Hz)
              varargin  : Optional input pairs (see table below)
        Output parameters:
              c         : Transform coefficients (matrix or cell array)
              Ls        : Original signal length (in samples)
              g         : Cell array of Fourier transforms of the analysis
                          windows
              shift     : Vector of frequency shifts
              M         : Number of time channels

        This function computes an ERBlet constant-Q transform via nonstationary
        Gabor filterbanks. Given the signal f, the ERBlet parameter bins,
        as well as the sampling rate fs of f, the corresponding ERBlet
        coefficients c are given as output. For reconstruction, the length of
        f and the filterbank parameters can be returned also.

        The transform produces phase-locked coefficients in the
        sense that each filter is considered to be centered at
        0 and the signal itself is modulated accordingly.

        Optional input arguments arguments can be supplied like this:

            erblett(f,bins,fs,'Qvar',Qvar)

        The arguments must be character strings followed by an
        argument:

          'Qvar',Qvar              Bandwidth variation factor

          'M_fac',M_fac            Number of time channels are rounded to
                                   multiples of this

          'winfun',winfun          Filter prototype (see FIRWIN for available
                                   filters)

        Examples:
        ---------

        The following example shows analysis and synthesis with ERBLETT and
        IERBLETT:

            [f,fs] = gspi;
            binsPerERB = 4;
            [c,Ls,g,shift,M] = erblett(f,binsPerERB,fs);
            fr = ierblett(c,g,shift,Ls);
            rel_err = norm(f-fr)/norm(f)
            plotfilterbank(c,Ls./M,[],fs,'dynrange',60);


        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.sourceforge.net/doc/filterbank/erblett.php>

     See also: ierblett, firwin.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
ERBLETT  ERBlet nonstationary Gabor filterbank
   Usage: [c,Ls,g,shift,M] = erbl



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1492
 -- 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.sourceforge.net/doc/filterbank/filterbank.php>

     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: 614
 -- Function: filterbankbounds
     FILTERBANKBOUNDS  Frame bounds of filter bank
        Usage: fcond=filterbankbounds(g,a);
               [A,B]=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.

        [A,B]=FILTERBANKBOUNDS(g,a,L) returns the lower and upper frame bounds
        explicitly.

     *Url*:
     <http://ltfat.sourceforge.net/doc/filterbank/filterbankbounds.php>

     See also: filterbank, filterbankdual.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FILTERBANKBOUNDS  Frame bounds of filter bank
   Usage: fcond=filterbankbounds(g



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1343
 -- 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).

        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 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: 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.sourceforge.net/doc/filterbank/filterbankdual.php>

     See also: filterbank, ufilterbank, ifilterbank.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 579
 -- 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.sourceforge.net/doc/filterbank/filterbankfreqz.php>




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



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
   *Url*:
<http://ltfat.sourceforge.net/doc/filterbank/filterbankinit.php>



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 642
 -- 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.sourceforge.net/doc/filterbank/filterbanklength.php>

     See also: filterbank, filterbanklengthcoef.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 525
 -- 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.sourceforge.net/doc/filterbank/filterbanklengthcoef.php>

     See also: filterbank, filterbanklength.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 785
 -- Function: filterbankrealbounds
     FILTERBANKREALBOUNDS  Frame bounds of filter bank for real signals only
        Usage: fcond=filterbankrealbounds(g,a);
               [A,B]=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.

        [A,B]=FILTERBANKREALBOUNDS(g,a) returns the lower and upper frame
        bounds explicitly.

     *Url*:
     <http://ltfat.sourceforge.net/doc/filterbank/filterbankrealbounds.php>

     See also: filterbank, filterbankdual.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1555
 -- 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.sourceforge.net/doc/filterbank/filterbankrealdual.php>

     See also: filterbank, ufilterbank, ifilterbank.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1260
 -- 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.

        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.sourceforge.net/doc/filterbank/filterbankrealtight.php>

     See also: filterbank, ufilterbank, ifilterbank.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2109
 -- 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.sourceforge.net/doc/filterbank/filterbankresponse.php>

     See also: filterbank, filterbankbounds.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1065
 -- 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.

        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.sourceforge.net/doc/filterbank/filterbanktight.php>

     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: 2482
 -- 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.sourceforge.net/doc/filterbank/filterbankwin.php>

     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
   Usa



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1784
 -- Function: icqt
     ICQT  Constant-Q nonstationary Gabor synthesis
        Usage: fr = icqt(c,g,shift,Ls,dual)
               fr = icqt(c,g,shift,Ls)
               fr = icqt(c,g,shift)

        Input parameters:
              c         : Transform coefficients (matrix or cell array)
              g         : Cell array of Fourier transforms of the analysis
                          windows
              shift     : Vector of frequency shifts
              Ls        : Original signal length (in samples)
              dual      : Synthesize with the dual frame
        Output parameters:
              fr        : Synthesized signal (Channels are stored in the
                          columns)

        Given the cell array c of non-stationary Gabor coefficients, and a
        set of filters g and frequency shifts shift this function computes
        the corresponding constant-Q synthesis.

        If dual is set to 1 (default), an attempt is made to compute the
        canonical dual frame for the system given by g, shift and the size
        of the vectors in c. This provides perfect reconstruction in the
        painless case, see the references for more information.

        This is just a dummy routine calling INSDGFB.


        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.

     *Url*: <http://ltfat.sourceforge.net/doc/filterbank/icqt.php>

     See also: cqt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
ICQT  Constant-Q nonstationary Gabor synthesis
   Usage: fr = icqt(c,g,shift,Ls,



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1748
 -- Function: ierblett
     IERBLETT  ERBlet nonstationary Gabor synthesis
        Usage: fr = ierblett(c,g,shift,Ls,dual)
               fr = ierblett(c,g,shift,Ls)
               fr = ierblett(c,g,shift)

        Input parameters:
              c         : Transform coefficients (matrix or cell array)
              g         : Cell array of Fourier transforms of the analysis
                          windows
              shift     : Vector of frequency shifts
              Ls        : Original signal length (in samples)
              dual      : Synthesize with the dual frame
        Output parameters:
              fr        : Synthesized signal (Channels are stored in the
                          columns)
        Given the cell array c of non-stationary Gabor coefficients, and a
        set of filters g and frequency shifts shift this function computes
        the corresponding ERBlet synthesis.

        If dual is set to 1 (default), an attempt is made to compute the
        canonical dual frame for the system given by g, shift and the size
        of the vectors in c. This provides perfect reconstruction in the
        painless case, see the references for more information.

        This is just a dummy routine calling INSDGFB.


        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.sourceforge.net/doc/filterbank/ierblett.php>

     See also: erblett.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IERBLETT  ERBlet nonstationary Gabor synthesis
   Usage: fr = ierblett(c,g,shift



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 972
 -- 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.


        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.sourceforge.net/doc/filterbank/ifilterbank.php>

     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: 7
insdgfb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1813
 -- Function: insdgfb
     INSDGFB  Nonstationary Gabor filterbank synthesis
        Usage: fr = insdgfb(c,g,shift,Ls,dual)
               fr = insdgfb(c,g,shift,Ls)
               fr = insdgfb(c,g,shift)

        Input parameters:
              c         : Transform coefficients (matrix or cell array)
              g         : Cell array of Fourier transforms of the analysis
                          windows
              shift     : Vector of frequency shifts
              Ls        : Original signal length (in samples)
              dual      : Synthesize with the dual frame
        Output parameters:
              fr        : Synthesized signal (Channels are stored in the
                          columns)

        Given the cell array c of non-stationary Gabor coefficients, and a
        set of filters g and frequency shifts shift this function computes
        the corresponding nonstationary Gabor filterbank synthesis.

        If dual is set to 1 (default), an attempt is made to compute the
        canonical dual frame for the system given by g, shift and the size
        of the vectors in c. This provides perfect reconstruction in the
        painless case, see the references for more information.


        References:
          P. Balazs, M. Doerfler, F. Jaillet, N. Holighaus, and G. A. Velasco.
          Theory, implementation and applications of nonstationary Gabor frames.
          J. Comput. Appl. Math., 236(6):1481-1496, 2011.

          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.

     *Url*: <http://ltfat.sourceforge.net/doc/filterbank/insdgfb.php>

     See also: cqt, icqt, erblett, ierblett.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
INSDGFB  Nonstationary Gabor filterbank synthesis
   Usage: fr = insdgfb(c,g,shi



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1100
 -- 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.sourceforge.net/doc/filterbank/nonu2ucfmt.php>

     See also: nonu2ufilterbank, u2nonucfmt.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1720
 -- 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.sourceforge.net/doc/filterbank/nonu2ufilterbank.php>

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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2412
 -- 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.sourceforge.net/doc/filterbank/plotfilterbank.php>

     See also: filterbank, ufilterbank, tfplot, sgram.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1083
 -- 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.sourceforge.net/doc/filterbank/u2nonucfmt.php>

     See also: nonu2ufilterbank.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1308
 -- 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.sourceforge.net/doc/filterbank/ufilterbank.php>

     See also: ifilterbank, filterbankdual.




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





