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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4489
 LTFAT - Gabor analysis

  Peter L. Soendergaard, 2007 - 2023.

  Basic Time/Frequency analysis
    TCONV          -  Twisted convolution
    DSFT           -  Discrete Symplectic Fourier Transform
    ZAK            -  Zak transform
    IZAK           -  Inverse Zak transform
    COL2DIAG       -  Move columns of a matrix to diagonals
    S0NORM         -  S0-norm

  Gabor systems
    DGT            -  Discrete Gabor transform
    IDGT           -  Inverse discrete Gabor transform
    ISGRAM         -  Iterative reconstruction from spectrogram
    ISGRAMREAL     -  Iterative reconstruction from spectrogram for real-valued signals
    DGT2           -  2D Discrete Gabor transform
    IDGT2          -  2D Inverse discrete Gabor transform
    DGTREAL        -  DGT for real-valued signals
    IDGTREAL       -  IDGT for real-valued signals
    GABWIN         -  Evaluate Gabor window
    PROJKERN	    -  Projection of Gabor coefficients onto kernel space
    DGTLENGTH      -  Length of Gabor system to expand a signal

  Multi-Gabor systems
    MULTIDGTREALMP -  Matching pursuit decomposition in Multi-Gabor system 

  Wilson bases and WMDCT
    DWILT          -  Discrete Wilson transform
    IDWILT         -  Inverse discrete Wilson transform
    DWILT2         -  2-D Discrete Wilson transform
    IDWILT2        -  2-D inverse discrete Wilson transform
    WMDCT          -  Modified Discrete Cosine transform
    IWMDCT         -  Inverse WMDCT
    WMDCT2         -  2-D WMDCT
    IWMDCT2        -  2-D inverse WMDCT
    WIL2RECT       -  Rectangular layout of Wilson coefficients
    RECT2WIL       -  Inverse of WIL2RECT
    WILWIN         -  Evaluate Wilson window
    DWILTLENGTH    -  Length of Wilson/WMDCT system to expand a signal

  Reconstructing windows
    GABDUAL        -  Canonical dual window
    GABTIGHT       -  Canonical tight window
    GABFIRDUAL     -  FIR optimized dual window 
    GABOPTDUAL     -  Optimized dual window
    GABFIRTIGHT    -  FIR optimized tight window
    GABOPTTIGHT    -  Optimized tight window
    GABCONVEXOPT   -  Optimized window
    GABPROJDUAL    -  Dual window by projection
    GABMIXDUAL     -  Dual window by mixing windows
    WILORTH        -  Window of Wilson/WMDCT orthonormal basis
    WILDUAL        -  Riesz dual window of Wilson/WMDCT basis 

  Conditions numbers
    GABFRAMEBOUNDS -  Frame bounds of Gabor system
    GABRIESZBOUNDS -  Riesz sequence/basis bounds of Gabor system
    WILBOUNDS      -  Frame bounds of Wilson basis
    GABDUALNORM    -  Test if two windows are dual
    GABFRAMEDIAG   -  Diagonal of Gabor frame operator
    WILFRAMEDIAG   -  Diagonal of Wilson/WMDCT frame operator

  Phase gradient methods and reassignment
    GABPHASEGRAD   -  Instantaneous time/frequency from signal
    GABPHASEDERIV  -  Phase derivatives
    GABPHASEDERIVREAL  -  Phase derivatives for DGTREAL
    GABREASSIGN    -  Reassign positive distribution
    GABREASSIGNREAL    -  Reassign positive distribution for real signals
    GABREASSIGNADJUST - Adjustable t-f reassignment

  Phase reconstruction
    CONSTRUCTPHASE     - Phase construction from abs. values of DGT
    CONSTRUCTPHASEREAL - CONSTRUCTPHASE for DGTREAL

  Phase conversions
    PHASELOCK       -  Phase Lock Gabor coefficients to time. inv.
    PHASEUNLOCK     -  Undo phase locking
    PHASELOCKREAL   -  Same as PHASELOCK for DGTREAL
    PHASEUNLOCKREAL -  Same as PHASEUNLOCK for IDGTREAL
    SYMPHASE        -  Convert to symmetric phase

  Support for non-separable lattices
    MATRIX2LATTICETYPE - Matrix form to standard lattice description
    LATTICETYPE2MATRIX - Standard lattice description to matrix form
    SHEARFIND      -  Shears to transform a general lattice to a separable
    NOSHEARLENGTH  -  Next transform side not requiring a frequency side shear

  Plots
    TFPLOT         -  Plot coefficients on the time-frequency plane
    PLOTDGT        -  Plot DGT coefficients
    PLOTDGTREAL    -  Plot DGTREAL coefficients
    PLOTDWILT      -  Plot DWILT coefficients
    PLOTWMDCT      -  Plot WMDCT coefficients
    SGRAM          -  Spectrogram based on DGT
    GABIMAGEPARS   -  Choose parameters for nice Gabor image
    RESGRAM        -  Reassigned spectrogram
    INSTFREQPLOT   -  Plot of the instantaneous frequency
    PHASEPLOT      -  Plot of STFT phase

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

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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
 LTFAT - Gabor analysis



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 665
 -- Function: col2diag
     COL2DIAG  Move columns of a matrix to diagonals
        Usage:  cout=col2diag(cin);
     
        COL2DIAG(cin) will rearrange the elements in the square matrix cin so
        that columns of cin appears as diagonals. Column number n will appear
        as diagonal number -n and L-n, where L is the size of the matrix.
     
        The function is its own inverse.
     
        COL2DIAG performs the underlying coordinate transform for spreading
        function and Kohn-Nirenberg calculus in the finite, discrete setting.
     
     *Url*: <http://ltfat.github.io/doc/gabor/col2diag.html>

     See also: spreadop, spreadfun, tconv.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
COL2DIAG  Move columns of a matrix to diagonals
   Usage:  cout=col2diag(cin);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3548
 -- Function: constructphase
     CONSTRUCTPHASE  Construct phase for DGT
        Usage:  c=constructphase(s,g,a);
                c=constructphase(s,g,a,tol);
                c=constructphase(c,g,a,tol,mask);
                c=constructphase(c,g,a,tol,mask,usephase);
                [c,newphase,usedmask,tgrad,fgrad] = constructphase(...);
     
        Input parameters:
              s        : Initial coefficients.
              g        : Analysis Gabor window.
              a        : Hop factor.
              tol      : Relative tolerance.
              mask     : Mask for selecting known phase.
              usephase : Explicit known phase.
        Output parameters:
              c        : Coefficients with the constructed phase.
              newphase : Just the (unwrapped) phase.
              usedmask : Mask for selecting coefficients with the new phase.
              tgrad    : Relative time phase derivative.
              fgrad    : Relative frequency phase derivative.
     
        CONSTRUCTPHASE(s,g,a) will construct a suitable phase for the postive
        valued coefficients s. 
       
        If s is the absolute values of the Gabor coefficients of a signal
        obtained using the window g and time-shift a, i.e.:
     
          c=dgt(f,g,a,M);
          s=abs(c);
     
        then constuctphase(s,g,a) will attempt to reconstruct c.
     
        The window g must be Gaussian, i.e. g must have the value 'gauss'
        or be a cell array {'gauss',tfr}. 
     
        CONSTRUCTPHASE(s,g,a,tol) does as above, but sets the phase of
        coefficients less than tol to random values. 
        By default, tol has the value 1e-10.
     
        CONSTRUCTPHASE(c,g,a,M,tol,mask) accepts real or complex valued
        c and real valued mask of the same size. Values in mask which can
        be converted to logical true (anything other than 0) determine
        coefficients with known phase which is used in the output. Only the
        phase of remaining coefficients (for which mask==0) is computed.
     
        CONSTRUCTPHASEreal(c,g,a,M,tol,mask,usephase) does the same as before
        but uses the known phase values from usephase rather than from c.
     
        In addition, tol can be a vector containing decreasing values. In 
        that case, the algorithm is run numel(tol) times, initialized with
        the result from the previous step in the 2nd and the further steps.
     
        Further, the function accepts the following flags:
     
           'freqinv'  The constructed phase complies with the frequency
                      invariant phase convention such that it can be directly
                      used in IDGTREAL.
                      This is the default.
     
           'timeinv'  The constructed phase complies with the time-invariant
                      phase convention. The same flag must be used in the other
                      functions e.g. IDGTREAL
     
        This function requires a computational subroutine that is only
        available in C. Use LTFATMEX to compile it.
     
     
        References:
          Z. Průša, P. Balazs, and P. L. Soendergaard. A Non-iterative Method for
          STFT Phase (Re)Construction. IEEE/ACM Transactions on Audio, Speech,
          and Language Processing, 2016. In preparation. Preprint will be
          available at http://ltfat.github.io/notes/ltfatnote040.pdf.
          
     
     *Url*: <http://ltfat.github.io/doc/gabor/constructphase.html>

     See also: dgt, gabphasegrad, ltfatmex.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
CONSTRUCTPHASE  Construct phase for DGT
   Usage:  c=constructphase(s,g,a);
 ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3702
 -- Function: constructphasereal
     CONSTRUCTPHASEREAL  Construct phase for DGTREAL
        Usage:  c=constructphasereal(s,g,a,M);
                c=constructphasereal(s,g,a,M,tol);
                c=constructphasereal(c,g,a,M,tol,mask);
                c=constructphasereal(s,g,a,M,tol,mask,usephase);
                [c,newphase,usedmask,tgrad,fgrad] = constructphasereal(...);
     
        Input parameters:
              s        : Initial coefficients.
              g        : Analysis Gabor window.
              a        : Hop factor.
              M        : Number of channels.
              tol      : Relative tolerance.
              mask     : Mask for selecting known phase.
              usephase : Explicit known phase.
        Output parameters:
              c        : Coefficients with the constructed phase.
              newphase : Just the (unwrapped) phase.
              usedmask : Mask for selecting coefficients with the new phase.
              tgrad    : Relative time phase derivative.
              fgrad    : Relative frequency phase derivative.
     
        CONSTRUCTPHASEREAL(s,g,a,M) will construct a suitable phase for the 
        positive valued coefficients s.
     
        If s contains the absolute values of the Gabor coefficients of a signal
        obtained using the window g, time-shift a and number of channels 
        M, i.e.:
     
          c=dgtreal(f,g,a,M);
          s=abs(c);
     
        then constuctphasereal(s,g,a,M) will attempt to reconstruct c.
     
        The window g must be Gaussian, i.e. g must have the value 'gauss'
        or be a cell array {'gauss',...}.
     
        CONSTRUCTPHASEREAL(s,g,a,M,tol) does as above, but sets the phase of
        coefficients less than tol to random values.
        By default, tol has the value 1e-10. 
     
        CONSTRUCTPHASEREAL(c,g,a,M,tol,mask) accepts real or complex valued
        c and real valued mask of the same size. Values in mask which can
        be converted to logical true (anything other than 0) determine
        coefficients with known phase which is used in the output. Only the
        phase of remaining coefficients (for which mask==0) is computed.
     
        CONSTRUCTPHASEREAL(s,g,a,M,tol,mask,usephase) does the same as before
        but uses the known phase values from usephase rather than from s.
     
        In addition, tol can be a vector containing decreasing values. In 
        that case, the algorithm is run numel(tol) times, initialized with
        the result from the previous step in the 2nd and the further steps.
     
        Further, the function accepts the following flags:
     
           'freqinv'  The constructed phase complies with the frequency
                      invariant phase convention such that it can be directly
                      used in IDGTREAL.
                      This is the default.
     
           'timeinv'  The constructed phase complies with the time-invariant
                      phase convention. The same flag must be used in the other
                      functions e.g. IDGTREAL
     
        This function requires a computational subroutine that is only
        available in C. Use LTFATMEX to compile it.
     
     
        References:
          Z. Průša, P. Balazs, and P. L. Soendergaard. A Non-iterative Method for
          STFT Phase (Re)Construction. IEEE/ACM Transactions on Audio, Speech,
          and Language Processing, 2016. In preparation. Preprint will be
          available at http://ltfat.github.io/notes/ltfatnote040.pdf.
          
     
     *Url*: <http://ltfat.github.io/doc/gabor/constructphasereal.html>

     See also: dgtreal, gabphasegrad, ltfatmex.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
