# doc-cache created by Octave 9.2.0
# name: cache
# type: cell
# rows: 3
# columns: 109
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
arg_fwt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 161
 -- Function: arg_fwt
     definput.flags.ext=  {'per','zpd','sym','symw','asym','asymw','ppd','sp0'};
     *Url*: <http://ltfat.github.io/doc/comp/arg_fwt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
definput.flags.ext=  {'per','zpd','sym','symw','asym','asymw','ppd','sp0'};
 ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 134
 -- Function: arg_fwtcommon
     definput.flags.ansy = {'syn','ana'};
     *Url*: <http://ltfat.github.io/doc/comp/arg_fwtcommon.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
definput.flags.ansy = {'syn','ana'};
   *Url*: <http://ltfat.github.io/doc/co...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 167
 -- Function: arg_fwtext
     definput.flags.ext=  {'per','zpd','sym','symw','asym','asymw','ppd','sp0'};
     *Url*: <http://ltfat.github.io/doc/comp/arg_fwtext.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
definput.flags.ext=  {'per','zpd','sym','symw','asym','asymw','ppd','sp0'};
 ...



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


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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 117
 -- Function: arg_uwfbtcommon
      Filter scaling
     *Url*: <http://ltfat.github.io/doc/comp/arg_uwfbtcommon.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 Filter scaling
   *Url*: <http://ltfat.github.io/doc/comp/arg_uwfbtcommon.ht...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 231
 -- Function: arg_wfbtcommon
      definput.keyvals.J = 1;
      definput.flags.treetype = {'full','dwt'};
      Frequency vs. natral ordering of the output subbands
     *Url*: <http://ltfat.github.io/doc/comp/arg_wfbtcommon.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 definput.keyvals.J = 1;
 definput.flags.treetype = {'full','dwt'};
 Frequenc...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
arghelper_filterswinparser


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 167
 -- Function: arghelper_filterswinparser
      Search for window given as cell array
     *Url*:
     <http://ltfat.github.io/doc/comp/arghelper_filterswinparser.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 Search for window given as cell array
   *Url*:
<http://ltfat.github.io/doc/...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1000
 -- Function: assert_L
     ASSERT_L  Validate lattice and window size.
        Usage:  [b,N,L]=assert_L(Ls,Lwindow,L,a,M,callfun);
     
        Input parameters:
              Ls      : Length of signal (see below).
              Lwindow : Length of window.
              L       : Specified length of transform (may be [])
              a       : Length of time shift.
              M       : Number of modulations.
              callfun : Name of calling function.
        Output parameters:
              b       : Length of frequency shift.
              N       : Number of translations.
              L       : Transform length.         
     
       Calculate a minimal transform length, or verify a user specified
       input length.
     
       The routine assumes that a and M has already been checked. use
       assert_squarelat for this.
     
       If the window length is not yet determined, it is safe to pass Lwindow=0
     *Url*: <http://ltfat.github.io/doc/comp/assert_L.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
ASSERT_L  Validate lattice and window size.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 189
 -- Function: assert_classname
      ASSERT_CLASSNAME 
     
      Returns name of the least "simplest" common data type.
     *Url*: <http://ltfat.github.io/doc/comp/assert_classname.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 505
 -- Function: assert_groworder
     ASSERT_GROWORDER  Grow the order parameter
     
        ASSERT_GROWORDER is meant to be used in conjunction with
        assert_sigreshape_pre and assert_sigreshape_post. It is used to
        modify the order parameter in between calls in order to expand the
        processed dimension by 1, i.e. for use in a routine that creates 2D
        output from 1D input, for instance in dgt or filterbank.
     *Url*: <http://ltfat.github.io/doc/comp/assert_groworder.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
ASSERT_GROWORDER  Grow the order parameter



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
assert_sigreshape_post


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 639
 -- Function: assert_sigreshape_post
     ASSERT_SIGRESHAPE_POST  Restore dimension input.
     
        Input parameters:
           f            : Input signal as matrix
           dim          : Verified dim
           permutedsize : pass to assert_sigreshape_post
           order        : pass to assert_sigreshape_post
        Output parameters:
           f            : signal, possibly ND-array
     
        ASSERT_SIGRESHAPE_POST works in conjunction with
        assert_sigreshape_pre and restores the original
        dimensions of the input array
     *Url*:
     <http://ltfat.github.io/doc/comp/assert_sigreshape_post.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
ASSERT_SIGRESHAPE_POST  Restore dimension input.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
assert_sigreshape_pre


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 783
 -- Function: assert_sigreshape_pre
     ASSERT_SIGRESHAPE_PRE  Preprocess and handle dimension input.
     
        Input parameters:
           f            : signal, possibly ND-array
           L            : L parameter
           dim          : dim parameter
           callfun      : Name of calling function
        Output parameters:
           f            : Input signal as matrix
           L            : Verified L
           Ls           : Length of signal along dimension to be processed
           W            : Number of transforms to do.
           dim          : Verified dim
           permutedsize : pass to assert_sigreshape_post
           order        : pass to assert_sigreshape_post
     *Url*: <http://ltfat.github.io/doc/comp/assert_sigreshape_pre.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
ASSERT_SIGRESHAPE_PRE  Preprocess and handle dimension input.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 707
 -- Function: assert_squarelat
     ASSERT_SQUARELAT  Validate lattice and window size.
        Usage:  assert_squarelat(a,M,R,callfun,flag);
     
        Input parameters:
              a       : Length of time shift.
              M       : Number of modulations.
              R       : Number of multiwindows.
              callfun : Name of calling function.
              flag    : See below.
              
       if flag>0 test if system is at least critically sampled.
     
       This routine deliberately checks the validity of M before a, such
       that it can be used for DWILT etc., where you just pass a=M.
     
       
     *Url*: <http://ltfat.github.io/doc/comp/assert_squarelat.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
ASSERT_SQUARELAT  Validate lattice and window size.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 243
 -- Function: block_interface
     BLOCK_INTERFACE Common block processing backend
     
       Object-like interface for sharing data between block handling
       functions. 
     *Url*: <http://ltfat.github.io/doc/comp/block_interface.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
BLOCK_INTERFACE Common block processing backend



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1184
 -- Function: comp_dgt
     COMP_DGT  Compute a DGT
        Usage:  c=comp_dgt(f,g,a,M,L,phasetype);
     
        Input parameters:
              f     : Input data
              g     : Window function.
              a     : Length of time shift.
              M     : Number of modulations.
              L     : Length of transform to do.
              lt    : Lattice type
              phasetype : Type of phase
              algtype : Select algorithm
        Output parameters:
              c     : M*N*W array of coefficients.
     
        If phasetype is zero, a freq-invariant transform is computed. If
        phase-type is one, a time-invariant transform is computed.
     
        The algorithm chooser do the following:
     
            algfir=0 : Default value, automatically choose the fastest
             algorithm.
            
            algfir=1 : Choose the algorithm depending on the input.
     
            algns=0  : Default value, automatically choose the fastest
             algorithm.
     
            algns=1  : Always choose multiwindow.
     
            algns=2  : Always choose shear
     *Url*: <http://ltfat.github.io/doc/comp/comp_dgt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
COMP_DGT  Compute a DGT
   Usage:  c=comp_dgt(f,g,a,M,L,phasetype);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 267
 -- Function: comp_dgt_fb
     COMP_DGT_FB  Filter bank DGT
        Usage:  c=comp_dgt_fb(f,g,a,M);
       
        This is a computational routine. Do not call it directly.
     
        See help on DGT.
     *Url*: <http://ltfat.github.io/doc/comp/comp_dgt_fb.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_DGT_FB  Filter bank DGT
   Usage:  c=comp_dgt_fb(f,g,a,M);
  
   This is...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1071
 -- Function: comp_dgt_long
     COMP_DGT_LONG  Gabor transform using long windows.
        Usage:  c=comp_dgt_long(f,g,a,M);
     
        Input parameters:
              f      : Factored input data
              g      : Window.
              a      : Length of time shift.
              M      : Number of channels.
        Output parameters:
              c      : M x N*W*R array of coefficients, where N=L/a
     
        Do not call this function directly, use DGT instead.
        This function does not check input parameters!
     
        References:
          T. Strohmer. Numerical algorithms for discrete Gabor expansions. In
          H. G. Feichtinger and T. Strohmer, editors, Gabor Analysis and
          Algorithms, chapter 8, pages 267--294. Birkhauser, Boston, 1998.
          
          P. L. Soendergaard. An efficient algorithm for the discrete Gabor
          transform using full length windows. IEEE Signal Process. Letters,
          submitted for publication, 2007.
          
     *Url*: <http://ltfat.github.io/doc/comp/comp_dgt_long.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
