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


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

  Peter L. Soendergaard, 2007 - 2014.

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

  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 color model
    JPEG2RGB       -  Convert values from the JPEG color model to RGB

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

  For help, bug reports, suggestions etc. please send email to
  ltfat-help@lists.sourceforge.net


   Url: http://ltfat.sourceforge.net/doc/sigproc/Contents.php



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



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


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

     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(insig);



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


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

     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,dynran



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


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

     See also: groupthresh, demo_audioshrink.




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



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


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

     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: 1944
 -- 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.sourceforge.net/doc/sigproc/groupthresh.php>

     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: 365
 -- 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.sourceforge.net/doc/sigproc/iqam4.php>

     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: 959
 -- 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.sourceforge.net/doc/sigproc/jpeg2rgb.php>

     See also: rgb2jpeg.




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



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


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

     See also: largestr.




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



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


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

     See also: largestn.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1547
 -- Function: normalize
     NORMALIZE  Normalize input signal by specified norm
        Usage:  h=normalize(f,...);

        NORMALIZE(f,...) will normalize the signal f by the specified norm.

        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 dimension:

           'dim',d  Work along specified dimension. The default value of []
                     means to work along the first non-singleton one.

     *Url*: <http://ltfat.sourceforge.net/doc/sigproc/normalize.php>

     See also: rms, s0norm.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
NORMALIZE  Normalize input signal by specified norm
   Usage:  h=normalize(f,...



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


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

     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: 769
 -- 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.sourceforge.net/doc/sigproc/rampdown.php>

     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: 1327
 -- 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.sourceforge.net/doc/sigproc/rampsignal.php>

     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: 729
 -- 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.sourceforge.net/doc/sigproc/rampup.php>

     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: 1867
 -- 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.sourceforge.net/doc/sigproc/rgb2jpeg.php>

     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:  YC



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


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




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


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




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
   *Url*: <http://ltfat.sourceforge.net/doc/sigproc/sigprocinit.php>



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


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

     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: 6
uquant


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




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