CONSTRUCTPHASEREAL  Construct phase for DGTREAL
   Usage:  c=constructphasere...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5044
 -- Function: dgt
     DGT  Discrete Gabor transform
        Usage:  c=dgt(f,g,a,M);
                c=dgt(f,g,a,M,L);
                c=dgt(f,g,a,M,'lt',lt);
                [c,Ls]=dgt(...);
     
        Input parameters:
              f     : Input data.
              g     : Window function.
              a     : Length of time shift.
              M     : Number of channels.
              L     : Length of transform to do.
              lt    : Lattice type (for non-separable lattices).
        Output parameters:
              c     : M xN array of coefficients.
              Ls    : Length of input signal.
     
        DGT(f,g,a,M) computes the Gabor coefficients (also known as a windowed
        Fourier transform) of the input signal f with respect to the window
        g and parameters a and M. The output is a vector/matrix in a
        rectangular layout.
     
        The length of the transform will be the smallest multiple of a and M*
        that is larger than the signal. f will be zero-extended to the length of
        the transform. If f is a matrix, the transformation is applied to each
        column. The length of the transform done can be obtained by
        L=size(c,2)*a;
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of GABWIN for more details.
     
        DGT(f,g,a,M,L) computes the Gabor coefficients as above, but does
        a transform of length L. f will be cut or zero-extended to length L before
        the transform is done.
     
        [c,Ls]=DGT(f,g,a,M) or [c,Ls]=DGT(f,g,a,M,L) additionally returns the
        length of the input signal f. This is handy for reconstruction:
     
                    [c,Ls]=dgt(f,g,a,M);
                    fr=idgt(c,gd,a,Ls);
     
        will reconstruct the signal f no matter what the length of f is, provided
        that gd is a dual window of g.
     
        [c,Ls,g]=DGT(...) additionally outputs the window used in the
        transform. This is useful if the window was generated from a description
        in a string or cell array.
     
        The Discrete Gabor Transform is defined as follows: Consider a window g*
        and a one-dimensional signal f of length L and define N=L/a.
        The output from c=DGT(f,g,a,M) is then given by:
     
                        L-1 
           c(m+1,n+1) = sum f(l+1)*conj(g(l-a*n+1))*exp(-2*pi*i*m*l/M), 
                        l=0  
     
        where m=0,...,M-1 and n=0,...,N-1 and l-an is computed
        modulo L.
     
        Non-separable lattices:
        -----------------------
     
        DGT(f,g,a,M,'lt',lt) computes the DGT for a non-separable lattice
        given by the time-shift a, number of channels M and lattice type
        lt. Please see the help of MATRIX2LATTICETYPE for a precise
        description of the parameter lt.
     
        The non-separable discrete Gabor transform is defined as follows:
        Consider a window g and a one-dimensional signal f of length L and
        define N=L/a.  The output from c=DGT(f,g,a,M,L,lt) is then given
        by:
     
                        L-1 
           c(m+1,n+1) = sum f(l+1)*conj(g(l-a*n+1))*exp(-2*pi*i*(m+w(n))*l/M), 
                        l=0  
     
        where m=0,...,M-1 and n=0,...,N-1 and l-an are computed
        modulo L.  The additional offset w is given by w(n)=mod(n*lt_1,lt_2)/lt_2
        in the formula above.
     
        Additional parameters:
        ----------------------
     
        DGT takes the following flags at the end of the line of input
        arguments:
     
          'freqinv'  Compute a DGT using a frequency-invariant phase. This
                     is the default convention described above.
     
          'timeinv'  Compute a DGT using a time-invariant phase. This
                     convention is typically used in FIR-filter algorithms.
     
        Examples:
        ---------
     
        In the following example we create a Hermite function, which is a
        complex-valued function with a circular spectrogram, and visualize
        the coefficients using both imagesc and PLOTDGT:
     
          a=10;
          M=40;
          L=a*M;
          h=pherm(L,4); % 4th order hermite function.
          c=dgt(h,'gauss',a,M);
     
          % Simple plot: The squared modulus of the coefficients on
          % a linear scale
          figure(1);
          imagesc(abs(c).^2);
     
          % Better plot: zero-frequency is displayed in the middle, 
          % and the coefficients are show on a logarithmic scale.
          figure(2);
          plotdgt(c,a,'dynrange',50);
     
     
      
        References:
          K. Groechenig. Foundations of Time-Frequency Analysis. Birkhauser, 2001.
          
          H. G. Feichtinger and T. Strohmer, editors. Gabor Analysis and
          Algorithms. Birkhauser, Boston, 1998.
          
     *Url*: <http://ltfat.github.io/doc/gabor/dgt.html>

     See also: idgt, gabwin, dwilt, gabdual, phaselock, demo_dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DGT  Discrete Gabor transform
   Usage:  c=dgt(f,g,a,M);
           c=dgt(f,g...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2577
 -- Function: dgt2
     DGT2  2-D Discrete Gabor transform
        Usage: c=dgt2(f,g,a,M);
               c=dgt2(f,g1,g2,[a1,a2],[M1,M2]);
               c=dgt2(f,g1,g2,[a1,a2],[M1,M2],[L1,L2]);
               [c,Ls]=dgt2(f,g1,g2,[a1,a2],[M1,M2]);
               [c,Ls]=dgt2(f,g1,g2,[a1,a2],[M1,M2],[L1,L2]);
     
        Input parameters:
              f       : Input data, matrix.
              g,g1,g2 : Window functions.
              a,a1,a2 : Length of time shifts.
              M,M1,M2 : Number of modulations.
              L1,L2   : Length of transform to do 
     
        Output parameters:
              c       : array of coefficients.
              Ls      : Original size of input matrix.
     
        DGT2(f,g,a,M) will calculate a separable two-dimensional discrete
        Gabor transformation of the input signal f with respect to the window
        g and parameters a and M.
     
        For each dimension, the length of the transform will be the smallest
        possible that is larger than the length of the signal along that dimension.
        f will be appropriately zero-extended.
     
        DGT2(f,g,a,M,L) computes a Gabor transform as above, but does
        a transform of length L along each dimension. f will be cut or
        zero-extended to length L before the transform is done.
     
        [c,Ls]=DGT2(f,g,a,M) or [c,Ls]=DGT2(f,g,a,M,L) additionally returns
        the length of the input signal f. This is handy for reconstruction:
     
                     [c,Ls]=dgt2(f,g,a,M);
                     fr=idgt2(c,gd,a,Ls);
     
        will reconstruct the signal f no matter what the size of f is, provided
        that gd is a dual window of g. 
     
        DGT2(f,g1,g2,a,M) makes it possible to use a different window along the
        two dimensions. 
     
        The parameters a, M, L and Ls can also be vectors of length 2.
        In this case the first element will be used for the first dimension
        and the second element will be used for the second dimension.
     
        The output c has 4 or 5 dimensions. The dimensions index the
        following properties:
     
        1. Number of translation along 1st dimension of input.
     
        2. Number of channel along 1st dimension  of input
     
        3. Number of translation along 2nd dimension of input.
     
        4. Number of channel along 2nd dimension  of input
     
        5. Plane number, corresponds to 3rd dimension of input. 
      
     *Url*: <http://ltfat.github.io/doc/gabor/dgt2.html>

     See also: dgt, idgt2, gabdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DGT2  2-D Discrete Gabor transform
   Usage: c=dgt2(f,g,a,M);
          c=dgt...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1229
 -- Function: dgtlength
     DGTLENGTH  DGT length from signal
        Usage: L=dgtlength(Ls,a,M);
               L=dgtlength(Ls,a,M,lt);
     
        DGTLENGTH(Ls,a,M) returns the length of a Gabor system that is long
        enough to expand a signal of length Ls. Please see the help on
        DGT for an explanation of the parameters a and M.
     
        If the returned length is longer than the signal length, the signal
        will be zero-padded by DGT.
     
        A valid transform length must be divisable by both a and M. This
        means that the minumal admissable transform length is :
     
          Lsmallest = lcm(a,M);
     
        and all valid transform lengths are multipla of Lsmallest*
     
        Non-separable lattices:
        -----------------------
     
        DGTLENGTH(Ls,a,M,lt) does as above for a non-separable lattice with
        lattice-type lt. For non-separable lattices, there is the additinal
        requirement on the transform length, that the structure of the
        lattice must be periodic. This gives a minimal transform length of :
     
          Lsmallest = lcm(a,M)*lt(2);
     
     *Url*: <http://ltfat.github.io/doc/gabor/dgtlength.html>

     See also: dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DGTLENGTH  DGT length from signal
   Usage: L=dgtlength(Ls,a,M);
          L=...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4026
 -- Function: dgtreal
     DGTREAL  Discrete Gabor transform for real-valued signals
        Usage:  c=dgtreal(f,g,a,M);
                c=dgtreal(f,g,a,M,L);
                [c,Ls]=dgtreal(f,g,a,M);
                [c,Ls]=dgtreal(f,g,a,M,L);
     
        Input parameters:
              f     : Input data
              g     : Window function.
              a     : Length of time shift.
              M     : Number of modulations.
              L     : Length of transform to do.
        Output parameters:
              c     : M*N array of coefficients.
              Ls    : Length of input signal.
     
        DGTREAL(f,g,a,M) computes the Gabor coefficients (also known as a
        windowed Fourier transform) of the real-valued input signal f with
        respect to the real-valued window g and parameters a and M. The
        output is a vector/matrix in a rectangular layout.
     
        As opposed to DGT only the coefficients of the positive frequencies
        of the output are returned. DGTREAL will refuse to work for complex
        valued input signals.
     
        The length of the transform will be the smallest multiple of a and M*
        that is larger than the signal. f will be zero-extended to the length of
        the transform. If f is a matrix, the transformation is applied to each
        column. The length of the transform done can be obtained by
        L=size(c,2)*a.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of GABWIN for more details.
     
        DGTREAL(f,g,a,M,L) computes the Gabor coefficients as above, but does
        a transform of length L. f will be cut or zero-extended to length L before
        the transform is done.
     
        [c,Ls]=DGTREAL(f,g,a,M) or [c,Ls]=DGTREAL(f,g,a,M,L) additionally
        returns the length of the input signal f. This is handy for
        reconstruction:
     
          [c,Ls]=dgtreal(f,g,a,M);
          fr=idgtreal(c,gd,a,M,Ls);
     
        will reconstruct the signal f no matter what the length of f is, provided
        that gd is a dual window of g.
     
        [c,Ls,g]=DGTREAL(...) additionally outputs the window used in the
        transform. This is useful if the window was generated from a description
        in a string or cell array.
     
        See the help on DGT for the definition of the discrete Gabor
        transform. This routine will return the coefficients for channel
        frequencies from 0 to floor(M/2).
     
        DGTREAL takes the following flags at the end of the line of input
        arguments:
     
          'freqinv'  Compute a DGTREAL using a frequency-invariant phase. This
                     is the default convention described in the help for DGT.
     
          'timeinv'  Compute a DGTREAL using a time-invariant phase. This
                     convention is typically used in filter bank algorithms.
     
        DGTREAL can be used to manually compute a spectrogram, if you
        want full control over the parameters and want to capture the output
        :
     
          f=greasy;  % Input test signal
          fs=16000;  % The sampling rate of this particular test signal
          a=10;      % Downsampling factor in time
          M=200;     % Total number of channels, only 101 will be computed
     
          % Compute the coefficients using a 20 ms long Hann window
          c=dgtreal(f,{'hann',0.02*fs'},a,M);
     
          % Visualize the coefficients as a spectrogram
          dynrange=90; % 90 dB dynamical range for the plotting
          plotdgtreal(c,a,M,fs,dynrange);
          
     
        References:
          K. Groechenig. Foundations of Time-Frequency Analysis. Birkhauser, 2001.
          
          H. G. Feichtinger and T. Strohmer, editors. Gabor Analysis and
          Algorithms. Birkhauser, Boston, 1998.
          
     *Url*: <http://ltfat.github.io/doc/gabor/dgtreal.html>

     See also: dgt, idgtreal, gabwin, dwilt, gabtight, plotdgtreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DGTREAL  Discrete Gabor transform for real-valued signals
   Usage:  c=dgtrea...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 934
 -- Function: dsft
     DSFT  Discrete Symplectic Fourier Transform
        Usage:  C=dsft(F);
     
        DSFT(F) computes the discrete symplectic Fourier transform of F.
        F must be a matrix or a 3D array. If F is a 3D array, the 
        transformation is applied along the first two dimensions.
     
        Let F be a K xL matrix. Then the DSFT of F is given by
     
                                     L-1 K-1
          C(m+1,n+1) = 1/sqrt(K*L) * sum sum F(k+1,l+1)*exp(2*pi*i(k*n/K-l*m/L))
                                     l=0 k=0
     
        for m=0,...,L-1 and n=0,...,K-1.
     
        The DSFT is its own inverse.
     
        References:
          H. G. Feichtinger, M. Hazewinkel, N. Kaiblinger, E. Matusiak, and
          M. Neuhauser. Metaplectic operators on c^n. The Quarterly Journal of
          Mathematics, 59(1):15--28, 2008.
          
     *Url*: <http://ltfat.github.io/doc/gabor/dsft.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
DSFT  Discrete Symplectic Fourier Transform
   Usage:  C=dsft(F);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4121
 -- Function: dwilt
     DWILT  Discrete Wilson transform
        Usage:  c=dwilt(f,g,M);
                c=dwilt(f,g,M,L);
                [c,Ls]=dwilt(...);
     
        Input parameters:
              f     : Input data
              g     : Window function.
              M     : Number of bands.
              L     : Length of transform to do.
        Output parameters:
              c     : 2M xN array of coefficients.
              Ls    : Length of input signal.
     
        DWILT(f,g,M) computes a discrete Wilson transform with M bands and
        window g.
     
        The length of the transform will be the smallest possible that is
        larger than the signal. f will be zero-extended to the length of the 
        transform. If f is a matrix, the transformation is applied to each column.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of WILWIN for more details.
     
        DWILT(f,g,M,L) computes the Wilson transform as above, but does a
        transform of length L. f will be cut or zero-extended to length L*
        before the transform is done.
     
        [c,Ls]=DWILT(f,g,M) or [c,Ls]=DWILT(f,g,M,L) additionally return the
        length of the input signal f. This is handy for reconstruction:
     
          [c,Ls]=dwilt(f,g,M);
          fr=idwilt(c,gd,M,Ls);
     
        will reconstruct the signal f no matter what the length of f is, provided
        that gd is a dual Wilson window of g.
     
        [c,Ls,g]=DWILT(...) additionally outputs the window used in the
        transform. This is useful if the window was generated from a description
        in a string or cell array.
     
        A Wilson transform is also known as a maximally decimated, even-stacked
        cosine modulated filter bank.
     
        Use the function WIL2RECT to visualize the coefficients or to work
        with the coefficients in the TF-plane.
     
        Assume that the following code has been executed for a column vector f*:
     
          c=dwilt(f,g,M);  % Compute a Wilson transform of f.
          N=size(c,2)*2;   % Number of translation coefficients.
     
        The following holds for m=0,...,M-1 and n=0,...,N/2-1:
     
        If m=0:
     
                         L-1 
          c(m+1,n+1)   = sum f(l+1)*g(l-2*n*M+1)
                         l=0  
     
     
        If m is odd and less than M
     
                         L-1 
          c(m+1,n+1)   = sum f(l+1)*sqrt(2)*sin(pi*m/M*l)*g(k-2*n*M+1)
                         l=0  
      
                         L-1 
          c(m+M+1,n+1) = sum f(l+1)*sqrt(2)*cos(pi*m/M*l)*g(k-(2*n+1)*M+1)
                         l=0  
     
        If m is even and less than M
     
                         L-1 
          c(m+1,n+1)   = sum f(l+1)*sqrt(2)*cos(pi*m/M*l)*g(l-2*n*M+1)
                         l=0  
      
                         L-1 
          c(m+M+1,n+1) = sum f(l+1)*sqrt(2)*sin(pi*m/M*l)*g(l-(2*n+1)*M+1)
                         l=0  
     
        if m=M and M is even:
     
                         L-1 
          c(m+1,n+1)   = sum f(l+1)*(-1)^(l)*g(l-2*n*M+1)
                         l=0
     
        else if m=M and M is odd
     
                         L-1 
          c(m+1,n+1)   = sum f(l+1)*(-1)^l*g(l-(2*n+1)*M+1)
                         l=0
     
     
        References:
          H. Boelcskei, H. G. Feichtinger, K. Groechenig, and F. Hlawatsch.
          Discrete-time Wilson expansions. In Proc. IEEE-SP 1996 Int. Sympos.
          Time-Frequency Time-Scale Analysis, june 1996.
          
          I. Daubechies, S. Jaffard, and J. Journe. A simple Wilson orthonormal
          basis with exponential decay. SIAM J. Math. Anal., 22:554--573, 1991.
          
          Y.-P. Lin and P. Vaidyanathan. Linear phase cosine modulated maximally
          decimated filter banks with perfectreconstruction. IEEE Trans. Signal
          Process., 43(11):2525--2539, 1995.
          
     *Url*: <http://ltfat.github.io/doc/gabor/dwilt.html>

     See also: idwilt, wilwin, wil2rect, dgt, wmdct, wilorth.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DWILT  Discrete Wilson transform
   Usage:  c=dwilt(f,g,M);
           c=dwil...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2818
 -- Function: dwilt2
     DWILT2  2D Discrete Wilson transform
        Usage: c=dwilt2(f,g,M); 
               c=dwilt2(f,g1,g2,[M1,M2]);
               c=dwilt2(f,g1,g2,[M1,M2],[L1,L2]);
               [c,Ls]=dwilt2(f,g1,g2,[M1,M2],[L1,L2]);
     
        Input parameters:
              f        : Input data, matrix.
              g,g1,g2  : Window functions.
              M,M1,M2  : Number of bands.
              L1,L2    : Length of transform to do.
        Output parameters:
              c        : array of coefficients.
              Ls       : Original size of input matrix.
     
        DWILT2(f,g,M) calculates a two dimensional discrete Wilson transform
        of the input signal f using the window g and parameter M along each
        dimension.
     
        For each dimension, the length of the transform will be the smallest
        possible that is larger than the length of the signal along that dimension.
        f will be appropriately zero-extended.
     
        All windows must be whole-point even.
      
        DWILT2(f,g,M,L) computes a Wilson transform as above, but does
        a transform of length L along each dimension. f will be cut or
        zero-extended to length L before the transform is done.
     
        [c,Ls]=dwilt(f,g,M) or [c,Ls]=dwilt(f,g,M,L) additionally returns the
        length of the input signal f. This is handy for reconstruction.
     
        c=DWILT2(f,g1,g2,M) makes it possible to use a different window along the
        two dimensions. 
     
        The parameters L, M and Ls can also be vectors of length 2. In
        this case the first element will be used for the first dimension and the
        second element will be used for the second dimension.
     
        The output c has 4 or 5 dimensions. The dimensions index the
        following properties:
     
          1. Number of translations along 1st dimension of input.
     
          2. Number of channels along 1st dimension  of input
     
          3. Number of translations along 2nd dimension of input.
     
          4. Number of channels along 2nd dimension  of input
     
          5. Plane number, corresponds to 3rd dimension of input. 
     
        Examples:
        ---------
     
        The following example visualize the DWILT2 coefficients of a test
        image. For clarity, only the 50 dB largest coefficients are show:
     
          c=dwilt2(cameraman,'itersine',16);
          c=reshape(c,256,256);
          
          figure(1);
          imagesc(cameraman), colormap(gray), axis('image');
     
          figure(2);
          cc=dynlimit(20*log10(abs(c)),50);
          imagesc(cc), colormap(flipud(bone)), axis('image'), colorbar;
     
     *Url*: <http://ltfat.github.io/doc/gabor/dwilt2.html>

     See also: dwilt, idwilt2, dgt2, wildual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DWILT2  2D Discrete Wilson transform
   Usage: c=dwilt2(f,g,M); 
          c=...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 828
 -- Function: dwiltlength
     DWILTLENGTH  DWILT/WMDCT length from signal
        Usage: L=dwiltlength(Ls,M);
     
        DWILTLENGTH(Ls,M) returns the length of a Wilson / WMDCT system with
        M channels system is long enough to expand a signal of length
        Ls. Please see the help on DWILT or WMDCT for an explanation of the
        parameter M.
     
        If the returned length is longer than the signal length, the signal will
        be zero-padded by DWILT or WMDCT.
     
        A valid transform length must be divisable by 2M. This
        means that the minumal admissable transform length is :
     
          Lsmallest = 2*M;
     
        and all valid transform lengths are multipla of Lsmallest*
     
     *Url*: <http://ltfat.github.io/doc/gabor/dwiltlength.html>

     See also: dwilt, wmdct.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
DWILTLENGTH  DWILT/WMDCT length from signal
   Usage: L=dwiltlength(Ls,M);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5173
 -- Function: gabconvexopt
     GABCONVEXOPT Compute a window using convex optimization
        Usage: gout=gabconvexopt(g,a,M);
               gout=gabconvexopt(g,a,M, varagin);
     
        Input parameters:
          g      : Window function /initial point (tight case)
          a      : Time shift
          M      : Number of Channels
     
        Output parameters:
          gout   : Output window
          iter   : Number of iterations
          relres : Reconstruction error
     
        GABCONVEXOPT(g,a,M) computes a window gout which is the optimal
        solution of the convex optimization problem below
     
           gd  = argmin_x    || alpha x||_1 +  || beta Fx||_1  
     
                           + || omega (x -g_l) ||_2^2 + delta || x ||_S0
     
                           + gamma || nabla F x ||_2^2 + mu || nabla x ||_2^2
     
               such that  x satifies the constraints
     
        Three constraints are possible:
        
         x is dual with respect of g
     
         x is tight
     
         x is compactly supported on Ldual
     
        *Note**: This function require the unlocbox. You can download it at
        http://unlocbox.sourceforge.net
     
        The function uses an iterative algorithm to compute the approximate.
        The algorithm can be controlled by the following flags:
     
          'alpha',alpha  Weight in time. If it is a scalar, it represent the
                       weights of the entire L1 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm (length: Ldual).
                       Default value is alpha=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-time constraint: alpha=0
     
          'beta',beta  Weight in frequency. If it is a scalar, it represent the
                       weights of the entire L1 function in frequency. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm in frequency. (length: Ldual).
                       Default value is beta=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-frequency constraint: beta=0
     
          'omega',omega  Weight in time of the L2-norm. If it is a scalar, it represent the
                       weights of the entire L2 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L2 norm (length: Ldual).
                       Default value is omega=0.
                       No L2-time constraint: omega=0
     
          'glike',g_l  g_l is a windows in time. The algorithm try to shape
                       the dual window like g_l. Normalization of g_l is done
                       automatically. To use option omega should be different
                       from 0. By default g_d=0.
     
          'mu', mu     Weight of the smooth constraint Default value is 1. 
                       No smooth constraint: mu=0
        
          'gamma', gamma  Weight of the smooth constraint in frequency. Default value is 1. 
                       No smooth constraint: gamma=0
        
          'delta', delta  Weight of the S0-norm. Default value is 0. 
                       No S0-norm: delta=0
     
          'support' Ldual  Add a constraint on the support. The windows should
                       be compactly supported on Ldual.
     
          'tight'      Look for a tight windows
     
          'dual'       Look for a dual windows (default)
     
          'painless'   Construct a starting guess using a painless-case
                       approximation. This is the default
     
          'zero'       Choose a starting guess of zero.
     
          'rand'       Choose a random starting phase.
     
          'tol',t      Stop if relative residual error is less than the 
                       specified tolerance.  
     
          'maxit',n    Do at most n iterations. default 200
     
          'print'      Display the progress.
     
          'debug'      Display all the progresses.
     
          'quiet'      Don't print anything, this is the default.
     
          'fast'       Fast algorithm, this is the default.
     
          'slow'       Safer algorithm, you can try this if the fast algorithm
                       is not working. Before using this, try to iterate more.
     
          'printstep',p  If 'print' is specified, then print every p'th
                         iteration. Default value is p=10;
     
          'hardconstraint' Force the projection at the end (default)
     
          'softconstaint' Do not force the projection at the end
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabconvexopt.html>

     See also: gaboptdual, gabdual, gabtight, gabfirtight, gabopttight.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABCONVEXOPT Compute a window using convex optimization
   Usage: gout=gabcon...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2159
 -- Function: gabdual
     GABDUAL  Canonical dual window of Gabor frame
        Usage:  gd=gabdual(g,a,M);
                gd=gabdual(g,a,M,L);
                gd=gabdual(g,a,M,'lt',lt);
     
        Input parameters:
              g     : Gabor window.
              a     : Length of time shift.
              M     : Number of channels.
              L     : Length of window. (optional)
              lt    : Lattice type (for non-separable lattices).
        Output parameters:
              gd : Canonical dual window.
     
        GABDUAL(g,a,M) computes the canonical dual window of the discrete Gabor
        frame with window g and parameters a, M.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of GABWIN for more details.
     
        If the length of g is equal to M, then the input window is assumed
        to be an FIR window. In this case, the canonical dual window also has
        length of M. Otherwise the smallest possible transform length is chosen
        as the window length.
     
        GABDUAL(g,a,M,L) returns a window that is the dual window for a system
        of length L. Unless the dual window is a FIR window, the dual window
        will have length L.
     
        GABDUAL(g,a,M,'lt',lt) does the same for a non-separable lattice
        specified by lt. Please see the help of MATRIX2LATTICETYPE for a
        precise description of the parameter lt.
     
        If a>M then the dual window of the Gabor Riesz sequence with window
        g and parameters a and M will be calculated.
     
        Examples:
        ---------
     
        The following example shows the canonical dual window of the Gaussian
        window:
     
          a=20;
          M=30;
          L=300;
          g=pgauss(L,a*M/L);
          gd=gabdual(g,a,M);
          
          % Simple plot in the time-domain
          figure(1);
          plot(gd);
     
          % Frequency domain
          figure(2);
          magresp(gd,'dynrange',100);
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabdual.html>

     See also: gabtight, gabwin, fir2long, dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABDUAL  Canonical dual window of Gabor frame
   Usage:  gd=gabdual(g,a,M);
 ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2434
 -- Function: gabdualnorm
     GABDUALNORM  Measure of how close a window is to being a dual window
        Usage:  dn=gabdualnorm(g,gamma,a,M);
                dn=gabdualnorm(g,gamma,a,M,L);
                dn=gabdualnorm(g,gamma,a,M,'lt',lt);
                [scal,res]=gabdualnorm(...);
     
        Input parameters:
              gamma  : input window..
              g      : window function.
              a      : Length of time shift.
              M      : Number of modulations.
              L      : Length of transform to consider
        Output parameters:
              dn     : dual norm.
              scal   : Scaling factor
              res    : Residual
     
        GABDUALNORM(g,gamma,a,M) calculates how close gamma is to being a
        dual window of the Gabor frame with window g and parameters a and M.
     
        The windows g and gamma may be vectors of numerical values, text strings
        or cell arrays. See the help of GABWIN for more details.
     
        [scal,res]=GABDUALNORM(...) computes two entities: scal determines
        if the windows are scaled correctly, it must be 1 for the windows to be
        dual. Note that the scaling factor scal is expected to be real for 
        real-valued window pairs g and gamma, but may be complex for general 
        windows. res is close to zero if the windows (scaled correctly) are dual
        windows.
     
        GABDUALNORM(g,gamma,a,M,L) does the same, but considers a transform
        length of L.
     
        GABDUALNORM(g,gamma,a,M,'lt',lt) does the same for a non-separable
        lattice specified by lt. Please see the help of MATRIX2LATTICETYPE
        for a precise description of the parameter lt.
     
        GABDUALNORM can be used to get the maximum relative reconstruction
        error when using the two specified windows. Consider the following code
        for some signal f, windows g, gamma, parameters a and M and 
        transform-length L (See help on DGT on how to obtain L*):
     
          fr=idgt(dgt(f,g,a,M),gamma,a); 
          er=norm(f-fr)/norm(f);
          eest=gabdualnorm(g,gamma,a,M,L);
     
        Then  er<eest for all possible input signals f.
     
        To get a similar estimate for an almost tight window gt, simply use :
       
          eest=gabdualnorm(gt,gt,a,M,L);
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabdualnorm.html>

     See also: gabframebounds, dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABDUALNORM  Measure of how close a window is to being a dual window
   Usage...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5023
 -- Function: gabfirdual
     GABFIRDUAL  Compute FIR dual window
        Usage: gd=gabfirdual(Ldual,g,a,M);
               gd=gabfirdual(Ldual,g,a,M, varagin);
     
        Input parameters:
          Ldual  : Length of dual window
          g      : Window function
          a      : Time shift
          M      : Number of Channels
          alpha1 : Weight of l^1-norm in the time domain
          alpha2 : Weight of l^1-norm in the freq. domain
     
        Output parameters:
          gd     : Dual window
     
        GABFIRDUAL(Ldual,g,a,M) computes an FIR window gd which is an
        approximate dual window of the Gabor system defined by g, a and
        M. The FIR dual window will be supported on Ldual samples.
     
        This function solve a convex optimization problem that can be written
        as:
     
           gd  = argmin_x    || alpha x||_1 +  || beta Fx||_1  
     
                           + || omega (x -g_l) ||_2^2 + delta || x ||_S0
     
                           + gamma || nabla F x ||_2^2 + mu || nabla x ||_2^2
     
               such that  x is a dual windows of g
     
        *Note**: This function require the unlocbox. You can download it at
        http://unlocbox.sourceforge.net
        
        The function uses an iterative algorithm to compute the approximate
        FIR dual. The algorithm can be controlled by the following flags:
     
          'alpha',alpha  Weight in time. If it is a scalar, it represent the
                       weights of the entire L1 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm (length: Ldual).
                       Default value is alpha=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-time constraint: alpha=0
     
          'beta',beta  Weight in frequency. If it is a scalar, it represent the
                       weights of the entire L1 function in frequency. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm in frequency. (length: Ldual).
                       Default value is beta=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-frequency constraint: beta=0
     
          'omega',omega  Weight in time of the L2-norm. If it is a scalar, it represent the
                       weights of the entire L2 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L2 norm (length: Ldual).
                       Default value is omega=0.
                       No L2-time constraint: omega=0
     
          'glike',g_l  g_l is a windows in time. The algorithm try to shape
                       the dual window like g_l. Normalization of g_l is done
                       automatically. To use option omega should be different
                       from 0. By default g_d=0.
     
          'mu',mu      Weight of the smooth constraint Default value is 1. 
                       No smooth constraint: mu=0
        
          'gamma',gamma  Weight of the smooth constraint in frequency. Default value is 1. 
                         No smooth constraint: gamma=0
        
          'delta',delta  Weight of the S0-norm. Default value is 0. 
                         No S0-norm: delta=0
     
          'dual'       Look for a dual windows (default)
     
          'painless'   Construct a starting guess using a painless-case
                       approximation. This is the default
     
          'zero'       Choose a starting guess of zero.
     
          'rand'       Choose a random starting phase.
     
          'tol',t      Stop if relative residual error is less than the 
                       specified tolerance.  
     
          'maxit',n    Do at most n iterations. default 200
     
          'print'      Display the progress.
     
          'debug'      Display all the progresses.
     
          'quiet'      Don't print anything, this is the default.
     
          'fast'       Fast algorithm, this is the default.
     
          'slow'       Safer algorithm, you can try this if the fast algorithm
                       is not working. Before using this, try to iterate more.
     
          'printstep',p  If 'print' is specified, then print every p'th
                         iteration. Default value is p=10;
     
          'hardconstraint' Force the projection at the end (default)
     
          'softconstaint' Do not force the projection at the end
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabfirdual.html>

     See also: gaboptdual, gabdual, gabtight, gabfirtight, gaboptdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABFIRDUAL  Compute FIR dual window
   Usage: gd=gabfirdual(Ldual,g,a,M);
   ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5031
 -- Function: gabfirtight
     GABFIRTIGHT  Compute FIR tight window
        Usage: gt=gabfirtight(Lsupport,g,a,M);
               gt=gabfirtight(Lsupport,g,a,M, varagin);
     
        Input parameters:
          Lsupport  : Length of the tight window
          g      : Initial window function
          a      : Time shift
          M      : Number of Channels
     
        Output parameters:
          gt     : Tight window
     
        GABFIRTIGHT(Lsupport,g,a,M) computes an FIR window gd which is tight. 
        The FIR dual window will be supported on Lsupport samples.
     
        This function solve a convex optimization problem that can be written
        as:
     
           gd  = argmin_x    || alpha x||_1 +  || beta Fx||_1  
     
                           + || omega (x -g_l) ||_2^2 + delta || x ||_S0
     
                           + gamma || nabla F x ||_2^2 + mu || nabla x ||_2^2
     
               such that  x is a tight FIR windows
     
        *Note**: This function require the unlocbox. You can download it at
        http://unlocbox.sourceforge.net
     
        The function uses an iterative algorithm to compute the approximate
        FIR tight windows. Warning The algorithm solve a non convex problem and
        might be stack in bad local minima. The algorithm can be controlled by
        the following flags: 
     
          'alpha',alpha  Weight in time. If it is a scalar, it represent the
                       weights of the entire L1 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm (length: Ldual).
                       Default value is alpha=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-time constraint: alpha=0
     
          'beta',beta  Weight in frequency. If it is a scalar, it represent the
                       weights of the entire L1 function in frequency. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm in frequency. (length: Ldual).
                       Default value is beta=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-frequency constraint: beta=0
     
          'omega',omega
                       Weight in time of the L2-norm. If it is a scalar,
                       it represent the
                       weights of the entire L2 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L2 norm (length: Ldual).
                       Default value is omega=0.
                       No L2-time constraint: omega=0
     
          'glike',g_l  g_l is a windows in time. The algorithm try to shape
                       the dual window like g_l. Normalization of g_l is done
                       automatically. To use option omega should be different
                       from 0. By default g_d=0.
     
          'mu',mu      Weight of the smooth constraint Default value is 1. 
                       No smooth constraint: mu=0
        
          'gamma',gamma  Weight of the smooth constraint in frequency.
                         Default value is 1. No smooth constraint: gamma=0
        
          'delta',delta  Weight of the S0-norm. Default value is 0. 
                         No S0-norm: delta=0
     
          'dual'       Look for a dual windows (default)
     
          'painless'   Construct a starting guess using a painless-case
                       approximation. This is the default
     
          'zero'       Choose a starting guess of zero.
     
          'rand'       Choose a random starting phase.
     
          'tol',t      Stop if relative residual error is less than the 
                       specified tolerance.  
     
          'maxit',n    Do at most n iterations. default 200
     
          'print'      Display the progress.
     
          'debug'      Display all the progresses.
     
          'quiet'      Don't print anything, this is the default.
     
          'fast'       Fast algorithm, this is the default.
     
          'slow'       Safer algorithm, you can try this if the fast algorithm
                       is not working. Before using this, try to iterate more.
     
          'printstep',p  If 'print' is specified, then print every p'th
                         iteration. Default value is p=10;
     
          'hardconstraint' Force the projection at the end (default)
     
          'softconstaint' Do not force the projection at the end
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabfirtight.html>

     See also: gaboptdual, gabdual, gabtight, gabfirdual, gabconvexopt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABFIRTIGHT  Compute FIR tight window
   Usage: gt=gabfirtight(Lsupport,g,a,M...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1511
 -- Function: gabframebounds
     GABFRAMEBOUNDS  Calculate frame bounds of Gabor frame
        Usage:  fcond=gabframebounds(g,a,M);
                [A,B]=gabframebounds(g,a,M);
                [A,B]=gabframebounds(g,a,M,L);
                [A,B]=gabframebounds(g,a,M,'lt',lt);
     
        Input parameters:
                g     : The window function.
                a     : Length of time shift.
                M     : Number of channels.
                L     : Length of transform to consider.
                lt    : Lattice type (for non-separable lattices).
        Output parameters:
                fcond : Frame condition number (B/A)
                A,B   : Frame bounds.
               
        GABFRAMEBOUNDS(g,a,M) calculates the ratio B/A of the frame bounds
        of the Gabor system with window g, and parameters a, M.
     
        [A,B]=GABFRAMEBOUNDS(...) returns the frame bounds A and B*
        instead of just the ratio.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of GABWIN for more details.
       
        GABFRAMEBOUNDS(g,a,M,L) will cut or zero-extend the window to length
        L.
     
        GABFRAMEBOUNDS(g,a,M,'lt',lt) does the same for a non-separable
        lattice specified by lt. Please see the help of MATRIX2LATTICETYPE
        for a precise description of the parameter lt.
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabframebounds.html>

     See also: gabrieszbounds, gabwin.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABFRAMEBOUNDS  Calculate frame bounds of Gabor frame
   Usage:  fcond=gabfra...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 928
 -- Function: gabframediag
     GABFRAMEDIAG  Diagonal of Gabor frame operator
        Usage:  d=gabframediag(g,a,M,L);
                d=gabframediag(g,a,M,L,'lt',lt);
     
        Input parameters:
              g     : Window function.
              a     : Length of time shift.
              M     : Number of channels.
              L     : Length of transform to do.
              lt    : Lattice type (for non-separable lattices).
        Output parameters:
              d     : Diagonal stored as a column vector
     
        GABFRAMEDIAG(g,a,M,L) computes the diagonal of the Gabor frame operator
        with respect to the window g and parameters a and M. The
        diagonal is stored a as column vector of length L.
     
        The diagonal of the frame operator can for instance be used as a
        preconditioner.
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabframediag.html>

     See also: dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABFRAMEDIAG  Diagonal of Gabor frame operator
   Usage:  d=gabframediag(g,a,...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1691
 -- Function: gabimagepars
     GABIMAGEPARS  Find Gabor parameters to generate image
        Usage: [a,M,L,N,Ngood]=gabimagepars(Ls,x,y);
     
        [a,M,L,N,Ngood]=GABIMAGEPARS(Ls,x,y) will compute a reasonable set of
        parameters a, M and L to produce a nice Gabor 'image' of a signal
        of length Ls. The approximate number of pixels in the time direction is
        given as x and the number of pixels in the frequency direction is given
        as y.
     
        The output parameter Ngood contains the number of time steps (columns
        in the coefficients matrix) that contains relevant information. The
        columns from Ngood until N only contains information from a
        zero-extension of the signal.
     
        If you use this function to calculate a grid size for analysis of a
        real-valued signal (using DGTREAL), please input twice of the desired
        size y. This is because DGTREAL only returns half as many
        coefficients in the frequency direction as DGT.
     
        An example: We wish to compute a Gabor image of a real valued signal f*
        of length 7500. The image should have an approximate resolution of
        600 x800 pixels:
     
          [f,fs]=linus; f=f(4001:4000+7500);
          [a,M,L,N,Ngood] = gabimagepars(7500,800,2*600);
          c = dgtreal(f,'gauss',a,M);
          plotdgtreal(c,a,M,fs,90);
     
        The size of c is (M/2)+1 xN equal to 601 x700 pixels. 
     
        For this function to work properly, the specified numbers for x and
        y must not be large prime numbers.
       
     *Url*: <http://ltfat.github.io/doc/gabor/gabimagepars.html>

     See also: dgt, dgtreal, sgram.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABIMAGEPARS  Find Gabor parameters to generate image
   Usage: [a,M,L,N,Ngoo...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 816
 -- Function: gabmixdual
     GABMIXDUAL  Computes the mixdual of g1
        Usage: gamma=mixdual(g1,g2,a,M)
     
        Input parameters:
             g1     : Window 1
             g2     : Window 2
             a      : Length of time shift.
             M      : Number of modulations.
     
        Output parameters:
             gammaf : Mixdual of window 1.
     
        GABMIXDUAL(g1,g2,a,M) computes a dual window of g1 from a mix of the
        canonical dual windows of g1 and g2.
     
     
     
        References:
          T. Werther, Y. Eldar, and N. Subbana. Dual Gabor Frames: Theory and
          Computational Aspects. IEEE Trans. Signal Process., 53(11), 2005.
          
     *Url*: <http://ltfat.github.io/doc/gabor/gabmixdual.html>

     See also: gabdual, gabprojdual, demo_gabmixdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
GABMIXDUAL  Computes the mixdual of g1
   Usage: gamma=mixdual(g1,g2,a,M)



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4788
 -- Function: gaboptdual
     GABOPTDUAL  Compute dual window
        Usage: gd=gaboptdual(g,a,M);
               gd=gaboptdual(g,a,M, varagin);
     
        Input parameters:
          g      : Window function
          a      : Time shift
          M      : Number of Channels
     
        Output parameters:
          gd     : Dual window
     
        GABOPTDUAL(g,a,M) computes a window gd which is an
        approximate dual window of the Gabor system defined by g, a and
        M. 
     
        This function solve a convex optimization problem that can be written
        as:
     
           gd  = argmin_x    || alpha x||_1 +  || beta Fx||_1  
     
                           + || omega (x -g_l) ||_2^2 + delta || x ||_S0
     
                           + gamma || nabla F x ||_2^2 + mu || nabla x ||_2^2
     
               such that  x is a dual windows of g
     
        *Note**: This function require the unlocbox. You can download it at
        http://unlocbox.sourceforge.net
     
        The function uses an iterative algorithm to compute the approximate
        optimized dual. The algorithm can be controlled by the following flags:
     
          'alpha',alpha  Weight in time. If it is a scalar, it represent the
                       weights of the entire L1 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm (length: Ldual).
                       Default value is alpha=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-time constraint: alpha=0
     
          'beta',beta  Weight in frequency. If it is a scalar, it represent the
                       weights of the entire L1 function in frequency. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm in frequency. (length: Ldual).
                       Default value is beta=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-frequency constraint: beta=0
     
          'omega',omega  Weight in time of the L2-norm. If it is a scalar, it represent the
                       weights of the entire L2 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L2 norm (length: Ldual).
                       Default value is omega=0.
                       No L2-time constraint: omega=0
     
          'glike',g_l  g_l is a windows in time. The algorithm try to shape
                       the dual window like g_l. Normalization of g_l is done
                       automatically. To use option omega should be different
                       from 0. By default g_d=0.
     
          'mu',mu      Weight of the smooth constraint Default value is 1. 
                       No smooth constraint: mu=0
        
          'gamma',gamma  Weight of the smooth constraint in frequency. Default value is 1. 
                         No smooth constraint: gamma=0
        
          'delta',delta  Weight of the S0-norm. Default value is 0. 
                         No S0-norm: delta=0
     
          'dual'       Look for a dual windows (default)
     
          'painless'   Construct a starting guess using a painless-case
                       approximation. This is the default
     
          'zero'       Choose a starting guess of zero.
     
          'rand'       Choose a random starting phase.
     
          'tol',t      Stop if relative residual error is less than the 
                       specified tolerance.  
     
          'maxit',n    Do at most n iterations. default 200
     
          'print'      Display the progress.
     
          'debug'      Display all the progresses.
     
          'quiet'      Don't print anything, this is the default.
     
          'fast'       Fast algorithm, this is the default.
     
          'slow'       Safer algorithm, you can try this if the fast algorithm
                       is not working. Before using this, try to iterate more.
     
          'printstep',p  If 'print' is specified, then print every p'th
                         iteration. Default value is p=10;
     
          'hardconstraint' Force the projection at the end (default)
     
          'softconstaint' Do not force the projection at the end
     
     *Url*: <http://ltfat.github.io/doc/gabor/gaboptdual.html>

     See also: gabfirdual, gabdual, gabtight, gabopttight, gaboptdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABOPTDUAL  Compute dual window
   Usage: gd=gaboptdual(g,a,M);
          gd=...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4891
 -- Function: gabopttight
     GABOPTTIGHT  Compute a optimized tight window
        Usage: gt=gabopttight(Ltight,g,a,M);
               gt=gabopttight(Ltight,g,a,M, varagin);
     
        Input parameters:
          g      : Initial window function
          a      : Time shift
          M      : Number of Channels
     
        Output parameters:
          gt     : Tight window
     
        GABOPTTIGHT(g,a,M) computes a tight window gt for a frame of
        parameter a and M
     
        This function solves a convex optimization problem that can be written
        as:
     
           gd  = argmin_x    || alpha x||_1 +  || beta Fx||_1  
     
                           + || omega (x -g_l) ||_2^2 + delta || x ||_S0
     
                           + gamma || nabla F x ||_2^2 + mu || nabla x ||_2^2
     
               such that  x is a tight window
     
        *Note**: This function require the unlocbox. You can download it at
        http://unlocbox.sourceforge.net
     
        The function uses an iterative algorithm to compute the approximate
        optimized tight window. Warning The algorithm solve a non convex
        problem and might be stack in bad local minima.  The algorithm can be
        controlled by the following flags: 
     
          'alpha',alpha  Weight in time. If it is a scalar, it represent the
                       weights of the entire L1 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm (length: Ldual).
                       Default value is alpha=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-time constraint: alpha=0
     
          'beta',beta  Weight in frequency. If it is a scalar, it represent the
                       weights of the entire L1 function in frequency. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L1 norm in frequency. (length: Ldual).
                       Default value is beta=0.
                       *Warning**: this value should not be too big in order to
                       avoid the the L1 norm proximal operator kill the signal.
                       No L1-frequency constraint: beta=0
     
          'omega',omega  Weight in time of the L2-norm. If it is a scalar, it represent the
                       weights of the entire L2 function in time. If it is a 
                       vector, it is the associated weight assotiated to each
                       component of the L2 norm (length: Ldual).
                       Default value is omega=0.
                       No L2-time constraint: omega=0
     
          'glike',g_l  g_l is a windows in time. The algorithm try to shape
                       the dual window like g_l. Normalization of g_l is done
                       automatically. To use option omega should be different
                       from 0. By default g_d=0.
     
          'mu', mu     Weight of the smooth constraint Default value is 1. 
                       No smooth constraint: mu=0
        
          'gamma', gamma  Weight of the smooth constraint in frequency. Default value is 1. 
                       No smooth constraint: gamma=0
        
          'delta', delta  Weight of the S0-norm. Default value is 0. 
                       No S0-norm: delta=0
     
          'dual'       Look for a dual windows (default)
     
          'painless'   Construct a starting guess using a painless-case
                       approximation. This is the default
     
          'zero'       Choose a starting guess of zero.
     
          'rand'       Choose a random starting phase.
     
          'tol',t      Stop if relative residual error is less than the 
                       specified tolerance.  
     
          'maxit',n    Do at most n iterations. default 200
     
          'print'      Display the progress.
     
          'debug'      Display all the progresses.
     
          'quiet'      Don't print anything, this is the default.
     
          'fast'       Fast algorithm, this is the default.
     
          'slow'       Safer algorithm, you can try this if the fast algorithm
                       is not working. Before using this, try to iterate more.
     
          'printstep',p  If 'print' is specified, then print every p'th
                         iteration. Default value is p=10;
     
          'hardconstraint' Force the projection at the end (default)
     
          'softconstaint' Do not force the projection at the end
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabopttight.html>

     See also: gabfirdual, gabdual, gabtight, gaboptdual, gabconvexopt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABOPTTIGHT  Compute a optimized tight window
   Usage: gt=gabopttight(Ltight...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8053
 -- Function: gabphasederiv
     GABPHASEDERIV   DGT phase derivatives
        Usage:  [phased,c] = gabphasederiv(dflag,'dgt',f,g,a,M);
                 phased    = gabphasederiv(dflag,'cross',f,g,a,M)
                 phased    = gabphasederiv(dflag,'phase',cphase,a);
                 phased    = gabphasederiv(dflag,'abs',s,g,a,difforder);
                [{phased1,phased2,...}] = gabphasederiv({dflag1,dflag2,...},...);
                [{phased1,phased2,...},c] = gabphasederiv({dflag1,dflag2,...},'dgt',...);
     
        phased=GABPHASEDERIV(dflag,method,...) computes the time-frequency
        derivative dflag of the phase of the DGT of a signal using algorithm
        method.
     
        The following strings can be used in place of dflag:
     
          't'   First phase derivative in time.
     
          'f'   First phase derivative in frequency.
     
          'tt'  Second phase derivative in time.
     
          'ff'  Second phase derivative in frequency.
     
          'tf' or 'ft'  Second order mixed phase derivative.
     
        phased is scaled such that (possibly non-integer) distances are measured
        in samples. Similarly, the frequencies are scaled such that the Nyquist
        frequency (the highest possible frequency) corresponds to a value of L/2.
     
        The computation of phased is inaccurate when the absolute
        value of the Gabor coefficients is low. This is due to the fact the the
        phase of complex numbers close to the machine precision is almost
        random. Therefore, phased attain very large random values when abs(c)
        is close to zero.
     
        The phase derivative computation can be done using four different methods
        depending on the string method:
     
          'dgt'    Directly from the signal using algorithm by Auger and
                   Flandrin.
     
          'cross'  Directly from the signal using algorithm by Nelson.
     
          'phase'  From the unwrapped phase of a DGT of the signal using a
                   finite differences scheme. This is the classic method used
                   in the phase vocoder.
     
          'abs'    From the absolute value of the DGT exploiting explicit
                   dependency between partial derivatives of log-magnitudes and
                   phase.
                   Currently this method works only for Gaussian windows.
     
        phased=GABPHASEDERIV(dflag,'dgt',f,g,a,M) computes the time-frequency
        derivative using a DGT of the signal f. The DGT is computed using the
        window g on the lattice specified by the time shift a and the number
        of channels M. The algorithm used to perform this calculation computes
        several DGTs, and therefore this routine takes the exact same input
        parameters as DGT.
     
        [phased,c]=GABPHASEDERIV(dflag,'dgt',f,g,a,M) additionally returns
        the Gabor coefficients c, as they are always computed as a byproduct
        of the algorithm.
     
        phased=GABPHASEDERIV(dflag,'cross',f,g,a,M) does the same as above
        but this time using algorithm by Nelson which is based on computing
        several DGTs.
     
        phased=GABPHASEDERIV(dflag,'phase',cphase,a) computes the phase
        derivative from the phase cphase of a DGT of the signal. The original DGT
        from which the phase is obtained must have been computed using a
        time-shift of a using the default phase convention ('freqinv') e.g.:
     
             phased=gabphasederiv(dflag,'phase',angle(dgt(f,g,a,M)),a)
     
        phased=GABPHASEDERIV(dflag,'abs',s,g,a) computes the phase derivative
        from the absolute values of DGT coefficients s. The spectrogram must have
        been computed using the window g and time-shift a e.g.:
     
             phased=gabphasederiv(dflag,'abs',abs(dgt(f,g,a,M)),g,a)
     
        Currently the 'abs' method only works if the window g is a Gaussian
        window specified as a string or a cell array.
     
        phased=GABPHASEDERIV(dflag,'abs',s,g,a,difforder) uses a centered finite
        diffence scheme of order difforder to perform the needed numerical
        differentiation. Default is to use a 4th order scheme.
     
        Phase conventions
        -----------------
     
        First derivatives in either direction are subject to phase convention.
        The following additional flags define the phase convention the original
        phase would have had:
     
          'freqinv'     Derivatives reflect the frequency-invariant phase of dgt.
                        This is the default.
     
          'timeinv'     Derivatives reflect the time-invariant phase of dgt.
     
          'symphase'    Derivatives reflect the symmetric phase of dgt.
     
          'relative'    This is a combination of 'freqinv' and 'timeinv'.
                        It uses 'timeinv' for derivatives along frequency and
                        and 'freqinv' for derivatives along time and for the
                        mixed derivative.
                        This is usefull for the reassignment functions.
     
        Please see ltfatnote042 for the description of relations between the
        phase derivatives with different phase conventions. Note that for the
        'relative' convention, the following holds:
     
           gabphasederiv('t',...,'relative') == gabphasederiv('t',...,'freqinv')
           gabphasederiv('f',...,'relative') == -gabphasederiv('f',...,'timeinv')
           gabphasederiv('tt',...,'relative') == gabphasederiv('tt',...)
           gabphasederiv('ff',...,'relative') == -gabphasederiv('ff',...)
           gabphasederiv('tf',...,'relative') == gabphasederiv('tf',...,'freqinv')
     
        Several derivatives at once
        ---------------------------
     
        phasedcell=GABPHASEDERIV({dflag1,dflag2,...},...) computes several
        phase derivatives at once while reusing some temporary computations thus
        saving computation time.
        {dflag1,dflag2,...} is a cell array of the derivative flags and
        cell elements of the returned phasedcell contain the corresponding
        derivatives i.e.:
     
            [pderiv1,pderiv2,...] = deal(phasedcell{:});
     
        [phasedcell,c]=GABPHASEDERIV({dflag1,dflag2,...},'dgt',...) works the
        same as above but in addition returns coefficients c which are the
        byproduct of the 'dgt' method.
     
        Other flags and parameters work as before.
     
     
        References:
          F. Auger and P. Flandrin. Improving the readability of time-frequency
          and time-scale representations by the reassignment method. IEEE Trans.
          Signal Process., 43(5):1068--1089, 1995.
          
          E. Chassande-Mottin, I. Daubechies, F. Auger, and P. Flandrin.
          Differential reassignment. Signal Processing Letters, IEEE,
          4(10):293--294, 1997.
          
          J. Flanagan, D. Meinhart, R. Golden, and M. Sondhi. Phase Vocoder. The
          Journal of the Acoustical Society of America, 38:939, 1965.
          
          K. R. Fitz and S. A. Fulop. A unified theory of time-frequency
          reassignment. CoRR, abs/0903.3080, 2009.
          
          D. J. Nelson. Instantaneous higher order phase derivatives. Digital
          Signal Processing, 12(2-3):416--428, 2002. [1]http ]
          
          F. Auger, E. Chassande-Mottin, and P. Flandrin. On phase-magnitude
          relationships in the short-time fourier transform. Signal Processing
          Letters, IEEE, 19(5):267--270, May 2012.
          
          Z. Průša. STFT and DGT phase conventions and phase derivatives
          interpretation. Technical report, Acoustics Research Institute,
          Austrian Academy of Sciences, 2015.
          
          References
          
          1. http://dx.doi.org/10.1006/dspr.2002.0456
          
     *Url*: <http://ltfat.github.io/doc/gabor/gabphasederiv.html>

     See also: resgram, gabreassign, dgt, pderiv, gabphasegrad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABPHASEDERIV   DGT phase derivatives
   Usage:  [phased,c] = gabphasederiv(d...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8671
 -- Function: gabphasederivreal
     GABPHASEDERIV   DGT phase derivatives
        Usage:  [phased,c] = gabphasederivreal(dflag,'dgt',f,g,a,M);
                 phased    = gabphasederivreal(dflag,'cross',f,g,a,M)
                 phased    = gabphasederivreal(dflag,'phase',cphase,a,M);
                 phased    = gabphasederivreal(dflag,'phase',cphase,a,M,difforder);
                 phased    = gabphasederivreal(dflag,'abs',s,g,a,M);
                 phased    = gabphasederivreal(dflag,'abs',s,a,M,difforder);
                [{phased1,phased2,...}] = gabphasederivreal({dflag1,dflag2,...},...);
                [{phased1,phased2,...},c] = gabphasederivreal({dflag1,dflag2,...},'dgt',...);
     
        phased=GABPHASEDERIVREAL(dflag,method,...) computes the time-frequency
        derivative dflag of the phase of the DGTREAL of a signal using algorithm
        method.
     
        The following strings can be used in place of dflag:
     
          't'   First phase derivative in time.
     
          'f'   First phase derivative in frequency.
     
          'tt'  Second phase derivative in time.
     
          'ff'  Second phase derivative in frequency.
     
          'tf' or 'ft'  Second order mixed phase derivative.
     
        phased is scaled such that (possibly non-integer) distances are measured
        in samples. Similarly, the frequencies are scaled such that the Nyquist
        frequency (the highest possible frequency) corresponds to a value of L/2.
     
        The computation of phased is inaccurate when the absolute
        value of the Gabor coefficients is low. This is due to the fact the the
        phase of complex numbers close to the machine precision is almost
        random. Therefore, phased attain very large random values when abs(c)
        is close to zero.
     
        The phase derivative computation can be done using four different methods
        depending on the string method:
     
          'dgt'    Directly from the signal using algorithm by Auger and
                   Flandrin.
     
          'cross'  Directly from the signal using algorithm by Nelson.
     
          'phase'  From the unwrapped phase of a DGT of the signal using a
                   finite differences scheme. This is the classic method used
                   in the phase vocoder.
     
          'abs'    From the absolute value of the DGT exploiting explicit
                   dependency between partial derivatives of log-magnitudes and
                   phase.
                   Currently this method works only for Gaussian windows.
     
        phased=GABPHASEDERIVREAL(dflag,'dgt',f,g,a,M) computes the time-frequency
        derivative using a DGT of the signal f. The DGT is computed using the
        window g on the lattice specified by the time shift a and the number
        of channels M. The algorithm used to perform this calculation computes
        several DGTs, and therefore this routine takes the exact same input
        parameters as DGTREAL.
     
        [phased,c]=GABPHASEDERIVREAL(dflag,'dgt',f,g,a,M) additionally returns
        the Gabor coefficients c, as they are always computed as a byproduct
        of the algorithm.
     
        phased=GABPHASEDERIVREAL(dflag,'cross',f,g,a,M) does the same as above
        but this time using algorithm by Nelson which is based on computing
        several DGTs.
     
        phased=GABPHASEDERIVREAL(dflag,'phase',cphase,a,M) computes the phase
        derivative from the phase cphase of a DGT of the signal. The number of
        channels M is a required input to disambiguate the existence of a 
        Nyquist channel, which is only present if M is even. The original DGT 
        from which the phase is obtained must have been computed using a
        time-shift of a using the default phase convention ('freqinv') e.g.:
     
             phased=gabphasederivreal(dflag,'phase',angle(dgt(f,g,a,M)),a,M)
     
        phased=GABPHASEDERIVREAL(dflag,'abs',s,g,a) computes the phase 
        derivative from the absolute values of DGT coefficients s. The number 
        of channels M is a required input to disambiguate the existence of a 
        Nyquist channel, which is only present if M is even. The spectrogram 
        must have been computed using the window g and time-shift a e.g.:
     
             phased=gabphasederivreal(dflag,'abs',abs(dgt(f,g,a,M)),g,a,M)
     
        Currently the 'abs' method only works if the window g is a Gaussian
        window specified as a string or a cell array.
     
        phased=GABPHASEDERIVREAL(dflag,'abs',s,g,a,M,difforder) and 
        phased=GABPHASEDERIVREAL(dflag,'pgase',cphase,a,M,difforder) use a 
        centered finite diffence scheme of order difforder to perform the 
        needed numerical differentiation. Default is to use a 4th order scheme.
     
        Phase conventions
        -----------------
     
        First derivatives in either direction are subject to phase convention.
        The following additional flags define the phase convention the original
        phase would have had:
     
          'freqinv'     Derivatives reflect the frequency-invariant phase of dgt.
                        This is the default.
     
          'timeinv'     Derivatives reflect the time-invariant phase of dgt.
     
          'symphase'    Derivatives reflect the symmetric phase of dgt.
     
          'relative'    This is a combination of 'freqinv' and 'timeinv'.
                        It uses 'timeinv' for derivatives along frequency and
                        and 'freqinv' for derivatives along time and for the
                        mixed derivative.
                        This is usefull for the reassignment functions.
     
        Please see ltfatnote042 for the description of relations between the
        phase derivatives with different phase conventions. Note that for the
        'relative' convention, the following holds:
     
           gabphasederiv('t',...,'relative') == gabphasederiv('t',...,'freqinv')
           gabphasederiv('f',...,'relative') == -gabphasederiv('f',...,'timeinv')
           gabphasederiv('tt',...,'relative') == gabphasederiv('tt',...)
           gabphasederiv('ff',...,'relative') == -gabphasederiv('ff',...)
           gabphasederiv('tf',...,'relative') == gabphasederiv('tf',...,'freqinv')
     
        Several derivatives at once
        ---------------------------
     
        phasedcell=gabphasederiv({dflag1,dflag2,...},...) computes several
        phase derivatives at once while reusing some temporary computations thus
        saving computation time.
        {dflag1,dflag2,...} is a cell array of the derivative flags and
        cell elements of the returned phasedcell contain the corresponding
        derivatives i.e.:
     
            [pderiv1,pderiv2,...] = deal(phasedcell{:});
     
        [phasedcell,c]=gabphasederiv({dflag1,dflag2,...},'dgt',...) works the
        same as above but in addition returns coefficients c which are the
        byproduct of the 'dgt' method.
     
        Other flags and parameters work as before.
     
     
        References:
          F. Auger and P. Flandrin. Improving the readability of time-frequency
          and time-scale representations by the reassignment method. IEEE Trans.
          Signal Process., 43(5):1068--1089, 1995.
          
          E. Chassande-Mottin, I. Daubechies, F. Auger, and P. Flandrin.
          Differential reassignment. Signal Processing Letters, IEEE,
          4(10):293--294, 1997.
          
          J. Flanagan, D. Meinhart, R. Golden, and M. Sondhi. Phase Vocoder. The
          Journal of the Acoustical Society of America, 38:939, 1965.
          
          K. R. Fitz and S. A. Fulop. A unified theory of time-frequency
          reassignment. CoRR, abs/0903.3080, 2009.
          
          D. J. Nelson. Instantaneous higher order phase derivatives. Digital
          Signal Processing, 12(2-3):416--428, 2002. [1]http ]
          
          F. Auger, E. Chassande-Mottin, and P. Flandrin. On phase-magnitude
          relationships in the short-time fourier transform. Signal Processing
          Letters, IEEE, 19(5):267--270, May 2012.
          
          Z. Průša. STFT and DGT phase conventions and phase derivatives
          interpretation. Technical report, Acoustics Research Institute,
          Austrian Academy of Sciences, 2015.
          
          References
          
          1. http://dx.doi.org/10.1006/dspr.2002.0456
          
     *Url*: <http://ltfat.github.io/doc/gabor/gabphasederivreal.html>

     See also: resgram, gabreassign, dgt, pderiv, gabphasegrad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABPHASEDERIV   DGT phase derivatives
   Usage:  [phased,c] = gabphasederivre...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5476
 -- Function: gabphasegrad
     GABPHASEGRAD   Phase gradient of the DGT
        Usage:  [tgrad,fgrad,c] = gabphasegrad('dgt',f,g,a,M);
                [tgrad,fgrad]   = gabphasegrad('phase',cphase,a);
                [tgrad,fgrad]   = gabphasegrad('abs',s,g,a);
     
        [tgrad,fgrad]=GABPHASEGRAD(method,...) computes the relative 
        time-frequency gradient of the phase of the DGT of a signal. 
        The derivative in time tgrad is the relative instantaneous 
        frequency while the frequency derivative fgrad is the negative
        of the local group delay.
     
        tgrad is a measure the deviation from the current channel frequency,
        so a value of zero means that the instantaneous frequency is equal to 
        the center frequency of the considered channel, a positive value means
        the true absolute intantaneous frequency is higher than the current 
        channel frequency and vice versa. 
        Similarly, fgrad is a measure of deviation from the current time 
        positions.
     
        fgrad is scaled such that distances are measured in samples. Similarly,
        tgrad is scaled such that the Nyquist frequency (the highest possible
        frequency) corresponds to a value of L/2. The absolute time and 
        frequency positions can be obtained as
     
           tgradabs = bsxfun(@plus,tgrad,fftindex(M)*L/M);
           fgradabs = bsxfun(@plus,fgrad,(0:L/a-1)*a);
     
        Please note that neither tgrad and fgrad nor tgradabs and 
        fgradabs are true derivatives of the DGT phase. To obtain the true
        phase derivatives, one has to explicitly pass either 'freqinv' or 
        'timeinv' flags and scale both tgrad and fgrad by 2*pi/L.
     
        The computation of tgrad and fgrad is inaccurate when the absolute
        value of the Gabor coefficients is low. This is due to the fact the the
        phase of complex numbers close to the machine precision is almost
        random. Therefore, tgrad and fgrad may attain very large random values
        when abs(c) is close to zero.
     
        The computation can be done using four different methods.
     
          'dgt'    Directly from the signal using algorithm by Auger and
                   Flandrin.
     
          'phase'  From the phase of a DGT of the signal. This is the
                   classic method used in the phase vocoder.
     
          'abs'    From the absolute value of the DGT. Currently this
                   method works only for Gaussian windows.
     
          'cross'  Directly from the signal using algorithm by Nelson.
     
        [tgrad,fgrad]=GABPHASEGRAD('dgt',f,g,a,M) computes the time-frequency
        gradient using a DGT of the signal f. The DGT is computed using the
        window g on the lattice specified by the time shift a and the number
        of channels M. The algorithm used to perform this calculation computes
        several DGTs, and therefore this routine takes the exact same input
        parameters as DGT.
     
        The window g may be specified as in DGT. If the window used is
        'gauss', the computation will be done by a faster algorithm.
     
        [tgrad,fgrad,c]=GABPHASEGRAD('dgt',f,g,a,M) additionally returns the
        Gabor coefficients c, as they are always computed as a byproduct of the
        algorithm.
     
        [tgrad,fgrad]=GABPHASEGRAD('cross',f,g,a,M) does the same as above
        but this time using algorithm by Nelson which is based on computing 
        several DGTs.
     
        [tgrad,fgrad]=GABPHASEGRAD('phase',cphase,a) computes the phase
        gradient from the phase cphase of a DGT of the signal. The original DGT
        from which the phase is obtained must have been computed using a
        time-shift of a using the default phase convention ('freqinv') e.g.:
     
             [tgrad,fgrad]=gabphasegrad('phase',angle(dgt(f,g,a,M)),a)
     
        [tgrad,fgrad]=GABPHASEGRAD('abs',s,g,a) computes the phase gradient
        from the spectrogram s. The spectrogram must have been computed using
        the window g and time-shift a e.g.:
     
             [tgrad,fgrad]=gabphasegrad('abs',abs(dgt(f,g,a,M)),g,a)
     
        [tgrad,fgrad]=GABPHASEGRAD('abs',s,g,a,difforder) uses a centered finite
        diffence scheme of order difforder to perform the needed numerical
        differentiation. Default is to use a 4th order scheme.
     
        Currently the 'abs' method only works if the window g is a Gaussian
        window specified as a string or cell array.
     
     
        References:
          F. Auger and P. Flandrin. Improving the readability of time-frequency
          and time-scale representations by the reassignment method. IEEE Trans.
          Signal Process., 43(5):1068--1089, 1995.
          
          E. Chassande-Mottin, I. Daubechies, F. Auger, and P. Flandrin.
          Differential reassignment. Signal Processing Letters, IEEE,
          4(10):293--294, 1997.
          
          J. Flanagan, D. Meinhart, R. Golden, and M. Sondhi. Phase Vocoder. The
          Journal of the Acoustical Society of America, 38:939, 1965.
          
          Z. Průša. STFT and DGT phase conventions and phase derivatives
          interpretation. Technical report, Acoustics Research Institute,
          Austrian Academy of Sciences, 2015.
          
     *Url*: <http://ltfat.github.io/doc/gabor/gabphasegrad.html>

     See also: resgram, gabreassign, dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABPHASEGRAD   Phase gradient of the DGT
   Usage:  [tgrad,fgrad,c] = gabphas...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1192
 -- Function: gabprojdual
     GABPROJDUAL   Gabor Dual window by projection
        Usage:  gd=gabprojdual(gm,g,a,M)
                gd=gabprojdual(gm,g,a,M,L)
     
        Input parameters:
              gm    : Window to project.
              g     : Window function.
              a     : Length of time shift.
              M     : Number of modulations.
              L     : Length of transform to consider
        Output parameters:
              gd    : Dual window.
     
        GABPROJDUAL(gm,g,a,M) calculates the dual window of the Gabor frame given
        by g, a and M closest to gm measured in the l^2 norm. The
        function projects the suggested window gm onto the subspace of
        admissable dual windows, hence the name of the function.
     
        GABPROJDUAL(gm,g,a,M,L) first extends the windows g and gm to
        length L.
     
        GABPROJDUAL(...,'lt',lt) does the same for a non-separable lattice
        specified by lt. Please see the help of MATRIX2LATTICETYPE for a
        precise description of the parameter lt.
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabprojdual.html>

     See also: gabdual, gabtight, gabdualnorm, fir2long.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABPROJDUAL   Gabor Dual window by projection
   Usage:  gd=gabprojdual(gm,g,...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1379
 -- Function: gabreassign
     GABREASSIGN  Reassign time-frequency distribution
        Usage:  sr = gabreassign(s,tgrad,fgrad,a);
     
        GABREASSIGN(s,tgrad,fgrad,a) reassigns the values of the positive
        time-frequency distribution s using the phase gradient given by fgrad*
        and tgrad. The lattice is determined by the time shift a and the 
        number of channels deduced from the size of s.
     
        fgrad and tgrad can be obtained by the routine GABPHASEGRAD.
     
        Examples:
        ---------
     
        The following example demonstrates how to manually create a
        reassigned spectrogram. An easier way is to just call RESGRAM:
     
          % Create reassigned vector field of the bat signal.
          a=4; M=100;
          [tgrad, fgrad, c] = gabphasegrad('dgt',bat,'gauss',a,M);
     
          % Perform the actual reassignment
          sr = gabreassign(abs(c).^2,tgrad,fgrad,a);
     
          % Display it using plotdgt
          plotdgt(sr,a,143000,50);
       
     
        References:
          F. Auger and P. Flandrin. Improving the readability of time-frequency
          and time-scale representations by the reassignment method. IEEE Trans.
          Signal Process., 43(5):1068--1089, 1995.
          
     *Url*: <http://ltfat.github.io/doc/gabor/gabreassign.html>

     See also: resgram, gabphasegrad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABREASSIGN  Reassign time-frequency distribution
   Usage:  sr = gabreassign...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2935
 -- Function: gabreassignadjust
     GABREASSIGNADJUST Adjustable reassignment of a time-frequency distribution
        Usage:  sr = gabreassignadjust(s,pderivs,a,mu);
     
        GABREASSIGNADJUST(s,pderivs,a,mu) reassigns the values of the positive
        time-frequency distribution s using first and second order phase 
        derivatives given by pderivs and parameter mu*>0. 
        The lattice is determined by the time shift a and the number of 
        channels deduced from the size of s.
     
        pderivs is a cell array of phase derivatives which can be obtained 
        as follows:
     
           pderivs = gabphasederiv({'t','f','tt','ff','tf'},...,'relative');
     
        Please see help of GABPHASEDERIV for description of the missing
        parameters.
     
        gabreassign(s,pderivs,a,mu,despeckle) works as above, but some 
        coeficients are removed prior to the reassignment process. More
        precisely a mixed phase derivative pderivs{5} is used to determine 
        which coefficients m,n belong to sinusoidal components (such that 
        abs(1+pderivs{5}(m,n)) is close to zero) and to impulsive
        components (such that abs(pderivs{5}(m,n)) is close to zero).
        Parameter despeckle determines a threshold on the previous quantities
        such that coefficients with higher associated values are set to zeros.
     
        Algorithm
        ---------
     
        The routine uses the adjustable reassignment presented in the
        references.
     
        Examples:
        ---------
     
        The following example demonstrates how to manually create a
        reassigned spectrogram.:
     
          % Compute the phase derivatives
          a=4; M=100;
          [pderivs, c] = gabphasederiv({'t','f','tt','ff','tf'},'dgt',bat,'gauss',a,M,'relative');
     
          % Reassignemt parameter
          mu = 0.1;
          % Perform the actual reassignment
          sr = gabreassignadjust(abs(c).^2,pderivs,a,mu);
     
          % Display it using plotdgt
          plotdgt(sr,a,143000,50);
       
     
        References:
          F. Auger, E. Chassande-Mottin, and P. Flandrin. On phase-magnitude
          relationships in the short-time fourier transform. Signal Processing
          Letters, IEEE, 19(5):267--270, May 2012.
          
          F. Auger, E. Chassande-Mottin, and P. Flandrin. Making reassignment
          adjustable: The Levenberg-Marquardt approach. In Acoustics, Speech and
          Signal Processing (ICASSP), 2012 IEEE International Conference on,
          pages 3889--3892, March 2012.
          
          Z. Průša. STFT and DGT phase conventions and phase derivatives
          interpretation. Technical report, Acoustics Research Institute,
          Austrian Academy of Sciences, 2015.
          
     *Url*: <http://ltfat.github.io/doc/gabor/gabreassignadjust.html>

     See also: gabphasederiv, gabreassign.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABREASSIGNADJUST Adjustable reassignment of a time-frequency distribution
  ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1486
 -- Function: gabreassignreal
     GABREASSIGNREAL  Reassign time-frequency distribution for real signals
        Usage:  sr = gabreassignreal(s,tgrad,fgrad,a,M);
     
        GABREASSIGNREAL(s,tgrad,fgrad,a,M) reassigns the values of the positive
        time-frequency distribution s using the phase gradient given by fgrad*
        and tgrad. The lattice is determined by the time shift a and the 
        number of channels M.
     
        fgrad and tgrad can be obtained by the routine GABPHASEGRADREAL.
     
        Examples:
        ---------
     
        The following example demonstrates how to manually create a
        reassigned spectrogram. An easier way is to just call RESGRAM:
     
          % Create reassigned vector field of the bat signal.
          a=4; M=100;
          [phased,c] = gabphasederivreal({'t','f'},'dgt',bat,'gauss',a,M,'relative');
          [tgrad, fgrad] = deal(phased{:});
     
          % Perform the actual reassignment
          sr = gabreassignreal(abs(c).^2,tgrad,fgrad,a,M);
     
          % Display it using plotdgt
          plotdgt(sr,a,143000,50);
       
     
        References:
          F. Auger and P. Flandrin. Improving the readability of time-frequency
          and time-scale representations by the reassignment method. IEEE Trans.
          Signal Process., 43(5):1068--1089, 1995.
          
     *Url*: <http://ltfat.github.io/doc/gabor/gabreassignreal.html>

     See also: resgram, gabphasederivreal, gabreassign.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABREASSIGNREAL  Reassign time-frequency distribution for real signals
   Usa...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1234
 -- Function: gabrieszbounds
     GABRIESZBOUNDS  Calculate Riesz sequence/basis bounds of Gabor frame
        Usage:  fcond=gabrieszbounds(g,a,M);
                [A,B]=gabrieszbounds(g,a,M);
                [A,B]=gabrieszbounds(g,a,M,L);
     
        Input parameters:
                g     : The window function.
                a     : Length of time shift.
                M     : Number of channels.
                L     : Length of transform to consider.
        Output parameters:
                fcond : Frame condition number (B/A)
                A,B   : Frame bounds.
               
        GABRIESZBOUNDS(g,a,M) calculates the ratio B/A of the Riesz bounds
        of the Gabor system with window g, and parameters a, M.
     
        [A,B]=GABRIESZBOUNDS(g,a,M) calculates the Riesz bounds A and B*
        instead of just the ratio.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of GABWIN for more details.
       
        If the optional parameter L is specified, the window is cut or
        zero-extended to length L.
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabrieszbounds.html>

     See also: gabframebounds, gabwin, gabdualnorm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABRIESZBOUNDS  Calculate Riesz sequence/basis bounds of Gabor frame
   Usage...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2528
 -- Function: gabtight
     GABTIGHT  Canonical tight window of Gabor frame
        Usage:  gt=gabtight(a,M,L);
                gt=gabtight(g,a,M);
                gt=gabtight(g,a,M,L);
                gd=gabtight(g,a,M,'lt',lt);
     
        Input parameters:
              g     : Gabor window.
              a     : Length of time shift.
              M     : Number of modulations.
              L     : Length of window. (optional)
              lt    : Lattice type (for non-separable lattices).
        Output parameters:
              gt    : Canonical tight window, column vector.
     
        GABTIGHT(a,M,L) computes a nice tight window of length L for a
        lattice with parameters a, M. The window is not an FIR window,
        meaning that it will only generate a tight system if the system
        length is equal to L.
     
        GABTIGHT(g,a,M) computes the canonical tight window of the Gabor frame
        with window g and parameters a, M.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of GABWIN for more details.
       
        If the length of g is equal to M, then the input window is assumed to
        be a FIR window. In this case, the canonical dual window also has
        length of M. Otherwise the smallest possible transform length is
        chosen as the window length.
     
        GABTIGHT(g,a,M,L) returns a window that is tight for a system of
        length L. Unless the input window g is a FIR window, the returned
        tight window will have length L.
     
        GABTIGHT(g,a,M,'lt',lt) does the same for a non-separable lattice
        specified by lt. Please see the help of MATRIX2LATTICETYPE for a
        precise description of the parameter lt.
     
        If a>M then an orthonormal window of the Gabor Riesz sequence with
        window g and parameters a and M will be calculated.
     
        Examples:
        ---------
     
        The following example shows the canonical tight window of the Gaussian
        window. This is calculated by default by GABTIGHT if no window is
        specified:
     
          a=20;
          M=30;
          L=300;
          gt=gabtight(a,M,L);
          
          % Simple plot in the time-domain
          figure(1);
          plot(gt);
     
          % Frequency domain
          figure(2);
          magresp(gt,'dynrange',100);
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabtight.html>

     See also: gabdual, gabwin, fir2long, dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABTIGHT  Canonical tight window of Gabor frame
   Usage:  gt=gabtight(a,M,L)...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3833
 -- Function: gabwin
     GABWIN  Compute a Gabor window from text or cell array
        Usage: [g,info] = gabwin(g,a,M,L);
     
        [g,info]=GABWIN(g,a,M,L) computes a window that fits well with the
        specified number of channels M, time shift a and transform length
        L. The window itself is specified by a text description or a cell array
        containing additional parameters.
     
        The window can be specified directly as a vector of numerical
        values. In this case, GABWIN only checks assumptions about transform
        sizes etc.
     
        [g,info]=GABWIN(g,a,M) does the same, but the window must be a FIR
        window, as the transform length is unspecified.
     
        GABWIN(g,a,M,L,lt) or GABWIN(g,a,M,[],lt) does as above but for a
        non-separable lattice specified by lt. Please see the help of
        MATRIX2LATTICETYPE for a precise description of the parameter lt.
     
        The window can be specified as one of the following text strings:
       
          'gauss'      Gaussian window fitted to the lattice,
                       i.e. tfr=a*M/L.
     
          'dualgauss'  Canonical dual of Gaussian window.
     
          'tight'      Tight window generated from a Gaussian.
     
        In these cases, a long window is generated with a length of L.
     
        It is also possible to specify one of the window names from FIRWIN. In
        such a case, GABWIN will generate the specified FIR window with a length
        of M.
     
        The window can also be specified as cell array. The possibilities are:
     
          {'gauss',...}
              Additional parameters are passed to PGAUSS. When no additional
              parameters are passed, the window is generated according to the
              defaults in PGAUSS.
     
          {'dual',...}
              Canonical dual window of whatever follows. See the examples below.
     
          {'tight',...} 
              Canonical tight window of whatever follows.
     
        It is also possible to specify one of the window names from FIRWIN as
        the first field in the cell array. In this case, the remaining
        entries of the cell array are passed directly to FIRWIN.
     
        Some examples: To compute a Gaussian window of length L fitted for a
        system with time-shift a and M channels use:
     
          g=gabwin('gauss',a,M,L);
     
        To compute Gaussian window with equal time and frequency support
        irrespective of a and M*:
     
          g=gabwin({'gauss'},a,M,L);
     
        To compute the canonical dual of a Gaussian window fitted for a
        system with time-shift a and M channels:
     
          gd=gabwin('gaussdual',a,M,L);
     
        To compute the canonical tight window of the Gaussian window fitted
        for the system:
     
          gd=gabwin({'tight','gauss'},a,M,L);
     
        To compute the dual of a Hann window of length 20:  
      
          g=gabwin({'dual',{'hann',20}},a,M,L);
     
        The structure info provides some information about the computed
        window:
     
          info.gauss
             True if the window is a Gaussian.
     
          info.tfr
             Time/frequency support ratio of the window. Set whenever it makes sense.
     
          info.wasrow
             Input was a row window
     
          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 window.
     
     *Url*: <http://ltfat.github.io/doc/gabor/gabwin.html>

     See also: pgauss, firwin, wilwin.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABWIN  Compute a Gabor window from text or cell array
   Usage: [g,info] = g...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4260
 -- Function: idgt
     IDGT  Inverse discrete Gabor transform
        Usage:  f=idgt(c,g,a);
                f=idgt(c,g,a,Ls);
                f=idgt(c,g,a,Ls,lt);
     
        Input parameters:
              c     : Array of coefficients.
              g     : Window function.
              a     : Length of time shift.
              Ls    : Length of signal.
              lt    : Lattice type (for non-separable lattices)
        Output parameters:
              f     : Signal.
     
        IDGT(c,g,a) computes the inverste discrete Gabor transform of the
        input coefficients c with respect to the window g and time shift a.
        The number of  channels is deduced from the size of the coefficients c.
     
        IDGT(c,g,a,Ls) does as above but cuts or extends f to length Ls.
     
        [f,g]=IDGT(...) additionally outputs the window used in the
        transform. This is useful if the window was generated from a description
        in a string or cell array.
     
        For perfect reconstruction, the window used must be a dual window of the
        one used to generate the coefficients.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of GABWIN for more details.
     
        If g is a row vector, then the output will also be a row vector. If c is
        3-dimensional, then IDGT will return a matrix consisting of one column
        vector for each of the TF-planes in c.
     
        Assume that f=IDGT(c,g,a,L) for an array c of size M xN. 
        Then the following holds for k=0,...,L-1: 
      
                    N-1 M-1          
          f(l+1)  = sum sum c(m+1,n+1)*exp(2*pi*i*m*l/M)*g(l-a*n+1)
                    n=0 m=0          
     
        Non-separable lattices:
        -----------------------
     
        IDGT(c,g,a,'lt',lt) computes the Gabor expansion of the input
        coefficients c with respect to the window g, time shift a and
        lattice type lt. Please see the help of MATRIX2LATTICETYPE for a
        precise description of the parameter lt.
     
        Assume that f=dgt(c,g,a,L,lt) for an array c of size MxN.
        Then the following holds for k=0,...,L-1:
      
                    N-1 M-1          
          f(l+1)  = sum sum c(m+1,n+1)*exp(2*pi*i*m*l/M)*g(l-a*n+1)
                    n=0 m=0          
     
        Additional parameters:
        ----------------------
     
        IDGT takes the following flags at the end of the line of input
        arguments:
     
          'freqinv'  Compute an IDGT using a frequency-invariant phase. This
                     is the default convention described above.
     
          'timeinv'  Compute an IDGT using a time-invariant phase. This
                     convention is typically used in FIR-filter algorithms.
     
        Examples:
        ---------
     
        The following example demostrates the basic pricinples for getting
        perfect reconstruction (short version):
     
          f=greasy;            % test signal
          a=32;                % time shift
          M=64;                % frequency shift
          gs={'blackman',128}; % synthesis window
          ga={'dual',gs};      % analysis window
     
          [c,Ls]=dgt(f,ga,a,M);    % analysis
     
          % ... do interesting stuff to c at this point ...
       
          r=idgt(c,gs,a,Ls); % synthesis
     
          norm(f-r)          % test
     
        The following example does the same as the previous one, with an
        explicit construction of the analysis and synthesis windows:
     
          f=greasy;     % test signal
          a=32;         % time shift
          M=64;         % frequency shift
          Ls=length(f); % signal length
     
          % Length of transform to do
          L=dgtlength(Ls,a,M);
     
          % Analysis and synthesis window
          gs=firwin('blackman',128);
          ga=gabdual(gs,a,M,L);
     
          c=dgt(f,ga,a,M); % analysis
     
          % ... do interesting stuff to c at this point ...
       
          r=idgt(c,gs,a,Ls);  % synthesis
     
          norm(f-r)  % test
     
     *Url*: <http://ltfat.github.io/doc/gabor/idgt.html>

     See also: dgt, gabwin, dwilt, gabtight.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IDGT  Inverse discrete Gabor transform
   Usage:  f=idgt(c,g,a);
           f...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1487
 -- Function: idgt2
     IDGT2  2D Inverse discrete Gabor transform
        Usage: f=idgt2(c,g,a);
               f=idgt2(c,g1,g2,a);
               f=idgt2(c,g1,g2,[a1 a2]);
               f=idgt2(c,g,a,Ls);
               f=idgt2(c,g1,g2,a,Ls);
               f=idgt2(c,g1,g2,[a1 a2],Ls);
     
        Input parameters:
              c       : Array of coefficients.
              g,g1,g2 : Window function(s).
              a,a1,a2 : Length(s) of time shift.
              Ls      : Length(s) of reconstructed signal (optional).
     
        Output parameters:
              f       : Output data, matrix.
     
        IDGT2(c,g,a,M) will calculate a separable two dimensional inverse
        discrete Gabor transformation of the input coefficients c using the
        window g and parameters a, along each dimension. The number of channels
        is deduced from the size of the coefficients c.
     
        IDGT2(c,g1,g2,a) will do the same using the window g1 along the first
        dimension, and window g2 along the second dimension.
     
        IDGT2(c,g,a,Ls) or IDGT2(c,g1,g2,a,Ls) will cut the signal to size Ls*
        after the transformation is done.
     
        The parameters a and Ls can also be vectors of length 2.
        In this case the first element will be used for the first dimension
        and the second element will be used for the second dimension. 
     
     *Url*: <http://ltfat.github.io/doc/gabor/idgt2.html>

     See also: dgt2, gabdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IDGT2  2D Inverse discrete Gabor transform
   Usage: f=idgt2(c,g,a);
        ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3715
 -- Function: idgtreal
     IDGTREAL  Inverse discrete Gabor transform for real-valued signals
        Usage:  f=idgtreal(c,g,a,M);
                f=idgtreal(c,g,a,M,Ls);
     
        Input parameters:
              c     : Array of coefficients.
              g     : Window function.
              a     : Length of time shift.
              M     : Number of channels.
              Ls    : length of signal.
        Output parameters:
              f     : Signal.
     
        IDGTREAL(c,g,a,M) computes the inverse discrete Gabor transform of the 
        input coefficients c with respect to the real-valued window g, time 
        shift a and number of channels M.
        c is assumed to be the positive frequencies of the Gabor
        expansion of a real-valued signal. It must hold that size(c,1)==floor(M/2)+1. 
     
        Note that since the correct number of channels cannot be deduced from 
        the input, IDGTREAL takes an additional parameter as opposed to IDGT.   
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of GABWIN for more details.
       
        IDGTREAL(c,g,a,M,Ls) does as above but cuts or extends f to length Ls.
     
        [f,g]=IDGTREAL(...) additionally outputs the window used in the
        transform. This is usefull if the window was generated from a description
        in a string or cell array.
     
        For perfect reconstruction, the window used must be a dual window of the
        one used to generate the coefficients.
     
        If g is a row vector, then the output will also be a row vector. If c is
        3-dimensional, then IDGTREAL will return a matrix consisting of one column
        vector for each of the TF-planes in c.
     
        See the help on IDGT for the precise definition of the inverse Gabor
        transform.
     
        IDGTREAL takes the following flags at the end of the line of input
        arguments:
     
          'freqinv'  Use a frequency-invariant phase. This is the default
                     convention described in the help for DGT.
     
          'timeinv'  Use a time-invariant phase. This convention is typically 
                     used in filter bank algorithms.
     
        Examples:
        ---------
     
        The following example demostrates the basic pricinples for getting
        perfect reconstruction (short version):
     
          f=greasy;            % test signal
          a=32;                % time shift
          M=64;                % frequency shift
          gs={'blackman',128}; % synthesis window
          ga={'dual',gs};      %  analysis window
     
          [c,Ls]=dgtreal(f,ga,a,M); % analysis
     
          % ... do interesting stuff to c at this point ...
       
          r=idgtreal(c,gs,a,M,Ls); % synthesis
     
          norm(f-r)                % test
     
        The following example does the same as the previous one, with an
        explicit construction of the analysis and synthesis windows:
     
          f=greasy;     % test signal
          a=32;         % time shift
          M=64;         % frequency shift
          Ls=length(f); % signal length
     
          % Length of transform to do
          L=dgtlength(Ls,a,M);
     
          % Analysis and synthesis window
          gs=firwin('blackman',128);
          ga=gabdual(gs,a,M,L);
     
          c=dgtreal(f,ga,a,M);  % analysis
     
          % ... do interesting stuff to c at this point ...
       
          r=idgtreal(c,gs,a,M,Ls); % synthesis
     
          norm(f-r)       % test
     
     *Url*: <http://ltfat.github.io/doc/gabor/idgtreal.html>

     See also: idgt, gabwin, gabdual, dwilt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IDGTREAL  Inverse discrete Gabor transform for real-valued signals
   Usage: ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1552
 -- Function: idwilt
     IDWILT  Inverse discrete Wilson transform
        Usage:  f=idwilt(c,g);
                f=idwilt(c,g,Ls);
     
        Input parameters:
           c     : 2M xN array of coefficients.
           g     : Window function.
           Ls    : Final length of function (optional)
        Output parameters:
           f     : Input data
     
        IDWILT(c,g) computes an inverse discrete Wilson transform with window g.
        The number of channels is deduced from the size of the coefficient array c.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of WILWIN for more details.
       
        IDWILT(f,g,Ls) does the same, but cuts of zero-extend the final
        result to length Ls.
     
        [f,g]=IDWILT(...) additionally outputs the window used in the
        transform. This is usefull if the window was generated from a
        description in a string or cell array.
     
     
        References:
          H. Boelcskei, H. G. Feichtinger, K. Groechenig, and F. Hlawatsch.
          Discrete-time Wilson expansions. In Proc. IEEE-SP 1996 Int. Sympos.
          Time-Frequency Time-Scale Analysis, june 1996.
          
          Y.-P. Lin and P. Vaidyanathan. Linear phase cosine modulated maximally
          decimated filter banks with perfectreconstruction. IEEE Trans. Signal
          Process., 43(11):2525--2539, 1995.
          
     *Url*: <http://ltfat.github.io/doc/gabor/idwilt.html>

     See also: dwilt, wilwin, dgt, wilorth.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IDWILT  Inverse discrete Wilson transform
   Usage:  f=idwilt(c,g);
         ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1021
 -- Function: idwilt2
     IDWILT2  2D Inverse Discrete Wilson transform
        Usage: f=idwilt2(c,g);
               f=idwilt2(c,g1,g2);
               f=idwilt2(c,g1,g2,Ls);
     
        Input parameters:
              c       : Array of coefficients.
              g,g1,g2 : Window functions.
              Ls      : Size of reconstructed signal.
        Output parameters:
              f       : Output data, matrix.
     
        IDWILT2(c,g) calculates a separable two dimensional inverse
        discrete Wilson transformation of the input coefficients c using the
        window g. The number of channels is deduced from the size of the
        coefficients c.
     
        IDWILT2(c,g1,g2) does the same using the window g1 along the first
        dimension, and window g2 along the second dimension.
     
        IDWILT2(c,g1,g2,Ls) cuts the signal to size Ls after the transformation
        is done.
     
     *Url*: <http://ltfat.github.io/doc/gabor/idwilt2.html>

     See also: dwilt2, dgt2, wildual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IDWILT2  2D Inverse Discrete Wilson transform
   Usage: f=idwilt2(c,g);
     ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2812
 -- Function: instfreqplot
     INSTFREQPLOT  Plot of instantaneous frequency
        Usage: instfreqplot(f,op1,op2, ... );
               instfreqplot(f,fs,op1,op2, ... );
     
        INSTFREQPLOT(f) plots the instantaneous frequency of f using a DGT.
     
        INSTFREQPLOT(f,fs) does the same for a signal with sampling rate
        fs Hz.
     
        The instantaneous frequency contains extreme spikes in regions
        where the spectrogram is close to zero. These points are usually
        uninteresting and destroy the visibility of the plot. Use the 'thr'
        or 'clim' or 'climsym' options (see below) to remove these points.
     
        An example:
     
          instfreqplot(greasy,16000,'thr',.03,'climsym',100);
     
        will produce a nice instantaneous frequency plot of the GREASY
        signal.
     
        INSTFREQPLOT accepts the following optional arguments:
     
          'tfr',v     Set the ratio of frequency resolution to time resolution.
                      A value v=1 is the default. Setting v>1 will give better
                      frequency resolution at the expense of a worse time
                      resolution. A value of 0<v<1 will do the opposite.
       
          'wlen',s    Window length. Specifies the length of the window
                      measured in samples. See help of PGAUSS on the exact
                      details of the window length.
       
          'thr',r     Keep the coefficients with a magnitude larger than r*
                      times the largest magnitude. Set the instantaneous 
                      frequency of the rest of the coefficients to zero
       
          'nf'        Display negative frequencies, with the zero-frequency
                      centered in the middle. For real signals, this will just
                      mirror the upper half plane. This is standard for complex
                      signals.
       
          'tc'        Time centering. Move the beginning of the signal to the
                      middle of the plot. This is useful for visualizing the
                      window functions of the toolbox.
       
          'image'     Use imagesc to display the spectrogram. This is the
                      default.
       
          'dgt'       Use the 'dgt' method to compute the instantaneous
                      frequency. This is the default.
       
          'clim',clim  Use a colormap ranging from clim(1) to clim(2). These
                       values are passed to imagesc. See the help on imagesc.
       
          'climsym',cval  Use a colormap ranging from -cval to cval
       
          'fmax',y    Display y as the highest frequency.
     
     *Url*: <http://ltfat.github.io/doc/gabor/instfreqplot.html>

     See also: sgram, resgram, phaseplot.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
INSTFREQPLOT  Plot of instantaneous frequency
   Usage: instfreqplot(f,op1,op...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4262
 -- Function: isgram
     ISGRAM  Spectrogram inversion
        Usage:  f=isgram(c,g,a);
                f=isgram(c,g,a,Ls);
                [f,relres,iter]=isgram(...);
     
        Input parameters:
              c       : Array of coefficients.
              g       : Window function.
              a       : Length of time shift.
              Ls      : length of signal.
        Output parameters:
              f       : Signal.
              relres  : Vector of residuals.
              iter    : Number of iterations done.
     
        ISGRAM(s,g,a) attempts to invert a spectrogram computed by :
     
          s = abs(dgt(f,g,a,M)).^2;
     
        using an iterative method.
     
        ISGRAM(c,g,a,Ls) does as above but cuts or extends f to length Ls.
     
        If the phase of the spectrogram is known, it is much better to use
        idgt.
     
        [f,relres,iter]=ISGRAM(...) additionally return the residuals in a
        vector relres and the number of iteration steps iter.
     
        Generally, if the spectrogram has not been modified, the iterative
        algorithm will converge slowly to the correct result. If the
        spectrogram has been modified, the algorithm is not guaranteed to
        converge at all.  
     
        ISGRAM takes the following parameters at the end of the line of input
        arguments:
     
          'lt',lt      Specify the lattice type. See the help on MATRIX2LATTICETYPE.
     
          'zero'       Choose a starting phase of zero. This is the default
     
          'rand'       Choose a random starting phase.
     
          'int'        Construct a starting phase by integration. Only works
                       for Gaussian windows.
     
          'griflim'    Use the Griffin-Lim iterative method, this is the
                       default.
     
          'bfgs'       Use the limited-memory Broyden Fletcher Goldfarb
                       Shanno (BFGS) method.  
     
          'tol',t      Stop if relative residual error is less than the specified tolerance.  
     
          'maxit',n    Do at most n iterations.
     
          '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 p=10;
     
        The BFGS method makes use of the minFunc software. To use the BFGS method, 
        please install the minFunc software from:
        http://www.cs.ubc.ca/~schmidtm/Software/minFunc.html.
     
        Examples:
        ---------
     
        To reconstruct the phase of 'greasy', use the following:
     
          % Setup the problem and the coefficients
          f=greasy;
          g='gauss';
          a=20; M=200;
          c=dgt(f,g,a,M);
          s=abs(c).^2;
          theta=angle(c);
     
          % Reconstruct and get spectrogram and angle
          r=isgram(s,g,a);
          c_r=dgt(r,g,a,M);
          s_r=abs(c_r).^2;
          theta_r=angle(c_r);
     
          % Compute the angular difference
          d1=abs(theta-theta_r);
          d2=2*pi-d1;
          anglediff=min(d1,d2);
     
          % Plot the difference in spectrogram and phase
          figure(1);
          plotdgt(s./s_r,a,16000,'clim',[-10,10]);
          colormap([bone;flipud(bone)])
          title('Relative difference in spectrogram');
     
          figure(2);
          plotdgt(anglediff,a,16000,'lin');
          colormap(bone);
          title('Difference in angle');
     
     
        References:
          R. Decorsiere and P. L. Soendergaard. Modulation filtering using an
          optimization approach to spectrogram reconstruction. In Proceedings of
          the Forum Acousticum, 2011.
          
          D. Griffin and J. Lim. Signal estimation from modified short-time
          Fourier transform. IEEE Trans. Acoust. Speech Signal Process.,
          32(2):236--243, 1984.
          
          D. Liu and J. Nocedal. On the limited memory BFGS method for large
          scale optimization. Mathematical programming, 45(1):503--528, 1989.
          
     *Url*: <http://ltfat.github.io/doc/gabor/isgram.html>

     See also: isgramreal, frsynabs, dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
ISGRAM  Spectrogram inversion
   Usage:  f=isgram(c,g,a);
           f=isgram...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3504
 -- Function: isgramreal
     ISGRAMREAL  Spectrogram inversion (real signal)
        Usage:  f=isgramreal(s,g,a,M);
                f=isgramreal(s,g,a,M,Ls);
                [f,relres,iter]=isgramreal(...);
     
        Input parameters:
              s       : Array of coefficients.
              g       : Window function.
              a       : Length of time shift.
              M       : Number of channels.
              Ls      : length of signal.
        Output parameters:
              f       : Signal.
              relres  : Vector of residuals.
              iter    : Number of iterations done.
     
        ISGRAMREAL(s,g,a,M) attempts to invert a spectrogram computed by :
     
          s = abs(dgtreal(f,g,a,M)).^2;
     
        by an iterative method.
     
        ISGRAMREAL(s,g,a,M,Ls) does as above but cuts or extends f to length Ls.
     
        If the phase of the spectrogram is known, it is much better to use
        DGTREAL
     
        f,relres,iter]=ISGRAMREAL(...) additionally returns the residuals in a
        vector relres and the number of iteration steps done.
     
        Generally, if the spectrogram has not been modified, the iterative
        algorithm will converge slowly to the correct result. If the
        spectrogram has been modified, the algorithm is not guaranteed to
        converge at all.  
     
        ISGRAMREAL takes the following parameters at the end of the line of
        input arguments:
     
          'lt',lt      Specify the lattice type. See the help on
                       MATRIX2LATTICETYPE. Only the rectangular or quinqux
                       lattices can be specified.
     
          'zero'       Choose a starting phase of zero. This is the default
     
          'rand'       Choose a random starting phase.
     
          'int'        Construct a starting phase by integration. Only works
                       for Gaussian windows.
     
          'griflim'    Use the Griffin-Lim iterative method, this is the
                       default.
     
          'bfgs'       Use the limited-memory Broyden Fletcher Goldfarb
                       Shanno (BFGS) method.  
     
          'tol',t      Stop if relative residual error is less than the specified tolerance.  
     
          'maxit',n    Do at most n iterations.
     
          '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 p=10.
     
        The BFGS method makes use of the minFunc software. To use the BFGS method, 
        please install the minFunc software from:
        http://www.cs.ubc.ca/~schmidtm/Software/minFunc.html.
     
     
        References:
          R. Decorsiere and P. L. Soendergaard. Modulation filtering using an
          optimization approach to spectrogram reconstruction. In Proceedings of
          the Forum Acousticum, 2011.
          
          D. Griffin and J. Lim. Signal estimation from modified short-time
          Fourier transform. IEEE Trans. Acoust. Speech Signal Process.,
          32(2):236--243, 1984.
          
          D. Liu and J. Nocedal. On the limited memory BFGS method for large
          scale optimization. Mathematical programming, 45(1):503--528, 1989.
          
     *Url*: <http://ltfat.github.io/doc/gabor/isgramreal.html>

     See also: dgtreal, idgtreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
ISGRAMREAL  Spectrogram inversion (real signal)
   Usage:  f=isgramreal(s,g,a...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2005
 -- Function: iwmdct
     IWMDCT  Inverse MDCT
        Usage:  f=iwmdct(c,g);
                f=iwmdct(c,g,Ls);
     
        Input parameters:
              c     : M*N array of coefficients.
              g     : Window function.
              Ls    : Final length of function (optional)
        Output parameters:
              f     : Input data
     
        IWMDCT(c,g) computes an inverse windowed MDCT with window g. The
        number of channels is deduced from the size of the coefficient array c.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of WILWIN for more details.
     
        IWMDCT(f,g,Ls) does the same, but cuts or zero-extends the final
        result to length Ls.
     
        [f,g]=IWMDCT(...) additionally outputs the window used in the
        transform. This is usefull if the window was generated from a
        description in a string or cell array.
     
     
        References:
          H. Boelcskei and F. Hlawatsch. Oversampled Wilson-type cosine modulated
          filter banks with linear phase. In Asilomar Conf. on Signals, Systems,
          and Computers, pages 998--1002, nov 1996.
          
          H. S. Malvar. Signal Processing with Lapped Transforms. Artech House
          Publishers, 1992.
          
          J. P. Princen and A. B. Bradley. Analysis/synthesis filter bank design
          based on time domain aliasing cancellation. IEEE Transactions on
          Acoustics, Speech, and Signal Processing, ASSP-34(5):1153--1161, 1986.
          
          J. P. Princen, A. W. Johnson, and A. B. Bradley. Subband/transform
          coding using filter bank designs based on time domain aliasing
          cancellation. Proceedings - ICASSP, IEEE International Conference on
          Acoustics, Speech and Signal Processing, pages 2161--2164, 1987.
          
     *Url*: <http://ltfat.github.io/doc/gabor/iwmdct.html>

     See also: wmdct, wilwin, dgt, wildual, wilorth.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
IWMDCT  Inverse MDCT
   Usage:  f=iwmdct(c,g);
           f=iwmdct(c,g,Ls);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 991
 -- Function: iwmdct2
     IWMDCT2  2D Inverse windowed MDCT transform
        Usage: f=iwmdct2(c,g);
               f=iwmdct2(c,g1,g2);
               f=iwmdct2(c,g1,g2,Ls);
     
        Input parameters:
              c       : Array of coefficients.
              g,g1,g2 : Window functions.
              Ls      : Size of reconstructed signal.
        Output parameters:
              f       : Output data, matrix.
     
        IWMDCT2(c,g) calculates a separable two dimensional inverse WMDCT
        transform of the input coefficients c using the window g. The number of
        channels is deduced from the size of the coefficients c.
     
        IWMDCT2(c,g1,g2) does the same using the window g1 along the first
        dimension, and window g2 along the second dimension.
     
        IWMDCT2(c,g1,g2,Ls) cuts the signal to size Ls after the transform
        is done.
     
     *Url*: <http://ltfat.github.io/doc/gabor/iwmdct2.html>

     See also: wmdct2, dgt2, wildual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IWMDCT2  2D Inverse windowed MDCT transform
   Usage: f=iwmdct2(c,g);
       ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 701
 -- Function: izak
     IZAK  Inverse Zak transform
        Usage:  f=izak(c);
     
        IZAK(c) computes the inverse Zak transform of c. The parameter of
        the Zak transform is deduced from the size of c.
     
     
        References:
          A. J. E. M. Janssen. Duality and biorthogonality for discrete-time
          Weyl-Heisenberg frames. Unclassified report, Philips Electronics,
          002/94.
          
          H. Boelcskei and F. Hlawatsch. Discrete Zak transforms, polyphase
          transforms, and applications. IEEE Trans. Signal Process.,
          45(4):851--866, april 1997.
          
     *Url*: <http://ltfat.github.io/doc/gabor/izak.html>

     See also: zak.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
IZAK  Inverse Zak transform
   Usage:  f=izak(c);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 766
 -- Function: latticetype2matrix
     LATTICETYPE2MATRIX  Convert lattice description to matrix form
        Usage: V=latticetype2matrix(L,a,M,lt);
     
        V=LATTICETYPE2MATRIX(L,a,M,lt) converts a standard description of a
        lattice using the a, M and lt parameters into a 2x2
        integer matrix description. The conversion is only valid for the
        specified transform length L.
     
        The output will be in lower triangular Hemite normal form.
     
        For more information, see
        http://en.wikipedia.org/wiki/Hermite_normal_form.
     
        An example:
     
          V = latticetype2matrix(120,10,12,[1 2])
     
     *Url*: <http://ltfat.github.io/doc/gabor/latticetype2matrix.html>

     See also: matrix2latticetype.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
LATTICETYPE2MATRIX  Convert lattice description to matrix form
   Usage: V=la...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1192
 -- Function: longpar
     LONGPAR  Parameters for LONG windows
        Usage:  [L,tfr]=longpar(Ls,a,M);
                [L,tfr]=longpar('dgt',Ls,a,M);
                [L,tfr]=longpar('dwilt',Ls,M);
                [L,tfr]=longpar('wmdct',Ls,M);
     
        [L,tfr]=LONGPAR(Ls,a,M) or [L,tfr]=LONGPAR('dgt',Ls,a,M) calculates the 
        minimal transform length L for a DGT of a signal of length Ls with
        parameters a and M. L is always larger than Ls. The parameters tfr*
        describes the time-to-frequency ratio of the chosen lattice.
     
        An example can most easily describe the use of LONGPAR. Assume that
        we wish to perform Gabor analysis of an input signal f with a 
        suitable Gaussian window and lattice given by a and M. The following
        code will always work:
     
          Ls=length(f);
          [L,tfr]=longpar(Ls,a,M);
          g=pgauss(L,tfr);
          c=dgt(f,g,a,M);
     
        [L,tfr]=LONGPAR('dwilt',Ls,M) and [L,tfr]=LONGPAR('wmdct',Ls,M) will
        do the same for a Wilson/WMDCT basis with M channels.
     
     *Url*: <http://ltfat.github.io/doc/gabor/longpar.html>

     See also: dgt, dwilt, pgauss, psech, pherm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
LONGPAR  Parameters for LONG windows
   Usage:  [L,tfr]=longpar(Ls,a,M);
    ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2112
 -- Function: matrix2latticetype
     MATRIX2LATTICETYPE  Convert matrix form to standard lattice description
        Usage: [a,M,lt] = matrix2latticetype(L,V);
     
        [a,M,lt]=MATRIX2LATTICETYPE(L,V) converts a 2x2 integer matrix
        description into the standard description of a lattice using the a,
        M and lt. The conversion is only valid for the specified transform
        length L.
     
        The lattice type lt is a 1 x2 vector [lt_1,lt_2] denoting an
        irreducible fraction lt_1/lt_2. This fraction describes the distance
        in frequency (counted in frequency channels) that each coefficient is
        offset when moving in time by the time-shift of a. Some examples:
        lt=[0 1] defines a square lattice, lt=[1 2] defines the quinqux
        (almost hexagonal) lattice, lt=[1 3] describes a lattice with a
        1/3 frequency offset for each time shift and so forth.
     
        An example:
     
          [a,M,lt] = matrix2latticetype(120,[10 0; 5 10])
     
        Coefficient layout:
        -------------------
     
        The following code generates plots which show the coefficient layout
        and enumeration of the first 4 lattices in the time-frequecy plane:
     
          a=6;
          M=6;
          L=36;
          b=L/M;
          N=L/a;
          cw=3;
          ftz=12;
          
          [x,y]=meshgrid(a*(0:N-1),b*(0:M-1));
     
          lt1=[0 1 1 2];
          lt2=[1 2 3 3];
     
          for fignum=1:4
            subplot(2,2,fignum);
            z=y;
            if lt2(fignum)>0
              z=z+mod(lt1(fignum)*x/lt2(fignum),b);
            end;
            for ii=1:M*N
              text(x(ii)-cw/4,z(ii),sprintf('%2.0i',ii),'Fontsize',ftz);
              rectangle('Curvature',[1 1], 'Position',[x(ii)-cw/2,z(ii)-cw/2,cw,cw]);
            end;
            axis([-cw L -cw L]);
            axis('square');
            title(sprintf('lt=[%i %i]',lt1(fignum),lt2(fignum)),'Fontsize',ftz);
          end;
     
     *Url*: <http://ltfat.github.io/doc/gabor/matrix2latticetype.html>

     See also: latticetype2matrix.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
MATRIX2LATTICETYPE  Convert matrix form to standard lattice description
   Us...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6982
 -- Function: multidgtrealmp
     MULTIDGTREALMP  Matching Pursuit Decomposition with Multi-Gabor Dictionary
        Usage:  c = multidgtrealmp(f,dicts)
                c = multidgtrealmp(f,dicts,errdb,maxit)
                [c,frec,info] = multidgtrealmp(...)
     
        Input parameters:
            f        : Input signal
            dicts    : Dictionaries. Format {g1,a1,M1,g2,a2,M2,...}
            errdb    : Target normalized approximation error in dB
            maxit    : Maximum number of iterations.
        Output parameters:
            c        : Sparse representation
            frec     : Reconstructed signal
            info     : Struct with additional output paramerets
     
        MULTIDGTREALMP(f,{g1,a1,M1,g2,a2,M2,...,gW,aW,MW}) returns sparse 
        representation of a signal in W Gabor dictionaries using the 
        fast matching pursuit algorithm. gw is a Gabor window defined
        as in DGT and DGTREAL, aw is a hop factor, Mw is the number of 
        frequency channels. All aw and Mw must be divisible by min(a1,...,aW).
        The algorithm will try to reach -40 dB relative approximation error
        in at most numel(f) iterations.
        The function returns a cell-array with elements storing coefficients
        for individual Gabor systems such that they can be directly used in
        IDGTREAL. 
     
        MULTIDGTREALMP(f,dicts,errdb,maxit) tries to reach normalized 
        approximation error errdb dB in at most maxit iterations.
     
        [c,frec,info] = MULTIDGTREALMP(...) in addition returns the
        aproximation frec and a struct info with the following fields:
     
          .iter     Number of iterations done.
     
          .atoms    Number of atoms selected.
     
          .relres   Final approximation error. If resets are enabled, this is a
                    vector additionally containing the approximation error at 
                    every reset.
     
          .g        Cell array of numeric windows used in the multi-dictionary
     
          .a        Array of hop factors for indivitual dictionaries
     
          .M        Array of numbers of channels for individual dictionaries
     
          .synthetize  Anonymous function which can be used to synthetize from
                       the (modified) coefficients as 
                       frec = sum(info.synthetize(c),dim)
                       where dim=2 if the input f was a column vector and
                       dim=1 if it was a row vector. 
     
        The normalized approximation error is computed as 
        errdb=20*log10(norm(f-frec)/norm(f)).
     
        The function takes the following optional parameters at the end of
        the line of input arguments:
     
          'kenrnthr',kt     Kernel threshold. Must be in range ]0,1]. 
                            Default is 1e-4.
     
          'timeinv'         Use the time invariant phase convention. The
                            default is 'freqinv'.
     
          'pedanticsearch'  Be pedantic about the energy of pairs of 
                            conjugated atoms in the selection step. 
                            Disabled by default.
     
          'algorithm',alg   Algorithm to use. Available: 
                            'mp'(default),'selfprojmp','cyclicmp'
     
          'reset'           Reset the decomposition until stopping criteria
                            are met. The reset means a complete synthesis and 
                            re-analysis. Available: 
                            'noreset' (default), 'reset', 'quickreset'
                            Option 'quickreset' applies a heuristic to stop the 
                            algorithm more quickly when the targer error is 
                            reached.
     
        Reset conditions can be controlled by the following key-value pairs:
     
          'resetit',it      Reset the decomposition every it iteration.
                            Must be a positive integer.
     
          'reseterrdb',err  Reset the decomposition when the error estimate 
                            in dB decreases below err. Must be negative. 
                            Default is 10*log10(1.1*kv.kernthr).
     
        The computational routine is only available in C. Use LTFATMEX to
        to compile it.
     
        Algorithms
        ----------
     
        By default, the function uses the fast MP using approximate update 
        in the coefficient domain as described in:
        
        "Z. Prusa, N. Holighaus, P. Balazs: Fast Matching Pursuit with Multi-Gabor Dictionaries"
        
        The kernel threshold limits the minimum approximation error which
        can be reached. For example the default threshold 1e-4 in general 
        allows achieving at least -40 dB.
      
        Note that this algorithm internally computes the error as
        errdb = 10*log10(err(k)/norm(f)^2), with err(0) = norm(f)^2 and 
        err(k) = err(k-1) - abs(cselected(k))^2. Here, cselected(k) is the
        Gabor coefficient selected at the k-th MP step. This formula is exact 
        only if the kernel threshold equals 0. Otherwise it serves as a cheap
        estimate. The exact error is only computed when this function is run
        with resets enabled and only in between resets. 
        
        Examples
        --------
     
        The following example shows the decomposition in 3 dictionaries and
        plots contributions from the individual dictionaries and the residual.:
     
            [f,fs] = gspi;
            [c, frec, info] = multidgtrealmp(f,...
            {'blackman',128,512,'blackman',512,2048,'blackman',2048,8192});
            frecd = info.synthetize(c);
            figure(1); 
            xvals = (0:numel(f)-1)/fs;
            subplot(4,1,1); plot(xvals,frecd(:,1));ylim([-0.5,0.5]);
            subplot(4,1,2); plot(xvals,frecd(:,2));ylim([-0.5,0.5]);
            subplot(4,1,3); plot(xvals,frecd(:,3));ylim([-0.5,0.5]);
            subplot(4,1,4); plot(xvals,f-frec);ylim([-0.5,0.5]); xlabel('Time (s)');
     
     
        References:
          S. Mallat and Z. Zhang. Matching pursuits with time-frequency
          dictionaries. IEEE Trans. Signal Process., 41(12):3397--3415, 1993.
          
          Z. Průša. Fast matching pursuit with multi-gabor dictionaries.
          Submitted., 2018.
          
          L. Rebollo-Neira, M. Rozložnik, and P. Sasmal. Analysis of a low memory
          implementation of the orthogonal matching pursuit greedy strategy.
          CoRR, abs/1609.00053v2, 2017.
          
          B. L. Sturm and M. G. Christensen. Cyclic matching pursuits with
          multiscale time-frequency dictionaries. In Conf. Record of the 44th
          Asilomar Conference on Signals, Systems and Computers, pages 581--585,
          Nov 2010.
          
     *Url*: <http://ltfat.github.io/doc/gabor/multidgtrealmp.html>

     See also: dgtreal, idgtreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
MULTIDGTREALMP  Matching Pursuit Decomposition with Multi-Gabor Dictionary
  ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 746
 -- Function: noshearlength
     NOSHEARLENGTH  Transform length that does not require a frequency shear
        Usage: L=noshearlength(Ls,a,M,lt)
     
        NOSHEARLENGTH(Ls,a,M,lt) computes the next larger transform length
        bigger or equal to Ls for which the shear algorithm does not require
        a frequency side shear for a non-separable Gabor system specified by
        a, M and lt. 
     
        This property makes computation of the canonical dual and tight Gabor
        windows GABDUAL and GABTIGHT and the DGT for a full length window
        faster, if this transform length is choosen.
     
     *Url*: <http://ltfat.github.io/doc/gabor/noshearlength.html>

     See also: matrix2latticetype, dgt, gabdual, gabtight.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
NOSHEARLENGTH  Transform length that does not require a frequency shear
   Us...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1390
 -- Function: phaselock
     PHASELOCK  Phaselock Gabor coefficients
        Usage:  c=phaselock(c,a);
     
        PHASELOCK(c,a) phaselocks the Gabor coefficients c. The coefficients
        must have been obtained from a DGT with parameter a.
     
        Phaselocking the coefficients modifies them so as if they were obtained
        from a time-invariant Gabor system. A filter bank produces phase locked
        coefficients.
     
        Phaselocking of Gabor coefficients correspond to the following transform:
        Consider a signal f of length L and define N=L/a.
        The output from c=PHASELOCK(dgt(f,g,a,M),a) is given by
     
                       L-1 
          c(m+1,n+1) = sum f(l+1)*exp(-2*pi*i*m*(l-n*a)/M)*conj(g(l-a*n+1)), 
                       l=0  
     
        where m=0,...,M-1 and n=0,...,N-1 and l-an is computed modulo L.
     
        PHASELOCK(c,a,'lt',lt) does the same for a non-separable lattice
        specified by lt. Please see the help of MATRIX2LATTICETYPE for a
        precise description of the parameter lt.
     
     
        References:
          M. Puckette. Phase-locked vocoder. Applications of Signal Processing to
          Audio and Acoustics, 1995., IEEE ASSP Workshop on, pages 222 --225,
          1995.
          
     *Url*: <http://ltfat.github.io/doc/gabor/phaselock.html>

     See also: dgt, phaseunlock, symphase.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
PHASELOCK  Phaselock Gabor coefficients
   Usage:  c=phaselock(c,a);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 856
 -- Function: phaselockreal
     PHASELOCKREAL  Phaselock Gabor coefficients
        Usage:  c=phaselockreal(c,a,M);
     
        PHASELOCKREAL(c,a,M) phaselocks the Gabor coefficients c. 
        The coefficients must have been obtained from a DGTREAL with 
        parameter a.
     
        Phaselocking the coefficients modifies them so as if they were obtained
        from a time-invariant Gabor system. A filter bank produces phase locked
        coefficients.
     
        Please see help of PHASELOCK for more details.
     
     
        References:
          M. Puckette. Phase-locked vocoder. Applications of Signal Processing to
          Audio and Acoustics, 1995., IEEE ASSP Workshop on, pages 222 --225,
          1995.
          
     *Url*: <http://ltfat.github.io/doc/gabor/phaselockreal.html>

     See also: dgtreal, phaseunlockreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
PHASELOCKREAL  Phaselock Gabor coefficients
   Usage:  c=phaselockreal(c,a,M);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3486
 -- Function: phaseplot
     PHASEPLOT  Phase plot
        Usage: phaseplot(f,op1,op2, ... );
               phaseplot(f,fs,op1,op2, ... );
     
        PHASEPLOT(f) plots the phase of f using a DGT.
     
        PHASEPLOT(f,fs) does the same for a signal with sampling rate fs Hz.
     
        PHASEPLOT should only be used for short signals (shorter than the
        resolution of the screen), as there will otherwise be some visual
        aliasing, such that very fast changing areas will look very smooth.
        PHASEPLOT always calculates the phase of the full time/frequency plane
        (as opposed to SGRAM), and you therefore risk running out of memory
        for long signals.
     
        PHASEPLOT takes the following flags at the end of the line of input
        arguments:
     
          'tfr',v     Set the ratio of frequency resolution to time resolution.
                      A value v=1 is the default. Setting v>1 will give better
                      frequency resolution at the expense of a worse time
                      resolution. A value of 0<v<1 will do the opposite.
       
          'wlen',s    Window length. Specifies the length of the window
                      measured in samples. See help of PGAUSS on the exact
                      details of the window length.
       
          'nf'        Display negative frequencies, with the zero-frequency
                      centered in the middle. For real signals, this will just
                      mirror the upper half plane. This is standard for complex
                      signals.
       
          'tc'        Time centering. Move the beginning of the signal to the
                      middle of the plot. This is usefull for visualizing the
                      window functions of the toolbox.
       
          'thr',r     Keep the coefficients with a magnitude larger than r times the
                      largest magnitude. Set the phase of the rest of the
                      coefficients to zero. This is useful, because for small
                      amplitude the phase values can be meaningless.
       
          'timeinv'   Display the phase as computed by a time-invariant
                      DGT. This is the default.
       
          'freqinv'   Display the phase as computed by a frequency-invariant
                      DGT.
       
          'fmax',y    Display y as the highest frequency.
     
          'colorbar'   Display the colorbar. This is the default.
         
          'nocolorbar'  Do not display the colorbar.
     
        For the best result when using PHASEPLOT, use a circulant color
        map, for instance hsv.
     
        Examples:
        ---------
     
        The following code shows the phaseplot of a
        periodic, hyperbolic secant visualized using the hsv colormap:
     
          phaseplot(psech(200),'tc','nf');
          colormap(hsv);
     
        The following phaseplot shows the phase of white, Gaussian noise:
     
          phaseplot(randn(200,1));
          colormap(hsv);
      
     
     
        References:
          R. Carmona, W. Hwang, and B. Torresani. Practical Time-Frequency
          Analysis: continuous wavelet and Gabor transforms, with an
          implementation in S, volume 9 of Wavelet Analysis and its Applications.
          Academic Press, San Diego, 1998.
          
     *Url*: <http://ltfat.github.io/doc/gabor/phaseplot.html>

     See also: phaselock, demo_phaseplot.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PHASEPLOT  Phase plot
   Usage: phaseplot(f,op1,op2, ... );
          phasepl...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 793
 -- Function: phaseunlock
     PHASEUNLOCK  Undo phase lock of Gabor coefficients
        Usage:  c=phaseunlock(c,a);
     
        PHASEUNLOCK(c,a) removes phase locking from the Gabor coefficients c.
        The coefficient must have been obtained from a DGT with parameter a.
     
        Phase locking the coefficients modifies them so as if they were obtained
        from a time-invariant Gabor system. A filter bank produces phase locked
        coefficients. 
     
     
        References:
          M. Puckette. Phase-locked vocoder. Applications of Signal Processing to
          Audio and Acoustics, 1995., IEEE ASSP Workshop on, pages 222 --225,
          1995.
          
     *Url*: <http://ltfat.github.io/doc/gabor/phaseunlock.html>

     See also: dgt, phaselock, symphase.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PHASEUNLOCK  Undo phase lock of Gabor coefficients
   Usage:  c=phaseunlock(c...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 858
 -- Function: phaseunlockreal
     PHASEUNLOCKREAL  Undo phase lock of Gabor coefficients
        Usage:  c=phaseunlockreal(c,a,M);
     
        PHASEUNLOCKREAL(c,a,M) removes phase locking from the Gabor coefficients c.
        The coefficient must have been obtained from a DGTREAL with parameter a*
        and using the 'timeinv' flag.
     
        Phase locking the coefficients modifies them so as if they were obtained
        from a frequency-invariant Gabor system. A filter bank produces phase locked
        coefficients. 
     
     
        References:
          M. Puckette. Phase-locked vocoder. Applications of Signal Processing to
          Audio and Acoustics, 1995., IEEE ASSP Workshop on, pages 222 --225,
          1995.
          
     *Url*: <http://ltfat.github.io/doc/gabor/phaseunlockreal.html>

     See also: dgt, phaselockreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PHASEUNLOCKREAL  Undo phase lock of Gabor coefficients
   Usage:  c=phaseunlo...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1189
 -- Function: plotdgt
     PLOTDGT  Plot DGT coefficients
        Usage: plotdgt(coef,a);
               plotdgt(coef,a,fs);
               plotdgt(coef,a,fs,dynrange);
     
        PLOTDGT(coef,a) plots the Gabor coefficients coef. The coefficients
        must have been produced with a time shift of a.
     
        PLOTDGT(coef,a,fs) does the same assuming a sampling rate of
        fs Hz of the original signal.
     
        PLOTDGT(coef,a,fs,dynrange) additionally limits the dynamic range.
     
        The figure generated by this function places the zero-frequency in
        the center of the y-axis, with positive frequencies above and
        negative frequencies below.
        
        C=PLOTDGT(...) returns the processed image data used in the
        plotting. Inputting this data directly to imagesc or similar
        functions will create the plot. This is useful for custom
        post-processing of the image data.
     
        PLOTDGT supports all the optional parameters of TFPLOT. Please see
        the help of TFPLOT for an exhaustive list.
     
     *Url*: <http://ltfat.github.io/doc/gabor/plotdgt.html>

     See also: dgt, tfplot, sgram, plotdgtreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTDGT  Plot DGT coefficients
   Usage: plotdgt(coef,a);
          plotdgt(c...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1073
 -- Function: plotdgtreal
     PLOTDGTREAL  Plot DGTREAL coefficients
        Usage: plotdgtreal(coef,a,M);
               plotdgtreal(coef,a,M,fs);
               plotdgtreal(coef,a,M,fs,dynrange);
     
        PLOTDGTREAL(coef,a,M) plots Gabor coefficient from DGTREAL. The
        parameters a and M must match those from the call to DGTREAL.
     
        PLOTDGTREAL(coef,a,M,fs) does the same assuming a sampling rate of fs*
        Hz of the original signal.
     
        PLOTDGTREAL(coef,a,M,fs,dynrange) additionally limits the dynamic
        range.
     
        C=PLOTDGTREAL(...) 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.
     
        PLOTDGTREAL supports all the optional parameters of TFPLOT. Please
        see the help of TFPLOT for an exhaustive list.
     
     *Url*: <http://ltfat.github.io/doc/gabor/plotdgtreal.html>

     See also: dgtreal, tfplot, sgram, plotdgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTDGTREAL  Plot DGTREAL coefficients
   Usage: plotdgtreal(coef,a,M);
     ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1203
 -- Function: plotdwilt
     PLOTDWILT  Plot DWILT coefficients
        Usage: plotdwilt(coef);
               plotdwilt(coef,fs);
               plotdwilt(coef,fs,dynrange);
     
        PLOTDWILT(coef) will plot coefficients from DWILT.
     
        PLOTDWILT(coef,fs) will do the same assuming a sampling rate of fs*
        Hz of the original signal. Since a Wilson representation does not
        contain coefficients for all positions on a rectangular TF-grid, there
        will be visible 'holes' among the lowest (DC) and highest (Nyquist rate)
        coefficients. See the help on WIL2RECT.
     
        PLOTDWILT(coef,fs,dynrange) will additionally limit the dynamic
        range.
     
        C=PLOTDWILT(...) returns the processed image data used in the
        plotting. Inputting this data directly to imagesc or similar
        functions will create the plot. This is useful for custom
        post-processing of the image data.
        
        PLOTDWILT supports all the optional parameters of TFPLOT. Please
        see the help of TFPLOT for an exhaustive list.
     
     *Url*: <http://ltfat.github.io/doc/gabor/plotdwilt.html>

     See also: dwilt, tfplot, sgram, wil2rect.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTDWILT  Plot DWILT coefficients
   Usage: plotdwilt(coef);
          plotd...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 943
 -- Function: plotwmdct
     PLOTWMDCT  Plot WMDCT coefficients
        Usage: plotwmdct(coef);
               plotwmdct(coef,fs);
               plotwmdct(coef,fs,dynrange);
     
        PLOTWMDCT(coef) plots coefficients from WMDCT.
     
        PLOTWMDCT(coef,fs) does the same assuming a sampling rate of
        fs Hz of the original signal.
     
        PLOTWMDCT(coef,fs,dynrange) additionally limits the dynamic
        range.
     
        C=PLOTWMDCT(...) returns the processed image data used in the
        plotting. Inputting this data directly to imagesc or similar
        functions will create the plot. This is useful for custom
        post-processing of the image data.
        
        PLOTWMDCT supports all the optional parameters of TFPLOT. Please
        see the help of TFPLOT for an exhaustive list.
     
     *Url*: <http://ltfat.github.io/doc/gabor/plotwmdct.html>

     See also: wmdct, tfplot, sgram, plotdgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTWMDCT  Plot WMDCT coefficients
   Usage: plotwmdct(coef);
          plotw...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1787
 -- Function: proj_dual
     PROJ_DUAL projection onto the dual windows space
        Usage:  sol=proj_proj(x, ~, param)
                [sol, infos]=proj_b2(x, ~, param)
     
        Input parameters:
              x     : Input signal.
              param : Structure of optional parameters.
        Output parameters:
              sol   : Solution.
              infos : Structure summarizing informations at convergence
     
        PROJ_DUAL(x,~,param) solves:
     
           sol = argmin_{z} ||x - z||_2^2   s.t.  A z=y
     
        param is a Matlab structure containing the following fields:
     
         param.y : measurements (default: 0).
     
         param.A : Matrix (default: Id).
     
         param.AAtinv : (A A^*)^(-1) Define this parameter to speed up computation.
     
         param.verbose : 0 no log, 1 a summary at convergence, 2 print main
          steps (default: 1)
     
     
        infos is a Matlab structure containing the following fields:
     
         infos.algo : Algorithm used
     
         infos.iter : Number of iteration
     
         infos.time : Time of execution of the function in sec.
     
         infos.final_eval : Final evaluation of the function
     
         infos.crit : Stopping critterion used 
     
         infos.residue : Final residue  
     
     
        Rem: The input "~" is useless but needed for compatibility issue.
     
     
        References:
          M.-J. Fadili and J.-L. Starck. Monotone operator splitting for
          optimization problems in sparse recovery. In Image Processing (ICIP),
          2009 16th IEEE International Conference on, pages 1461--1464. IEEE,
          2009.
          
     *Url*: <http://ltfat.github.io/doc/gabor/proj_dual.html>

     See also: prox_l2, proj_b1.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PROJ_DUAL projection onto the dual windows space
   Usage:  sol=proj_proj(x, ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1514
 -- Function: projkern
     PROJKERN  Projection onto generating kernel space
        Usage:  cout=projkern(cin,a);
                cout=projkern(cin,g,a);
                cout=projkern(cin,ga,gs,a);
     
        Input parameters:
              cin   : Input coefficients
              g     : analysis/synthesis window
              ga    : analysis window
              gs    : synthesis window
              a     : Length of time shift.
        Output parameters:
              cout  : Output coefficients
     
        cout=PROJKERN(cin,a) projects a set of Gabor coefficients c onto the
        space of possible Gabor coefficients. This means that cin and cout*
        synthesize to the same signal. A tight window generated from a Gaussian
        will be used for both analysis and synthesis.
     
        The rationale for this function is a follows: Because the coefficient
        space of a Gabor frame is larger than the signal space (since the frame
        is redundant) then there are many coefficients that correspond to the
        same signal.
     
        Therefore, you might desire to work with the coefficients cin, but you
        are in reality working with cout.
     
        cout=PROJKERN(cin,g,a) does the same, using the window g for analysis
        and synthesis.
     
        cout=PROJKERN(cin,ga,gs,a) does the same, but for different analysis
        ga and synthesis gs windows.
     
     *Url*: <http://ltfat.github.io/doc/gabor/projkern.html>

     See also: dgt, idgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PROJKERN  Projection onto generating kernel space
   Usage:  cout=projkern(ci...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 404
 -- Function: rect2wil
     RECT2WIL  Inverse of WIL2RECT
        Usage:  c=rect2wil(c);
        
        RECT2WIL(c) takes Wilson coefficients processed by WIL2RECT and
        puts them back in the compact form used by DWILT and IDWILT. The
        coefficients can then be processed by IDWILT.
     
     *Url*: <http://ltfat.github.io/doc/gabor/rect2wil.html>

     See also: wil2rect, dwilt, idwilt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
RECT2WIL  Inverse of WIL2RECT
   Usage:  c=rect2wil(c);
   
   RECT2WIL(c) ta...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4785
 -- Function: resgram
     RESGRAM  Reassigned spectrogram plot
        Usage: resgram(f,op1,op2, ... );
               resgram(f,fs,op1,op2, ... );
     
        RESGRAM(f) plots a reassigned spectrogram of f.
     
        RESGRAM(f,fs) does the same for a signal with sampling rate fs*
        (sampled with fs samples per second).
     
        Because reassigned spectrograms can have an extreme dynamical range,
        consider always using the 'dynrange' or 'clim' options (see below)
        in conjunction with the 'db' option (on by default). An example:
     
          resgram(greasy,16000,'dynrange',70);
     
        This will produce a reassigned spectrogram of the GREASY signal
        without drowning the interesting features in noise.
     
        C=RESGRAM(f, ... ) returns the image to be displayed as a matrix. Use this
        in conjunction with imwrite etc. These coefficients are *only* intended to
        be used by post-processing image tools. Reassignment should be done
        using the GABREASSIGN function instead.
     
        RESGRAM accepts the following additional arguments:
     
     
          'dynrange',r  Limit the dynamical range to r by using a colormap in
                        the interval [chigh-r,chigh], where chigh is the highest
                        value in the plot. The default value of [] means to not
                        limit the dynamical range.
         
          'db'         Apply 20*log10 to the coefficients. This makes it possible to
                       see very weak phenomena, but it might show too much noise. A
                       logarithmic scale is more adapted to perception of sound.
                       This is the default.
     
          'sharp',alpha
                       Set the sharpness of the plot. If alpha=0 the regular
                       spectrogram is obtained. alpha=1 means full
                       reassignment. Anything in between will produce a partially
                       sharpened picture. Default is alpha=1.
         
          'lin'        Show the energy of the coefficients on a linear scale.
         
          'tfr',v      Set the ratio of frequency resolution to time resolution.
                       A value v=1 is the default. Setting v>1 will give better
                       frequency resolution at the expense of a worse time
                       resolution. A value of 0<v<1 will do the opposite.
         
          'wlen',s     Window length. Specifies the length of the window
                       measured in samples. See help of PGAUSS on the exact
                       details of the window length.
     
          'posfreq'    Display only the positive frequencies. This is the
                       default for real-valued signals.
         
          'nf'         Display negative frequencies, with the zero-frequency
                       centered in the middle. For real signals, this will just
                       mirror the upper half plane. This is standard for complex
                       signals.
         
          'tc'         Time centering. Move the beginning of the signal to the
                       middle of the plot. This is useful for visualizing the
                       window functions of the toolbox.
         
          'image'      Use imagesc to display the spectrogram. This is the
                       default.
         
          'clim',clim  Use a colormap ranging from clim(1) to clim(2). These
                       values are passed to imagesc. See the help on imagesc.
         
          'thr',r      Keep only the largest fraction r of the coefficients, and
                       set the rest to zero.
         
          'fmax',y     Display y as the highest frequency. Default value of []
                       means to use the Nyquist frequency.
         
          'xres',xres  Approximate number of pixels along x-axis / time.
                       The default value is 800
         
          'yres',yres  Approximate number of pixels along y-axis / frequency
                       The default value is 600
         
          'contour'    Do a contour plot to display the spectrogram.
                
          'surf'       Do a surf plot to display the spectrogram.
         
          'mesh'       Do a mesh plot to display the spectrogram.
         
          'colorbar'   Display the colorbar. This is the default.
         
          'nocolorbar'  Do not display the colorbar.
     
        In addition to these parameters, sgram accepts any of the flags from
        SETNORM. The window used to calculate the spectrogram will be
        normalized as specified.
     
     *Url*: <http://ltfat.github.io/doc/gabor/resgram.html>

     See also: sgram.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
RESGRAM  Reassigned spectrogram plot
   Usage: resgram(f,op1,op2, ... );
    ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 973
 -- Function: s0norm
     S0NORM S0-norm of signal
        Usage: y = s0norm(f);
               y = s0norm(f,...);
     
        S0NORM(f) computes the S_0-norm of a vector.
     
        If the input is a matrix or ND-array, the S_0-norm is computed along
        the first (non-singleton) dimension, and a vector of values is returned.
     
        *WARNING**: The S_0-norm is computed by computing a full Short-time
        Fourier transform of a signal, which can be quite time-consuming. Use
        this function with care for long signals.
     
        S0NORM takes the following flags at the end of the line of input
        parameters:
     
          'dim',d   Work along specified dimension. The default value of []
                    means to work along the first non-singleton one.
     
          'rel'     Return the result relative to the l^2 norm (the energy) of the
                    signal.
     *Url*: <http://ltfat.github.io/doc/gabor/s0norm.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
S0NORM S0-norm of signal
   Usage: y = s0norm(f);
          y = s0norm(f,...);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4791
 -- Function: sgram
     SGRAM  Spectrogram
        Usage: sgram(f,op1,op2, ... );
               sgram(f,fs,op1,op2, ... );
               C=sgram(f, ... );
     
        SGRAM(f) plots a spectrogram of f using a Discrete Gabor Transform (DGT).
     
        SGRAM(f,fs) does the same for a signal with sampling rate fs (sampled
        with fs samples per second);
     
        SGRAM(f,fs,dynrange) additionally limits the dynamic range of the
        plot. See the description of the 'dynrange' parameter below.
     
        C=SGRAM(f, ... ) returns the image to be displayed as a matrix. Use this
        in conjunction with imwrite etc. These coefficients are *only* intended to
        be used by post-processing image tools. Numerical Gabor signal analysis
        and synthesis should *always* be done using the DGT, IDGT, DGTREAL and
        IDGTREAL functions.
     
        Additional arguments can be supplied like this:
     
            sgram(f,fs,'dynrange',50)
     
        The arguments must be character strings possibly followed by an
        argument:
     
          'dynrange',r  Limit the dynamical range to r by using a colormap in
                        the interval [chigh-r,chigh], where chigh is the highest
                        value in the plot. The default value of [] means to not
                        limit the dynamical range.
         
          'db'         Apply 20*log10 to the coefficients. This makes it possible to
                       see very weak phenomena, but it might show too much noise. A
                       logarithmic scale is more adapted to perception of sound.
                       This is the default.
         
          'lin'        Show the energy of the coefficients on a linear scale.
         
          'tfr',v      Set the ratio of frequency resolution to time resolution.
                       A value v=1 is the default. Setting v>1 will give better
                       frequency resolution at the expense of a worse time
                       resolution. A value of 0<v<1 will do the opposite.
         
          'wlen',s     Window length. Specifies the length of the window
                       measured in samples. See help of PGAUSS on the exact
                       details of the window length.
     
          'posfreq'    Display only the positive frequencies. This is the
                       default for real-valued signals.
         
          'nf'         Display negative frequencies, with the zero-frequency
                       centered in the middle. For real signals, this will just
                       mirror the upper half plane. This is standard for complex
                       signals.
         
          'tc'         Time centering. Move the beginning of the signal to the
                       middle of the plot. This is useful for visualizing the
                       window functions of the toolbox.
         
          'image'      Use imagesc to display the spectrogram. This is the
                       default.
         
          'clim',clim  Use a colormap ranging from clim(1) to clim(2). These
                       values are passed to imagesc. See the help on imagesc.
         
          'thr',r      Keep only the largest fraction r of the coefficients, and
                       set the rest to zero.
         
          'fmax',y     Display y as the highest frequency. Default value of []
                       means to use the Nyquist frequency.
         
          'xres',xres  Approximate number of pixels along x-axis / time.
                       The default value is 800
         
          'yres',yres  Approximate number of pixels along y-axis / frequency
                       The Default value is 600
         
          'contour'    Do a contour plot to display the spectrogram.
                
          'surf'       Do a surf plot to display the spectrogram.
         
          'colorbar'   Display the colorbar. This is the default.
         
          'nocolorbar'  Do not display the colorbar.
     
        In addition to these parameters, SGRAM accepts any of the flags from
        SETNORM. The window used to calculate the spectrogram will be
        normalized as specified.
     
        Examples:
        ---------
     
        The GREASY signal is sampled using a sampling rate of 16 kHz. To
        display a spectrogram of GREASY with a dynamic range of 90 dB, use:
     
          sgram(greasy,16000,90);
     
        To create a spectrogram with a window length of 20ms (which is
        typically used in speech analysis) use :
     
          fs=16000;
          sgram(greasy,fs,90,'wlen',round(20/1000*fs));
     
     *Url*: <http://ltfat.github.io/doc/gabor/sgram.html>

     See also: dgt, dgtreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
SGRAM  Spectrogram
   Usage: sgram(f,op1,op2, ... );
          sgram(f,fs,op1...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 816
 -- Function: shearfind
     SHEARFIND  Shears for transformation of a general lattice to separable
        Usage:  [s0,s1,br] = shearfind(L,a,M,lt);
     
        [s0,s1,br]=SHEARFIND(L,a,M,lt) computes three numbers, the first two
        represent a frequency and time shear respectively. With the returned
        choices of s_0 and s_1 one can transform an initial lattice given by
        a, M and lt into a separable (rectangular) lattice given by 
     
            ar = a*L/(br*M)  and  Mr = L/br.
     
        If s_0 is non-zero, the transformation from general to separable
        lattice requires a frequency-side shear. Similarly, if s_1 is
        non-zero, a time-side shear is required.
     
     *Url*: <http://ltfat.github.io/doc/gabor/shearfind.html>

     See also: pchirp, matrix2latticetype.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
SHEARFIND  Shears for transformation of a general lattice to separable
   Usa...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1343
 -- Function: symphase
     SYMPHASE  Change Gabor coefficients to symmetric phase
        Usage:  c=symphase(c,a);
     
        SYMPHASE(c,a) alters the phase of the Gabor coefficients c so as if
        they were obtained from a Gabor transform based on symmetric
        time/frequency shifts. The coefficient must have been obtained from a
        DGT with parameter a.
     
        Gabor coefficients with symmetric phase correspond to the following 
        transform:
        Consider a signal f of length L and define N=L/a.
        The output from c=SYMPHASE(dgt(f,g,a,M),a) is given by
     
                       L-1 
          c(m+1,n+1) = sum f(l+1)*exp(-2*pi*i*m*(l-n*a/2)/M)*conj(g(l-a*n+1)), 
                       l=0  
     
        where m=0,...,M-1 and n=0,...,N-1 and l-an is computed modulo L.
     
        SYMPHASE(c,a,'lt',lt) does the same for a non-separable lattice
        specified by lt. Please see the help of MATRIX2LATTICETYPE for a
        precise description of the parameter lt.
     
     
        References:
          E. Chassande-Mottin, I. Daubechies, F. Auger, and P. Flandrin.
          Differential reassignment. Signal Processing Letters, IEEE,
          4(10):293--294, 1997.
          
     *Url*: <http://ltfat.github.io/doc/gabor/symphase.html>

     See also: dgt, phaselock, phaseunlock.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
SYMPHASE  Change Gabor coefficients to symmetric phase
   Usage:  c=symphase(...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1096
 -- Function: tconv
     TCONV  Twisted convolution
        Usage:  h=tconv(f,g);
     
        TCONV(f,g) computes the twisted convolution of the square matrices
        f and g.
     
        Let h=TCONV(f,g) for f,g being L xL matrices. Then h is given by
     
                        L-1 L-1
           h(m+1,n+1) = sum sum f(k+1,l+1)*g(m-k+1,n-l+1)*exp(-2*pi*i*(m-k)*l/L);
                        l=0 k=0
     
        where m-k and n-l are computed modulo L.
     
        If both f and g are of class sparse then h will also be a sparse
        matrix. The number of non-zero elements of h is usually much larger than
        the numbers for f and g. Unless f and g are very sparse, it can be
        faster to convert them to full matrices before calling TCONV. 
     
        The routine SPREADINV can be used to calculate an inverse convolution.
        Define h and r by:
     
          h=tconv(f,g);
          r=tconv(spreadinv(f),h);
     
        then r is equal to g.
     
     *Url*: <http://ltfat.github.io/doc/gabor/tconv.html>

     See also: spreadop, spreadfun, spreadinv.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
TCONV  Twisted convolution
   Usage:  h=tconv(f,g);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3491
 -- Function: tfplot
     TFPLOT  Plot coefficient matrix on the TF plane
        Usage: tfplot(coef,step,yr);
               tfplot(coef,step,yr,...);
     
        TFPLOT(coef,step,yr) will plot a rectangular coefficient array on the
        TF-plane. The shift in samples between each column of coefficients is
        given by the variable step. The vector yr is a 1 x2 vector
        containing the lowest and highest normalized frequency.
     
        C=TFPLOT(...) 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.
     
        TFPLOT is not meant to be called directly. Instead, it is called by
        other plotting routines to give a uniform display format. 
     
        TFPLOT (and all functions that call it) takes the following arguments.
     
          'dynrange',r
                   Limit the dynamical range to r by using a colormap in
                   the interval [chigh-r,chigh], where chigh is the highest
                   value in the plot. The default value of [] means to not
                   limit the dynamical range.
     
          'db'     Apply 20*log_{10} to the coefficients. This makes 
                   it possible to see very weak phenomena, but it might show 
                   too much noise. A logarithmic scale is more adapted to 
                   perception of sound. This is the default.
     
          'dbsq'   Apply 10*log_{10} to the coefficients. Same as the
                   'db' option, but assume that the input is already squared.  
     
          'lin'    Show the coefficients on a linear scale. This will
                   display the raw input without any modifications. Only works for
                   real-valued input.
     
          'linsq'  Show the square of the coefficients on a linear scale.
     
          'linabs'  Show the absolute value of the coefficients on a linear scale.
     
          'tc'     Time centering. Move the beginning of the signal to the
                   middle of the plot. 
     
          'clim',clim   Use a colormap ranging from clim(1) to clim(2). These
                        values are passed to imagesc. See the help on imagesc.
     
          'image'       Use imagesc to display the plot. This is the default.
     
          'contour'     Do a contour plot.
               
          'surf'        Do a surf plot.
     
          'colorbar'    Display the colorbar. This is the default.
     
          'nocolorbar'  Do not display the colorbar.
     
          'display'     Display the figure. This is the default.
     
          'nodisplay'   Do not display figure. This is usefull if you only
                        want to obtain the output for further processing.
     
        If both 'clim' and 'dynrange' are specified, then 'clim' takes
        precedence.
     
        It is possible to customize the text by setting the following values:
     
          'time', t       The word denoting time. Default is 'Time'
     
          'frequency',f   The word denoting frequency. Default is 'Frequency'
       
          'samples',s     The word denoting samples. Default is 'samples'
       
          'normalized',n  Defult value is 'normalized'.
       
     *Url*: <http://ltfat.github.io/doc/gabor/tfplot.html>

     See also: sgram, plotdgt, plotdgtreal, plotwmdct, plotdwilt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
TFPLOT  Plot coefficient matrix on the TF plane
   Usage: tfplot(coef,step,yr...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 642
 -- Function: wil2rect
     WIL2RECT  Arrange Wilson coefficients in a rectangular layout
        Usage:  c=wil2rect(c);
     
        WIL2RECT(c) rearranges the coefficients c in a rectangular shape. The
        coefficients must have been obtained from DWILT. After rearrangement
        the coefficients are placed correctly on the time/frequency-plane.
     
        The rearranged array is larger than the input array: it contains
        zeros on the spots where the Wilson transform is missing a DC or
        Nyquest component.
     
     *Url*: <http://ltfat.github.io/doc/gabor/wil2rect.html>

     See also: rect2wil, dwilt, wmdct.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WIL2RECT  Arrange Wilson coefficients in a rectangular layout
   Usage:  c=wi...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1231
 -- Function: wilbounds
     WILBOUNDS  Calculate frame bounds of Wilson basis
        Usage:  [AF,BF]=wilbounds(g,M)
                [AF,BF]=wilbounds(g,M,L)
     
        Input parameters:
                g       : Window function.
                M       : Number of channels.
                L       : Length of transform to do (optional)
        Output parameters:
                AF,BF   : Frame bounds.
               
        WILBOUNDS(g,M) calculates the frame bounds of the Wilson frame operator
        of the Wilson basis with window g and M channels.
     
        [A,B]=WILBOUNDS(g,a,M) returns the frame bounds A and B instead of
        just the ratio.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of WILWIN for more details.
     
        If the length of g is equal to 2*M then the input window is
        assumed to be a FIR window. Otherwise the smallest possible transform
        length is chosen as the window length.
     
        If the optional parameter L is specified, the window is cut or
        zero-extended to length L.
     
     *Url*: <http://ltfat.github.io/doc/gabor/wilbounds.html>

     See also: wilwin, gabframebounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WILBOUNDS  Calculate frame bounds of Wilson basis
   Usage:  [AF,BF]=wilbound...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1602
 -- Function: wildual
     WILDUAL  Wilson dual window
        Usage:  gamma=wildual(g,M);
                gamma=wildual(g,M,L);
     
        Input parameters:
              g     : Gabor window.
              M     : Number of modulations.
              L     : Length of window. (optional)
        Output parameters:
              gamma : Canonical dual window.
     
        WILDUAL(g,M) returns the dual window of the Wilson or WMDCT basis with
        window g, parameter M and length equal to the length of the window g.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of WILWIN for more details.
     
        If the length of g is equal to 2*M then the input window is
        assumed to be an FIR window. In this case, the dual window also has
        length of 2*M. Otherwise the smallest possible transform length is
        chosen as the window length.
     
        WILDUAL(g,M,L) does the same, but now L is used as the length of the
        Wilson basis.
     
        The input window g must be real and whole-point even. If g is not
        whole-point even, then reconstruction using the dual window will not be
        perfect. For a random window g, the window closest to g that satisfies
        these restrictions can be found by :
     
          g_wpe = real(peven(g));
     
        All windows in the toolbox satisfies these restrictions unless
        clearly stated otherwise.
     
     *Url*: <http://ltfat.github.io/doc/gabor/wildual.html>

     See also: dwilt, wilwin, wmdct, wilorth, isevenfunction.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WILDUAL  Wilson dual window
   Usage:  gamma=wildual(g,M);
           gamma=w...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 812
 -- Function: wilframediag
     WILFRAMEDIAG  Diagonal of Wilson and WMDCT frame operator
        Usage:  d=wilframediag(g,M,L);
     
        Input parameters:
              g     : Window function.
              M     : Number of channels.
              L     : Length of transform to do.
        Output parameters:
              d     : Diagonal stored as a column vector
     
        WILFRAMEDIAG(g,M,L) computes the diagonal of the Wilson or WMDCT frame
        operator with respect to the window g and number of channels M. The
        diagonal is stored a as column vector of length L.
     
        The diagonal of the frame operator can for instance be used as a
        preconditioner.
     
     *Url*: <http://ltfat.github.io/doc/gabor/wilframediag.html>

     See also: dwilt, wmdct, gabframediag.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WILFRAMEDIAG  Diagonal of Wilson and WMDCT frame operator
   Usage:  d=wilfra...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1918
 -- Function: wilorth
     WILORTH  Wilson orthonormal window
        Usage:   gt=wilorth(M,L);
                 gt=wilorth(g,M);
                 gt=wilorth(g,M,L);
     
        Input parameters:
              g   : Auxiliary window window function (optional).
              M   : Number of modulations.
              L   : Length of window (optional).
        Output parameters:
              gt  : Window generating an orthonormal Wilson basis.
     
        WILORTH(M,L) computes a nice window of length L generating an
        orthonormal Wilson or WMDCT basis with M frequency bands for signals
        of length L.
     
        WILORTH(g,M) computes a window generating an orthonomal basis from the
        window g and number of channels M.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of WILWIN for more details.
     
        If the length of g is equal to 2xM, then the input window is
        assumed to be a FIR window. In this case, the orthonormal window also
        has length of 2xM. Otherwise the smallest possible transform
        length is chosen as the window length.
     
        WILORTH(g,M,L) pads or truncates g to length L before calculating
        the orthonormal window. The output will also be of length L.
     
        The input window g must be real whole-point even. If g is not
        whole-point even, the computed window will not generate an orthonormal
        system (i.e. reconstruction will not be perfect). For a random window
        g, the window closest to g that satisfies these restrictions can be
        found by :
     
          g_wpe = real(peven(g));
     
        All Gabor windows in the toolbox satisfies these restrictions unless
        clearly stated otherwise.
     
     *Url*: <http://ltfat.github.io/doc/gabor/wilorth.html>

     See also: dwilt, wmdct, wildual, isevenfunction.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WILORTH  Wilson orthonormal window
   Usage:   gt=wilorth(M,L);
            g...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3398
 -- Function: wilwin
     WILWIN  Compute a Wilson/WMDCT window from text or cell array
        Usage: [g,info] = wilwin(g,M,L);
     
        [g,info]=WILWIN(g,M,L) computes a window that fits well with the
        specified number of channels M and transform length L. The window itself
        is specified by a text description or a cell array containing additional
        parameters.
     
        The window can be specified directly as a vector of numerical
        values. In this case, WILWIN only checks assumptions about transform
        sizes etc.
     
        [g,info]=WILWIN(g,M) does the same, but the window must be a FIR
        window, as the transform length is unspecified.
     
        The window can be specified as one of the following text strings:
       
          'gauss'      Gaussian window with optimal concentration
     
          'dualgauss'  Riesz dual of Gaussian window with optimal concentration.
     
          'tight'      Window generating an orthonormal basis
     
        In these cases, a long window is generated with a length of L.
     
        It is also possible to specify one of the window names from FIRWIN. In
        such a case, WILWIN generates the specified FIR window with a length
        of M.
     
        The window can also be specified as cell array. The possibilities are:
     
          {'gauss',...}
            Additional parameters are passed to PGAUSS
     
          {'dual',...}
            Dual window of whatever follows. See the examples below.
     
          {'tight',...}
            Orthonormal window of whatever follows.
     
        It is also possible to specify one of the window names from FIRWIN as
        the first field in the cell array. In this case, the remaining
        entries of the cell array are passed directly to FIRWIN.
     
        Some examples:
     
          g=wilwin('gauss',M,L);
     
        This computes a Gaussian window of length L fitted for a system with
        M channels. :
     
          g=wilwin({'gauss',1},M,L);
     
        This computes a Gaussian window with equal time and frequency support
        irrespective of M. :
     
          gd=wilwin('gaussdual',M,L);
     
        This computes the dual of a Gaussian window fitted for a system with M*
        channels. :
     
          gd=wilwin({'tight','gauss'},M,L);
     
        This computes the orthonormal window of the Gaussian window fitted for
        the system. :
     
          g=wilwin({'dual',{'hann',20}},M,L);
     
        This computes the dual of a Hann window of length 20.  
     
        The structure info provides some information about the computed
        window:
     
          info.gauss
             True if the window is a Gaussian.
     
          info.tfr
             Time/frequency support ratio of the window. Set whenever it makes sense.
     
          info.wasrow
             Input was a row window
     
          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 window.
     
     *Url*: <http://ltfat.github.io/doc/gabor/wilwin.html>

     See also: pgauss, firwin, gabwin.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WILWIN  Compute a Wilson/WMDCT window from text or cell array
   Usage: [g,in...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4149
 -- Function: wmdct
     WMDCT  Windowed MDCT transform
        Usage:  c=wmdct(f,g,M);
                c=wmdct(f,g,M,L);
                [c,Ls]=wmdct(...);
     
        Input parameters:
              f     : Input data
              g     : Window function.
              M     : Number of bands.
              L     : Length of transform to do.
        Output parameters:
              c     : M xN array of coefficients.
              Ls    : Length of input signal.
     
        WMDCT(f,g,M) computes a Windowed Modified Discrete Cosine Transform with
        M bands and window g.
     
        The length of the transform will be the smallest possible that is
        larger than the signal. f will be zero-extended to the length of the 
        transform. If f is a matrix, the transformation is applied to each column.
        g must be whole-point even.
     
        The window g may be a vector of numerical values, a text string or a
        cell array. See the help of WILWIN for more details.
     
        WMDCT(f,g,M,L) computes the MDCT transform as above, but does
        a transform of length L. f will be cut or zero-extended to length L*
        before the transform is done.
     
        [c,Ls]=WMDCT(f,g,M) or [c,Ls]=wmdct(f,g,M,L)` additionally returns the
        length of the input signal f. This is handy for reconstruction:
     
          [c,Ls]=wmdct(f,g,M);
          fr=iwmdct(c,gd,M,Ls);
     
        will reconstruct the signal f no matter what the length of f is, provided
        that gd is a dual Wilson window of g.
     
        [c,Ls,g]=WMDCT(...) additionally outputs the window used in the
        transform. This is useful if the window was generated from a description
        in a string or cell array.
     
        The WMDCT is sometimes known as an odd-stacked cosine modulated filter
        bank. The WMDCT defined by this routine is slightly different from the
        most common definition of the WMDCT, in order to be able to use the
        same window functions as the Wilson transform.
     
        Assume that the following code has been executed for a column vector f
        of length L:
     
          c=wmdct(f,g,M);  % Compute the WMDCT of f.
          N=size(c,2);     % Number of translation coefficients.
     
        The following holds for m=0,...,M-1 and n=0,...,N-1:
     
        If m+n is even:
     
                         L-1
            c(m+1,n+1) = sum f(l+1)*cos(pi*(m+.5)*l/M+pi/4)*g(l-n*M+1)
                         l=0
     
        If m+n is odd:
     
                        L-1
           c(m+1,n+1) = sum f(l+1)*sin(pi*(m+.5)*l/M+pi/4)*g(l-n*M+1)
                        l=0
     
        Examples:
        ---------
     
        The following example shows the WMDCT coefficients (128 channels) of the
        GREASY test signal:
     
          fs=16000; % Sampling rate
          c=wmdct(greasy,{'hann',0.02*fs},128);
          plotwmdct(c,fs,90);
     
        Compare the visual difference with the redundant expansion of the
        same signal given in the example of the DGTREAL function.
     
     
        References:
          H. Boelcskei and F. Hlawatsch. Oversampled Wilson-type cosine modulated
          filter banks with linear phase. In Asilomar Conf. on Signals, Systems,
          and Computers, pages 998--1002, nov 1996.
          
          H. S. Malvar. Signal Processing with Lapped Transforms. Artech House
          Publishers, 1992.
          
          J. P. Princen and A. B. Bradley. Analysis/synthesis filter bank design
          based on time domain aliasing cancellation. IEEE Transactions on
          Acoustics, Speech, and Signal Processing, ASSP-34(5):1153--1161, 1986.
          
          J. P. Princen, A. W. Johnson, and A. B. Bradley. Subband/transform
          coding using filter bank designs based on time domain aliasing
          cancellation. Proceedings - ICASSP, IEEE International Conference on
          Acoustics, Speech and Signal Processing, pages 2161--2164, 1987.
          
     *Url*: <http://ltfat.github.io/doc/gabor/wmdct.html>

     See also: iwmdct, wilwin, dwilt, wildual, wilorth.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WMDCT  Windowed MDCT transform
   Usage:  c=wmdct(f,g,M);
           c=wmdct(...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2319
 -- Function: wmdct2
     WMDCT2  2D Discrete windowed MDCT transform
        Usage: c=wmdct2(f,g,M); 
               c=wmdct2(f,g1,g2,[M1,M2]);
               c=wmdct2(f,g1,g2,[M1,M2],[L1,L2]);
               [c,L]=wmdct2(f,g1,g2,[M1,M2],[L1,L2]);
     
        Input parameters:
              f        : Input data, matrix.
              g,g1,g2  : Window functions.
              M,M1,M2  : Number of bands.
              L1,L2    : Length of transform to do.
        Output parameters:
              c        : array of coefficients.
              Ls       : Original size of input matrix.
     
        WMDCT2(f,g,M) calculates a two dimensional Modified Discrete Cosine
        transform of the input signal f using the window g and parameter 
        M along each dimension.
     
        For each dimension, the length of the transform will be the smallest
        possible that is larger than the length of the signal along that
        dimension. f will be appropriately zero-extended.
     
        All windows must be whole-point even.
      
        WMDCT2(f,g,M,L) computes a 2D windowed MDCT as above, but does a
        transform of length L along each dimension. f will be cut or
        zero-extended to length L before the transform is done.
     
        [c,Ls]=wmdct(f,g,M) or [c,Ls]=wmdct(f,g,M,L) additionally return the
        length of the input signal f. This is handy for reconstruction.
     
        c=WMDCT2(f,g1,g2,M) makes it possible to use different windows along
        the two dimensions.
     
        The parameters L, M and Ls can also be vectors of length 2. In this case
        the first element will be used for the first dimension and the second
        element will be used for the second dimension. 
     
        The output c has 4 or 5 dimensions. The dimensions index the following
        properties:
     
           1. Number of translation along 1st dimension of input.
     
           2. Number of channel along 1st dimension  of input
     
           3. Number of translation along 2nd dimension of input.
     
           4. Number of channel along 2nd dimension  of input
     
           5. Plane number, corresponds to 3rd dimension of input. 
      
     *Url*: <http://ltfat.github.io/doc/gabor/wmdct2.html>

     See also: wmdct, iwmdct2, dgt2, wildual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WMDCT2  2D Discrete windowed MDCT transform
   Usage: c=wmdct2(f,g,M); 
     ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1864
 -- Function: zak
     ZAK  Zak transform
        Usage:  c=zak(f,a);
     
        ZAK(f,a) computes the Zak transform of f with parameter a.  The
        coefficients are arranged in an a xL/a matrix, where L is the
        length of f.
     
        If f is a matrix then the transformation is applied to each column.
        This is then indexed by the third dimension of the output.
     
        Assume that c=zak(f,a), where f is a column vector of length L and
        N=L/a. Then the following holds for m=0,...,a-1 and n=0,...,N-1
     
                               N-1  
          c(m+1,n+1)=1/sqrt(N)*sum f(m-k*a+1)*exp(2*pi*i*n*k/N)
                               k=0
     
        Examples:
        ---------
     
        This figure shows the absolute value of the Zak-transform of a Gaussian.
        Notice that the Zak-transform is 0 in only a single point right in the
        middle of the plot :
     
          a=64;
          L=a^2; 
          g=pgauss(L);
          zg=zak(g,a);
     
          surf(abs(zg));
        
        This figure shows the absolute value of the Zak-transform of a 4th order
        Hermite function.  Notice how the Zak transform of the Hermite functions
        is zero on a circle centered on the corner :
     
          a=64;
          L=a^2; 
          g=pherm(L,4);
          zg=zak(g,a);
     
          surf(abs(zg));
     
     
        References:
          A. J. E. M. Janssen. Duality and biorthogonality for discrete-time
          Weyl-Heisenberg frames. Unclassified report, Philips Electronics,
          002/94.
          
          H. Boelcskei and F. Hlawatsch. Discrete Zak transforms, polyphase
          transforms, and applications. IEEE Trans. Signal Process.,
          45(4):851--866, april 1997.
          
     *Url*: <http://ltfat.github.io/doc/gabor/zak.html>

     See also: izak.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
ZAK  Zak transform
   Usage:  c=zak(f,a);