COMP_DGT_LONG  Gabor transform using long windows.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 227
 -- Function: comp_dgt_ola
     
       This function implements periodic convolution using overlap-add. The
       window g is supposed to be extended by fir2iir.
     *Url*: <http://ltfat.github.io/doc/comp/comp_dgt_ola.html>


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

  This function implements periodic convolution using overlap-add.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1379
 -- Function: comp_dgt_walnut
     COMP_DGT_WALNUT  First step of full-window factorization of a Gabor matrix.
        Usage:  c=comp_dgt_walnut(f,gf,a,M);
     
        Input parameters:
              f      : Factored input data
              gf     : Factorization of window (from facgabm).
              a      : Length of time shift.
              M      : Number of channels.
        Output parameters:
              c      : M x N*W*R array of coefficients, where N=L/a
     
        Do not call this function directly, use DGT instead.
        This function does not check input parameters!
     
        The length of f and gamma must match.
     
        If input is a matrix, the transformation is applied to
        each column.
     
        This function does not handle the multidim case. Take care before
        calling this.
     
        References:
          T. Strohmer. Numerical algorithms for discrete Gabor expansions. In
          H. G. Feichtinger and T. Strohmer, editors, Gabor Analysis and
          Algorithms, chapter 8, pages 267--294. Birkhauser, Boston, 1998.
          
          P. L. Soendergaard. An efficient algorithm for the discrete Gabor
          transform using full length windows. IEEE Signal Process. Letters,
          submitted for publication, 2007.
          
     *Url*: <http://ltfat.github.io/doc/comp/comp_dgt_walnut.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
