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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2282
 LTFAT - Signal processing tools

  Peter L. Soendergaard, 2007 - 2023.

  General
    RMS            -  Root Mean Square norm of signal.
    SETNORM        -  Normalize signal by specified norm.
    GAINDB         -  Scale input signal.
    CRESTFACTOR    -  Compute the crest factor of a signal.
    LOWDISCREPANCY -  Compute a low discrepancy sequence.
    UQUANT         -  Simulate uniform quantization.

  Window functions
    FIRWIN         -  FIR windows (Hanning,Hamming,Blackman,...).
    FIRKAISER      -  FIR Kaiser-Bessel window.
    FIR2LONG       -  Extend FIR window to LONG window.
    LONG2FIR       -  Cut LONG window to FIR window.
    FREQWIN        -  Freq responses (Gauss,Gammatone,Butterworth,...)

  Wavelet functions
    FREQWAVELET    -  Frequency responses of wavelets (Cauchy, Morse)

  Filtering
    FIRFILTER      -  Construct an FIR filter.
    BLFILTER       -  Construct a band-limited filter.
    WARPEDBLFILTER -  Warped, band-limited filter.
    FREQFILTER     -  Construct a full length frequency side filter.
    PFILT          -  Apply filter with periodic boundary conditions.
    MAGRESP        -  Magnitude response plot.
    TRANSFERFUNCTION - Compute the transfer function of a filter.
    PGRPDELAY      -  Periodic Group Delay

  Ramping
    RAMPUP         -  Rising ramp.
    RAMPDOWN       -  Falling ramp.
    RAMPSIGNAL     -  Ramp a signal.

  Thresholding methods
    THRESH         -  Coefficient thresholding.
    LARGESTR       -  Keep largest ratio of coefficients.
    LARGESTN       -  Keep N largest coefficients.
    DYNLIMIT       -  Limit the dynamical range.
    GROUPTHRESH    -  Group thresholding.

  Image processing
    RGB2JPEG       -  Convert RGB values to the JPEG colour model
    JPEG2RGB       -  Convert values from the JPEG colour model to RGB

  Tools for OFDM
    QAM4           -  Quadrature amplitude modulation, order 4
    IQAM4          -  Inverse QAM of order 4

  Tonal-transient separation
    tfjigsawsep      - Tonal-transient-residual separation using the T-F jigsaw puzzle algorithm.
    plottfjigsawsep  - Plot the separated layers.

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


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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
 LTFAT - Signal processing tools



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4101
 -- Function: blfilter
     BLFILTER  Construct a band-limited filter
        Usage:  g=blfilter(winname,fsupp,fc);
                g=blfilter(winname,fsupp,fc,...);
     
        Input parameters:
           winname  : Name of prototype
           fsupp    : Support length of the prototype
     
        BLFILTER(winname,fsupp) constructs a band-limited filter. The parameter
        winname specifies the shape of the frequency response. The name must be
        one of the shapes accepted by FIRWIN. The support of the frequency
        response measured in normalized frequencies is specified by fsupp.
     
        BLFILTER(winname,fsupp,fc) constructs a filter with a centre
        frequency of fc measured in normalized frequencies.
     
        If one of the inputs is a vector, the output will be a cell array
        with one entry in the cell array for each element in the vector. If
        more input are vectors, they must have the same size and shape and the
        filters will be generated by stepping through the vectors. This
        is a quick way to create filters for FILTERBANK and UFILTERBANK.
     
        BLFILTER accepts the following optional parameters:
     
          'fs',fs     If the sampling frequency fs is specified then the support
                      fsupp and the centre frequency fc is specified in Hz.
     
          'complex'   Make the filter complex valued if the centre frequency
                      is non-zero. This is the default.
     
          'real'      Make the filter real-valued if the centre frequency
                      is non-zero.
     
          'delay',d   Set the delay of the filter. Default value is zero.
     
          'scal',s    Scale the filter by the constant s. This can be
                      useful to equalize channels in a filter bank.
     
          'pedantic'  Force window frequency offset (g.foff) to a subsample 
                      precision by a subsample shift of the firwin output.
                      
     
        It is possible to normalize the transfer function of the filter by
        passing any of the flags from the SETNORM function. The default
        normalization is 'energy'.
     
        The filter can be used in the PFILT routine to filter a signal, or
        in can be placed in a cell-array for use with FILTERBANK or
        UFILTERBANK.
     
        Output format:
        --------------
     
        The output g from BLFILTER is a structure. This type of structure can
        be used to describe any bandlimited filter defined in terms of its
        transfer function. The structure contains the following fields:
     
          g.H     This is an anonymous function taking the transform length L as
                  input and producing the bandlimited transfer function in the
                  form of a vector.
     
          g.foff  This is an anonymous function taking the transform length L as
                  input and procing the frequency offset of H as an integer. The
                  offset is the value of the lowest frequency of H measured in
                  frequency samples. foff is used to position the bandlimited
                  tranfer function stored in H correctly when multiplying in the
                  frequency domain.
     
          g.delay  This is the desired delay of the filter measured in samples.
     
          g.realonly
                  This is an integer with value 1 if the filter defined a
                  real-valued filter. In this case, the bandlimited transfer
                  function H will be mirrored from the positive frequencies to
                  the negative frequencies. If the filter is a natural lowpass
                  filter correctly centered around 0, realonly does not need
                  to be 1.
     
          g.fs    The intended sampling frequency. This is an optional parameter
                  that is *only* used for plotting and visualization.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/blfilter.html>

     See also: firfilter, firwin, pfilt, filterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
