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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1307
 LTFAT - Deprecated functions

  Peter L. Soendergaard, 2012 - 2023.

  The functions in this directory are deprecated, and their use is
  no longer recommended. The help of each function provides a
  description on how to replace the function.
  
  Deprecated functions
    ARG_NORMALIZE	 - Use ARG_SETNORM
    NORMALIZE	        - Use SETNORM
    CONVOLVE	        - Use LCONV
    GABELITISTLASSO   - Use FRANAGROUPLASSO  
    GABGROUPLASSO     - Use FRANAGROUPLASSO
    GABLASSO          - Use FRANALASSO
    GABMULEIGS        - Use FRAMEMULEIGS
    GABMUL            - Use FRAMEMUL
    FRAMEMATRIX       - Use FRSYNMATRIX
    IUFILTERBANK      - Use IFILTERBANK
    IUNSDGT           - Use INSDGT
    IUNSDGTREAL       - Use INSDGTREAL
    TFMAT             - Use FRSYNMATRIX or OPERATORMATRIX
    UWFBTBOUNDS       - Use WFBTBOUNDS
    UWPFBTBOUNDS      - Use WPFBTBOUNDS
    CQT               - Use CQTFILTERS and FILTERBANK
    ICQT              - Use FILTERBANKDUAL and IFILTERBANK or IFILTERBANKITER
    ERBLETT           - Use AUDFILTERS with 'erb' and FILTERBANK
    IERBLETT          - Use FILTERBANKDUAL and IFILTERBANK or IFILTERBANKITER

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

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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
 LTFAT - Deprecated functions



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 360
 -- Function: arg_normalize
      Both 'null' and 'empty' do no scaling when normalize is called
      directly.
      When used in different functions,
      'empty' can be set as default by definput.importdefaults={'empty'};
      to detect whether any of the other flags were set.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/arg_normalize.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
 Both 'null' and 'empty' do no scaling when normalize is called
 directly.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 819
 -- Function: comp_gdgt
     COMP_GDGT  Compute generalized DGT
        Usage:  c=comp_gdgt(f,g,a,M,L,c_t,c_f,c_w,timeinv);
     
        Input parameters:
              f       : Input data
              g       : Window function.
              a       : Length of time shift.
              M       : Number of modulations.
              L       : Length of transform to do.
              c_t     : Centering in time of modulation.
              c_f     : Centering in frequency of modulation.
              c_w     : Centering in time of window.
              timeinv : Should we compute a time invariant Gabor system.
        Output parameters:
              c       : M*N array of coefficients.
              Ls      : Length of input signal.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/comp_gdgt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_GDGT  Compute generalized DGT
   Usage:  c=comp_gdgt(f,g,a,M,L,c_t,c_f,c...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 334
 -- Function: convolve
     CONVOLVE  Convolution
        Usage:  h=convolve(f,g);
     
        CONVOLVE has been deprecated. Please use LCONV instead.
     
        A call to CONVOLVE(f,g) can be replaced by :
     
          lconv(f,g);
     
     *Url*: <http://ltfat.github.io/doc/deprecated/convolve.html>

     See also: lconv.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
CONVOLVE  Convolution
   Usage:  h=convolve(f,g);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3613
 -- Function: cqt
     CQT  Constant-Q non-stationary 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 non-stationary 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.github.io/doc/deprecated/cqt.html>

     See also: icqt, firwin.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 152
 -- Function: demo_gablasso
     DEMO_GABLASSO  Sparse regression by Lasso method
     *Url*: <http://ltfat.github.io/doc/deprecated/demo_gablasso.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_GABLASSO  Sparse regression by Lasso method
   *Url*: <http://ltfat.gith...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3053
 -- Function: erblett
     ERBLETT  ERBlet non-stationary 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 non-stationary 
        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.github.io/doc/deprecated/erblett.html>

     See also: ierblett, firwin.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1197
 -- Function: framematrix
     FRAMEMATRIX  Frame synthesis operator matrix
        Usage: G=framematrix(F,L);
     
        G=frsynmatrix(F,L) returns the matrix representation G of the frame
        synthesis operator for a frame F of length L. The frame object F*
        must have been created using FRAME.
     
        The frame synthesis operator matrix contains all the frame atoms as
        column vectors. It has dimensions L xNcoef, where Ncoef is the
        number of coefficients. The number of coefficients can be found as
        Ncoef=framered(F)*L. This means that the frame matrix is usually
        *very* large, and this routine should only be used for small values of
        L.
     
        The action of the frame analysis operator FRANA is equal to
        multiplication with the Hermitean transpose of the frame
        matrix. Consider the following simple example:
     
          L=200;
          F=frame('dgt','gauss',10,20);
          G=frsynmatrix(F,L);
          testsig = randn(L,1);
          res = frana(F,testsig)-G'*testsig;
          norm(res)
     
     *Url*: <http://ltfat.github.io/doc/deprecated/framematrix.html>

     See also: frame, frana, frsyn.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
FRAMEMATRIX  Frame synthesis operator matrix
   Usage: G=framematrix(F,L);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3352
 -- Function: gabelitistlasso
     GABELITISTLASSO  Elitist LASSO regression in Gabor domain
        Usage: [tc,xrec] = gabelitistlasso(x,g,a,M,lambda,C,tol,maxit)
        Input parameters:
            x        : Input signal
            g        : Synthesis window function
            a        : Length of time shift
            M        : Number of channels
            lambda   : Regularization parameter, controls sparsity of the
                       solution
        Output parameters:
           tc        : Thresholded coefficients
           relres    : Vector of residuals.
           iter      : Number of iterations done.
           xrec      : Reconstructed signal
     
        GABELITISTLASSO(x,g,a,M,lambda) solves the elitist LASSO regression
        problem in the Gabor domain: minimize a functional of the synthesis
        coefficients defined as the sum of half the l^2 norm of the
        approximation error and the mixed l^2 / l^1 norm of the coefficient
        sequence, with a penalization coefficient lambda.
       
        The matrix of Gabor coefficients is labelled in terms of groups and
        members.  The obtained expansion is sparse in terms of groups, no
        sparsity being imposed to the members of a given group. This is achieved
        by a regularization term composed of l^2 norm within a group, and l^1 norm
        with respect to groups.
     
        [tc,relres,iter] = GABELITISTLASSO(...) returns the residuals relres*
        in a vector and the number of iteration steps done, maxit.
     
        [tc,relres,iter,xrec] = GABELITISTLASSO(...) returns the reconstructed
        signal from the coefficients, xrec. Note that this requires additional
        computations.
     
        The function takes the following optional parameters at the end of
        the line of input arguments:
     
          'freq'     Group in frequency (search for tonal components). This is the
                     default.
     
          'time'     Group in time (search for transient components). 
     
          'C',cval   Landweber iteration parameter: must be larger than
                     square of upper frame bound. Default value is the upper
                     frame bound.
     
          'tol',tol  Stopping criterion: minimum relative difference between
                     norms in two consecutive iterations. Default value is
                     1e-2.
     
          'maxit',maxit
                     Stopping criterion: maximal number of iterations to do. Default value is 100.
     
          'print'    Display the progress.
     
          'quiet'    Don't print anything, this is the default.
     
          'printstep',p
                     If 'print' is specified, then print every p'th
                     iteration. Default value is 10;
     
        The parameters C, itermax and tol may also be specified on the
        command line in that order: gabgrouplasso(x,g,a,M,lambda,C,tol,maxit).
     
        The solution is obtained via an iterative procedure, called Landweber
        iteration, involving iterative group thresholdings.
     
        The relationship between the output coefficients is given by :
     
          xrec = idgt(tc,g,a);
     
     *Url*: <http://ltfat.github.io/doc/deprecated/gabelitistlasso.html>

     See also: gablasso, gabframebounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABELITISTLASSO  Elitist LASSO regression in Gabor domain
   Usage: [tc,xrec]...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 641
 -- Function: gabgrouplasso
     GABGROUPLASSO  Group LASSO regression in Gabor domain
        Usage: [tc,xrec] = gabgrouplasso(x,g,a,M,group,lambda,C,maxit,tol)
     
        GABGROUPLASSO has been deprecated. Please use FRANAGROUPLASSO instead.
     
        A call to GABGROUPLASSO(x,g,a,M,lambda) can be replaced by :
     
          F=frame('dgt',g,a,M);
          tc=franagrouplasso(F,lambda);
     
        Any additional parameters passed to GABGROUPLASSO can be passed to
        FRANAGROUPLASSO in the same manner.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/gabgrouplasso.html>

     See also: frame, franagrouplasso.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABGROUPLASSO  Group LASSO regression in Gabor domain
   Usage: [tc,xrec] = g...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 575
 -- Function: gablasso
     GABLASSO  LASSO regression in Gabor domain
        Usage: [tc,xrec] = gablasso(x,a,M,lambda,C,tol,maxit)
     
        GABLASSO has been deprecated. Please use FRANALASSO instead.
     
        A call to GABLASSO(x,g,a,M,lambda) can be replaced by :
     
          F=frame('dgt',[],g,a,M);
          tc=franalasso(F,lambda);
     
        Any additional parameters passed to GABLASSO can be passed to
        FRANALASSO in the same manner.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/gablasso.html>

     See also: frame, franalasso.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABLASSO  LASSO regression in Gabor domain
   Usage: [tc,xrec] = gablasso(x,a...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1650
 -- Function: gabmul
     GABMUL  Apply Gabor multiplier
        Usage:  h=gabmul(f,c,a);
                h=gabmul(f,c,g,a);
                h=gabmul(f,c,ga,gs,a);
     
        Input parameters:
              f     : Input signal
              c     : symbol of Gabor multiplier
              g     : analysis/synthesis window
              ga    : analysis window
              gs    : synthesis window
              a     : Length of time shift.
        Output parameters:
              h     : Output signal
     
        GABMUL has been deprecated. Please use construct a frame multiplier
        and use FRAMEMUL instead.
     
        A call to GABMUL(f,c,ga,gs,a) can be replaced by :
     
          [Fa,Fs]=framepair('dgt',ga,gs,a,M);
          fout=framemul(f,Fa,Fs,s);
     
        Original help:
        --------------
     
        GABMUL(f,c,g,a) filters f by a Gabor multiplier determined by
        the symbol c over the rectangular time-frequency lattice determined by
        a and M, where M is deduced from the size of c. The rows of c*
        correspond to frequency, the columns to temporal sampling points.  The
        window g will be used for both analysis and synthesis.
     
        GABMUL(f,c,a) does the same using an optimally concentrated, tight
        Gaussian as window function.
     
        GABMUL(f,c,ga,gs,a) does the same using the window ga for analysis
        and gs for synthesis.
     
        The adjoint operator of GABMUL(f,c,ga,gs,a) is given by
        GABMUL(f,conj(c),gs,ga,a).
     
     *Url*: <http://ltfat.github.io/doc/deprecated/gabmul.html>

     See also: dgt, idgt, gabdual, gabtight.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABMUL  Apply Gabor multiplier
   Usage:  h=gabmul(f,c,a);
           h=gabmu...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2584
 -- Function: gabmuleigs
     GABMULEIGS  Eigenpairs of Gabor multiplier
        Usage:  h=gabmuleigs(K,c,g,a);
                h=gabmuleigs(K,c,a);
                h=gabmuleigs(K,c,ga,gs,a);
     
        Input parameters:
              K     : Number of eigenvectors to compute.
              c     : symbol of Gabor multiplier
              g     : analysis/synthesis window
              ga    : analysis window
              gs    : synthesis window
              a     : Length of time shift.
        Output parameters:
              V     : Matrix containing eigenvectors.
              D     : Eigenvalues.
     
        GABMULEIGS has been deprecated. Please use construct a frame multiplier
        and use FRAMEMULEIGS instead.
     
        A call to GABMULEIGS(K,c,ga,gs,a) can be replaced by :
     
          [Fa,Fs]=framepair('dgt',ga,gs,a,M);
          [V,D]=framemuleigs(Fa,Fs,s,K);
     
        Original help:
        --------------
     
        GABMULEIGS(K,c,g,a) computes the K largest eigenvalues and eigen-
        vectors of the Gabor multiplier with symbol c and time shift a.  The
        number of channels is deduced from the size of the symbol c.  The
        window g will be used for both analysis and synthesis.
     
        GABMULEIGS(K,c,ga,gs,a) does the same using the window the window ga*
        for analysis and gs for synthesis.
     
        GABMULEIGS(K,c,a) does the same using the a tight Gaussian window of
        for analysis and synthesis.
     
        If K is empty, then all eigenvalues/pairs will be returned.
     
        GABMULEIGS takes the following parameters at the end of the line of input
        arguments:
     
          'tol',t      Stop if relative residual error is less than the
                       specified tolerance. Default is 1e-9 
     
          'maxit',n    Do at most n iterations.
     
          'iter'       Call eigs to use an iterative algorithm.
     
          'full'       Call eig to sole the full problem.
     
          'auto'       Use the full method for small problems and the
                       iterative method for larger problems. This is the
                       default. 
     
          'crossover',c
                       Set the problem size for which the 'auto' method
                       switches. Default is 200.
     
          'print'      Display the progress.
     
          'quiet'      Don't print anything, this is the default.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/gabmuleigs.html>

     See also: gabmul, dgt, idgt, gabdual, gabtight.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABMULEIGS  Eigenpairs of Gabor multiplier
   Usage:  h=gabmuleigs(K,c,g,a);
...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1779
 -- Function: icqt
     ICQT  Constant-Q non-stationary 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.
      
      
        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.github.io/doc/deprecated/icqt.html>

     See also: cqt.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1727
 -- Function: ierblett
     IERBLETT  ERBlet non-stationary 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.
     
      
        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/deprecated/ierblett.html>

     See also: erblett.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 375
 -- Function: iufilterbank
     IUFILTERBANK  Filter bank inversion, DEPRECATED
        Usage:  f=iufilterbank(c,g,a);
     
        IUFILTERBANK has been deprecated by IFILTERBANK. Call IFILTERBANK
        with the exact same parameters as the old call to IUFILTERBANK.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/iufilterbank.html>

     See also: ifilterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IUFILTERBANK  Filter bank inversion, DEPRECATED
   Usage:  f=iufilterbank(c,g...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1257
 -- Function: iunsdgt
     IUNSDGT  Inverse uniform non-stationary discrete Gabor transform
        Usage:  f=iunsdgt(c,g,a,Ls);
     
        Input parameters:
              c     : Cell array of coefficients.
              g     : Cell array of window functions.
              a     : Vector of time positions of windows.
              Ls    : Length of input signal.
        Output parameters:
              f     : Signal.
     
        IUNSDGT(c,g,a,Ls) computes the non-stationary Gabor expansion of the 
        input coefficients c.
     
        IUNSDGT is used to invert the function NSDGT. Read the help of NSDGT
        for details of variables format and usage.
     
        For perfect reconstruction, the windows used must be dual windows of 
        the ones used to generate the coefficients. The windows can be
        generated unsing NSGABDUAL.
     
     
     
        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.
          
     *Url*: <http://ltfat.github.io/doc/deprecated/iunsdgt.html>

     See also: unsdgt, nsgabdual, nsgabtight, demo_nsdgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IUNSDGT  Inverse uniform non-stationary discrete Gabor transform
   Usage:  f...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1363
 -- Function: iunsdgtreal
     IUNSDGTREAL  Inverse uniform non-stationary discrete Gabor transform
        Usage:  f=iunsdgtreal(c,g,a,M,Ls);
     
        Input parameters:
              c     : Cell array of coefficients.
              g     : Cell array of window functions.
              a     : Vector of time positions of windows.
              M     : Numbers of frequency channels.
              Ls    : Length of input signal.
        Output parameters:
              f     : Signal.
     
        IUNSDGTREAL(c,g,a,M,Ls) computes the inverse uniform non-stationary Gabor
        expansion of the input coefficients c.
     
        IUNSDGTREAL is used to invert the function UNSDGTREAL. Read the help of
        UNSDGTREAL for details of variables format and usage.
     
        For perfect reconstruction, the windows used must be dual windows of 
        the ones used to generate the coefficients. The windows can be
        generated unsing NSGABDUAL.
     
     
     
        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.
          
     *Url*: <http://ltfat.github.io/doc/deprecated/iunsdgtreal.html>

     See also: unsdgt, nsgabdual, nsgabtight, demo_nsdgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IUNSDGTREAL  Inverse uniform non-stationary discrete Gabor transform
   Usage...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1774
 -- Function: normalize
     NORMALIZE  Normalize input signal by specified norm
        Usage:  h=normalize(f,...);
     
      
        NORMALIZE(f,...) will normalize the signal f by the specified norm.
     
        [f,fnorm]=NORMALIZE(f,...) does the same thing, but in addition
        returns norm fnorm of a signal f.
     
        The norm is specified as a string and may be one of:
     
          '1'       Normalize the l^1 norm to be 1.
     
          'area'    Normalize the area of the signal to be 1. This is exactly the same as '1'.
     
          '2'       Normalize the l^2 norm to be 1.
     
          'energy'  Normalize the energy of the signal to be 1. This is exactly
                    the same as '2'.
     
          'inf'     Normalize the l^{inf} norm to be 1.
     
          'peak'    Normalize the peak value of the signal to be 1. This is exactly
                    the same as 'inf'.
     
          'rms'     Normalize the Root Mean Square (RMS) norm of the
                    signal to be 1.
     
          's0'      Normalize the S0-norm to be 1.
     
          'wav'     Normalize to the l^{inf} norm to be 0.99 to avoid 
                    possible clipping introduced by the quantization procedure 
                    when saving as a wav file. This only works with floating
                    point data types.
     
          'null'    Do NOT normalize, output is identical to input.
     
     
        It is possible to specify the dimension:
     
           'dim',d  
                     Work along specified dimension. The default value of []
                     means to work along the first non-singleton one.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/normalize.html>

     See also: rms, s0norm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
NORMALIZE  Normalize input signal by specified norm
   Usage:  h=normalize(f,...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 198
 -- Function: test_dgts
      This is currently the tester for the
      new TF-transforms.
     
      It does not do multiwindow.
     *Url*: <http://ltfat.github.io/doc/deprecated/test_dgts.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
 This is currently the tester for the
 new TF-transforms.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 168
 -- Function: test_dwilts
      This is currently the tester for the
      new TF-transforms.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/test_dwilts.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
 This is currently the tester for the
 new TF-transforms.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 165
 -- Function: test_framemulappr
      This test example is taken from demo_gabmulappr
     *Url*:
     <http://ltfat.github.io/doc/deprecated/test_framemulappr.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 This test example is taken from demo_gabmulappr
   *Url*: <http://ltfat.gith...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 353
 -- Function: test_gabmul
      Compare approximation by Gabor Multiplier by LTFAT and XXL
     
      using
      LTFAT - this toolbox
      XXL   - the collection of MATLAB files by P. Balazs found at 
              http://www.kfs.oeaw.ac.at/xxl/Dissertation/matlabPhDXXL.html
     
     *Url*: <http://ltfat.github.io/doc/deprecated/test_gabmul.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
 Compare approximation by Gabor Multiplier by LTFAT and XXL



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 245
 -- Function: test_gdgt
     TEST_GDGT  Test GDGT
     
       This script runs a throrough test of the COMP_GDGT routine, testing it on
       a range of input parameters.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/test_gdgt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
TEST_GDGT  Test GDGT



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 158
 -- Function: test_pherm
      This script test the quality of the Hermite implementation.
     *Url*: <http://ltfat.github.io/doc/deprecated/test_pherm.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 This script test the quality of the Hermite implementation.
   *Url*: <http:...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 283
 -- Function: test_wfac
     TEST_WFAC  Test COMP_WFAC
     
       This script runs a test of only the comp_wfac and comp_iwfac procedures.
     
       The script TEST_DGT will test the complete DGT implementation.
     *Url*: <http://ltfat.github.io/doc/deprecated/test_wfac.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
TEST_WFAC  Test COMP_WFAC



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2652
 -- Function: tfmat
     TFMAT Matrix of transform / operator
        Usage:  F=tfmat('fourier',L);
                F=tfmat('dcti',L);
                F=tfmat('dgt',g,a,M);
                F=tfmat('dwilt',g,M);
                F=tfmat('wmdct',g,M);
                F=tfmat('zak',L,a);
                F=tfmat('gabmul',sym,a);
                F=tfmat('spread',c);
     
        TFMAT has been deprecated. Please construct a frame (using FRAME)
        and use FRSYNMATRIX, or construct an operator (using OPERATORNEW)
        and use OPERATORMATRIX instead.
     
        Original help
        -------------
     
        TFMAT returns a matrix F containing the basis functions / atoms of
        one of the transforms in the toolbox. The atoms are placed as column
        vectors in the matrix. A forward transform (analysis) can be done by:
     
          c=F'*f;
     
        and a backwards or adjoint transform (synthesis) can be done by:
     
          r=F*c;
     
        The possibilities are:
     
        TFMAT('fourier',L) returns the matrix of the unitary Fourier
        transform of length L. See DFT.
     
        TFMAT('dcti',L) returns the matrix of the DCTI transform of length
        L. Similarly for 'dctii', 'dctiii', 'dctiv', 'dsti', 'dstii',
        'dstiii' or 'dstiv'.
     
        TFMAT('dgt',g,a,M) returns a matrix containing all the atoms of the
        Gabor frame with window g and lattice constants a and M. 
        TFMAT('dgt',g,a,M,L) will do the same for a FIR window g.
     
        TFMAT('dwilt',g,M) returns a matrix containing all the atoms of the
        Wilson  basis with window g and M channels. TFMAT(g,M,L) will do the
        same for a FIR window g.
     
        TFMAT('wmdct',g,M) and TFMAT('wmdct',g,M,L) does the same for an WMDCT
        with M channels.
     
        TFMAT('gabmul',sym,a) return the matrix of the Gabor multiplier with
        symbol sym and time shift a. TFMAT('gabmul',c,g,a) does the same
        using the window g for both analysis and synthesis.
        TFMAT('gabmul',sym,ga,gs,a) does the same using ga as analysis window
        and gs as synthesis window.
     
        TFMAT('spread',c) returns the matrix of the spreading operator with
        symbol c.
     
        TFMAT('zak',L,a) returns the transform matrix for a Zak transform of
        length L and parameter a.
      
        This function should mainly be used for educational purposes or for 
        experimenting with systems, as the generated matrix can
        become very large.
     
     *Url*: <http://ltfat.github.io/doc/deprecated/tfmat.html>

     See also: frsynmatrix, operatormatrix.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
TFMAT Matrix of transform / operator
   Usage:  F=tfmat('fourier',L);
       ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1302
 -- Function: uwfbtbounds
     UWFBTBOUNDS Frame bounds of Undecimated WFBT
        Usage: fcond=uwfbtbounds(wt,L);
               [A,B]=uwfbtbounds(wt,L);
               [...]=uwfbtbounds(wt);
     
        UWFBTBOUNDS(wt,L) calculates the ratio B/A of the frame bounds
        of the undecimated filterbank specified by wt for a system of length
        L. The ratio is a measure of the stability of the system.
     
        UWFBTBOUNDS({w,J,'dwt'},L) calculates the ratio B/A of the frame
        bounds of the undecimated DWT (|UFWT|) filterbank specified by w and
        J for a system of length L.
     
        UWFBTBOUNDS(wt) does the same thing, but L is the length of the 
        longest filter in the identical filterbank.
     
        [A,B]=UWFBTBOUNDS(...) returns the lower and upper frame bounds
        explicitly.
     
        See WFBT for explanation of parameter wt and FWT for explanation
        of parameters w and J.
     
        The function supports the following flags:
     
        'sqrt'(default),'noscale','scale'
            The filters in the filterbank tree are scaled to reflect the
            behavior of UWFBT and IUWFBT with the same flags.  
     
     *Url*: <http://ltfat.github.io/doc/deprecated/uwfbtbounds.html>

     See also: uwfbt, filterbankbounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
UWFBTBOUNDS Frame bounds of Undecimated WFBT
   Usage: fcond=uwfbtbounds(wt,L...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1153
 -- Function: uwpfbtbounds
     UWPFBTBOUNDS Frame bounds of Undecimated WPFBT
        Usage: fcond=uwpfbtbounds(wt,L);
               [A,B]=uwpfbtbounds(wt,L);
     
        UWPFBTBOUNDS(wt,L) calculates the ratio B/A of the frame bounds
        of the undecimated wavelet packet filterbank specified by wt for a 
        system of length L. The ratio is a measure of the stability of the 
        system. 
     
        [A,B]=uwfbtbounds(wt,L) returns the lower and upper frame bounds
        explicitly. 
     
        See WFBT for explanation of parameter wt.
     
        Additionally, the function accepts the following flags:
     
        'intsqrt'(default),'intnoscale', 'intscale'
            The filters in the filterbank tree are scaled to reflect the
            behavior of UWPFBT and IUWPFBT with the same flags.
     
        'sqrt'(default),'noscale','scale'
            The filters in the filterbank tree are scaled to reflect the
            behavior of UWPFBT and IUWPFBT with the same flags.  
                   
     
     *Url*: <http://ltfat.github.io/doc/deprecated/uwpfbtbounds.html>

     See also: uwpfbt, filterbankbounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
UWPFBTBOUNDS Frame bounds of Undecimated WPFBT
   Usage: fcond=uwpfbtbounds(w...





