# Created by Octave 3.8.2, Thu Oct 09 19:51:06 2014 UTC <root@rama>
# name: cache
# type: cell
# rows: 3
# columns: 109
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
arg_filterbankdual


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_filterbankdual.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_firwin.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_freqtoaud.php>



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


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




# 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: 8
arg_fwt2


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_fwt2.php>



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


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




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



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


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




# 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: 15
arg_groupthresh


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_groupthresh.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_ltfattranslate.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_normalize.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_pfilt.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_plotfilterbank.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_plotfwt.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_tfplot.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
   *Url*: <http://ltfat.sourceforge.net/doc/comp/arg_thresh.php>



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


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




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



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


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




# 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: 190
 -- Function: assert_classname
      ASSERT_CLASSNAME

      Returns name of the least "simplest" common data type.
     *Url*: <http://ltfat.sourceforge.net/doc/comp/assert_classname.php>




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



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


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




# 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: 166
 -- Function: assert_sigreshape_post
      Restore the original, permuted shape.
     *Url*:
     <http://ltfat.sourceforge.net/doc/comp/assert_sigreshape_post.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
 Restore the original, permuted shape.



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


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




# 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: 678
 -- 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.sourceforge.net/doc/comp/assert_squarelat.php>




# 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: 249
 -- Function: block_interface
     BLOCK_INTERFACE Common block processing backend






       Object-like interface for sharing data between block handling
       functions.
     *Url*: <http://ltfat.sourceforge.net/doc/comp/block_interface.php>




# 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: 1144
 -- 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.sourceforge.net/doc/comp/comp_dgt.php>




# 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: 262
 -- 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.sourceforge.net/doc/comp/comp_dgt_fb.php>




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



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


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




# 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: 15
comp_dgt_walnut


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