BLFILTER  Construct a band-limited filter
   Usage:  g=blfilter(winname,fsupp...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 341
 -- Function: crestfactor
     CRESTFACTOR  Crest factor of input signal in dB
        Usage:  c=crestfactor(insig);
     
        CRESTFACTOR(insig) computes the crest factor of the input signal
        insig. The output is measured in dB.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/crestfactor.html>

     See also: rms, gaindb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
CRESTFACTOR  Crest factor of input signal in dB
   Usage:  c=crestfactor(insi...



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


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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 397
 -- Function: dynlimit
     DYNLIMIT  Limit the dynamical range of the input
        Usage: xo=dynlimit(xi,dynrange);
     
        DYNLIMIT(xi,dynrange) will threshold the input such that the
        difference between the maximum and minumum value of xi is exactly
        dynrange.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/dynlimit.html>

     See also: thresh, largestr, largestn.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DYNLIMIT  Limit the dynamical range of the input
   Usage: xo=dynlimit(xi,dyn...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1528
 -- Function: elitistthresh
     ELITISTTHRESH   elitist (hard/soft) thresholding
        Usage:  xo=elitistthresh(xi,lambda);
     
        ELITISTTHRESH(xi,lambda) performs hard elitist thresholding on xi,
        with threshold lambda. The input xi must be a two-dimensional array,
        the first dimension labelling groups, and the second one labelling
        members.  All coefficients within a given group are shrunk according to
        the value of the l^1 norm of the group in comparison to the threshold
        value lambda.
     
        ELITISTTHRESH(x,lambda,'soft') will do the same using soft
        thresholding.
     
        ELITISTTHRESH accepts the following flags at the end of the line of input
        arguments:
     
          'hard'    Perform hard thresholding. This is the default.
     
          'soft'    Perform soft thresholding.  
     
          'full'    Return the output as a full matrix. This is the default.
     
          'sparse'  Return the output as a sparse matrix.
       
     
     
        References:
          M. Kowalski. Sparse regression using mixed norms. Appl. Comput. Harmon.
          Anal., 27(3):303--324, 2009.
          
          M. Kowalski and B. Torresani. Sparsity and persistence: mixed norms
          provide simple signal models with dependent coefficients. Signal, Image
          and Video Processing, 3(3):251--264, 2009.
          
     *Url*: <http://ltfat.github.io/doc/sigproc/elitistthresh.html>

     See also: groupthresh, demo_audioshrink.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
ELITISTTHRESH   elitist (hard/soft) thresholding
   Usage:  xo=elitistthresh(...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 724
 -- Function: fir2long
     FIR2LONG   Extend FIR window to LONG
        Usage:  g=fir2long(g,Llong);
     
        FIR2LONG(g,Llong) will extend the FIR window g to a length Llong*
        window by inserting zeros. Note that this is a slightly different
        behaviour than MIDDLEPAD.
     
        FIR2LONG can also be used to extend a FIR window to a longer FIR
        window, for instance in order to satisfy the usual requirement that the
        window length should be divisible by the number of channels.
     
        If the input to FIR2LONG is a cell, FIR2LONG will recurse into
        the cell array.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/fir2long.html>

     See also: long2fir, middlepad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
FIR2LONG   Extend FIR window to LONG
   Usage:  g=fir2long(g,Llong);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2063
 -- Function: firfilter
     FIRFILTER  Construct an FIR filter
        Usage:  g=firfilter(name,M);
                g=firfilter(name,M,...);
     
        FIRFILTER(name,M) creates an FIR filter of length M. This is
        exactly the same as calling FIRWIN. The name must be one of the
        accepted window types of FIRWIN.
     
        FIRFILTER(name,M,fc) constructs a filter with a centre
        frequency of fc measured in normalized frequencies.
     
        If one of the inputs is a vector, the output will be a cell array
        with one entry in the cell array for each element in the vector. If
        more input are vectors, they must have the same size and shape and the
        the filters will be generated by stepping through the vectors. This
        is a quick way to create filters for FILTERBANK and UFILTERBANK.
     
        FIRFILTER accepts the following optional parameters:
     
          'fs',fs     If the sampling frequency fs is specified then the length
                      M is specified in seconds and the centre frequency
                      fc in Hz.
     
          'complex'   Make the filter complex valued if the centre frequency
                      is non-zero. This is the default.
     
          'real'      Make the filter real-valued if the centre frequency
                      is non-zero.
     
          'delay',d   Set the delay of the filter. Default value is zero.
     
          'causal'    Create a causal filter starting at the first sample. If
                      specified, this flag overwrites the delay setting.
     
        It is possible to normalize the impulse response of the filter by
        passing any of the flags from the SETNORM function. The default
        normalization is 'energy'.
     
        The filter can be used in the PFILT routine to filter a signal, or
        in can be placed in a cell-array for use with FILTERBANK or UFILTERBANK.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/firfilter.html>

     See also: blfilter, firwin, pfilt, filterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FIRFILTER  Construct an FIR filter
   Usage:  g=firfilter(name,M);
          ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1407
 -- Function: firkaiser
     FIRKAISER  Kaiser-Bessel window
        Usage:  g=firkaiser(L,beta);
                g=firkaiser(L,beta,...);
     
        FIRKAISER(L,beta) computes the Kaiser-Bessel window of length L with
        parameter beta. The smallest element of the window is set to zero when
        the window has an even length. This gives the window perfect whole-point
        even symmetry, and makes it possible to use the window for a Wilson
        basis.
     
        FIRKAISER takes the following flags at the end of the input arguments:
     
          'normal'   Normal Kaiser-Bessel window. This is the default.
     
          'derived'  Derived Kaiser-Bessel window.
     
          'wp'       Generate a whole point even window. This is the default.
     
          'hp'       Generate half point even window.
       
        Additionally, FIRKAISER accepts flags to normalize the output. Please
        see the help of SETNORM. Default is to use 'null' normalization.
     
        Note that odd-length Derived Kaiser-Bessel windows are not
        mathematically defined, yet they are supported by this code.
     
     
        References:
          A. V. Oppenheim and R. W. Schafer. Discrete-time signal processing.
          Prentice Hall, Englewood Cliffs, NJ, 1989.
          
     *Url*: <http://ltfat.github.io/doc/sigproc/firkaiser.html>

     See also: firwin, setnorm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FIRKAISER  Kaiser-Bessel window
   Usage:  g=firkaiser(L,beta);
           g=...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8275
 -- Function: firwin
     FIRWIN  FIR window
        Usage:  g=firwin(name,M);
                g=firwin(name,M,...);
                g=firwin(name,x);
                
        FIRWIN(name,M) will return an FIR window of length M of type name.
     
        All windows are symmetric and generate zero delay and zero phase
        filters. They can be used for the Wilson and WMDCT transform, except
        when noted otherwise.
     
        FIRWIN(name,x) where x is a vector will sample the window
        definition as the specified points. The normal sampling interval for
        the windows is -.5< x <.5.
     
        In the following PSL means "Peak Sidelobe level", and the main lobe
        width is measured in normalized frequencies.
     
        If a window g forms a "partition of unity" (PU) it means specifically
        that:
     
          g+fftshift(g)==ones(L,1);
     
        A PU can only be formed if the window length is even, but some windows
        may work for odd lengths anyway.
     
        If a window is the square root of a window that forms a PU, the window
        will generate a tight Gabor frame / orthonormal Wilson/WMDCT basis if
        the number of channels is less than M.
     
        The windows available are:
     
          'hann'       von Hann window. Forms a PU. The Hann window has a
                       mainlobe with of 8/M, a PSL of -31.5 dB and decay rate
                       of 18 dB/Octave.
     
          'sine'       Sine window. This is the square root of the Hanning
                       window. The sine window has a mainlobe width of 8/M,
                       a  PSL of -22.3 dB and decay rate of 12 dB/Octave.
                       Aliases: 'cosine', 'sqrthann'
     
          'rect'       (Almost) rectangular window. The rectangular window has a
                       mainlobe width of 4/M, a PSL of -13.3 dB and decay
                       rate of 6 dB/Octave. Forms a PU if the order is odd.
                       Alias: 'square'
     
          'tria'       (Almost) triangular window. Forms a PU. Alias: 'bartlett'
     
          'sqrttria'   Square root of the triangular window.
     
          'hamming'    Hamming window. Forms a PU that sums to 1.08 instead
                       of 1.0 as usual. The Hamming window has a
                       mainlobe width of 8/M, a  PSL of -42.7 dB and decay
                       rate of 6 dB/Octave. This window should not be used for
                       a Wilson basis, as a reconstruction window cannot be
                       found by WILDUAL.
     
          'blackman'   Blackman window. The Blackman window has a
                       mainlobe width of 12/M, a PSL of -58.1 dB and decay
                       rate of 18 dB/Octave.
     
          'blackman2'  Alternate Blackman window. This window has a
                       mainlobe width of 12/M, a PSL of -68.24 dB and decay
                       rate of 6 dB/Octave.
     
          'itersine'   Iterated sine window. Generates an orthonormal
                       Wilson/WMDCT basis. This window is described in 
                       Wesfreid and Wickerhauser (1993) and is used in  the
                       ogg sound codec. Alias: 'ogg'
     
          'nuttall'    Nuttall window. The Nuttall window has a
                       mainlobe width of 16/M, a PSL of -93.32 dB and decay
                       rate of 18 dB/Octave.
     
          'nuttall10'  2-term Nuttall window with 1 continuous derivative. 
                       Alias: 'hann', 'hanning'.
     
          'nuttall01'  2-term Nuttall window with 0 continuous derivatives. 
                       This is a slightly improved Hamming window. It has a
                       mainlobe width of 8/M, a  PSL of -43.19 dB and decay
                       rate of 6 dB/Octave.
     
          'nuttall20'  3-term Nuttall window with 3 continuous derivatives. 
                       The window has a mainlobe width of 12/M, a PSL of 
                       -46.74 dB and decay rate of 30 dB/Octave.
     
          'nuttall11'  3-term Nuttall window with 1 continuous derivative. 
                       The window has a mainlobe width of 12/M, a PSL of 
                       -64.19 dB and decay rate of 18 dB/Octave.
     
          'nuttall02'  3-term Nuttall window with 0 continuous derivatives. 
                       The window has a mainlobe width of 12/M, a PSL of 
                       -71.48 dB and decay rate of 6 dB/Octave.
     
          'nuttall30'  4-term Nuttall window with 5 continuous derivatives. 
                       The window has a mainlobe width of 16/M, a PSL of 
                       -60.95 dB and decay rate of 42 dB/Octave.
     
          'nuttall21'  4-term Nuttall window with 3 continuous derivatives. 
                       The window has a mainlobe width of 16/M, a PSL of 
                       -82.60 dB and decay rate of 30 dB/Octave.
     
          'nuttall12'  4-term Nuttall window with 1 continuous derivatives. 
                       Alias: 'nuttall'.
     
          'nuttall03'  4-term Nuttall window with 0 continuous derivatives. 
                       The window has a mainlobe width of 16/M, a PSL of 
                       -98.17 dB and decay rate of 6 dB/Octave.
     
          'truncgauss' Gaussian window truncated at 1% of its height.
                       Alternatively, a custom percentage can be appended to
                       'truncgauss' e.g. 'truncgauss0.1' will create Gaussian
                       window truncated at 0.1% of its height.
     
        FIRWIN understands the following flags at the end of the list of input
        parameters:
     
          'shift',s    Shift the window by s samples. The value can be a
                       fractional number.
     
          'wp'         Output is whole point even. This is the default. It
                       corresponds to a shift of s=0.
     
          'hp'         Output is half point even, as most Matlab filter
                       routines. This corresponds to a shift of s=-.5
                        
     
          'taper',t    Extend the window by a flat section in the middle. The
                       argument t is the ratio of the rising and falling
                       parts as compared to the total length of the
                       window. The default value of 1 means no
                       tapering. Accepted values lie in the range from 0 to 1.
     
        Additionally, FIRWIN accepts flags to normalize the output. Please see
        the help of SETNORM. Default is to use 'peak' normalization,
        which is useful for using the output from FIRWIN for windowing in the
        time-domain. For filtering in the time-domain, a normalization of '1'
        or 'area' is preferable.
     
        Examples:
        ---------
     
        The following plot shows the magnitude response for some common
        windows:
     
          hold all; 
          L=30;
          dr=110;
     
          magresp(firwin('hanning',L,'1'),'fir','dynrange',dr);
          magresp(firwin('hamming',L,'1'),'fir','dynrange',dr);
          magresp(firwin('blackman',L,'1'),'fir','dynrange',dr);
          magresp(firwin('nuttall',L,'1'),'fir','dynrange',dr);
          magresp(firwin('itersine',L,'1'),'fir','dynrange',dr);
     
          legend('Hann','Hamming','Blackman','Nuttall','Itersine');
     
     
        References:
          A. V. Oppenheim and R. W. Schafer. Discrete-time signal processing.
          Prentice Hall, Englewood Cliffs, NJ, 1989.
          
          A. Nuttall. Some windows with very good sidelobe behavior. IEEE Trans.
          Acoust. Speech Signal Process., 29(1):84--91, 1981.
          
          F. Harris. On the use of windows for harmonic analysis with the
          discrete Fourier transform. Proceedings of the IEEE, 66(1):51 -- 83,
          jan 1978.
          
          E. Wesfreid and M. Wickerhauser. Adapted local trigonometric transforms
          and speech processing. IEEE Trans. Signal Process., 41(12):3596--3600,
          1993.
          
     *Url*: <http://ltfat.github.io/doc/sigproc/firwin.html>

     See also: freqwin, pgauss, pbspline, firkaiser, setnorm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FIRWIN  FIR window
   Usage:  g=firwin(name,M);
           g=firwin(name,M,.....



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2110
 -- Function: freqfilter
     FREQFILTER Construct filter in frequency domain
        Usage:   g=freqfilter(winname,bw);
                 g=freqfilter(winname,bw,fc);
     
        Input parameters:
           winname  : Name of prototype
           bw       : Effective support length of the prototype
           fc       : Center frequency
        
        FREQFILTER(winname,bw) creates a full-length frequency response
        filter. The parameter winname specifies the shape of the frequency
        response. For accepted shape please see FREQWIN. bw defines a
        -6dB bandwidth of the filter in normalized frequencies.
        
        FREQFILTER(winname,bw,fc) constructs a filter with a centre
        frequency of fc measured in normalized frequencies.
     
        If one of the inputs is a vector, the output will be a cell array
        with one entry in the cell array for each element in the vector. If
        more input are vectors, they must have the same size and shape and the
        the filters will be generated by stepping through the vectors. This
        is a quick way to create filters for FILTERBANK and UFILTERBANK.
        
        FREQFILTER accepts the following optional parameters:
     
          'fs',fs     If the sampling frequency fs is specified then the 
                      bandwidth bw and the centre frequency fc are 
                      specified in Hz.
     
          'complex'   Make the filter complex valued if the centre frequency
                      is non-zero. This is the default.
     
          'real'      Make the filter real-valued if the centre frequency
                      is non-zero.
     
          'delay',d   Set the delay of the filter. Default value is zero.
     
          'scal',s    Scale the filter by the constant s. This can be
                      useful to equalize channels in a filter bank.
     
          'pedantic'  Force window frequency offset (g.foff) to a subsample 
                      precision by a subsample shift of the window.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/freqfilter.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FREQFILTER Construct filter in frequency domain
   Usage:   g=freqfilter(winn...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9361
 -- Function: freqwavelet
     FREQWAVELET  Wavelet in the freq. domain
        Usage: H=freqwavelet(name,L)
               H=freqwavelet(name,L,scale)
               [H,info]=freqwavelet(...)
     
        Input parameters:
              name  : Name of the wavelet
              L     : System length
        Output parameters:
              H     : Frequency domain wavelet
              info  : Struct with additional outputs
     
        FREQWAVELET(name,L) returns peak-normalized "mother" frequency-domain
        wavelet name for system length L. The basic scale is selected such
        that the peak is positioned at the frequency 0.1 relative to the Nyquist
        rate (fs/2).
     
        The supported wavelets that can be used in place of name (the actual
        equations can be found at the end of this help):
     
          'cauchy'    Cauchy wavelet with alpha=100. Custom order=(alpha-1)/2
                      (with alpha>1) can be set by {'cauchy',alpha}. The
                      higher the order, the narrower and more symmetric the
                      wavelet. A numericaly stable formula is used in order
                      to allow support even for very high alpha e.g.
                      10^6.
     
          'morse'     Morse wavelet with alpha=100 and gamma=3. Both parameters
                      can be set directly by {'morse',alpha,gamma}. alpha
                      has the same role as for 'cauchy', gamma is the
                      'skewness' parameter. 'morse' becomes 'cauchy' for
                      gamma=1.
     
          'morlet'    Morlet wavelet with sigma=4. The parameter sigma 
                      is the center frequency to standard deviation ratio of
                      the main generating Gaussian distribution. Note that the 
                      true peak and standard deviation of the Morlet wavelet 
                      differ, in particular for low values of sigma (<5). 
                      This is a consequence of the correction factor. The 
                      parameter can be set directly by {'morlet',sigma}.
      
         'fbsp'       Frequency B-spline wavelet of order m=3, center frequency
                      to bandwidth ratio fb = 2. The parameters can be set
                      by {'fbsp',m,fb}. Note that m must be integer and
                      greater than or equal to 1, and fb must be greater than 
                      or equal to 2. 
     
         'analyticsp' Positive frequency part of cosine-modulated B-spline 
                      wavelet of  order order=3, with center frequency to main 
                      lobe width ratio fb = 1. The parameters can be set by 
                      {'analyticsp',order,fb}. Note that order and fb 
                      must be integer and greater than or equal to 1.
     
         'cplxsp'     Complex-modulated B-spline of order order=3, with center
                      frequency to main lobe width ratio fb = 1. The parameters 
                      can be set by {'cplxsp',order,fb}. Note that order 
                      and fb must be integer and greater than or equal to 1.
     
        FREQWAVELET(name,L,scale) returns a "dilated" version of the wavelet.
        The nonzero scalar scale controls both the bandwidth and the center
        frequency. Values greater than 1 make the wavelet wider (and narrower 
        in the frequency domain), values lower than 1 make the wavelet narrower.
        The center frequency is moved to0.1/scale. The center frequency is 
        limited to the range of "positive" frequencies ]0,1] (up to Nyquist rate).
        If scale is a vector, the output is a L x numel(scale) matrix with 
        the individual wavelets as columns.
     
        The following additional flags and key-value parameters are available:
     
          'scale'           Wavelet scale (relative to basic scale)
     
          'waveletParams'   a vector containing the respective wavelet parameters
                            [alpha, beta, gamma] for cauchy and morse wavelets
                            [sigma] for morlet wavelets
                            [order, fb] for splines 
     
          'basefc',fc      Normalized center frequency of the mother wavelet
                           (scale=1). The default is 0.1.
     
          'bwthr',bwthr    The height at which the bandwidth is computed.
                           The default value is 10^(-3/10) (~0.5).
     
          'efsuppthr',thr  The threshold determining the effective support of
                           the wavelet. The default value is 10^(-5).
     
          'scal',s         Scale the filter by the constant s. This can be
                           useful to equalize channels in a filter bank.
     
          'delay',d        Set the delay of the filter. Can be either a scalar or
                           a vector of the same length as scale. Default value is zero.
     
        The admissible range of scales can be adjusted to handle different 
        scenarios:
     
          'positive'       Enables the construction of wavelets at postive
                           center frequencies ]0,1]. If basefc=0.1, this 
                           corresponds to scales larger than or equal to 0.1.
                           This is the default.
     
          'negative'       Enables the construction of wavelets at negative 
                           center frequencies [-1,0[. If basefc=0.1, this 
                           corresponds to scales smaller than or equal to -0.1.
     
          'analytic'       Enables the construction of wavelets with center 
                           frequencies in ]0,2] for analysis of analytic signals. 
                           [! This feature is currently experimental and may not
                           always work as intended. !]
     
        The format of the output is controlled by the following flags:
        'full' (default),'econ','asfreqfilter':
     
          'full'           The output is a L x numel(scale) matrix.
     
          'econ'           The output is a numel(scale) cell array with
                           individual freq. domain wavelets truncated to the
                           length of the effective support given by parameter 'efsuppthr'.
                           Does not run stably for system lengths > 2000
     
          'asfreqfilter'   As 'econ', but the elements of the cell-array are
                           filter structs with fields .H and .foff as in 
                           BLFILTER to be used in FILTERBANK and related. 
     
        [H,info]=FREQWAVELET(...) additionally returns a struct with the
        following fields:
     
          .fc             Normalized center frequency.
     
          .foff           Index of the first sample above the effective
                          support threshold (minus one). 
                          It can be directly used to convert the 'econ'
                          output to 'full' by circshift(postpad(H,L),foff).
     
          .fsupp          Length of the effective support (with values above 
                          efsuppthr).
     
          .basefc         Center frequency of the implied mother wavelet.
     
          .scale          The scale used.
     
          .dilation       The actual dilation used in the formula.
     
          .bw             Relative bandwidth at relative height 'bwthr'.
     
          .tfr            Time-frequency ratio of a Gaussian with the same
                          bandwidth as the wavelet.
     
          .aprecise       Exact natural subsampling factors (not rounded). 
     
          .a_natural      Fractional natural subsampling factors in the
                          format acceptable by FILTERBANK and related.
     
          .cauchyAlpha    Alpha value of closest Cauchy wavelet [NOTE: Not 
                          implemented for non-Morse wavelets.]
     
        Additionally, the function accepts flags to normalize the output.
        Please see the help of SETNORM. By default, no normaliazation is
        applied.
     
        Wavelet definitions
        -------------------
     
        C is a normalization constant.
     
        Cauchy wavelet
     
            H = C xi^{frac{alpha-1}{2}} exp( -2pixi )
     
        Morse wavelet
     
            H = C xi^{frac{alpha-1}{2gamma}} exp( -2pixi^{gamma} )
     
        Morlet wavelet
     
            H = C xi^{frac{alpha-1}{2gamma}} exp( -2pixi^{gamma} )
     
        Frequency bandlimited spline wavelet
     
            H = C B (xi - m frac{xi}{4})
     
        Analytic spline wavelet
     
            H = C exp(-j omega x) A(-exp(j omega)) H(exp(-j omega)
     
        Complex spline wavelet
     
            H = C exp(-j omega x + xi )
     
     
        References:
          O. Rioul and P. Duhamel. Fast algorithms for discrete and continuous
          wavelet transforms. IEEE Transactions on Information Theory,
          38(2):569--586, 1992.
          
          M. Unser, A. Aldroubi, and S. Schiff. B-spline signal processing. i.
          theory. IEEE Trans. Signal Process., 42(12):3519 --3523, 1994.
          
     
     *Url*: <http://ltfat.github.io/doc/sigproc/freqwavelet.html>

     See also: setnorm, filterbank, blfilter.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FREQWAVELET  Wavelet in the freq. domain
   Usage: H=freqwavelet(name,L)
    ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2048
 -- Function: freqwin
     FREQWIN Frequency response window
        Usage: H = freqwin(name,L,bw);
     
        FREQWIN(name,L,bw) returns a frequency window name of length L 
        with the mainlobe -6dB (half height) bandwidth bw. It is intended to
        represent frequency response of a band-pass filter/window with 
        bandwidth bw. The bandwidth is given in frequencies normalized
        to the Nyquist rate.
     
        The function is not periodically wrapped should it be nonzero outside
        of the L samples (as opposed to e.g. PGAUSS).
     
        The following windows can be used in place of name*:
     
          'gauss'        Gaussian window
     
          'gammatone'    Gammatone window. The default order is 4. Custom order 
                         can be set by {'gammatone',order}.
     
          'butterworth'  Butterworth window. The default order is 4. Custom 
                         order can be set by {'butterworth',order}.
     
        FREQWIN(name,L,bw,fs) does the same as above except bw is expected
        to be in Hz given sampling frequency fs.
     
        FREQWIN understands the following key-value pairs and flags at the end of 
        the list of input parameters:
     
          'fs',fs      If the sampling frequency fs is specified then the bw*
                       is expected to be in Hz.
     
          'shift',s    Shift the window by s samples. The value can be a
                       fractional number.   
     
          'wp'         Output is whole point even. This is the default. It
                       corresponds to a shift of s=0.
     
          'hp'         Output is half point even, as most Matlab filter
                       routines. This corresponds to a shift of s=-.5
     
        Additionally, the function accepts flags to normalize the output. Please see
        the help of SETNORM. Default is to use 'peak' normalization.
     
     
     *Url*: <http://ltfat.github.io/doc/sigproc/freqwin.html>

     See also: firwin, setnorm, plotfft.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
FREQWIN Frequency response window
   Usage: H = freqwin(name,L,bw);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 566
 -- Function: gaindb
     GAINDB  Increase/decrease level of signal
        Usage:  outsig = gaindb(insig,gn);
     
        GAINDB(insig,gn) increases the energy level of the signal by gn*
        dB.
     
        If gn is a scalar, the whole input signal is scaled.
     
        If gn is a vector, each column is scaled by the entries in
        gn. The length of gn must match the number of columns.
     
        GAINDB(insig,gn,dim) scales the signal along dimension dim.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/gaindb.html>

     See also: rms.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 79
GAINDB  Increase/decrease level of signal
   Usage:  outsig = gaindb(insig,gn);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2017
 -- Function: groupthresh
     GROUPTHRESH   Group thresholding
        Usage:  xo=groupthresh(xi,lambda);
     
        GROUPTHRESH(x,lambda) performs group thresholding on x, with
        threshold lambda.  x must be a two-dimensional array, the first
        dimension labelling groups, and the second one labelling members. This
        means that the groups are the row vectors of the input (the vectors
        along the 2nd dimension).
     
        Several types of grouping behaviour are available:
     
         GROUPTHRESH(x,lambda,'group') shrinks all coefficients within a given
          group according to the value of the l^2 norm of the group in
          comparison to the threshold lambda. This is the default.
     
         GROUPTHRESH(x,lambda,'elite') shrinks all coefficients within a
          given group according to the value of the l^1 norm of the
          group in comparison to the threshold value lambda.
     
        GROUPTHRESH(x,lambda,dim) chooses groups along dimension
        dim. The default value is dim=2.
     
        GROUPTHRESH accepts all the flags of THRESH to choose the
        thresholding type within each group and the output type (full / sparse
        matrix). Please see the help of THRESH for the available
        options. Default is to use soft thresholding and full matrix output.
       
     
     
        References:
          M. Kowalski. Sparse regression using mixed norms. Appl. Comput. Harmon.
          Anal., 27(3):303--324, 2009.
          
          M. Kowalski and B. Torresani. Sparsity and persistence: mixed norms
          provide simple signal models with dependent coefficients. Signal, Image
          and Video Processing, 3(3):251--264, 2009.
          
          G. Yu, S. Mallat, and E. Bacry. Audio Denoising by Time-Frequency Block
          Thresholding. IEEE Trans. Signal Process., 56(5):1830--1839, 2008.
          
     *Url*: <http://ltfat.github.io/doc/sigproc/groupthresh.html>

     See also: thresh, demo_audioshrink.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
GROUPTHRESH   Group thresholding
   Usage:  xo=groupthresh(xi,lambda);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 373
 -- Function: iqam4
     IQAM4  Inverse QAM of order 4
     
         IQAM4(xi) demodulates a signal mapping the input coefficients to the
         closest complex root of unity, and returning the associated bit
         pattern. This is the inverse operation of QAM4.
     
     
     *Url*: <http://ltfat.github.io/doc/sigproc/iqam4.html>

     See also: qam4, demo_ofdm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
IQAM4  Inverse QAM of order 4



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 981
 -- Function: jpeg2rgb
     JPEG2RGB  Coverts from RGB format to YCbCr format
        Usage:  RGB = jpeg2rgb(YCbCr);
      
        Input parameters:
              YCbCr : 3d data-cube, containing the YCbCr information of the
                      image
      
        Output parameters:
              RGB   : 3d data-cube, containing RGB information of the image
      
        'jpeg2rgb(YCbCr)' performs a transformation of the 3d data-cube YCbCr with
        dimensions N xM x3, which contains information of
        "luminance", "chrominance blue" and "chrominance red".  The output
        variable RGB is a 3d data-cube of the same size containing information
        about the colours "red", "green" and "blue". The output will be of
        the uint8 type.
      
        For more information, see
        http://en.wikipedia.org/wiki/YCbCr and http://de.wikipedia.org/wiki/JPEG
     
     *Url*: <http://ltfat.github.io/doc/sigproc/jpeg2rgb.html>

     See also: rgb2jpeg.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
JPEG2RGB  Coverts from RGB format to YCbCr format
   Usage:  RGB = jpeg2rgb(Y...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1333
 -- Function: largestn
     LARGESTN   Keep N largest coefficients
        Usage:  xo=largestn(x,N);
                xo=largestn(x,N,mtype);
     
        LARGESTN(x,N) returns an array of the same size as x keeping
        the N largest coefficients.
     
        LARGESTN takes the following flags at the end of the line of input
        arguments:
     
          'hard'    Perform hard thresholding. This is the default.
     
          'wiener'  Perform empirical Wiener shrinkage. This is in between
                    soft and hard thresholding.
     
          'soft'    Perform soft thresholding.  
     
          'full'    Returns the output as a full matrix. This is the default.
     
          'sparse'  Returns the output as a sparse matrix.   
     
        If the coefficients represents a signal expanded in an orthonormal
        basis then this will be the best N-term approximation.
     
        *Note:* If soft- or Wiener thresholding is selected, only N-1
        coefficients will actually be returned. This is caused by the N*'th
        coefficient being set to zero.
     
     
        References:
          S. Mallat. A wavelet tour of signal processing. Academic Press, San
          Diego, CA, 1998.
          
     *Url*: <http://ltfat.github.io/doc/sigproc/largestn.html>

     See also: largestr.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
LARGESTN   Keep N largest coefficients
   Usage:  xo=largestn(x,N);
         ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1731
 -- Function: largestr
     LARGESTR   Keep fixed ratio of largest coefficients
        Usage:  xo=largestr(x,p);
                xo=largestr(x,p,mtype);  
                [xo,N]=largestr(...);
     
        LARGESTR(x,p) returns an array of the same size as x keeping
        the fraction p of the coefficients. The coefficients with the largest
        magnitude are kept.
     
        [xo,n]=LARGESTR(xi,p) additionally returns the number of coefficients
        kept.
      
        *Note:* If the function is used on coefficients coming from a
        redundant transform or from a transform where the input signal was
        padded, the coefficient array will be larger than the original input
        signal. Therefore, the number of coefficients kept might be higher than
        expected.
     
        LARGESTR takes the following flags at the end of the line of input
        arguments:
     
          'hard'    Perform hard thresholding. This is the default.
     
          'wiener'  Perform empirical Wiener shrinkage. This is in between
                    soft and hard thresholding.
     
          'soft'    Perform soft thresholding.  
     
          'full'    Returns the output as a full matrix. This is the default.
     
          'sparse'  Returns the output as a sparse matrix.   
     
        *Note:* If soft- or Wiener thresholding is selected, one less
        coefficient will actually be returned. This is caused by that
        coefficient being set to zero.
     
     
        References:
          S. Mallat. A wavelet tour of signal processing. Academic Press, San
          Diego, CA, 1998.
          
     *Url*: <http://ltfat.github.io/doc/sigproc/largestr.html>

     See also: largestn.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
LARGESTR   Keep fixed ratio of largest coefficients
   Usage:  xo=largestr(x,...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 567
 -- Function: long2fir
     LONG2FIR   Cut LONG window to FIR
        Usage:  g=long2fir(g,L);
     
        LONG2FIR(g,L) will cut the LONG window g to a length L FIR window by
        cutting out the middle part. Note that this is a slightly different
        behaviour than MIDDLEPAD.
     
        LONG2FIR(g,L,'wp') or LONG2FIR(g,L,'hp') does the same assuming the
        input window is a whole-point even or half-point even window,
        respectively.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/long2fir.html>

     See also: fir2long, middlepad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
LONG2FIR   Cut LONG window to FIR
   Usage:  g=long2fir(g,L);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 731
 -- Function: lowdiscrepancy
     LOWDISCREPANCY  Returns a low discrepancy sequence
        Usage: delays=lowdiscrepancy(name)
     
        Input parameters:
              name  : Name of the low discrepancy sequence
        Output parameters:
              delays     : Anonymous function specifying the sequence
     
        LOWDISCREPANCY(name) returns a low discrepancy sequence for the usage
        as a delay generating function in conjunction with waveletfilters.
        Currently, a kronecker sequence and a digital net are implemented.
     
     
        Authors: Nicki Holighaus, Clara Hollomey, Guenther Koliander
     *Url*: <http://ltfat.github.io/doc/sigproc/lowdiscrepancy.html>

     See also: waveletfilters.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
LOWDISCREPANCY  Returns a low discrepancy sequence
   Usage: delays=lowdiscre...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2331
 -- Function: magresp
     MAGRESP   Magnitude response plot of window
        Usage:   magresp(g,...);
                 magresp(g,fs,...);
                 magresp(g,fs,dynrange,....);
     
        MAGRESP(g) will display the magnitude response of the window on a log
        scale (dB);
     
        MAGRESP(g,fs) does the same for windows that are intended to be used
        with signals with sampling rate fs. The x-axis will display Hz.
     
        MAGRESP(g,fs,dynrange) will limit the dynamic range (see below).
        
        MAGRESP takes the following parameters at the end of the line of
        input arguments.
     
          'dynrange',r  Limit the dynamic range of the plot to r dB.
     
          'fir'         Indicate that the input is an FIR window. MAGRESP will
                        zero-extend the window to display a smooth magnitude
                        response.
     
          'L',L         Zero-extend the window to length L.
     
          'posfreq'     Show only positive frequencies.
     
          'nf'          Show also negative frequencies
     
          'autoposfreq'  Show positive frequencies for real-valued signals,
                         otherwise show also the negative frequencies. This is
                         the default.
     
          'opts',op     Pass options onto the plot command. The extra options
                        op are specified as a cell array
     
        In addition to these flags, it is possible to speficy any of the
        normalization flags from SETNORM to normalize the input before
        calculation of the magnitude response. Specifying '1' or 'area' will
        display a magnitude response which peaks at 0 dB.
     
        Examples:
        ---------
     
        The following will display the magnitude response of a Hann window
        of length 20 normalized to a peak of 0 dB:
     
          magresp({'hann',20},'1');
     
        The following will display the magnitude response of a Gaussian window
        of length 100:
     
          magresp('gauss','L',100)
     
        The following passes additional options to the plot command to draw
        in red:
     
          magresp({'nuttall11',30},'opts',{'r'});
     
     *Url*: <http://ltfat.github.io/doc/sigproc/magresp.html>

     See also: demo_gabfir.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
MAGRESP   Magnitude response plot of window
   Usage:   magresp(g,...);
     ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1628
 -- Function: pfilt
     PFILT  Apply filter with periodic boundary conditions
        Usage:  h=pfilt(f,g);
                h=pfilt(f,g,a,dim);
     
        PFILT(f,g) applies the filter g to the input f. If f is a
        matrix, the filter is applied along each column.
     
        PFILT(f,g,a) does the same, but downsamples the output keeping only
        every a'th sample (starting with the first one).
     
        PFILT(f,g,a,dim) filters along dimension dim. The default value of
        [] means to filter along the first non-singleton dimension.
     
        The filter g can be a vector, in which case the vector is treated
        as a zero-delay FIR filter.
     
        The filter g can be a cell array. The following options are
        possible:
     
           If the first element of the cell array is the name of one of the
            windows from FIRWIN, the whole cell array is passed onto
            FIRFILTER.
     
           If the first element of the cell array is 'bl', the rest of the
            cell array is passed onto BLFILTER.
     
           If the first element of the cell array is 'pgauss', 'psech',
            the rest of the parameters is passed onto the respective
            function. Note that you do not need to specify the length L.
     
        The coefficients obtained from filtering a signal f by a filter g are
        defined by
     
                    L-1
           c(n+1) = sum f(l+1) * g(an-l+1)
                    l=0
     
        where an-l is computed modulo L.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/pfilt.html>

     See also: pconv.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PFILT  Apply filter with periodic boundary conditions
   Usage:  h=pfilt(f,g)...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1189
 -- Function: pgrpdelay
     PGRPDELAY Group delay of a filter with periodic boundaries
        Usage:  ggd = pgrpdelay(g,L);
     
        PGRPDELAY(g,L) computes group delay of filter g as a negative
        derivative of the phase frequency response of filter g assuming
        periodic (cyclic) boundaries i.e. the delay may be a negative number.
        The derivative is calculated using the second order centered difference
        approximation. 
        The resulting group delay is in samples.
     
        Example:
        --------
     
        The following example shows a group delay of causal, moving average
        6tap FIR filter and it's magnitude frequency response for comparison.
        The dips in the group delay correspond to places where modulus of the 
        frequency response falls to zero.:
     
           g = struct(struct('h',ones(6,1),'offset',0)); 
           L = 512;
           figure(1);
           subplot(2,1,1);
           plot(-L/2+1:L/2,fftshift(pgrpdelay(g,512)));
           axis tight;ylim([0,4]);
     
           subplot(2,1,2);
           magresp(g,L,'nf');
           
     *Url*: <http://ltfat.github.io/doc/sigproc/pgrpdelay.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PGRPDELAY Group delay of a filter with periodic boundaries
   Usage:  ggd = p...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1485
 -- Function: plottfjigsawsep
     PLOTTFJIGSAWSEP Plots separated layers from tfjigsawsep
        Usage: plottfjigsawsep(fplanes,cplanes,info);
               plottfjigsawsep(fplanes,cplanes,info,fs); 
            
        PLOTTFJIGSAWSEP(fplanes,cplanes,info) shows the original and the three 
        separated layers in both the time and the time-domains.
        All parameters can be obtained from TFJIGSAWSEP.
     
        PLOTTFJIGSAWSEP(fplanes,cplanes,info,fs) works as above but scales the
        axes labels according to the sampling rate fs. 
        
        The function calls PLOTDGTREAL and forwards any arguments it understands.
     
        Additional parameters
        ---------------------
     
           'equalyrange'   
                The y-axis range is equal in all time domain plots.
                By default, the individual y-axes are scaled automatically.
     
           'showbuttons'
                The figure will contain buttons for convenient playback of the
                separated layers. Note that the sampling rate fs must be provided.
                This is disabled by default and does not work on Octave.
                
     
        References:
          F. Jaillet and B. Torresani. Time-frequency jigsaw puzzle: Adaptive
          multiwindow and multilayered gabor expansions. IJWMIP, 5(2):293--315,
          2007.
          
     *Url*: <http://ltfat.github.io/doc/sigproc/plottfjigsawsep.html>

     See also: tfjigsawsep.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTTFJIGSAWSEP Plots separated layers from tfjigsawsep
   Usage: plottfjigsa...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 394
 -- Function: qam4
     QAM4  Quadrature amplitude modulation of order 4
        Usage:  xo=qam4(xi);
     
        QAM4(xi) converts a vector of 0's and 1's into the complex roots of
        unity (QAM4 modulation). Every 2 input coefficients are mapped into 1
        output coefficient.
     
     
     *Url*: <http://ltfat.github.io/doc/sigproc/qam4.html>

     See also: iqam4, demo_ofdm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
QAM4  Quadrature amplitude modulation of order 4
   Usage:  xo=qam4(xi);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 779
 -- Function: rampdown
     RAMPDOWN  Falling ramp function
        Usage: outsig=rampdown(siglen);
     
        RAMPDOWN(siglen) will return a falling ramp function of length
        siglen. The ramp is a sinusoid starting from one and ending at
        zero. The ramp is centered such that the first element is always one and
        the last element is not quite zero, such that the ramp fits with
        following zeros.
     
        RAMPDOWN(L,wintype) will use another window for ramping. This may be
        any of the window types from FIRWIN. Please see the help on FIRWIN
        for more information. The default is to use a piece of the Hann window.
       
     *Url*: <http://ltfat.github.io/doc/sigproc/rampdown.html>

     See also: rampup, rampsignal, firwin.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
RAMPDOWN  Falling ramp function
   Usage: outsig=rampdown(siglen);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1365
 -- Function: rampsignal
     RAMPSIGNAL  Ramp signal
        Usage: outsig=rampsignal(insig,L);
     
        RAMPSIGNAL(insig,L) applies a ramp function of length L to the
        beginning and the end of the input signal. The default ramp is a
        sinusoide starting from zero and ending at one (also known as a cosine
        squared ramp).
     
        If L is scalar, the starting and ending ramps will be of the same
        length. If L is a vector of length 2, the first entry will be used
        for the rising ramp, and the second for the falling.
     
        If the input is a matrix or an N-D array, the ramp will be applied
        along the first non-singleton dimension.
     
        RAMPSIGNAL(insig) will use a ramp length of half the signal.
     
        RAMPSIGNAL(insig,L,wintype) will use another window for ramping. This
        may be any of the window types from FIRWIN. Please see the help on
        FIRWIN for more information. The default is to use a piece of the
        Hann window.
     
        RAMPSIGNAL accepts the following optional parameters:
     
          'dim',d   Apply the ramp along dimension d. The default value of []
                    means to use the first non-singleton dimension.     
     
     *Url*: <http://ltfat.github.io/doc/sigproc/rampsignal.html>

     See also: rampdown, rampsignal, firwin.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
RAMPSIGNAL  Ramp signal
   Usage: outsig=rampsignal(insig,L);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 737
 -- Function: rampup
     RAMPUP  Rising ramp function
        Usage: outsig=rampup(L);
     
        RAMPUP(L) will return a rising ramp function of length L. The
        ramp is a sinusoide starting from zero and ending at one. The ramp
        is centered such that the first element is always 0 and the last
        element is not quite 1, such that the ramp fits with following ones.
     
        RAMPUP(L,wintype) will use another window for ramping. This may be any
        of the window types from FIRWIN. Please see the help on FIRWIN for
        more information. The default is to use a piece of the Hann window.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/rampup.html>

     See also: rampdown, rampsignal, firwin.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
RAMPUP  Rising ramp function
   Usage: outsig=rampup(L);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1934
 -- Function: rgb2jpeg
     RGB2JPEG  Coverts from RGB format to the YCbCr format used by JPEG 
        Usage:  YCbCr = rgb2jpeg(RGB);
      
        Input parameters:
              RGB   : 3d data-cube, containing RGB information of the image
      
        Output parameters:
              YCbCr : 3d data-cube, containing the YCbCr information of the
                      image
      
        'rgb2jpeg(RGB)' performs a transformation of the 3d data-cube RGB with
        dimensions N xM x3, which contains information of the
        colours "red", "green" and "blue". The output variable YCbCr is a 3d
        data-cube of the same size containing information about "luminance",
        "chrominance blue" and "chrominance red". The output will be of
        the uint8 type.
     
        See http://en.wikipedia.org/wiki/YCbCr and
        http://de.wikipedia.org/wiki/JPEG.
     
        Examples:
        ---------
     
        In the following example, the Lichtenstein test image is split into
        its three components. The very first subplot is the original image:
     
         f=lichtenstein;
      
         f_jpeg=rgb2jpeg(f);
      
         subplot(2,2,1);
         image(f);axis('image');
      
         Ymono=zeros(512,512,3,'uint8');
         Ymono(:,:,1)=f_jpeg(:,:,1);
         Ymono(:,:,2:3)=128;
         fmono=jpeg2rgb(Ymono);
         subplot(2,2,2);
         image(fmono);axis('image');
      
         Cbmono=zeros(512,512,3,'uint8');
         Cbmono(:,:,2)=f_jpeg(:,:,2);
         Cbmono(:,:,3)=128;
         fmono=jpeg2rgb(Cbmono);
         subplot(2,2,3);
         image(fmono);axis('image');
      
         Crmono=zeros(512,512,3,'uint8');
         Crmono(:,:,3)=f_jpeg(:,:,3);
         Crmono(:,:,2)=128;
         fmono=jpeg2rgb(Crmono);
         subplot(2,2,4);
         image(fmono);axis('image');
     
     *Url*: <http://ltfat.github.io/doc/sigproc/rgb2jpeg.html>

     See also: jpeg2rgb.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
RGB2JPEG  Coverts from RGB format to the YCbCr format used by JPEG 
   Usage:...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1115
 -- Function: rms
     RMS RMS value of signal
        Usage: y = rms(f);
               y = rms(f,...);
     
        RMS(f) computes the RMS (Root Mean Square) value of a finite sampled
        signal sampled at a uniform sampling rate. This is a vector norm
        equal to the l^2 averaged by the length of the signal.
     
        If the input is a matrix or ND-array, the RMS is computed along the
        first (non-singleton) dimension, and a vector of values is returned.
     
        The RMS value of a signal x of length N is computed by
     
                                 N
           rms(f) = 1/sqrt(N) ( sum |f(n)|^2 )^(1/2)
                                n=1
     
        RMS takes the following flags at the end of the line of input
        parameters:
     
          'ac'       Consider only the AC component of the signal (i.e. the mean is
                     removed).
     
          'dim',d    Work along specified dimension. The default value of []
                     means to work along the first non-singleton one.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/rms.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
RMS RMS value of signal
   Usage: y = rms(f);
          y = rms(f,...);



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


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

     See also: rms, s0norm.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
SETNORM  Set a norm of the input signal to a specified value
   Usage:  h=set...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2766
 -- Function: tfjigsawsep
     TFJIGSAWSEP Time frequency jigsaw puzzle tonal-transient separation
        Usage:  fplanes = tfjigsawsep(f);
                fplanes = tfjigsawsep(f,r1,r2);
                fplanes = tfjigsawsep(f,r1,r2,p);
                [fplanes, cplanes, info] = tfjigsawsep(...);
     
        Input parameters:
                 f        : Input signal
                 r1       : Significance level of the tonal layer refered to
                            a white noise reference
                 r2       : Same for the transient layer
                 p        : Proportionfactor of the supertilesizes relative 
                            to the time-, and frequency stepsize 
         
        Output parameters:
                fplanes   : signallength-by-3 array containing the 3 produced
                            layers, tonal in fplanes(:,1), transient in
                            fplanes(:,2) and the noisy residual in fplanes(:,3).
                cplanes   : 3-by-1 cellarray containing the Gabor coefficients
                            for the individual layers
     
        TFJIGSAWSEP(f) applies the separation algorithm on the input signal f*
        and returns the tonal, the transient and the residual parts.
        The following default values are used, r1=r2=0.95, p=4 and for the 
        3 Gabor systems:
        
            "Tonal" system:     g1 = {'hann',4096}; a1 = 512; M1 = 4096;
        
            "Transient" system: g2 = {'hann',256};  a2 = 32;  M2 = 256;
     
            "Residual" system:  g3 = {'hann',2048}; a3 = 512; M3 = 2048;
        
        TFJIGSAWSEP(f,r1,r2) works as before, but allows changing threshold
        parameters r1 and r2. Good values are in range [0.85,0.95]. 
        t2 sometimes has to be chosen larger (~ 1.05), eg. for 
        percussions in music signals.
     
        TFJIGSAWSEP(f,r1,r2,p) (recommended) additionally allows changing the
        size of the supertiles to a1*p in timesamples and b2*p in
        frequencysamples. The choice of this particular proportion is
        reasonable since it provides equal numbers of coefficients of the two
        Gabor systems in each supertile. Good values are in the range of [1,10],
        but it depends very much on the type of signal.
        E.g. for speech signals, higher values yield better results.   
     
        [fplanes, cplanes, info] = TFJIGSAWSEP(...) additionally returns
        a 3 element cell array cplanes containing DGTREAL coefficients
        of the respective separated layers and a structure info, with the
        parameters used in the algorithm. The relationship between fplanes*
        and cplanes is the following:
     *Url*: <http://ltfat.github.io/doc/sigproc/tfjigsawsep.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
TFJIGSAWSEP Time frequency jigsaw puzzle tonal-transient separation
   Usage:...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2389
 -- Function: thresh
     THRESH   Coefficient thresholding
        Usage:  x=thresh(x,lambda,...);
                [x,N]=thresh(x,lambda,...);
     
        THRESH(x,lambda) will perform hard thresholding on x, i.e. all
        elements with absolute value less than scalar lambda will be set to zero.
     
        THRESH(x,lambda,'soft') will perform soft thresholding on x,
        i.e. lambda will be subtracted from the absolute value of every element
        of x.
     
        The lambda parameter can also be a vector with number of elements
        equal to numel(xi) or it can be a numeric array of the same shape 
        as xi. lambda is then applied element-wise and in a column major 
        order if lambda is a vector. 
     
        [x,N]=THRESH(x,lambda) additionally returns a number N specifying
        how many numbers where kept.
     
        THRESH takes the following flags at the end of the line of input
        arguments:
     
          'hard'    Perform hard thresholding. This is the default.
     
          'wiener'  Perform empirical Wiener shrinkage. This is in between
                    soft and hard thresholding.
     
          'soft'    Perform soft thresholding.  
     
          'full'    Returns the output as a full matrix. This is the default.
     
          'sparse'  Returns the output as a sparse matrix.
     
        The function wTHRESH in the Matlab Wavelet toolbox implements some of
        the same functionality.
     
        The following code produces a plot to demonstrate the difference
        between hard and soft thresholding for a simple linear input:
     
          t=linspace(-4,4,100);
          plot(t,thresh(t,1,'soft'),'r',...
               t,thresh(t,1,'hard'),'.b',...
               t,thresh(t,1,'wiener'),'--g');
          legend('Soft thresh.','Hard thresh.','Wiener thresh.','Location','NorthWest');
     
     
        References:
          S. Ghael, A. Sayeed, and R. Baraniuk. Improved wavelet denoising via
          empirical Wiener filtering. In Proceedings of SPIE, volume 3169, pages
          389--399. San Diego, CA, 1997.
          
          J. Lim and A. Oppenheim. Enhancement and bandwidth compression of noisy
          speech. Proceedings of the IEEE, 67(12):1586--1604, 1979.
          
     *Url*: <http://ltfat.github.io/doc/sigproc/thresh.html>

     See also: largestr, largestn.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
THRESH   Coefficient thresholding
   Usage:  x=thresh(x,lambda,...);
        ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 342
 -- Function: transferfunction
     TRANSFERFUNCTION  The transferfunction of a filter
        Usage:  H=transferfunction(g,L);
     
        TRANSFERFUNCTION(g,L) computes the transferfunction of length L*
        of the filter defined by g.
     
     *Url*: <http://ltfat.github.io/doc/sigproc/transferfunction.html>

     See also: pfilt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
TRANSFERFUNCTION  The transferfunction of a filter
   Usage:  H=transferfunct...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1356
 -- Function: uquant
     UQUANT  Simulate uniform quantization
        Usage:  x=uquant(x);
                x=uquant(x,nbits,xmax,...);
     
        UQUANT(x,nbits,xmax) simulates the effect of uniform quantization of
        x using nbits bits. The output is simply x rounded to 2^{nbits}
        different values.  The xmax parameters specify the maximal value that
        should be quantifiable.
     
        UQUANT(x,nbits) assumes a maximal quantifiable value of 1.
     
        UQUANT(x) additionally assumes 8 bit quantization.
     
        UQUANT takes the following flags at the end of the input arguments:
     
          'nbits'  Number of bits to use in the quantization. Default is 8.
     
          'xmax'   Maximal quantifiable value. Default is 1.
       
          's'      Use signed quantization. This assumes that the signal
                   has a both positive and negative part. Useful for sound
                   signals. This is the default.
     
          'u'      Use unsigned quantization. Assumes the signal is positive.
                   Negative values are silently rounded to zero.
                   Useful for images.
     
        If this function is applied to a complex signal, it will be applied to
        the real and imaginary part separately.
     *Url*: <http://ltfat.github.io/doc/sigproc/uquant.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
UQUANT  Simulate uniform quantization
   Usage:  x=uquant(x);
           x=uq...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3016
 -- Function: warpedblfilter
     WARPEDBLFILTER  Construct a warped band-limited filter
        Usage:  g=warpedblfilter(winname,fsupp,fc,fs,freqtoscale,scaletofreq);
     
        Input parameters:
           winname     : Name of prototype.
           fsupp       : Support length of the prototype (in scale units).
           fc          : Centre frequency (in Hz).
           fs          : Sampling rate
           freqtoscale : Function handle to convert Hz to scale units
           scaletofreq : Function to convert scale units into Hz.
     
        Output parameters:
           g           : Filter definition, see BLFILTER.
     
        WARPEDBLFILTER(winname,fsupp,fc,fs,freqtoscale,scaletofreq) constructs
        a band-limited filter that is warped on a given frequency scale. The 
        parameter winname specifies the basic shape of the frequency response.
        The name must be one of the shapes accepted by FIRWIN. The support of
        the frequency response measured on the selected frequency scale is 
        specified by fsupp, the centre frequency by fc and the scale by the
        function handle freqtoscale of a function that converts Hz into the 
        choosen scale and scaletofreq doing the inverse.
     
        If one of the inputs is a vector, the output will be a cell array
        with one entry in the cell array for each element in the vector. If
        more input are vectors, they must have the same size and shape and the
        the filters will be generated by stepping through the vectors. This
        is a quick way to create filters for FILTERBANK and UFILTERBANK.
     
        WARPEDBLFILTER accepts the following optional parameters:
     
          'complex'      Make the filter complex valued if the centre frequency
                         is non-zero. This is the default.
     
          'real'         Make the filter real-valued if the centre frequency
                         is non-zero.
     
          'symmetric'    The filters with fc<0 (or fc>fs/2) will be created
                         on the positive frequencies and mirrored. This allows
                         using freqtoscale defined only for the positive 
                         numbers.
     
          'delay',d      Set the delay of the filter. Default value is zero.
     
          'scal',s       Scale the filter by the constant s. This can be
                         useful to equalize channels in a filterbank.
     
        It is possible to normalize the transfer function of the filter by
        passing any of the flags from the SETNORM function. The default
        normalization is 'energy'.
     
        The filter can be used in the PFILT routine to filter a signal, or
        in can be placed in a cell-array for use with FILTERBANK or
        UFILTERBANK.
     
        The output format is the same as that of BLFILTER. 
     
     *Url*: <http://ltfat.github.io/doc/sigproc/warpedblfilter.html>

     See also: blfilter, firwin, pfilt, filterbank.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
WARPEDBLFILTER  Construct a warped band-limited filter
   Usage:  g=warpedblf...