COMP_DGT_WALNUT  First step of full-window factorization of a Gabor matrix.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 509
 -- Function: comp_dgtreal
     COMP_DGTREAL  Compute a DGTREAL
        Usage:  c=comp_dgtreal(f,g,a,M,lt,phasetype);
     
        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/2+1*N array of coefficients.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_dgtreal.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_DGTREAL  Compute a DGTREAL
   Usage:  c=comp_dgtreal(f,g,a,M,lt,phasetyp...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 257
 -- Function: comp_dgtreal_fb
     COMP_DGTREAL_FB  Filter bank DGT
        Usage:  c=comp_dgt_fb(f,g,a,M,boundary);
       
        This is a computational routine. Do not call it directly.
     *Url*: <http://ltfat.github.io/doc/comp/comp_dgtreal_fb.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_DGTREAL_FB  Filter bank DGT
   Usage:  c=comp_dgt_fb(f,g,a,M,boundary);
...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1095
 -- Function: comp_dgtreal_long
     COMP_DGTREAL_LONG  Full-window factorization of a Gabor matrix.
        Usage:  c=comp_dgtreal_long(f,g,a,M);
     
        Input parameters:
              f      : Factored input data
              g      : Window
              a      : Length of time shift.
              M      : Number of channels.
        Output parameters:
              c      : M x N*W*R array of coefficients, where N=L/a
     
        Do not call this function directly, use DGT instead.
        This function does not check input parameters!
     
        References:
          T. Strohmer. Numerical algorithms for discrete Gabor expansions. In
          H. G. Feichtinger and T. Strohmer, editors, Gabor Analysis and
          Algorithms, chapter 8, pages 267--294. Birkhauser, Boston, 1998.
          
          P. L. Soendergaard. An efficient algorithm for the discrete Gabor
          transform using full length windows. IEEE Signal Process. Letters,
          submitted for publication, 2007.
          
     *Url*: <http://ltfat.github.io/doc/comp/comp_dgtreal_long.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
COMP_DGTREAL_LONG  Full-window factorization of a Gabor matrix.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 235
 -- Function: comp_dgtreal_ola
     
       This function implements periodic convolution using overlap-add. The
       window g is supposed to be extended by fir2iir.
     *Url*: <http://ltfat.github.io/doc/comp/comp_dgtreal_ola.html>


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

  This function implements periodic convolution using overlap-add.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1270
 -- Function: comp_downs
     COMP_DOWNS Downsampling
        Usage: fdowns = comp_downs(f,a) 
               fdowns = comp_downs(f,a,skip,L,'dim',dim) 
        
        Input parameters:
              f     : Input vector/matrix.
              a     : Downsampling factor.
              skip  : Skipped initial samples.
              L     : Length of the portion of the input to be used.
              dim   : Direction of downsampling.
        Output parameters:
              fdowns  : Downsampled vector/matrix.
     
        Downsamples input f by a factor a (leaves every a*th sample) along
        dimension dim. If dim is not specified, first non-singleton
        dimension is used. Parameter skip (integer) specifies how
        many samples to skip from the beginning and L defines how many
        elements of the input data are to be used starting at index 1+skip. 
     
        Examples:
        ---------
     
        The default behavior is equal to the subsampling performed
        in the frequency domain using reshape and sum:
     
           f = 1:9;
           a = 3;
           fupsTD = comp_downs(f,a)
           fupsFD = real(ifft(sum(reshape(fft(f),length(f)/a,a),2).'))/a
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_downs.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_DOWNS Downsampling
   Usage: fdowns = comp_downs(f,a) 
          fdowns ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 103
 -- Function: comp_dtwfb
      First tree
     *Url*: <http://ltfat.github.io/doc/comp/comp_dtwfb.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
 First tree
   *Url*: <http://ltfat.github.io/doc/comp/comp_dtwfb.html>



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 151
 -- Function: comp_dwiltii
     COMP_DWILT  Compute Discrete Wilson transform.
        
     *Url*: <http://ltfat.github.io/doc/comp/comp_dwiltii.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
COMP_DWILT  Compute Discrete Wilson transform.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 161
 -- Function: comp_dwiltiv
     COMP_DWILTIV  Compute Discrete Wilson transform type IV.
        
     *Url*: <http://ltfat.github.io/doc/comp/comp_dwiltiv.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
COMP_DWILTIV  Compute Discrete Wilson transform type IV.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 134
 -- Function: comp_edgt6
     COMP_EDGT6   Compute Even DGT type 6
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_edgt6.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
COMP_EDGT6   Compute Even DGT type 6



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 735
 -- Function: comp_extBoundary
     EXTENDBOUNDARY Extends collumns
         Usage: fout = comp_extBoundary(f,extLen,ext); 
                fout = comp_extBoundary(f,extLen,ext,'dim',dim);
     
        Input parameters:
              f          : Input collumn vector/matrix
              extLen     : Length of extensions
              ext        : Type of extensions
        Output parameters:
              fout       : Extended collumn vector/matrix
     
        Extends input collumn vector or matrix f at top and bottom by 
        extLen elements/rows. Extended values are determined from the input
        according to the type of extension ext.
     
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_extBoundary.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
EXTENDBOUNDARY Extends collumns
    Usage: fout = comp_extBoundary(f,extLen,e...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 353
 -- Function: comp_fftanalytic
     COMP_FFTANALYTIC Compute analytic representation
     
        Usage: z = comp_fftanalytic(s);
     
        COMP_FFTANALYTIC(s) computes the analytic representation of s.  
        The analytic representation is computed through the FFT of f.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_fftanalytic.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
COMP_FFTANALYTIC Compute analytic representation



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 128
 -- Function: comp_fftreal
     COMP_FFTREAL  Compute an FFTREAL
     *Url*: <http://ltfat.github.io/doc/comp/comp_fftreal.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_FFTREAL  Compute an FFTREAL
   *Url*: <http://ltfat.github.io/doc/comp/c...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 356
 -- Function: comp_filterbank
     COMP_FILTERBANK  Compute filtering
     
        Function groups filters in g according to a presence of .h and .H
        fields. If .H is present, it is further decided whether it is a full
        frequency response or a band-limited freq. resp.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_filterbank.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
COMP_FILTERBANK  Compute filtering



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 472
 -- Function: comp_filterbank_a
     COMP_FILTERBANK_A  Return sanitized a
        Usage:  [a,info]=comp_filterbank_a(a,M);
        
        [a,info]=COMP_FILTERBANK_A(a,M) returns a sanitized version of a*
        expand to a Mx2 matrix, and update the information in info.
     
        Sanitize means, that at the output of this function, a is either a
        single value or a matrix with 2 columns
     *Url*: <http://ltfat.github.io/doc/comp/comp_filterbank_a.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_FILTERBANK_A  Return sanitized a
   Usage:  [a,info]=comp_filterbank_a(a...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 503
 -- Function: comp_filterbank_pre
     COMP_FILTERBANK_PRE Return sanitized filterbank
     
        The purpose of this function is to evauate all parameters of the
        filters, which can be evaluated knowing L. The function can work only
        with g and a in proper formats i.e. processed by
        FILTERBANKWINDOW.
     
        This function expects all numeric g{ii}.H to be instantiated with a
        proper L.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_filterbank_pre.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
COMP_FILTERBANK_PRE Return sanitized filterbank



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
comp_filterbankconstphase


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 225
 -- Function: comp_filterbankconstphase
     sets the mask for the heap integration and acts as a wrapper for
     the corresponding C-function
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_filterbankconstphase.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
sets the mask for the heap integration and acts as a wrapper for
the correspo...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 172
 -- Function: comp_filterbankneighbors
     this function is called by filterbankconstphase
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_filterbankneighbors.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
this function is called by filterbankconstphase
   *Url*:
<http://ltfat.githu...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 178
 -- Function: comp_filterbankphasegrad
     
     this function is called by filterbankconstphase
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_filterbankphasegrad.html>


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

this function is called by filterbankconstphase
   *Url*:
<http://ltfat.gith...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 447
 -- Function: comp_fourierwindow
     COMP_FOURIERWINDOW  Compute the window from numeric, text or cell array.
        Usage: [g,info] = comp_fourierwindow(g,L,callfun);
     
        [g,info]=COMP_FOURIERWINDOW(g,L,callfun) will compute the window
        from a text description or a cell array containing additional
        parameters. 
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_fourierwindow.html>

     See also: gabwin, wilwin.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
COMP_FOURIERWINDOW  Compute the window from numeric, text or cell array.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
comp_framelength_fusion


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 243
 -- Function: comp_framelength_fusion
      This is highly tricky: Get the minimal transform length for each
      subframe, and set the length as the lcm of that.
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_framelength_fusion.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 This is highly tricky: Get the minimal transform length for each
 subframe, ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
comp_framelength_tensor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 192
 -- Function: comp_framelength_tensor
     COMP_FRAMELENGTH_TENSOR  Helper function for the Tensor frame
       
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_framelength_tensor.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_FRAMELENGTH_TENSOR  Helper function for the Tensor frame
  
   *Url*: <h...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
 -- Function: comp_frana_fusion
      All frames must use the same length signal.
     *Url*: <http://ltfat.github.io/doc/comp/comp_frana_fusion.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 All frames must use the same length signal.
   *Url*: <http://ltfat.github.i...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 655
 -- Function: comp_fwt
     COMP_FWT Compute DWT using FWT
        Usage:  c=comp_fwt(f,h,J,a,Lc,ext);
     
        Input parameters:
              f     : Input data - L*W array.
              h     : Analysis Wavelet filters - cell-array of length filtNo.
              J     : Number of filterbank iterations.
              a     : Subsampling factors - array of length filtNo. 
              ext   : 'per','zero','even','odd' Type of the forward transform boundary handling.
     
        Output parameters:
              c     : Cell array of length M. Each element is Lc(m)*W array.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_fwt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
COMP_FWT Compute DWT using FWT
   Usage:  c=comp_fwt(f,h,J,a,Lc,ext);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 838
 -- Function: comp_fwtpack2cell
     COMP_FWTPACK2CELL Change FWT coef. format from pack to cell
        Usage: ccell=comp_fwtpack2cell(F,c)
     
        Input parameters:
              F      : FWT frame object
              c      : Coefficients in pack format
        Output parameters:
              ccell  : Coefficients in cell format
     
        COMP_FWTPACK2CELL(F,c) exctracts individual FWT subbands from 
        coefficients in packed format c as elements of a cell array. F must
        be of type 'fwt' e.g. obtained by F=frame('fwt',...) and c must
        be a Lc xW matrix, obtained by FRANA or BLOCKANA.
        
        The inverse operation is mere c=cell2mat(ccel)
     
        THE FUNCTION DOES NOT CHECK THE INPUT PARAMETERS IN ANY WAY!
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_fwtpack2cell.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_FWTPACK2CELL Change FWT coef. format from pack to cell
   Usage: ccell=c...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 770
 -- Function: comp_gabmixdual_fac
     COMP_GABMIXDUAL_FAC  Computes factorization of mix-dual.
        Usage:  gammaf=comp_gabmixdual_fac(gf1,gf2,a,M)
     
        Input parameters:
           gf1    : Factorization of first window
           gf2    : Factorization of second window
           L      : Length of window.
           a      : Length of time shift.
           M      : Number of channels.
     
        Output parameters:
           gammaf : Factorization of mix-dual
     
        GAMMAF is a factorization of a dual window of gf1
     
        This function does not verify input parameters, call
        GABMIXDUAL instead
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_gabmixdual_fac.html>

     See also: gabmixdual, comp_fac, compute_ifac.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
COMP_GABMIXDUAL_FAC  Computes factorization of mix-dual.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 803
 -- Function: comp_gabreassignreal
     COMP_GABREASSIGNREAL  Reassign time-frequency distribution.
        Usage:  sr = comp_gabreassign(s,tgrad,fgrad,a);
     
        COMP_GABREASSIGNREAL(s,tgrad,fgrad,a,M) will reassign the values of the 
        positive time-frequency distribution s using the instantaneous time and 
        frequency fgrad and tgrad. The lattice is determined by the time shift 
        a and the number of channels M.
     
     
        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/comp/comp_gabreassignreal.html>

     See also: gabreassignreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
COMP_GABREASSIGNREAL  Reassign time-frequency distribution.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 352
 -- Function: comp_gfeigs
     COMP_GFEIGS_SEP
        Usage:  lambdas=comp_gfeigs(gf,a,M);
     
        Compute Eigenvalues of a Gabor frame operator in
        the separable case.
     
        This is a computational routine, do not call it directly.
     
        See help on GFBOUNDS
     *Url*: <http://ltfat.github.io/doc/comp/comp_gfeigs.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
COMP_GFEIGS_SEP
   Usage:  lambdas=comp_gfeigs(gf,a,M);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 519
 -- Function: comp_hermite
     COMP_HERMITE   Compute sampling of continuous Hermite function.
        Usage:  y = comp_hermite(n, x);
     
        COMP_HERMITE(n, x) evaluates the n-th Hermite function at the vector x.
        The function is normalized to have the L^2(-inf,inf) norm equal to one.
     
        A minimal effort is made to avoid underflow in recursion.
        If used to evaluate the Hermite quadratures, it works for n <= 2400
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_hermite.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
COMP_HERMITE   Compute sampling of continuous Hermite function.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 733
 -- Function: comp_hermite_all
     COMP_HERMITE_ALL  Compute all Hermite functions up to an order
        Usage:  y = hermite_fun_all(n, x);
     
        This function evaluates the Hermite functions
        of degree 0 through n-1 at the vector x.
        The functions are normalized to have the L^2 norm
        on (-inf,inf) equal to one. No effort is made to 
        avoid unerflow during recursion.	
        
        Input parameters: 
          n     : the number of Hermite functions
          x     : the vector of arguments
     
        Output parameters:
          y     : the values of the first n Hermite functions at 
                  the nodes x
     *Url*: <http://ltfat.github.io/doc/comp/comp_hermite_all.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_HERMITE_ALL  Compute all Hermite functions up to an order
   Usage:  y =...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 653
 -- Function: comp_idgt
     COMP_IDGT  Compute IDGT
        Usage:  f=comp_idgt(c,g,a,lt,phasetype);
     
        Input parameters:
              c     : Array of coefficients.
              g     : Window function.
              a     : Length of time shift.
              lt    : Lattice type
              phasetype : Type of phase
        Output parameters:
              f     : Signal.
     
        Value of the algorithm chooser
     
           algns=0 : Choose the fastest algorithm
     
           algns=0 : Always choose multi-win
     
           algns=1 : Always choose shear
     *Url*: <http://ltfat.github.io/doc/comp/comp_idgt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
COMP_IDGT  Compute IDGT
   Usage:  f=comp_idgt(c,g,a,lt,phasetype);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1288
 -- Function: comp_idgt_fac
     COMP_IDGT_FAC  Full-window factorization of a Gabor matrix.
        Usage:  f=comp_idgt_fac(c,g,a,M)
     
        Input parameters:
              c     : M x N array of coefficients.
              gf    : Factorization of window (from facgabm).
              a     : Length of time shift.
              M     : Number of frequency shifts.
        Output parameters:
              f     : Reconstructed signal.
     
        Do not call this function directly, use IDGT.
        This function does not check input parameters!
     
        If input is a matrix, the transformation is applied to
        each column.
     
        This function does not handle multidimensional data, take care before
        you call it.
     
        References:
          T. Strohmer. Numerical algorithms for discrete Gabor expansions. In
          H. G. Feichtinger and T. Strohmer, editors, Gabor Analysis and
          Algorithms, chapter 8, pages 267--294. Birkhauser, Boston, 1998.
          
          P. L. Soendergaard. An efficient algorithm for the discrete Gabor
          transform using full length windows. IEEE Signal Process. Letters,
          submitted for publication, 2007.
          
     *Url*: <http://ltfat.github.io/doc/comp/comp_idgt_fac.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
COMP_IDGT_FAC  Full-window factorization of a Gabor matrix.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 374
 -- Function: comp_idgt_fb
     COMP_IDGT_FB  Filter bank IDGT.
        Usage:  f=comp_idgt_fb(c,g,L,a,M);
            
        This is a computational routine. Do not call it directly.
     
        Input must be in the M x N*W format, so the N and W dimension is
        combined.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_idgt_fb.html>

     See also: idgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
COMP_IDGT_FB  Filter bank IDGT.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1265
 -- Function: comp_idgt_long
     COMP_IDGT_FAC  Full-window factorization of a Gabor matrix.
        Usage:  f=comp_idgt_long(c,g,L,a,M)
     
        Input parameters:
              c     : M x N x W array of coefficients.
              g     : Window.
              a     : Length of time shift.
              M     : Number of frequency shifts.
        Output parameters:
              f     : Reconstructed signal.
     
        Do not call this function directly, use IDGT.
        This function does not check input parameters!
     
        If input is a matrix, the transformation is applied to
        each column.
     
        This function does not handle multidimensional data, take care before
        you call it.
     
        References:
          T. Strohmer. Numerical algorithms for discrete Gabor expansions. In
          H. G. Feichtinger and T. Strohmer, editors, Gabor Analysis and
          Algorithms, chapter 8, pages 267--294. Birkhauser, Boston, 1998.
          
          P. L. Soendergaard. An efficient algorithm for the discrete Gabor
          transform using full length windows. IEEE Signal Process. Letters,
          submitted for publication, 2007.
          
     *Url*: <http://ltfat.github.io/doc/comp/comp_idgt_long.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
COMP_IDGT_FAC  Full-window factorization of a Gabor matrix.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 487
 -- Function: comp_idgtreal
     COMP_IDGTREAL  Compute IDGTREAL
        Usage:  f=comp_idgtreal(c,g,a,M,lt,phasetype);
     
        Input parameters:
              c     : Array of coefficients.
              g     : Window function.
              a     : Length of time shift.
              M     : Number of modulations.
              lt    : lattice type
        Output parameters:
              f     : Signal.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_idgtreal.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IDGTREAL  Compute IDGTREAL
   Usage:  f=comp_idgtreal(c,g,a,M,lt,phasety...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1316
 -- Function: comp_idgtreal_fac
     COMP_IDGTREAL_FAC  Full-window factorization of a Gabor matrix assuming.
        Usage:  f=comp_idgtreal_fac(c,gf,L,a,M)
     
        Input parameters:
              c     : M x N array of coefficients.
              gf    : Factorization of window (from facgabm).
              a     : Length of time shift.
              M     : Number of frequency shifts.
        Output parameters:
              f     : Reconstructed signal.
     
        Do not call this function directly, use IDGT.
        This function does not check input parameters!
     
        If input is a matrix, the transformation is applied to
        each column.
     
        This function does not handle multidimensional data, take care before
        you call it.
     
        References:
          T. Strohmer. Numerical algorithms for discrete Gabor expansions. In
          H. G. Feichtinger and T. Strohmer, editors, Gabor Analysis and
          Algorithms, chapter 8, pages 267--294. Birkhauser, Boston, 1998.
          
          P. L. Soendergaard. An efficient algorithm for the discrete Gabor
          transform using full length windows. IEEE Signal Process. Letters,
          submitted for publication, 2007.
          
     *Url*: <http://ltfat.github.io/doc/comp/comp_idgtreal_fac.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
COMP_IDGTREAL_FAC  Full-window factorization of a Gabor matrix assuming.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 382
 -- Function: comp_idgtreal_fb
     COMP_IDGT_FB  Filter bank IDGT.
        Usage:  f=comp_idgt_fb(c,g,L,a,M);
            
        This is a computational routine. Do not call it directly.
     
        Input must be in the M x N*W format, so the N and W dimension is
        combined.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_idgtreal_fb.html>

     See also: idgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
COMP_IDGT_FB  Filter bank IDGT.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1305
 -- Function: comp_idgtreal_long
     COMP_IDGTREAL_FAC  Full-window factorization of a Gabor matrix assuming.
        Usage:  f=comp_idgtreal_long(c,g,L,a,M)
     
        Input parameters:
              c     : M x N x W array of coefficients.
              g     : window (from facgabm).
              a     : Length of time shift.
              M     : Number of frequency shifts.
        Output parameters:
              f     : Reconstructed signal.
     
        Do not call this function directly, use IDGT.
        This function does not check input parameters!
     
        If input is a matrix, the transformation is applied to
        each column.
     
        This function does not handle multidimensional data, take care before
        you call it.
     
        References:
          T. Strohmer. Numerical algorithms for discrete Gabor expansions. In
          H. G. Feichtinger and T. Strohmer, editors, Gabor Analysis and
          Algorithms, chapter 8, pages 267--294. Birkhauser, Boston, 1998.
          
          P. L. Soendergaard. An efficient algorithm for the discrete Gabor
          transform using full length windows. IEEE Signal Process. Letters,
          submitted for publication, 2007.
          
     *Url*: <http://ltfat.github.io/doc/comp/comp_idgtreal_long.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
COMP_IDGTREAL_FAC  Full-window factorization of a Gabor matrix assuming.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 243
 -- Function: comp_idwiltii
     COMP_IDWILTII  Compute Inverse discrete Wilson transform type II
      
        This is a computational routine. Do not call it
        directly.
     *Url*: <http://ltfat.github.io/doc/comp/comp_idwiltii.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IDWILTII  Compute Inverse discrete Wilson transform type II
 
   This is...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 244
 -- Function: comp_idwiltiv
     COMP_IDWILTIV  Compute Inverse discrete Wilson transform type IV.
      
        This is a computational routine. Do not call it
        directly.
     *Url*: <http://ltfat.github.io/doc/comp/comp_idwiltiv.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
COMP_IDWILTIV  Compute Inverse discrete Wilson transform type IV.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 145
 -- Function: comp_iedgt6
     COMP_IEDGT6   Compute inverse even DGT type 6
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_iedgt6.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
COMP_IEDGT6   Compute inverse even DGT type 6



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
 -- Function: comp_ifftreal
     COMP_IFFTREAL  Compute an IFFTREAL
     *Url*: <http://ltfat.github.io/doc/comp/comp_ifftreal.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IFFTREAL  Compute an IFFTREAL
   *Url*: <http://ltfat.github.io/doc/comp...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 147
 -- Function: comp_ifilterbank
     COMP_IFILTERBANK Compute inverse filterbank
     *Url*: <http://ltfat.github.io/doc/comp/comp_ifilterbank.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IFILTERBANK Compute inverse filterbank
   *Url*: <http://ltfat.github.io...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 742
 -- Function: comp_ifwt
     COMP_IFWT Compute Inverse DWT
        Usage:  f = comp_ifwt(c,g,J,a,Ls,ext);
     
        Input parameters:
              c     : Cell array of length M = J*(filtNo-1)+1. Each element is Lc(m)*W array
              g     : Synthesis wavelet filters - cell-array of length filtNo.
              J     : Number of filterbank iterations.
              a     : Upsampling factors - array of length filtNo.
              Ls    : Length of the reconstructed signal.
              ext   : 'per','zero','odd','even', Type of the forward transform boundary handling.
     
        Output parameters:
              f     : Reconstructed data - Ls*W array.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_ifwt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
COMP_IFWT Compute Inverse DWT
   Usage:  f = comp_ifwt(c,g,J,a,Ls,ext);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 740
 -- Function: comp_igdgt
     COMP_IGDGT  Compute IGDGT
        Usage:  f=comp_igdgt(c,g,a,M,L,c_t,c_f,c_w,timeinv);
     
        Input parameters:
              c     : Array of coefficients.
              g     : Window function.
              a     : Length of time shift.
              M     : Number of modulations.
              L     : length of transform.
              c_t     : Centering in time of modulation.
              c_f     : Centering in frequency of modulation.
              c_w     : Centering in time of window.
              timeinv : Should we compute a time invariant Gabor system.
     
        Output parameters:
              f     : Signal.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_igdgt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IGDGT  Compute IGDGT
   Usage:  f=comp_igdgt(c,g,a,M,L,c_t,c_f,c_w,timei...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1062
 -- Function: comp_inonsepdgt
     COMP_INONSEPDGT  Compute Inverse discrete Gabor transform
        Usage:  f=inonsepdgt(c,g,a,lt);
                f=inonsepdgt(c,g,a,lt,Ls);
     
        Input parameters:
              c     : Array of coefficients.
              g     : Window function.
              a     : Length of time shift.
              lt    : Lattice type
              do_timeinv : Do a time invariant phase ?
              alg   : Choose algorithm
        Output parameters:
              f     : Signal.
     
        inonsepdgt(c,g,a,lt) computes the Gabor expansion of the input
        coefficients c with respect to the window g, time shift a and
        lattice type lt. The number of channels is deduced from the size of
        the coefficients c.
     
           alg=0 : Choose the fastest algorithm
     
           alg=0 : Always choose multi-win
     
           alg=1 : Always choose shear
     
        This is a computational subroutine, do not call it directly.
     *Url*: <http://ltfat.github.io/doc/comp/comp_inonsepdgt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_INONSEPDGT  Compute Inverse discrete Gabor transform
   Usage:  f=inonse...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
comp_inonsepdgt_shear


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 482
 -- Function: comp_inonsepdgt_shear
     COMP_INONSEPDGT_SHEAR  Compute IDGT
        Usage:  f=comp_inonsepdgt_shear(c,g,a,lt,phasetype);
     
        Input parameters:
              c        : Array of coefficients.
              g        : Window function.
              a        : Length of time shift.
              s0,s1,br : shearfind parameters
        Output parameters:
              f     : Signal.
     *Url*: <http://ltfat.github.io/doc/comp/comp_inonsepdgt_shear.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_INONSEPDGT_SHEAR  Compute IDGT
   Usage:  f=comp_inonsepdgt_shear(c,g,a,...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
comp_inonsepdgtreal_quinqux


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 633
 -- Function: comp_inonsepdgtreal_quinqux
     COMP_INONSEPDGTREAL_QUINQUX  Compute Inverse discrete Gabor transform
        Usage:  f=inonsepdgt(c,g,a,M);
     
        Input parameters:
              c     : Array of coefficients.
              g     : Window function.
              a     : Length of time shift.
              M     : Number of channels
              do_timeinv : Do a time invariant phase ?
        Output parameters:
              f     : Signal.
     
     
        This is a computational subroutine, do not call it directly.
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_inonsepdgtreal_quinqux.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_INONSEPDGTREAL_QUINQUX  Compute Inverse discrete Gabor transform
   Usag...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1889
 -- Function: comp_insdgfb
     COMP_INSDGFB  Non-stationary Gabor filterbank synthesis
        Usage: fr = comp_insdgfb(c,g,shift,Ls,dual)
               fr = comp_insdgfb(c,g,shift,Ls)
               fr = comp_insdgfb(c,g,shift)
     
        Input parameters: 
              c         : Transform coefficients (matrix or cell array)
              g         : Cell array of Fourier transforms of the analysis 
                          windows
              shift     : Vector of frequency shifts
              Ls        : Original signal length (in samples)
              dual      : Synthesize with the dual frame
        Output parameters:
              fr        : Synthesized signal (Channels are stored in the 
                          columns)
     
        Given the cell array c of non-stationary Gabor coefficients, and a 
        set of filters g and frequency shifts shift this function computes 
        the corresponding non-stationary Gabor filterbank synthesis.
     
        If dual is set to 1 (default), an attempt is made to compute the 
        canonical dual frame for the system given by g, shift and the size 
        of the vectors in c. This provides perfect reconstruction in the 
        painless case, see the references for more information.
      
      
        References:
          P. Balazs, M. Doerfler, F. Jaillet, N. Holighaus, and G. A. Velasco.
          Theory, implementation and applications of nonstationary Gabor frames.
          J. Comput. Appl. Math., 236(6):1481--1496, 2011.
          
          N. Holighaus, M. Doerfler, G. A. Velasco, and T. Grill. A framework for
          invertible, real-time constant-Q transforms. IEEE Transactions on
          Audio, Speech and Language Processing, 21(4):775 --785, 2013.
          
     *Url*: <http://ltfat.github.io/doc/comp/comp_insdgfb.html>

     See also: cqt, icqt, erblett, ierblett.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_INSDGFB  Non-stationary Gabor filterbank synthesis
   Usage: fr = comp_i...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 397
 -- Function: comp_instcorrmat
     COMP_INSTCORRMAT Compute instantaneous correlation matrix
        Usage R = comp_instcorrmat(f, g);
     
        Input parameters:
              f,g    : Input vectors of the same length.
     
        Output parameters:
              R      : Instantaneous correlation matrix.
     
        
     *Url*: <http://ltfat.github.io/doc/comp/comp_instcorrmat.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_INSTCORRMAT Compute instantaneous correlation matrix
   Usage R = comp_i...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 129
 -- Function: comp_irdgt
     COMP_IRDGT  Compute inverse real DGT.
     *Url*: <http://ltfat.github.io/doc/comp/comp_irdgt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IRDGT  Compute inverse real DGT.
   *Url*: <http://ltfat.github.io/doc/c...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 147
 -- Function: comp_irdgtii
     COMP_IRDGTII Compute inverse real DGT type II
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_irdgtii.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
COMP_IRDGTII Compute inverse real DGT type II



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 228
 -- Function: comp_irdgtiii
     COMP_IRDGTIII  Compute inverse real DGT type III.
      
        This is a computational routine. Do not call it
        directly.
     *Url*: <http://ltfat.github.io/doc/comp/comp_irdgtiii.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
COMP_IRDGTIII  Compute inverse real DGT type III.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 657
 -- Function: comp_iufilterbank_td
     COMP_IUFILTERBANK_TD   Synthesis Uniform filterbank by conv2
        Usage:  f=comp_iufilterbank_td(c,g,a,Ls,skip,ext);
     
        Input parameters:
              c    : N*M*W array of coefficients.
              g    : Filterbank filters - filtLen*M array. 
              a    : Upsampling factor - scalar.
              Ls   : Output length.
              skip : Delay of the filters - scalar or array of length M.
              ext  : Border exension technique.
     
        Output parameters:
              f  : Output Ls*W array. 
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_iufilterbank_td.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IUFILTERBANK_TD   Synthesis Uniform filterbank by conv2
   Usage:  f=com...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 575
 -- Function: comp_iufwt
     COMP_IUFWT Compute Inverse Undecimated DWT
        Usage:  f = comp_iufwt(c,g,J,a);
     
        Input parameters:
              c     : L*M*W array of coefficients, M=J*(filtNo-1)+1.
              g     : Synthesis wavelet filters-Cell-array of length filtNo.
              J     : Number of filterbank iterations.
              a     : Upsampling factors - array of length filtNo.
     
        Output parameters:
              f     : Reconstructed data - L*W array.
     
      
     *Url*: <http://ltfat.github.io/doc/comp/comp_iufwt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
COMP_IUFWT Compute Inverse Undecimated DWT
   Usage:  f = comp_iufwt(c,g,J,a);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 850
 -- Function: comp_iuwfbt
     COMP_IUWFBT Compute Inverse Undecimated Wavelet Filter-Bank Tree
        Usage:  f=comp_iuwfbt(c,wtNodes,nodesUps,rangeLoc,rangeOut)
     
        Input parameters:
              c        : Coefficient array of dim. L*M*W.
              wtNodes  : Filterbank tree nodes (elementary filterbanks) in
                         BF order. Length nodeNo cell array of structures.
              nodesUps : Filters upsampling factor of each node. Array of
                         length nodeNo.
              rangeLoc : Idxs of each node inputs. Length nodeNo 
                         cell array of vectors.
              rangeOut : Input subband idxs of each node inputs.
     
        Output parameters:
              f     : Reconstructed data L*W array.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_iuwfbt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IUWFBT Compute Inverse Undecimated Wavelet Filter-Bank Tree
   Usage:  f...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 909
 -- Function: comp_iuwpfbt
     COMP_IUWPFBT Compute Inverse Undecimated Wavelet Packet Filter-Bank Tree
        Usage:  f=comp_iuwpfbt(c,wtNodes,nodesUps,pOutIdxs,chOutIdxs)
     
        Input parameters:
              c          : Coefficients stored in L*M*W array.
              wtNodes    : Filterbank tree nodes (elementary filterbans) in
                           reverse BF order. Cell array of structures of length nodeNo.
              nodesUps   : Filters upsampling factor of each node. Array of
                           length nodeNo.
              pOutIdxs   : Idx of each node's parent. Array of length nodeNo.
              chOutIdxs  : Idxs of each node children. Cell array of vectors of
                           length nodeNo.
     
        Output parameters:
              f     : Reconstructed data in L*W array.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_iuwpfbt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IUWPFBT Compute Inverse Undecimated Wavelet Packet Filter-Bank Tree
   U...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 894
 -- Function: comp_iwfbt
     COMP_IWFBT Compute Inverse Wavelet Filter-Bank Tree
        Usage:  f=comp_iwfbt(c,wtNodes,outLens,rangeLoc,rangeOut,ext)
     
        Input parameters:
              c        : Coefficients stored in the cell array.
              wtNodes  : Filterbank tree nodes (elementary filterbanks) in
                         reverse BF order. Length nodeNo cell array of structures.
              outLens  : Output lengths of each node. Length nodeNo array.
              rangeLoc : Idxs of each node inputs. Length nodeNo 
                         cell array of vectors.
              rangeOut : Input subband idxs of each node inputs.
              ext      : Type of the forward transform boundary handling.
     
        Output parameters:
              f       : Reconstructed outLens(end)*W array.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_iwfbt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IWFBT Compute Inverse Wavelet Filter-Bank Tree
   Usage:  f=comp_iwfbt(c...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 852
 -- Function: comp_iwpfbt
     COMP_IWFBT Compute Inverse Wavelet Packet Filter-Bank Tree
        Usage:  f=comp_iwpfbt(c,wtNodes,pOutIdxs,chOutIdxs,Ls,ext)
     
        Input parameters:
              c          : Coefficients stored in cell array.
              wtNodes    : Filterbank tree nodes (elementary filterbans) in
                           reverse BF order. Cell array of structures of length nodeNo.
              pOutIdxs   : Idx of each node's parent. Array of length nodeNo.
              chOutIdxs  : Idxs of each node children. Cell array of vectors of
                           length nodeNo.
              ext        : Type of the forward transform boundary handling.
     
        Output parameters:
              f          : Reconstructed data in L*W array.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_iwpfbt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_IWFBT Compute Inverse Wavelet Packet Filter-Bank Tree
   Usage:  f=comp_...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
comp_nonsepdgtreal_quinqux


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 333
 -- Function: comp_nonsepdgtreal_quinqux
     COMP_NONSEPDGTREAL_QUINQUX  Compute Non-separable Discrete Gabor transform
        Usage:  c=comp_nonsepdgtreal_quinqux(f,g,a,M);
     
        This is a computational subroutine, do not call it directly.
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_nonsepdgtreal_quinqux.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_NONSEPDGTREAL_QUINQUX  Compute Non-separable Discrete Gabor transform
  ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 161
 -- Function: comp_nyquistfilt
     COMP_NYQUISTFILT high-pass filter for warped filter banks
     *Url*: <http://ltfat.github.io/doc/comp/comp_nyquistfilt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_NYQUISTFILT high-pass filter for warped filter banks
   *Url*: <http://l...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
comp_painlessfilterbank


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 239
 -- Function: comp_painlessfilterbank
     COMP_PAINLESSFILTERBANK
      
        Function computes filterbank dual or tight frame for the painless case.
     
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_painlessfilterbank.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_PAINLESSFILTERBANK
 
   Function computes filterbank dual or tight frame...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
comp_phasegradfilters


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 528
 -- Function: comp_phasegradfilters
        called by filterbankphasegrad
        worker function for computing the relative instantaneous 
        frequency tgrad and the negative of the group
        delay fgrad of the filterbank spectrogram s obtained from the 
        signal f and filterbank parameters g and a.
     
        uses the equivalence of the filterbank coefficients with those
        of an STFT and thus, may not apply to all filterbanks
     *Url*: <http://ltfat.github.io/doc/comp/comp_phasegradfilters.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
   called by filterbankphasegrad
   worker function for computing the relativ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 394
 -- Function: comp_quadtfdist
      Comp_QUADTFDIST Compute quadratic time-frequency distribution
        Usage p = comp_quadtfdist(f, q);;
     
        Input parameters:
              f      : Input vector
     	  q	 : Kernel
     
        Output parameters:
              p      : Quadratic time-frequency distribution
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_quadtfdist.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 Comp_QUADTFDIST Compute quadratic time-frequency distribution
   Usage p = c...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 138
 -- Function: comp_sigreshape_post
     COMP_SIGRESHAPE_POST
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_sigreshape_post.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 135
 -- Function: comp_sigreshape_pre
     COMP_SIGRESHAPE_PRE
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_sigreshape_pre.html>


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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
comp_transferfunction


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 414
 -- Function: comp_transferfunction
     COMP_TRANSFERFUNCTION  Compute the transfer function
     
       COMP_TRANSFERFUNCTION(g,L) computes length L transfer function 
       (frequency response) of a single filter g. This function can only
       handle filters in a proper internal format i.e. already processed by
       FILTERBANKWIN.
     *Url*: <http://ltfat.github.io/doc/comp/comp_transferfunction.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
COMP_TRANSFERFUNCTION  Compute the transfer function



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 212
 -- Function: comp_ufilterbank_fft
     COMP_UFILTERBANK_FFT   Classic filtering by FFT
        Usage:  c=comp_ufilterbank_fft(f,g,a);
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_ufilterbank_fft.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_UFILTERBANK_FFT   Classic filtering by FFT
   Usage:  c=comp_ufilterbank...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 604
 -- Function: comp_ufilterbank_td
     COMP_UFILTERBANK_TD   Uniform filterbank by conv2
        Usage:  c=comp_ufilterbank_td(f,g,a,skip,ext);
     
        Input parameters:
              f   : Input data - L*W array.
              g   : Filterbank filters - filtLen*M array. 
              a   : Subsampling factor - scalar.
              skip: Delay of the filters - scalar or array of length M. 
              ext : Border exension technique.
     
        Output parameters:
              c  : N*M*W array of coefficients
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_ufilterbank_td.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_UFILTERBANK_TD   Uniform filterbank by conv2
   Usage:  c=comp_ufilterba...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
comp_ufilterbankconstphase


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 239
 -- Function: comp_ufilterbankconstphase
        part of the heap integration for reconstructing phase from the
        magnitude of filterbank coefficients
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_ufilterbankconstphase.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
   part of the heap integration for reconstructing phase from the
   magnitud...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
comp_ufilterbankphasegradfrommag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 251
 -- Function: comp_ufilterbankphasegradfrommag
        part of the heap integration for reconstructing phase from the
        magnitude of filterbank coefficients
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_ufilterbankphasegradfrommag.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
   part of the heap integration for reconstructing phase from the
   magnitud...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 554
 -- Function: comp_ufwt
     COMP_UFWT Compute Undecimated DWT
        Usage:  c=comp_ufwt(f,h,J,a);
     
        Input parameters:
              f     : Input data - L*W array.
              h     : Analysis Wavelet filters - cell-array of length filtNo.
              J     : Number of filterbank iterations.
              a     : Subsampling factors - array of length filtNo.
     
        Output parameters:
              c     : L*M*W array of coefficients, where M=J*(filtNo-1)+1.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_ufwt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
COMP_UFWT Compute Undecimated DWT
   Usage:  c=comp_ufwt(f,h,J,a);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1600
 -- Function: comp_ups
     COMP_UPS Upsampling
        Usage: fups = comp_ups(f,a) 
               fups = comp_ups(f,a,type,'dim',dim)
               fups = comp_ups(f,a,skip,L,'dim',dim) 
        
        Input parameters:
              f     : Input vector/matrix.
              a     : Upsampling factor.
              type  : Type of the upsampling/initial skip.
              L     : Required output length.
              dim   : Direction of upsampling.
        Output parameters:
              fups  : Upsampled vector/matrix.
     
        Upsamples input f by a factor a (puts a-1 zeros between data elements)
        along dimension dim. If dim is not specified, first non-singleton
        dimension is used. Parameter type (integer from [0:3]) specifies whether the upsampling
        includes beginning/tailing zeros:
     
        type=0 (default): Includes just tailing zeros.
        type=1: No beginning nor tailing zeros.
        type=2: Includes just begining zeros.
        type=3: Includes both. 
     
        If non-empty parameter L is passed, it specifies the required output
        length and the type changes to skip which denotes how many zeros to
        add before the first sample.
     
        Examples:
        ---------
     
        The outcome of the default upsampling type is equal to the upsampling performed
        directly in the frequency domain using repmat:
     
           f = 1:4;
           a = 3;
           fupsTD = comp_ups(f,a)
           fupsFD = real(ifft(repmat(fft(f),1,a)))
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_ups.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_UPS Upsampling
   Usage: fups = comp_ups(f,a) 
          fups = comp_ups...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 846
 -- Function: comp_uwfbt
     COMP_UWFBT Compute Undecimated Wavelet Filterbank Tree
        Usage:  c=comp_uwfbt(f,wtNodes,nodesUps,rangeLoc,rangeOut);
     
        Input parameters:
              f        : Input L*W array.
              wtNodes  : Filterbank tree nodes (elementary filterbanks) in
                         BF order. Length nodeNo cell array of structures.
              nodesUps : Filters upsampling factor of each node. Array of
                         length nodeNo.
              rangeLoc : Idxs of each node terminal outputs. Length nodeNo 
                         cell array of vectors.
              rangeOut : Output subband idxs of each node terminal outputs.
     
        Output parameters:
              c     : Coefficient array of dim. L*M*W.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_uwfbt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_UWFBT Compute Undecimated Wavelet Filterbank Tree
   Usage:  c=comp_uwfb...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 657
 -- Function: comp_uwpfbt
     COMP_UWPFBT Compute Undecimated Wavelet Packet Filterbank Tree
        Usage:  c=comp_uwpfbt(f,wtNodes,nodesUps);
     
        Input parameters:
              f        : Input data as L*W array.
              wtNodes  : Filterbank tree nodes (elementary filterbanks) in
                         BF order. Cell array of structures of length nodeNo.
              nodesUps : Filters upsampling factor of each node. Array of
                         length nodeNo. 
     
        Output parameters:
              c        : Coefficients stored in L*M*W array.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_uwpfbt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_UWPFBT Compute Undecimated Wavelet Packet Filterbank Tree
   Usage:  c=c...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 142
 -- Function: comp_warpedfoff
     COMP_WARPEDFOFF  foff for warped filters
     *Url*: <http://ltfat.github.io/doc/comp/comp_warpedfoff.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_WARPEDFOFF  foff for warped filters
   *Url*: <http://ltfat.github.io/do...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
comp_warpedfreqresponse


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 838
 -- Function: comp_warpedfreqresponse
     COMP_WARPEDFREQRESPONSE  Transfer function of warped filter
        Usage: H=comp_warpedfreqresponse(wintype,fc,bw,fs,L,freqtoscale);
               H=comp_warpedfreqresponse(wintype,fc,bw,fs,L,freqtoscale,normtype);
     
        Input parameters:
           wintype     : Type of window (from firwin)
           fc          : Centre frequency, in scale units.
           bw          : Bandwith, in scale units.
           fs          : Sampling frequency in Hz.
           L           : Transform length (in samples).
           freqtoscale : Function to convert Hz into scale units.
           scaletofreq : Function to convert scale units into Hz.
           normtype    : Normalization flag to pass to SETNORM.
     *Url*:
     <http://ltfat.github.io/doc/comp/comp_warpedfreqresponse.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_WARPEDFREQRESPONSE  Transfer function of warped filter
   Usage: H=comp_...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 861
 -- Function: comp_wfbt
     COMP_WFBT Compute Wavelet Filterbank Tree
        Usage:  c=comp_wfbt(f,wtNodes,rangeLoc,rangeOut,ext);
     
        Input parameters:
              f        : Input L*W array.
              wtNodes  : Filterbank tree nodes (elementary filterbanks) in
                         BF order. Length nodeNo cell array of structures.
              rangeLoc : Idxs of each node terminal outputs. Length nodeNo 
                         cell array of vectors.
              rangeOut : Output subband idxs of each node terminal outputs.
              ext      : Type of the forward transform boundary handling.
     
        Output parameters:
              c        : Cell array of coefficients. Each element is one
                         subband (matrix with W columns).
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_wfbt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_WFBT Compute Wavelet Filterbank Tree
   Usage:  c=comp_wfbt(f,wtNodes,ra...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 571
 -- Function: comp_window
     COMP_WINDOW  Compute the window from numeric, text or cell array.
        Usage: [g,info] = comp_window(g,a,M,L,s,callfun);
     
        [g,info]=COMP_WINDOW(g,a,M,L,lt,callfun) will compute the window
        from a text description or a cell array containing additional
        parameters.
     
        This function is the driving routine behind GABWIN and WILWIN.
     
        See the help on GABWIN and WILWIN for more information.
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_window.html>

     See also: gabwin, wilwin.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
COMP_WINDOW  Compute the window from numeric, text or cell array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 661
 -- Function: comp_wpfbt
     COMP_WPFBT Compute Wavelet Packet Filterbank Tree
        Usage:  c=comp_wpfbt(f,wtNodes,ext);
     
        Input parameters:
              f        : Input L*W array.
              wtNodes  : Filterbank tree nodes (elementary filterbanks) in
                         BF order. Length nodeNo cell array of structures.
              ext      : Type of the forward transform boundary handling.
     
        Output parameters:
              c        : Coefficients stored in cell-array. Each element is one
                         subband (matrix with W columns).
     
     *Url*: <http://ltfat.github.io/doc/comp/comp_wpfbt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_WPFBT Compute Wavelet Packet Filterbank Tree
   Usage:  c=comp_wpfbt(f,w...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 154
 -- Function: comp_wpfbtscale
     COMP_WPFBTSCALE Scale filters in the filterbank tree
     *Url*: <http://ltfat.github.io/doc/comp/comp_wpfbtscale.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_WPFBTSCALE Scale filters in the filterbank tree
   *Url*: <http://ltfat....



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 151
 -- Function: comp_zerofilt
     COMP_ZEROFILT low-pass filter for warped filter banks
     *Url*: <http://ltfat.github.io/doc/comp/comp_zerofilt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
COMP_ZEROFILT low-pass filter for warped filter banks
   *Url*: <http://ltfat...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
complainif_argnonotinrange


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 189
 -- Function: complainif_argnonotinrange
      This is just a replacement for 
      narginchk and nargchk
     *Url*:
     <http://ltfat.github.io/doc/comp/complainif_argnonotinrange.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 This is just a replacement for 
 narginchk and nargchk
   *Url*:
<http://ltf...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
complainif_isjavaheadless


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 226
 -- Function: complainif_isjavaheadless
      COMPLAINIF_ISJAVAHEADLESS 
     
        Prints warning if the available JRE ius in headless mode.
     *Url*:
     <http://ltfat.github.io/doc/comp/complainif_isjavaheadless.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
 COMPLAINIF_ISJAVAHEADLESS 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
determine_freqatheight


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1502
 -- Function: determine_freqatheight
     FREQATHEIGHT the position at which the function fun [f(x = freq)] decreases 
     below the specified height 'height';
     
        Usage: freq = determine_freqatheight(fun,peakpos,height,direction)
     
        Input parameters:
              fun  : Function handle
              peakpos  : peak position on the abscissa
              height : threshold (ordinate value); designates the ordinate value
                        below which the algorithm terminates 
              direction : the direction in which the search is performed; 0 
                          specifies a search in the direction of decreasing indices, 
                          starting from peakpos. 1 specifies a search towards 
                          increasing indices.
     
        Output parameters:
              freq     : the value on the abscissa where fun decreases below height
     
      For a function fun monotonously decreasing around a unique peak peakpos or 
      plateau, this function determines the position at which fun decreases below 
      the specified height height. The search is performed in the direction indicated
      by direction: 0 specifies a search in the direction of decreasing indices, 
      starting from peakpos. 1 specifies a search towards increasing indices.
     
     
      AUTHORS: Zdenek Prusa, Nicki Holighaus, Guenther Koliander, Clara Hollomey
     *Url*:
     <http://ltfat.github.io/doc/comp/determine_freqatheight.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FREQATHEIGHT the position at which the function fun [f(x = freq)] decreases 
...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 573
 -- Function: gabpars_from_window
     GABPARS_FROM_WINDOW  Compute g and L from window
        Usage: [g,g.info,L] = gabpars_from_window(f,g,a,M);
     
        Use this function if you know a window and a lattice
        for the DGT. The function will calculate a transform length L and
        evaluate the window g into numerical form.
     
        If the transform length is unknown (as it usually is unless explicitly
        specified by the user), set L to be [] in the input to this function.
     *Url*: <http://ltfat.github.io/doc/comp/gabpars_from_window.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABPARS_FROM_WINDOW  Compute g and L from window
   Usage: [g,g.info,L] = gab...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
gabpars_from_windowsignal


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 699
 -- Function: gabpars_from_windowsignal
     GABPARS_FROM_WINDOWSIGNAL  Compute g and L from window and signal
        Usage: [g,g.info,L] = gabpars_from_windowsignal(f,g,a,M,L);
     
        Use this function if you know an input signal, a window and a lattice
        for the DGT. The function will calculate a transform length L and
        evaluate the window g into numerical form. The signal will be padded and
        returned as a column vector.
     
        If the transform length is unknown (as it usually is unless explicitly
        specified by the user), set L to be [] in the input to this function.
     *Url*:
     <http://ltfat.github.io/doc/comp/gabpars_from_windowsignal.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABPARS_FROM_WINDOWSIGNAL  Compute g and L from window and signal
   Usage: [...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
helper_waveletgeneratorfunc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1407
 -- Function: helper_waveletgeneratorfunc
     HELPER_WAVELETGENERATORFUNC returns a mother wavelet
        Usage: [fun, fsupp, peakpos, cauchyAlpha] = helper_waveletgeneratorfunc(name)
         [fun, fsupp, peakpos, cauchyAlpha] = helper_waveletgeneratorfunc(name, 'negative')
     
        Input parameters:
              name  : Name of the wavelet
     
        Output parameters:
              fun     : Frequency domain wavelet function handle
              fsupp  : Vector containing the (relative) support of the wavelet
              peakpos : Peak position of the wavelet
              cauchyAlpha : the equivalent cauchy alpha of the wavelet
     
        The admissible range of scales can be adjusted to handle different 
        scenarios:
     
          'positive'       Enables the construction of wavelets at postive
                           center frequencies ]0,1]. If basefc=0.1, this 
                           corresponds to scales larger than or equal to 0.1.
                           This is the default.
     
          'negative'       Enables the construction of wavelets at negative 
                           center frequencies [-1,0[. If basefc=0.1, this 
                           corresponds to scales smaller than or equal to -0.1.
     
     *Url*:
     <http://ltfat.github.io/doc/comp/helper_waveletgeneratorfunc.html>

     See also: freqwavelet, waveletfilters.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
HELPER_WAVELETGENERATORFUNC returns a mother wavelet
   Usage: [fun, fsupp, p...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
nonsepgabpars_from_window


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 607
 -- Function: nonsepgabpars_from_window
     NONSEPGABPARS_FROM_WINDOW  Compute g and L from window
        Usage: [g,g.info,L] = gabpars_from_window(f,g,a,M,lt,L);
     
        Use this function if you know a window and a lattice
        for the NONSEPDGT. The function will calculate a transform length L and
        evaluate the window g into numerical form.
     
        If the transform length is unknown (as it usually is unless explicitly
        specified by the user), set L to be [] in the input to this function.
     *Url*:
     <http://ltfat.github.io/doc/comp/nonsepgabpars_from_window.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
NONSEPGABPARS_FROM_WINDOW  Compute g and L from window
   Usage: [g,g.info,L]...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 199
 -- Function: vect2cell
     VECT2CELL Vector to cell
     
        Works exactly like mat2cell(x,idx,size(x,2))
        but it is faster.
     *Url*: <http://ltfat.github.io/doc/comp/vect2cell.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
VECT2CELL Vector to cell



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1613
 -- Function: wpghi_findalpha
     WPGHI_FINDALPHA  Approximates a matching Cauchy wavelet order alpha to given Wavelet
        Usage: H=wpghi_findalpha(name)
     
        Input parameters: 
              name  : Name of the wavelet (optionally with parameters)
              bwthr : Reference threshold for bandwidth comparison (default:
              0.5012); should be ]0 1[
        Output parameters:
              alpha : Matching Cauchy wavelet order
     
        For a wavelet type available in FREQWAVELET, WPGHI_FINDALPHA returns
        the Cauchy wavelet order alpha with matching bandwidth. Here, 
        bandwidth is the area in which the peak-normalized wavelet is larger 
        than or equal to 1/2.
        
        For a list of supported wavelets, please see the help of FREQWAVELET.
     
        This function is also compatible with filters generated by cqtfilters.
        When such filters are used, the additional key-value pair
     
          'bins',bins           Number of frequency bins per octave
                                (Default: bins = 12) 
     
        is required for correctly determining alpha. Additionally, the 
        following optional parameters can be given for CQT-type filters: 
     
          'Qvar',Qvar           Bandwidth variation factor. Multiplies the
                                calculated bandwidth (divides Q). 
                                Default value is 1.
     
        For a list of supported CQT-type filters, please see the help of 
        FIRWIN and FREQWIN. 
     *Url*: <http://ltfat.github.io/doc/comp/wpghi_findalpha.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WPGHI_FINDALPHA  Approximates a matching Cauchy wavelet order alpha to given ...