# 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: 507
 -- Function: comp_dgtreal
     COMP_DGTREAL  Compute a DGTREAL
        Usage:  c=comp_dgt_real(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.sourceforge.net/doc/comp/comp_dgtreal.php>




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



# 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.sourceforge.net/doc/comp/comp_dgtreal_fb.php>




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




# 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: 10
comp_downs


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




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 110
 -- Function: comp_dtwfb
      First tree
     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_dtwfb.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
 First tree
   *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_dtwfb.php>



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


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

     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_dwiltii.php>




# 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: 160
 -- Function: comp_dwiltiv
     COMP_DWILTIV  Compute Discrete Wilson transform type IV.

     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_dwiltiv.php>




# 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: 136
 -- Function: comp_edgt6
     COMP_EDGT6   Compute Even DGT type 6

     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_edgt6.php>




# 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: 720
 -- 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.sourceforge.net/doc/comp/comp_extBoundary.php>




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



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


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




# 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: 347
 -- 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.
     *Url*:
     <http://ltfat.sourceforge.net/doc/comp/comp_filterbank_a.php>




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



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


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




# 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: 23
comp_filterbankresponse


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
 G1 is done this way just so that we can determine the data type.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
 G1 is done this way just so that we can determine the data type.



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


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



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




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


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

     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: 250
 -- 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.sourceforge.net/doc/comp/comp_framelength_fusion.php>




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



# 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.sourceforge.net/doc/comp/comp_framelength_tensor.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
COMP_FRAMELENGTH_TENSOR  Helper function for the Tensor frame



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 162
 -- Function: comp_frana_fusion
      All frames must use the same length signal.
     *Url*:
     <http://ltfat.sourceforge.net/doc/comp/comp_frana_fusion.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
 All frames must use the same length signal.



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
   *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_frana_tensor.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
   *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_frsyn_fusion.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
   *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_frsyn_tensor.php>



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


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




# 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: 821
 -- 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.sourceforge.net/doc/comp/comp_fwtpack2cell.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
COMP_FWTPACK2CELL Change FWT coef.



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


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

     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: 9
comp_gdgt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 810
 -- Function: comp_gdgt
     COMP_GDGT  Compute generalized DGT
        Usage:  c=comp_gdgt(f,g,a,M,L,c_t,c_f,c_w,timeinv);

        Input parameters:
              f       : Input data
              g       : Window function.
              a       : Length of time shift.
              M       : Number of modulations.
              L       : Length of transform to do.
              c_t     : Centering in time of modulation.
              c_f     : Centering in frequency of modulation.
              c_w     : Centering in time of window.
              timeinv : Should we compute a time invariant Gabor system.
        Output parameters:
              c       : M*N array of coefficients.
              Ls      : Length of input signal.

     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_gdgt.php>




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



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


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




# 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: 511
 -- 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.sourceforge.net/doc/comp/comp_hermite.php>




# 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: 718
 -- 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.sourceforge.net/doc/comp/comp_hermite_all.php>




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



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


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




# 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: 1249
 -- 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.sourceforge.net/doc/comp/comp_idgt_fac.php>




# 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: 359
 -- 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.sourceforge.net/doc/comp/comp_idgt_fb.php>

     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: 1226
 -- 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.sourceforge.net/doc/comp/comp_idgt_long.php>




# 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: 484
 -- 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.sourceforge.net/doc/comp/comp_idgtreal.php>




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



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


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




# 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: 367
 -- 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.sourceforge.net/doc/comp/comp_idgtreal_fb.php>

     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: 1271
 -- 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.sourceforge.net/doc/comp/comp_idgtreal_long.php>




# 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: 11
comp_idtwfb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
 Split the coefficients



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
 Split the coefficients




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


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




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



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


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




# 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: 147
 -- Function: comp_iedgt6
     COMP_IEDGT6   Compute inverse even DGT type 6

     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_iedgt6.php>




# 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: 16
comp_ifilterbank


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 154
 -- Function: comp_ifilterbank
     COMP_IFILTERBANK Compute inverse filterbank
     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_ifilterbank.php>




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



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


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




# 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: 732
 -- 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.sourceforge.net/doc/comp/comp_igdgt.php>




# 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,timeinv)



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


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




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



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


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




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



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


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




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 136
 -- Function: comp_irdgt
     COMP_IRDGT  Compute inverse real DGT.
     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_irdgt.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
COMP_IRDGT  Compute inverse real DGT.



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


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

     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_irdgtii.php>




# 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: 229
 -- Function: comp_irdgtiii
     COMP_IRDGTIII  Compute inverse real DGT type III.

        This is a computational routine. Do not call it
        directly.
     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_irdgtiii.php>




# 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: 652
 -- 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.sourceforge.net/doc/comp/comp_iufilterbank_td.php>




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



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


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




# 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: 841
 -- 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.sourceforge.net/doc/comp/comp_iuwfbt.php>




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



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


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




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



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


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




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



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


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




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



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


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




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 291
 -- Function: comp_painlessfilterbank
     COMP_PAINLESSFILTERBANK

        Function computes filterbank dual or tight frame for the painless case.
        All g{ii}.H should already be numeric verctors.

     *Url*:
     <http://ltfat.sourceforge.net/doc/comp/comp_painlessfilterbank.php>




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 145
 -- Function: comp_sigreshape_post
     COMP_SIGRESHAPE_POST

     *Url*:
     <http://ltfat.sourceforge.net/doc/comp/comp_sigreshape_post.php>




# 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: 142
 -- Function: comp_sigreshape_pre
     COMP_SIGRESHAPE_PRE

     *Url*:
     <http://ltfat.sourceforge.net/doc/comp/comp_sigreshape_pre.php>




# 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: 420
 -- 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.sourceforge.net/doc/comp/comp_transferfunction.php>




# 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: 19
comp_ufilterbank_td


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




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



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


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




# 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: 1561
 -- 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.sourceforge.net/doc/comp/comp_ups.php>




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



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


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




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



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


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




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 149
 -- Function: comp_warpedfoff
     COMP_WARPEDFOFF  foff for warped filters
     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_warpedfoff.php>




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 842
 -- 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 NORMALIZE.
     *Url*:
     <http://ltfat.sourceforge.net/doc/comp/comp_warpedfreqresponse.php>




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



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


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




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



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


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

     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: 653
 -- 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.sourceforge.net/doc/comp/comp_wpfbt.php>




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 161
 -- Function: comp_wpfbtscale
     COMP_WPFBTSCALE Scale filters in the filterbank tree
     *Url*: <http://ltfat.sourceforge.net/doc/comp/comp_wpfbtscale.php>




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



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
   *Url*: <http://ltfat.sourceforge.net/doc/comp/compinit.php>



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 227
 -- Function: complainif_isjavaheadless
      COMPLAINIF_ISJAVAHEADLESS

        Prints warning if the available JRE ius in headless mode.
     *Url*:
     <http://ltfat.sourceforge.net/doc/comp/complainif_isjavaheadless.php>




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



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
   *Url*:
<http://ltfat.sourceforge.net/doc/comp/complainif_notenoughargs.php>



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


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




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



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
   *Url*:
<http://ltfat.sourceforge.net/doc/comp/complainif_notvalidframeobj.php



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
   *Url*:
<http://ltfat.sourceforge.net/doc/comp/complainif_toomanyargs.php>



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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
   *Url*:
<http://ltfat.sourceforge.net/doc/comp/demo_blockproc_header.php>



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


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




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



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


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




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



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


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




# 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: 201
 -- Function: vect2cell
     VECT2CELL Vector to cell

        Works exactly like mat2cell(x,idx,size(x,2))
        but it is faster.
     *Url*: <http://ltfat.sourceforge.net/doc/comp/vect2cell.php>




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





