# doc-cache created by Octave 4.0.0
# name: cache
# type: cell
# rows: 3
# columns: 118
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
arg_filterbankdual


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


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



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


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


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



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


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


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



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


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


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



# 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/comp/



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


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


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



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


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


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



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


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

     *Url*: <http://ltfat.github.io/doc/comp/arg_normalize.html>


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



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


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


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



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


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


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



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


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


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



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


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


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



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


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


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



# 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.html>



# 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'};
 Frequency v



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 971
 -- 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: 183
 -- 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: 17
 ASSERT_CLASSNAME



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 500
 -- 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: 159
 -- Function: assert_sigreshape_post
      Restore the original, permuted shape.
     *Url*:
     <http://ltfat.github.io/doc/comp/assert_sigreshape_post.html>


# 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: 778
 -- 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: 671
 -- 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: 237
 -- 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: 1137
 -- 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: 255
 -- 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: 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: 1035
 -- 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: 15
comp_dgt_walnut


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1328
 -- 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: 500
 -- 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.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_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: 250
 -- 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: 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: 1059
 -- 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: 10
comp_downs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1234
 -- 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 = co



# 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: 143
 -- 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: 153
 -- 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: 129
 -- 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: 713
 -- 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,ext)



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 336
 -- 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: 15
comp_filterbank


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 488
 -- 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: 24
comp_filterbankphasegrad


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


     *Url*:
     <http://ltfat.github.io/doc/comp/comp_filterbankphasegrad.html>


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




# 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: 436
 -- 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, and



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 185
 -- 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: 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: 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: 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: 100
 -- Function: comp_frana_tensor
     *Url*: <http://ltfat.github.io/doc/comp/comp_frana_tensor.html>


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



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


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


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



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


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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 639
 -- 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: 809
 -- 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: 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: 745
 -- 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: 9
comp_gdgt


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

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

     *Url*: <http://ltfat.github.io/doc/comp/comp_gdgt.html>


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 337
 -- 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: 504
 -- 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: 711
 -- 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 = he



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 628
 -- 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: 1242
 -- 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: 352
 -- 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: 1219
 -- 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: 477
 -- 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,phasetype)



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1270
 -- 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: 360
 -- 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: 1259
 -- 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: 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: 237
 -- 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: 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: 238
 -- 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: 140
 -- 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: 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/do



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 727
 -- 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: 725
 -- 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,timeinv)



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1032
 -- 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=inonsepdg



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 477
 -- 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,lt,



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


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



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


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



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


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



# 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: 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: 142
 -- 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: 222
 -- 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: 640
 -- 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=comp_i



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 554
 -- 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: 834
 -- 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=co



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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 878
 -- 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,wt



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


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



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


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



# 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://ltfa



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 228
 -- 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: 23
COMP_PAINLESSFILTERBANK



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
 -- Function: comp_phasegradfilters
      Number of filters
     *Url*: <http://ltfat.github.io/doc/comp/comp_phasegradfilters.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 Number of filters
   *Url*: <http://ltfat.github.io/doc/comp/comp_phasegradfilt



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 379
 -- 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 = comp



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 133
 -- 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: 130
 -- 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: 408
 -- 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: 19
comp_ufilterbank_td


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 539
 -- 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: 1554
 -- 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(f,a



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 830
 -- 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_uwfbt(f



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 641
 -- 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=comp



# 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/doc/c



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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 845
 -- 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,range



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 551
 -- 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: 646
 -- 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,wtNo



# 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.git



# 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.gi



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


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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 220
 -- 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: 26
 COMPLAINIF_ISJAVAHEADLESS



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


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


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



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


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


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



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


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


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



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


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


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



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


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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 563
 -- 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] = gabpar



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 689
 -- 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: [g,g



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


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





