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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3496
 LTFAT - Basic Fourier and DCT analysis.

  Peter L. Soendergaard, 2008 - 2014.

  Support routines
    FFTINDEX       -  Index of positive and negative frequencies.
    MODCENT        -  Centered modulo operation.
    FLOOR23        -  Previous number with only 2,3 factors
    FLOOR235       -  Previous number with only 2,3,5 factors
    CEIL23         -  Next number with only 2,3 factors
    CEIL235        -  Next number with only 2,3,5 factors
    NEXTFASTFFT    -  Next efficient FFT size (2,3,5,7).
  
  Basic Fourier analysis
    DFT            -  Unitary discrete Fourier transform.
    IDFT           -  Inverse of DFT.
    FFTREAL        -  FFT for real valued signals.
    IFFTREAL       -  Inverse of FFTREAL.
    GGA            -  Generalized Goertzel Algorithm.
    CHIRPZT        -  Chirped Z-transform.
    PLOTFFT        -  Plot FFT coefficients.
    PLOTFFTREAL    -  Plot FFTREAL coefficients.

  Simple operations on periodic functions
    INVOLUTE       -  Involution.
    PEVEN          -  Even part of periodic function.
    PODD           -  Odd part of periodic function.
    PCONV          -  Periodic convolution.
    CONVOLVE       -  Fast, non-periodic convolution.
    PXCORR         -  Periodic cross correlation.
    ISEVENFUNCTION -  Test if function is even.
    MIDDLEPAD      -  Cut or extend even function.

  Functions
    EXPWAVE        -  Complex exponential wave.
    PCHIRP         -  Periodic chirp.
    SHAH           -  Shah distribution.
    PHEAVISIDE     -  Periodic Heaviside function.
    PRECT          -  Periodic rectangle function.
    PSINC          -  Periodic sinc function.

  Window functions
    PGAUSS         -  Periodic Gaussian.
    PSECH          -  Periodic SECH.
    PBSPLINE       -  Periodic B-splines.
    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.

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

  Hermite functions and fractional Fourier transforms
    PHERM          -  Periodic Hermite functions.
    HERMBASIS      -  Orthonormal basis of Hermite functions.    
    DFRACFT        -  Discrete Fractional Fourier transform
    FFRACFT        -  Fast Fractional Fourier transform

  Approximation of continuous functions
    FFTRESAMPLE    -  Fourier interpolation.
    DCTRESAMPLE    -  Cosine interpolation.
    PDERIV         -  Derivative of periodic function.

  Cosine and Sine transforms.
    DCTI           -  Discrete cosine transform type I
    DCTII          -  Discrete cosine transform type II
    DCTIII         -  Discrete cosine transform type III
    DCTIV          -  Discrete cosine transform type IV
    DSTI           -  Discrete sine transform type I
    DSTII          -  Discrete sine transform type II
    DSTIII         -  Discrete sine transform type III
    DSTIV          -  Discrete sine transform type IV

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

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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
 LTFAT - Basic Fourier and DCT analysis.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3995
 -- 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
        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.necessary. 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 filterbank.

          '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 NORMALIZE 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.sourceforge.net/doc/fourier/blfilter.php>

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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 890
 -- Function: ceil23
     CEIL23  Next number with only 2,3 factors
        Usage: nceil=ceil23(n);

        CEIL23(n) returns the next number greater than or equal to n,
        which can be written as a product of powers of 2 and 3.

        The algorithm will look up the best size in a table, which is computed
        the first time the function is run. If the input size is larger than the
        largest value in the table, the input size will be reduced by factors of
        2, until it is in range.

        [nceil,table]=CEIL23(n) additionally returns the table used for lookup.

        Examples:
        ---------

        Return the first number larger or equal to 19 that can be written
        solely as products of powers of 2 and 3*:

          ceil23(19)

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/ceil23.php>

     See also: floor23, ceil235, nextfastfft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
CEIL23  Next number with only 2,3 factors
   Usage: nceil=ceil23(n);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 910
 -- Function: ceil235
     CEIL235  Next number with only 2,3 and 5 factors
        Usage: nceil=ceil235(n);

        CEIL235(n)  returns the next number greater than or equal to n,
        which can be written as a product of powers of 2, 3 and 5.

        The algorithm will look up the best size in a table, which is computed
        the first time the function is run. If the input size is larger than the
        largest value in the table, the input size will be reduced by factors of
        2, until it is in range.

        [nceil,table]=CEIL235(n) additionally returns the table used for lookup.

        Examples:
        ---------

        Return the first number larger or equal to 19 that can be written
        solely as products of powers of 2, 3 and 5*:

          ceil235(19)

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/ceil235.php>

     See also: floor235, ceil23, nextfastfft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
CEIL235  Next number with only 2,3 and 5 factors
   Usage: nceil=ceil235(n);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2932
 -- Function: chirpzt
     CHIRPZT Chirped Z-transform
        Usage:  c = chirpzt(f,K,fdiff)
                c = chirpzt(f,K,fdiff,foff)
                c = chirpzt(f,K,fdiff,foff,fs)

        Input parameters:
              f      : Input data.
              K      : Number of values.
              fdiff  : Frequency increment.
              foff   : Starting frequency.
              fs     : Sampling frequency.

        Output parameters:
              c      : Coefficient vector.

        c = CHIRPZT(f,K,fdiff,foff) computes K samples of the discrete-time
        fourier transform DTFT c of f at values c(k+1)=F(2pi(f_{off}+kf_{diff}))
        for k=0,dots,K-1 where F=DTFT(f). Values foff and fdiff should
        be in range of 0-1. If foff is ommited or empty, it is considered to
        be 0. If fdiff is ommited or empty, K equidistant values
        c(k+1)=F(2pi k/K) are computed. If even K is ommited or empty,
        input length is used instead resulting in the same values as fft does.

        c = CHIRPZT(f,K,fdiff,foff,fs) computes coefficients using frequency
        values relative to fs c(k+1)=F(2pi(f_{off}+kf_{diff})/fs) for k=0,dots,K-1.

        The input f is processed along the first non-singleton dimension or
        along dimension dim if specified.

        Examples:
        ---------

        Calculating DTFT samples of interest (aka zoom FFT):

          % Generate input signal
          fs = 8000;
          L = 2^10;
          k = (0:L-1).';
          f1 = 400;
          f2 = 825;
          f = 5*sin(2*pi*k*f1/fs + pi/4) + 2*sin(2*pi*k*f2/fs - pi/3);

          % This is equal to fft(f)
          ck = chirpzt(f,L);

          %chirpzt to FFT error:
          norm(ck-fft(f))

          % Frequency "resolution" in Hz
          fdiff = 0.4;
          % Frequency offset in Hz
          foff = 803.9;
          % Number of frequency values
          K = 125;
          % DTFT samples. The frequency range of interest is 803.9-853.5 Hz
          ckchzt = chirpzt(f,K,fdiff,foff,fs);

          % Plot modulus of coefficients
          figure(1);
          fax=foff+fdiff.*(0:K-1);
          hold on;
          stem(k/L*fs,abs(ck),'k');
          stem(fax,abs(ckchzt),'r:');
          set(gca,'XLim',[foff,foff+K*fdiff]);
          set(gca,'YLim',[0 1065]);
          xlabel('f[Hz]');
          ylabel('|ck|');

          % Plot phase of coefficients
          figure(2);
          hold on;
          stem(k/L*fs,angle(ck),'k');
          stem(fax,angle(ckchzt),'r:');
          set(gca,'XLim',[foff,foff+K*fdiff]);
          set(gca,'YLim',[-pi pi]);
          xlabel('f[Hz]');
          ylabel('angle(ck)');


        References:
          L. Rabiner, R. Schafer, and C. Rader. The chirp Z-transform algorithm.
          Audio and Electroacoustics, IEEE Transactions on, 17(2):86-92, 1969.


     *Url*: <http://ltfat.sourceforge.net/doc/fourier/chirpzt.php>

     See also: gga.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
CHIRPZT Chirped Z-transform
   Usage:  c = chirpzt(f,K,fdiff)
           c = chi



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 547
 -- Function: convolve
     CONVOLVE  Convolution
        Usage:  h=convolve(f,g);

        CONVOLVE(f,g) will convolve two vectors f and g. The
        convolution is not periodic, so the output will have a length of :

          output_len = length(f)+length(g)-1;

        This function works entirely similar to the Matlab routine conv
        using instead a fast FFT algorithm, making it much faster if one or
        more of the signals are long.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/convolve.php>

     See also: pconv.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
CONVOLVE  Convolution
   Usage:  h=convolve(f,g);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2145
 -- Function: dcti
     DCTI  Discrete Cosine Transform type I
        Usage:  c=dcti(f);
                c=dcti(f,L);
                c=dcti(f,[],dim);
                c=dcti(f,L,dim);

        DCTI(f) computes the discrete cosine transform of type I of the
        input signal f. If f is a matrix then the transformation is applied to
        each column. For N-D arrays, the transformation is applied to the first
        non-singleton dimension.

        DCTI(f,L) zero-pads or truncates f to length L before doing the
        transformation.

        DCTI(f,[],dim) or DCTI(f,L,dim) applies the transformation along
        dimension dim.

        The transform is real (output is real if input is real) and
        it is orthonormal.

        This transform is its own inverse.

        Let f be a signal of length L, let c=dcti(f) and define the vector
        w of length L by

           w = [1/sqrt(2) 1 1 1 1 ...1/sqrt(2)]

        Then

                                   L-1
          c(n+1) = sqrt(2/(L-1)) * sum w(n+1)*w(m+1)*f(m+1)*cos(pi*n*m/(L-1))
                                   m=0

        The implementation of this functions uses a simple algorithm that require
        an FFT of length 2L-2, which might potentially be the product of a large
        prime number. This may cause the function to sometimes execute slowly.
        If guaranteed high speed is a concern, please consider using one of the
        other DCT transforms.

        Examples:
        ---------

        The following figures show the first 4 basis functions of the DCTI of
        length 20:

          % The dcti is its own adjoint.
          F=dcti(eye(20));

          for ii=1:4
            subplot(4,1,ii);
            stem(F(:,ii));
          end;


        References:
          K. Rao and P. Yip. Discrete Cosine Transform, Algorithms, Advantages,
          Applications. Academic Press, 1990.

          M. V. Wickerhauser. Adapted wavelet analysis from theory to software.
          Wellesley-Cambridge Press, Wellesley, MA, 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dcti.php>

     See also: dctii, dctiv, dsti.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DCTI  Discrete Cosine Transform type I
   Usage:  c=dcti(f);
           c=dcti(f



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1712
 -- Function: dctii
     DCTII  Discrete Consine Transform type II
        Usage:  c=dctii(f);
                c=dctii(f,L);
                c=dctii(f,[],dim);
                c=dctii(f,L,dim);

        DCTII(f) computes the discrete cosine transform of type II of the
        input signal f. If f is multi-dimensional, the transformation is
        applied along the first non-singleton dimension.

        DCTII(f,L) zero-pads or truncates f to length L before doing the
        transformation.

        DCTII(f,[],dim) or DCTII(f,L,dim) applies the transformation along
        dimension dim.

        The transform is real (output is real if input is real) and orthonormal.

        This is the inverse of DCTIII.

        Let f be a signal of length L, let c=DCTII(f) and define the
        vector w of length L by

           w = [1/sqrt(2) 1 1 1 1 ...]

        Then

                               L-1
          c(n+1) = sqrt(2/L) * sum w(n+1)*f(m+1)*cos(pi*n*(m+.5)/L)
                               m=0

        Examples:
        ---------

        The following figures show the first 4 basis functions of the DCTII of
        length 20:

          % The dctiii is the adjoint of dctii.
          F=dctiii(eye(20));

          for ii=1:4
            subplot(4,1,ii);
            stem(F(:,ii));
          end;


        References:
          K. Rao and P. Yip. Discrete Cosine Transform, Algorithms, Advantages,
          Applications. Academic Press, 1990.

          M. V. Wickerhauser. Adapted wavelet analysis from theory to software.
          Wellesley-Cambridge Press, Wellesley, MA, 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dctii.php>

     See also: dctiii, dctiv, dstii.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DCTII  Discrete Consine Transform type II
   Usage:  c=dctii(f);
           c=dc



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1725
 -- Function: dctiii
     DCTIII  Discrete Consine Transform type III
        Usage:  c=dctiii(f);
                c=dctiii(f,L);
                c=dctiii(f,[],dim);
                c=dctiii(f,L,dim);

        DCTIII(f) computes the discrete cosine transform of type III of the
        input signal f. If f is multi-dimensional, the transformation is
        applied along the first non-singleton dimension.

        DCTIII(f,L) zero-pads or truncates f to length L before doing the
        transformation.

        DCTIII(f,[],dim) or DCTIII(f,L,dim) applies the transformation along
        dimension dim.

        The transform is real (output is real if input is real) and orthonormal.

        This is the inverse of DCTII.

        Let f be a signal of length L, let c=DCTIII(f) and define the vector
        w of length L by

            w = [1/sqrt(2) 1 1 1 1 ...]

        Then

                               L-1
          c(n+1) = sqrt(2/L) * sum w(m+1)*f(m+1)*cos(pi*(n+.5)*m/L)
                               m=0

        Examples:
        ---------

        The following figures show the first 4 basis functions of the DCTIII of
        length 20:

          % The dctii is the adjoint of dctiii.
          F=dctii(eye(20));

          for ii=1:4
            subplot(4,1,ii);
            stem(F(:,ii));
          end;


        References:
          K. Rao and P. Yip. Discrete Cosine Transform, Algorithms, Advantages,
          Applications. Academic Press, 1990.

          M. V. Wickerhauser. Adapted wavelet analysis from theory to software.
          Wellesley-Cambridge Press, Wellesley, MA, 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dctiii.php>

     See also: dctii, dctiv, dstii.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DCTIII  Discrete Consine Transform type III
   Usage:  c=dctiii(f);
           c



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1504
 -- Function: dctiv
     DCTIV  Discrete Consine Transform type IV
        Usage:  c=dctiv(f);

        DCTIV(f) computes the discrete cosine transform of type IV of the
        input signal f. If f is multi-dimensional, the transformation is
        applied along the first non-singleton dimension.

        DCTIV(f,L) zero-pads or truncates f to length L before doing the
        transformation.

        DCTIV(f,[],dim) or DCTIV(f,L,dim) applies the transformation along
        dimension dim.

        The transform is real (output is real if input is real) and
        orthonormal.  It is its own inverse.

        Let f be a signal of length L and let c=DCTIV(f). Then

                               L-1
          c(n+1) = sqrt(2/L) * sum f(m+1)*cos(pi*(n+.5)*(m+.5)/L)
                               m=0

        Examples:
        ---------

        The following figures show the first 4 basis functions of the DCTIV of
        length 20:

          % The dctiv is its own adjoint.
          F=dctiv(eye(20));

          for ii=1:4
            subplot(4,1,ii);
            stem(F(:,ii));
          end;


        References:
          K. Rao and P. Yip. Discrete Cosine Transform, Algorithms, Advantages,
          Applications. Academic Press, 1990.

          M. V. Wickerhauser. Adapted wavelet analysis from theory to software.
          Wellesley-Cambridge Press, Wellesley, MA, 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dctiv.php>

     See also: dctii, dctiii, dstii.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
DCTIV  Discrete Consine Transform type IV
   Usage:  c=dctiv(f);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 803
 -- Function: dctresample
     DCTRESAMPLE   Resample signal using Fourier interpolation
        Usage:  h=dctresample(f,L);
                h=dctresample(f,L,dim);

        DCTRESAMPLE(f,L) returns a discrete cosine interpolation of the signal f*
        to length L. If the function is applied to a matrix, it will apply
        to each column.

        DCTRESAMPLE(f,L,dim) does the same along dimension dim.

        If the input signal is not a periodic signal (or close to), this method
        will give much better results than FFTRESAMPLE at the endpoints, as
        this method assumes than the signal is even a the endpoints.

        The algorithm uses a DCT type iii.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dctresample.php>

     See also: fftresample, middlepad, dctiii.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DCTRESAMPLE   Resample signal using Fourier interpolation
   Usage:  h=dctresamp



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1061
 -- Function: dfracft
     DFRACFT  Discrete Fractional Fourier transform
        Usage:  V=dfracft(f,a,p);
                V=dfracft(f,a);

        DFRACFT(f,a) computes the discrete fractional Fourier Transform of the
        signal f to the power a. For a=1 it corresponds to the ordinary
        discrete Fourier Transform. If f is multi-dimensional, the
        transformation is applied along the first non-singleton dimension.

        DFRACFT(f,a,dim) does the same along dimension dim.

        DFRACFT(f,a,[],p) or DFRACFT(f,a,dim,p) allows to choose the order
        of approximation of the second difference operator (default: p=2*).


        References:
          A. Bultheel and S. Martinez. Computation of the Fractional Fourier
          Transform. Appl. Comput. Harmon. Anal., 16(3):182-202, 2004.

          H. M. Ozaktas, Z. Zalevsky, and M. A. Kutay. The Fractional Fourier
          Transform. John Wiley and Sons, 2001.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dfracft.php>

     See also: ffracft, dft, hermbasis, pherm.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DFRACFT  Discrete Fractional Fourier transform
   Usage:  V=dfracft(f,a,p);
    



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 460
 -- Function: dft
     DFT   Normalized Discrete Fourier Transform
        Usage: f=dft(f);
               f=dft(f,N,dim);

        DFT computes a normalized discrete Fourier transform. This is nothing
        but a scaled version of the output from fft. The function takes exactly
        the same arguments as fft. See the help on fft for a thorough
        description.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dft.php>

     See also: idft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DFT   Normalized Discrete Fourier Transform
   Usage: f=dft(f);
          f=dft(



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1952
 -- Function: dsti
     DSTI  Discrete Sine Transform type I
        Usage:  c=dsti(f);
                c=dsti(f,L);
                c=dsti(f,[],dim);
                c=dsti(f,L,dim);

        DSTI(f) computes the discrete sine transform of type I of the
        input signal f. If f is multi-dimensional, the transformation is
        applied along the first non-singleton dimension.

        DSTI(f,L) zero-pads or truncates f to length L before doing the
        transformation.

        DSTI(f,[],dim) or DSTI(f,L,dim) applies the transformation along
        dimension dim.

        The transform is real (output is real if input is real) and orthonormal.

        This transform is its own inverse.

        Let f be a signal of length L and let c=DSTI(f). Then

                                   L-1
          c(n+1) = sqrt(2/(L+1)) * sum sin(pi*(n+1)*(m+1)/(L+1))
                                   m=0
        The implementation of this functions uses a simple algorithm that requires
        an FFT of length 2N+2, which might potentially be the product of a large
        prime number. This may cause the function to sometimes execute slowly.
        If guaranteed high speed is a concern, please consider using one of the
        other DST transforms.

        Examples:
        ---------

        The following figures show the first 4 basis functions of the DSTI of
        length 20:

          % The dsti is its own adjoint.
          F=dsti(eye(20));

          for ii=1:4
            subplot(4,1,ii);
            stem(F(:,ii));
          end;


        References:
          K. Rao and P. Yip. Discrete Cosine Transform, Algorithms, Advantages,
          Applications. Academic Press, 1990.

          M. V. Wickerhauser. Adapted wavelet analysis from theory to software.
          Wellesley-Cambridge Press, Wellesley, MA, 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dsti.php>

     See also: dcti, dstiii, dstiv.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DSTI  Discrete Sine Transform type I
   Usage:  c=dsti(f);
           c=dsti(f,L



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1718
 -- Function: dstii
     DSTII  Discrete Sine Transform type II
        Usage:  c=dstii(f);
                c=dstii(f,L);
                c=dstii(f,[],dim);
                c=dstii(f,L,dim);

        DSTII(f) computes the discrete sine transform of type II of the
        input signal f. If f is multi-dimensional, the transformation is
        applied along the first non-singleton dimension.

        DSTII(f,L) zero-pads or truncates f to length L before doing the
        transformation.

        DSTII(f,[],dim) or DSTII(f,L,dim) applies the transformation along
        dimension dim.

        The transform is real (output is real if input is real) and orthonormal.

        The inverse transform of DSTII is DSTIII.

        Let f be a signal of length L, let c=DSTII(f) and define the vector
        w of length L by

           w = [1 1 1 1 ... 1/sqrt(2)]

        Then

                               L-1
          c(n+1) = sqrt(2/L) * sum w(n+1)*f(m+1)*sin(pi*n*(m+.5)/L)
                               m=0

        Examples:
        ---------

        The following figures show the first 4 basis functions of the DSTII of
        length 20:

          % The dstiii is the adjoint of dstii.
          F=dstiii(eye(20));

          for ii=1:4
            subplot(4,1,ii);
            stem(F(:,ii));
          end;


        References:
          K. Rao and P. Yip. Discrete Cosine Transform, Algorithms, Advantages,
          Applications. Academic Press, 1990.

          M. V. Wickerhauser. Adapted wavelet analysis from theory to software.
          Wellesley-Cambridge Press, Wellesley, MA, 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dstii.php>

     See also: dctii, dstiii, dstiv.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DSTII  Discrete Sine Transform type II
   Usage:  c=dstii(f);
           c=dstii



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1720
 -- Function: dstiii
     DSTIII  Discrete sine transform type III
        Usage:  c=dstiii(f);
                c=dstiii(f,L);
                c=dstiii(f,[],dim);
                c=dstiii(f,L,dim);

        DSTIII(f) computes the discrete sine transform of type III of the
        input signal f. If f is multi-dimensional, the transformation is
        applied along the first non-singleton dimension.

        DSTIII(f,L) zero-pads or truncates f to length L before doing the
        transformation.

        DSTIII(f,[],dim) or DSTIII(f,L,dim) applies the transformation along
        dimension dim.

        The transform is real (output is real if input is real) and orthonormal.

        This is the inverse of DSTII.

        Let f be a signal of length L, let c=DSTIII(f) and define the vector
        w of length L by

            w = [1 1 1 1 ... 1/sqrt(2)]

        Then

                               L-1
          c(n+1) = sqrt(2/L) * sum w(m+1)*f(m+1)*sin(pi*(n+.5)*m/L)
                               m=0


        Examples:
        ---------

        The following figures show the first 4 basis functions of the DSTIII of
        length 20:

          % The dstii is the adjoint of dstiii.
          F=dstii(eye(20));

          for ii=1:4
            subplot(4,1,ii);
            stem(F(:,ii));
          end;

        References:
          K. Rao and P. Yip. Discrete Cosine Transform, Algorithms, Advantages,
          Applications. Academic Press, 1990.

          M. V. Wickerhauser. Adapted wavelet analysis from theory to software.
          Wellesley-Cambridge Press, Wellesley, MA, 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dstiii.php>

     See also: dctii, dstii, dstiv.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DSTIII  Discrete sine transform type III
   Usage:  c=dstiii(f);
           c=ds



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1713
 -- Function: dstiv
     DSTIV  Discrete Sine Transform type IV
        Usage:  c=dstiv(f);
                c=dstiv(f,L);
                c=dstiv(f,[],dim);
                c=dstiv(f,L,dim);

        DSTIV(f) computes the discrete sine transform of type IV of the input
        signal f. If f is a matrix, then the transformation is applied to
        each column. For N-D arrays, the transformation is applied to the first
        non-singleton dimension.

        DSTIV(f,L) zero-pads or truncates f to length L before doing the
        transformation.

        DSTIV(f,[],dim) applies the transformation along dimension dim.
        DSTIV(f,L,dim) does the same, but pads or truncates to length L.

        The transform is real (output is real if input is real) and
        it is orthonormal. It is its own inverse.

        Let f be a signal of length L and let c=DSTIV(f). Then

                               L-1
          c(n+1) = sqrt(2/L) * sum f(m+1)*sin(pi*(n+.5)*(m+.5)/L)
                               m=0

        Examples:
        ---------

        The following figures show the first 4 basis functions of the DSTIV of
        length 20:

          % The dstiv is its own adjoint.
          F=dstiv(eye(20));

          for ii=1:4
            subplot(4,1,ii);
            stem(F(:,ii));
          end;


        References:
          K. Rao and P. Yip. Discrete Cosine Transform, Algorithms, Advantages,
          Applications. Academic Press, 1990.

          M. V. Wickerhauser. Adapted wavelet analysis from theory to software.
          Wellesley-Cambridge Press, Wellesley, MA, 1994.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/dstiv.php>

     See also: dstii, dstiii, dctii.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DSTIV  Discrete Sine Transform type IV
   Usage:  c=dstiv(f);
           c=dstiv



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 755
 -- Function: expwave
     EXPWAVE   Complex exponential wave
        Usage:  h=expwave(L,m);
                h=expwave(L,m,cent);

        EXPWAVE(L,m) returns an exponential wave revolving m times around the
        origin. The collection of all waves with wave number m=0,...,L-1
        forms the basis of the discrete Fourier transform.

        The wave has absolute value 1 everywhere. To get an exponential wave
        with unit l^2-norm, divide the wave by sqrt(L). This is the
        normalization used in the DFT function.

        EXPWAVE(L,m,cent) makes it possible to shift the sampling points by
        the amount cent. Default is cent=0.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/expwave.php>

     See also: dft, pchirp.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
EXPWAVE   Complex exponential wave
   Usage:  h=expwave(L,m);
           h=expwa



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1490
 -- Function: ffracft
     FFRACFT Approximate fast fractional Fourier transform
        Usage:  frf=ffracft(f,a)
                frf=ffracft(f,a,dim)

        FFRACFT(f,a) computes an approximation of the fractional Fourier
        transform of the signal f to the power a. If f is
        multi-dimensional, the transformation is applied along the first
        non-singleton dimension.

        FFRACFT(f,a,dim) does the same along dimension dim.

        FFRACFT takes the following flags at the end of the line of input
        arguments:

          'origin'    Rotate around the origin of the signal. This is the
                      same action as the DFT, but the signal will split in
                      the middle, which may not be the correct action for
                      data signals. This is the default.

          'middle'    Rotate around the middle of the signal. This will not
                      break the signal in the middle, but the DFT cannot be
                      obtained in this way.

        Examples:
        ---------

        The following example shows a rotation of the LTFATLOGO test
        signal:

           sgram(ffracft(ltfatlogo,.3,'middle'),'lin','nf');


        References:
          A. Bultheel and S. Martinez. Computation of the Fractional Fourier
          Transform. Appl. Comput. Harmon. Anal., 16(3):182-202, 2004.


     *Url*: <http://ltfat.sourceforge.net/doc/fourier/ffracft.php>

     See also: dfracft, hermbasis, pherm.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FFRACFT Approximate fast fractional Fourier transform
   Usage:  frf=ffracft(f,a



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 496
 -- Function: fftindex
     FFTINDEX  Frequency index of FFT modulations
        Usage: n=fftindex(N);

        FFTINDEX(N) returns the index of the frequencies of the standard FFT of
        length N as they are ordered in the output from the fft routine. The
        numbers returned are in the range -ceil(N/2)+1:floor(N/2)

        FFTINDEX(N,0) does as above, but sets the Nyquist frequency to zero.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/fftindex.php>

     See also: dft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
FFTINDEX  Frequency index of FFT modulations
   Usage: n=fftindex(N);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 493
 -- Function: fftreal
     FFTREAL   FFT for real valued input data
        Usage: f=fftreal(f);
               f=fftreal(f,N,dim);

        FFTREAL(f) computes the coefficients corresponding to the positive
        frequencies of the FFT of the real valued input signal f.

        The function takes exactly the same arguments as fft. See the help on
        fft for a thorough description.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/fftreal.php>

     See also: ifftreal, dft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FFTREAL   FFT for real valued input data
   Usage: f=fftreal(f);
          f=fft



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 663
 -- Function: fftresample
     FFTRESAMPLE   Resample signal using Fourier interpolation
        Usage:  h=fftresample(f,L);
                h=fftresample(f,L,dim);

        FFTRESAMPLE(f,L) returns a Fourier interpolation of the signal f*
        to length L. If the function is applied to a matrix, it will apply
        to each column.

        FFTRESAMPLE(f,L,dim) does the same along dimension dim.

        If the input signal is *not* a periodic signal (or close to), the
        DCTRESAMPLE method gives much better results at the endpoints.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/fftresample.php>

     See also: dctresample, middlepad.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FFTRESAMPLE   Resample signal using Fourier interpolation
   Usage:  h=fftresamp



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


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

     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: 2012
 -- 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 NORMALIZE 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.sourceforge.net/doc/fourier/firfilter.php>

     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);
           g=



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1220
 -- 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 NORMALIZE. Default is to use 'peak' normalization.


        References:
          A. V. Oppenheim and R. W. Schafer. Discrete-time signal processing.
          Prentice Hall, Englewood Cliffs, NJ, 1989.


     *Url*: <http://ltfat.sourceforge.net/doc/fourier/firkaiser.php>

     See also: firwin, normalize.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7704
 -- 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. Alias: 'square'

          'sqrtrect'   Square root of the rectangular window.

          '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.

        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 NORMALIZE. 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.sourceforge.net/doc/fourier/firwin.php>

     See also: pgauss, pbspline, firkaiser, normalize.




# 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: 7
floor23


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1115
 -- Function: floor23
     FLOOR23  Previous number with only 2,3 factors
        Usage: nceil=floor23(n);

        FLOOR23(n) returns the first number less than or equal to n,
        which can be written as a product of powers of 2 and 3.

        The algorithm will look up the best size in a table, which is computed
        the first time the function is run. If the input size is larger than the
        largest value in the table, the input size will be reduced by factors of
        2, until it is in range.

        [nceil,table]=FLOOR23(n) additionally returns the table used for lookup.

        Examples:
        ---------

        Return the first number smaller or equal to 26 that can be written
        solely as products of powers of 2 and 3*:

          floor23(26)

        This plot shows the behaviour of FLOOR23 and CEIL23 for numbers
        up to 100:

          x=1:100;
          plot(x,floor23(x),x,ceil23(x));
          legend('floor23','ceil23','Location','Northwest');

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/floor23.php>

     See also: ceil23, floor235, nextfastfft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
FLOOR23  Previous number with only 2,3 factors
   Usage: nceil=floor23(n);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1145
 -- Function: floor235
     FLOOR235  Previous number with only 2,3 and 5 factors
        Usage: nfloor=floor235(n);

        FLOOR235(n)  returns the next number greater than or equal to n,
        which can be written as a product of powers of 2, 3 and 5.

        The algorithm will look up the best size in a table, which is computed
        the first time the function is run. If the input size is larger than the
        largest value in the table, the input size will be reduced by factors of
        2, until it is in range.

        [nfloor,table]=FLOOR235(n) additionally returns the table used for lookup.

        Examples:
        ---------

        Return the first number smaller or equal to 26 that can be written
        solely as products of powers of 2, 3 and 5*:

          floor235(26)

        This plot shows the behaviour of FLOOR235 and CEIL235 for numbers
        up to 100:

          x=1:100;
          plot(x,floor235(x),x,ceil235(x));
          legend('floor235','ceil235','Location','Northwest');

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/floor235.php>

     See also: floor23, ceil235, nextfastfft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FLOOR235  Previous number with only 2,3 and 5 factors
   Usage: nfloor=floor235(



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


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




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2939
 -- Function: gga
     GGA Generalized Goertzel algorithm
        Usage:  c = gga(x,fvec)
                c = gga(x,fvec,fs)

        Input parameters:
              x      : Input data.
              fvec   : Indices to calculate.
              fs     : Sampling frequency.

        Output parameters:
              c      : Coefficient vector.

        c=GGA(f,fvec) computes the discrete-time fourier transform DTFT of
        f at frequencies in fvec as c(k)=F(2pi f_{vec}(k)) where
        F=DTFT(f), k=1,dots K and K=length(fvec) using the generalized
        second-order Goertzel algorithm. Thanks to the generalization, values
        in fvec can be arbitrary numbers in range 0-1 and not restricted to
        l/Ls, l=0,dots Ls-1 (usual DFT samples) as the original Goertzel
        algorithm is. Ls is the length of the first non-singleton dimension
        of f. If fvec is empty or ommited, fvec is assumed to be
        (0:Ls-1)/Ls and results in the same output as fft.

        c=GGA(f,fvec,fs) computes the same with fvec in Hz relative to fs.

        The input f is processed along the first non-singleton dimension or
        along dimension dim if specified.

        *Remark:**
        Besides the generalization the algorithm is also shortened by one
        iteration compared to the conventional Goertzel.

        Examples:
        ---------

        Calculating DTFT samples of interest:

          % Generate input signal
          fs = 8000;
          L = 2^10;
          k = (0:L-1).';
          freq = [400,510,620,680,825];
          phase = [pi/4,-pi/4,-pi/8,pi/4,-pi/3];
          amp = [5,3,4,1,2];
          f = arrayfun(@(a,f,p) a*sin(2*pi*k*f/fs+p),...
                       amp,freq,phase,'UniformOutput',0);
          f = sum(cell2mat(f),2);

          % This is equal to fft(f)
          ck = gga(f);

          %GGA to FFT error:
          norm(ck-fft(f))

          % DTFT samples at 400,510,620,680,825 Hz
          ckgga = gga(f,freq,fs);

          % Plot modulus of coefficients
          figure(1);clf;hold on;
          stem(k/L*fs,2*abs(ck)/L,'k');
          stem(freq,2*abs(ckgga)/L,'r:');
          set(gca,'XLim',[freq(1)-50,freq(end)+50]);
          set(gca,'YLim',[0 6]);
          xlabel('f[Hz]');
          ylabel('|c(k)|');
          hold off;

          % Plot phase of coefficients
          figure(2);clf;hold on;
          stem(k/L*fs,angle(ck),'k');
          stem(freq,angle(ckgga),'r:');
          set(gca,'XLim',[freq(1)-50,freq(end)+50]);
          set(gca,'YLim',[-pi pi]);
          xlabel('f[Hz]');
          ylabel('angle(c(k))');
          hold off;


        References:
          P. Sysel and P. Rajmic. Goertzel algorithm generalized to non-integer
          multiples of fundamental frequency. EURASIP Journal on Advances in
          Signal Processing, 2012(1):56, 2012.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/gga.php>

     See also: chirpzt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GGA Generalized Goertzel algorithm
   Usage:  c = gga(x,fvec)
           c = gga



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1777
 -- Function: hermbasis
     HERMBASIS  Orthonormal basis of discrete Hermite functions
        Usage:  V=hermbasis(L,p);
                V=hermbasis(L);
                [V,D]=hermbasis(...);

        HERMBASIS(L,p) computes an orthonormal basis of discrete Hermite
        functions of length L. The vectors are returned as columns in the
        output. p is the order of approximation used to construct the
        position and difference operator.

        All the vectors in the output are eigenvectors of the discrete Fourier
        transform, and resemble samplings of the continuous Hermite functions
        to some degree (for low orders).

        [V,D]=HERMBASIS(...) also returns the eigenvalues D of the Discrete
        Fourier Transform corresponding to the Hermite functions.

        Examples:
        ---------

        The following plot shows the spectrograms of 4 Hermite functions of
        length 200 with order 1, 10, 100, and 190:

          H=hermbasis(200);

          subplot(2,2,1);
          sgram(H(:,1),'nf','tc','lin','nocolorbar'); axis('square');

          subplot(2,2,2);
          sgram(H(:,10),'nf','tc','lin','nocolorbar'); axis('square');

          subplot(2,2,3);
          sgram(H(:,100),'nf','tc','lin','nocolorbar'); axis('square');

          subplot(2,2,4);
          sgram(H(:,190),'nf','tc','lin','nocolorbar'); axis('square');


        References:
          A. Bultheel and S. Martinez. Computation of the Fractional Fourier
          Transform. Appl. Comput. Harmon. Anal., 16(3):182-202, 2004.

          H. M. Ozaktas, Z. Zalevsky, and M. A. Kutay. The Fractional Fourier
          Transform. John Wiley and Sons, 2001.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/hermbasis.php>

     See also: dft, pherm.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
HERMBASIS  Orthonormal basis of discrete Hermite functions
   Usage:  V=hermbasi



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 458
 -- Function: idft
     IDFT  Inverse DFT
        Usage: f=idft(f);
               f=idft(f,N,dim);

        This function computes a normalized inverse discrete Fourier transform.
        This is nothing but a scaled version of the output from ifft. The
        function takes exactly the same arguments as ifft. See the help on ifft
        for a thorough description.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/idft.php>

     See also: dft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
IDFT  Inverse DFT
   Usage: f=idft(f);
          f=idft(f,N,dim);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 537
 -- Function: ifftreal
     IFFTREAL  Inverse FFT for real valued signals
        Usage: f=ifftreal(c,N);
               f=ifftreal(c,N,dim);

        IFFTREAL(c,N) computes an inverse FFT of the positive frequency
        Fourier coefficients c. The length N must always be specified,
        because the correct transform length cannot be determined from the
        size of c.

        IFFTREAL(c,N,dim) does the same along dimension dim.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/ifftreal.php>

     See also: fftreal.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IFFTREAL  Inverse FFT for real valued signals
   Usage: f=ifftreal(c,N);
       



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 882
 -- Function: involute
     INVOLUTE  Involution
        Usage: finv=involute(f);
               finv=involute(f,dim);

        INVOLUTE(f) will return the involution of f.

        INVOLUTE(f,dim) will return the involution of f along dimension dim.
        This can for instance be used to calculate the 2D involution:

          f=involute(f,1);
          f=involute(f,2);

        The involution finv of f is given by:

          finv(l+1)=conj(f(mod(-l,L)+1));

        for l=0,...,L-1.

        The relation between conjugation, Fourier transformation and involution
        is expressed by:

          conj(dft(f)) == dft(involute(f))

        for all signals f. The inverse discrete Fourier transform can be
        expressed by:

          idft(f) == conj(involute(dft(f)));

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/involute.php>

     See also: dft, pconv.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
INVOLUTE  Involution
   Usage: finv=involute(f);
          finv=involute(f,dim);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 646
 -- Function: isevenfunction
     ISEVENFUNCTION  True if function is even
        Usage:  t=isevenfunction(f);
                t=isevenfunction(f,tol);

        ISEVENFUNCTION(f) returns 1 if f is whole point even. Otherwise it
        returns 0.

        ISEVENFUNCTION(f,tol) does the same, using the tolerance tol to measure
        how large the error between the two parts of the vector can be. Default
        is 1e-10.

        Adding the flag 'hp' as the last argument does the same for half point
        even functions.

     *Url*:
     <http://ltfat.sourceforge.net/doc/fourier/isevenfunction.php>

     See also: middlepad, peven.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
ISEVENFUNCTION  True if function is even
   Usage:  t=isevenfunction(f);
       



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


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

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2237
 -- 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 NORMALIZE 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.sourceforge.net/doc/fourier/magresp.php>

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1017
 -- Function: middlepad
     MIDDLEPAD  Symmetrically zero-extends or cuts a function
        Usage:  h=middlepad(f,L);
                h=middlepad(f,L,dim);
                h=middlepad(f,L,...);

        MIDDLEPAD(f,L) cuts or zero-extends f to length L by inserting
        zeros in the middle of the vector, or by cutting in the middle
        of the vector.

        If f is whole-point even, MIDDLEPAD(f,L) will also be whole-point
        even.

        MIDDLEPAD(f,L,dim) does the same along dimension dim.

        If f has even length, then f will not be purely zero-extended, but
        the last element will be repeated once and multiplied by 1/2.
        That is, the support of f will increase by one!

        Adding the flag 'wp' as the last argument will cut or extend whole point
        even functions.  Adding 'hp' will do the same for half point even
        functions.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/middlepad.php>

     See also: isevenfunction, fir2long, fftresample.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
MIDDLEPAD  Symmetrically zero-extends or cuts a function
   Usage:  h=middlepad(



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 351
 -- Function: modcent
     MODCENT  Centered modulo
        Usage:  y=modcent(x,r);

        MODCENT(x,r) computes the modulo of x in the range [-r/2,r/2[.

        As an example, to compute the modulo of x in the range [-pi,pi[ use
        the call:

          y = modcent(x,2*pi);
     *Url*: <http://ltfat.sourceforge.net/doc/fourier/modcent.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
MODCENT  Centered modulo
   Usage:  y=modcent(x,r);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1619
 -- Function: nextfastfft
     NEXTFASTFFT  Next higher number with a fast FFT
        Usage: nfft=nextfastfft(n);

        NEXTFASTFFT(n) returns the next number greater than or equal to n,
        for which the computation of a FFT is fast. Such a number is solely
        comprised of small prime-factors of 2, 3, 5 and 7.

        NEXTFASTFFT is intended as a replacement of nextpow2, which is often
        used for the same purpose. However, a modern FFT implementation (like
        FFTW) usually performs well for sizes which are powers or 2,3,5 and 7,
        and not only just for powers of 2.

        The algorithm will look up the best size in a table, which is computed
        the first time the function is run. If the input size is larger than the
        largest value in the table, the input size will be reduced by factors of
        2, until it is in range.

        [n,nfft]=NEXTFASTFFT(n) additionally returns the table used for
        lookup.



        References:
          J. Cooley and J. Tukey. An algorithm for the machine calculation of
          complex Fourier series. Math. Comput, 19(90):297-301, 1965.

          M. Frigo and S. G. Johnson. The design and implementation of FFTW3.
          Proceedings of the IEEE, 93(2):216-231, 2005. Special issue on "Program
          Generation, Optimization, and Platform Adaptation".

          P. L. Soendergaard. LTFAT-note 17: Next fast FFT size. Technical report,
          Technical University of Denmark, 2011.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/nextfastfft.php>

     See also: ceil23, ceil235, demo_nextfastfft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
NEXTFASTFFT  Next higher number with a fast FFT
   Usage: nfft=nextfastfft(n);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2560
 -- Function: pbspline
     PBSPLINE   Periodized B-spline
        Usage:   g=pbspline(L,order,a,...);
                 [g,nlen]=pbspline(L,order,a,...);

        Input parameters:
              L      : Length of window.
              order  : Order of B-spline.
              a      : Time-shift parameter for partition of unity.
        Output parameters:
              g      : Fractional B-spline.
              nlen   : Number of non-zero elements in out.

        PBSPLINE(L,order,a) computes a (slightly modified) B-spline of order
        order of total length L.

        If shifted by the distance a, the returned function will form a
        partition of unity. The result is normalized such that the functions sum
        to 1/sqrt(a).

        PBSPLINE takes the following flags at the end of the input arguments:

          'ed'     Even discrete fractional spline. This is the default

          'xd'     'flat' discrete fractional spline.

          'stard'  'pointy' discrete fractional spline

          'ec'     Even fractional spline by sampling.

          'xc'     'flat' fractional spline by sampling.

          'starc'  'pointy' fractional spline by sampling.

          'wp'     Generate whole point centered splines. This is the default.

          'hp'     Generate half point centered splines.

        The different types are accurately described in the referenced paper.
        Generally, the 'd' types of splines are very fast to compute, while
        the 'c' types are samplings of the continuous splines. The 'e' types
        coincides with the regular B-splines for integer orders. The 'x' types
        do not coincide, but generate Gabor frames with favorable frame
        bounds. The default type is 'ed' to guarantee fast computation and a
        familiar shape of the splines.

        [out,nlen]=PBSPLINE(...) will additionally compute the number of
        non-zero elements in out.

        If nlen = L, the function returned will be a periodization of a
        B-spline.

        If nlen < L, you can choose to remove the additional zeros by calling
        g=middlepad(g,nlen).

        Additionally, PBSPLINE accepts flags to normalize the output. Please
        see the help of NORMALIZE. Default is to use 'peak' normalization.



        References:
          P. L. Soendergaard. Symmetric, discrete fractional splines and Gabor
          systems. preprint, 2008.


     *Url*: <http://ltfat.sourceforge.net/doc/fourier/pbspline.php>

     See also: pgauss, firwin, middlepad, normalize, demo_pbspline.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PBSPLINE   Periodized B-spline
   Usage:   g=pbspline(L,order,a,...);
          



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1331
 -- Function: pchirp
     PCHIRP  Periodic chirp
        Usage:  g=pchirp(L,n);

        PCHIRP(L,n) returns a periodic, discrete chirp of length L that
        revolves n times around the time-frequency plane in frequency. n must be
        an integer number.

        To get a chirp that revolves around the time-frequency plane in time,
        use :

          dft(pchirp(L,N));

        The chirp is computed by:

            g(l+1) = exp(pi*i*n*(l-ceil(L/2))^2*(L+1)/L) for l=0,...,L-1

        The chirp has absolute value 1 everywhere. To get a chirp with unit
        l^2-norm, divide the chirp by sqrt L.

        Examples:
        ---------

        A spectrogram on a linear scale of an even length chirp:

          sgram(pchirp(40,2),'lin');

        The DFT of the same chirp, now revolving around in time:

          sgram(dft(pchirp(40,2)),'lin');

        An odd-length chirp. Notice that the chirp starts at a frequency between
        two sampling points:

          sgram(pchirp(41,2),'lin');


        References:
          H. G. Feichtinger, M. Hazewinkel, N. Kaiblinger, E. Matusiak, and
          M. Neuhauser. Metaplectic operators on c^n. The Quarterly Journal of
          Mathematics, 59(1):15-28, 2008.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/pchirp.php>

     See also: dft, expwave.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
PCHIRP  Periodic chirp
   Usage:  g=pchirp(L,n);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 949
 -- Function: pconv
     PCONV  Periodic convolution
        Usage:  h=pconv(f,g)
                h=pconv(f,g, ftype);

        PCONV(f,g) computes the periodic convolution of f and g. The convolution
        is given by

                    L-1
           h(l+1) = sum f(k+1) * g(l-k+1)
                    k=0

        PCONV(f,g,'r') computes the convolution where g is reversed
        (involuted) given by

                    L-1
           h(l+1) = sum f(k+1) * conj(g(k-l+1))
                    k=0

        This type of convolution is also known as cross-correlation.

        PCONV(f,g,'rr') computes the alternative where both f and g are
        reversed given by

                    L-1
           h(l+1) = sum conj(f(-k+1)) * conj(g(k-l+1))
                    k=0

        In the above formulas, l-k, k-l and -k are computed modulo L.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/pconv.php>

     See also: dft, involute.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PCONV  Periodic convolution
   Usage:  h=pconv(f,g)
           h=pconv(f,g, ftyp



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 964
 -- Function: pderiv
     PDERIV   Derivative of smooth periodic function
        Usage:  fd=pderiv(f);
                fd=pderiv(f,dim);
                fd=pderiv(f,dim,difforder);

        PDERIV(f) will compute the derivative of f using a using a 4th order
        centered finite difference scheme. f must have been obtained by a
        regular sampling. If f is a matrix, the derivative along the columns
        will be found.

        PDERIV(f,dim) will do the same along dimension dim.

        PDERIV(f,dim,difforder) uses a centered finite difference scheme of
        order difforder instead of the default.

        PDERIV(f,dim,Inf) will compute the spectral derivative using a DFT.

        PDERIV assumes that f is a regular sampling of a function on the
        torus [0,1). The derivative of a function on a general torus [0,T)
        can be found by scaling the output by 1/T.
     *Url*: <http://ltfat.sourceforge.net/doc/fourier/pderiv.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PDERIV   Derivative of smooth periodic function
   Usage:  fd=pderiv(f);
       



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 362
 -- Function: peven
     PEVEN   Even part of periodic function
        Usage:  fe=peven(f);
                fe=peven(f,dim);

        PEVEN(f) returns the even part of the periodic sequence f.

        PEVEN(f,dim) does the same along dimension dim.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/peven.php>

     See also: podd, dft, involute, pconv.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PEVEN   Even part of periodic function
   Usage:  fe=peven(f);
           fe=pev



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


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

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3863
 -- Function: pgauss
     PGAUSS  Sampled, periodized Gaussian
        Usage: g=pgauss(L);
               g=pgauss(L,tfr);
               g=pgauss(L,...);
               [g,tfr]=pgauss( ... );

        Input parameters:
              L    : Length of vector.
              tfr  : ratio between time and frequency support.

        Output parameters:
              g    : The periodized Gaussian.

        PGAUSS(L,tfr) computes samples of a periodized Gaussian. The function
        returns a regular sampling of the periodization of the function
        exp(-pi*(x.^2/tfr)).

        The l^2 norm of the returned Gaussian is equal to 1.

        The parameter tfr determines the ratio between the effective support
        of g and the effective support of the DFT of g. If tfr>1 then g*
        has a wider support than the DFT of g.

        PGAUSS(L) does the same setting tfr=1.

        [g,tfr] = PGAUSS( ... ) will additionally return the time-to-frequency
        support ratio. This is useful if you did not specify it (i.e. used the
        'width' or 'bw' flag).

        The function is whole-point even. This implies that fft(PGAUSS(L,tfr))
        is real for any L and tfr. The DFT of g is equal to
        PGAUSS(L,1/tfr).

        In addition to the 'width' flag, PGAUSS understands the following
        flags at the end of the list of input parameters:

          'fs',fs     Use a sampling rate of fs Hz as unit for specifying the
                      width, bandwidth, centre frequency and delay of the
                      Gaussian. Default is fs=[] which indicates to measure
                      everything in samples.

          'width',s   Set the width of the Gaussian such that it has an
                      effective support of s samples. This means that
                      approx. 96% of the energy or 79% of the area
                      under the graph is contained within s samples. This
                      corresponds to a -6 db cutoff. This is equivalent to
                      calling PGAUSS(L,s^2/L).

          'bw',bw     As for the 'width' argument, but specifies the width
                      in the frequency domain. The bandwidth is measured in
                      normalized frequencies, unless the 'fs' value is given.

          'cf',cf     Set the centre frequency of the Gaussian to fc.

          'wp'        Output is whole point even. This is the default.

          'hp'        Output is half point even, as most Matlab filter
                      routines.

          'delay',d   Delay the output by d. Default is zero delay.

        In addition to these parameteres, PGAUSS accepts any of the flags
        from NORMALIZE. The output will be normalized as specified.

        If this function is used to generate a window for a Gabor frame, then
        the window giving the smallest frame bound ratio is generated by
        PGAUSS(L,a*M/L).

        Examples:
        ---------

        This example creates a Gaussian function, and demonstrates that it is
        its own Discrete Fourier Transform:

          g=pgauss(128);

          % Test of DFT invariance: Should be close to zero.
          norm(g-dft(g))

        The next plot shows the Gaussian in the time domain:

          plot(fftshift(pgauss(128)));

        The next plot shows the Gaussian in the frequency domain on a log scale:

          magresp(pgauss(128),'dynrange',100);

        The next plot shows the Gaussian in the time-frequency plane:

          sgram(pgauss(128),'tc','nf','lin');



        References:
          S. Mallat and Z. Zhang. Matching pursuits with time-frequency
          dictionaries. IEEE Trans. Signal Process., 41(12):3397-3415, 1993.


     *Url*: <http://ltfat.sourceforge.net/doc/fourier/pgauss.php>

     See also: dgtlength, psech, firwin, pbspline, normalize,
     demo_pgauss.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PGAUSS  Sampled, periodized Gaussian
   Usage: g=pgauss(L);
          g=pgauss(L



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


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




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 813
 -- Function: pheaviside
     PHEAVISIDE  Periodic Heaviside function
        Usage: h=pheaviside(L);

        PHEAVISIDE(L) returns a periodic Heaviside function. The periodic
        Heaviside function takes on the value 1 for indices corresponding to
        positive frequencies, 0 corresponding to negative frequencies and the
        value .5 for the zero and Nyquist frequencies.

        To get a function that weights the negative frequencies by 1 and the
        positive by 0, use involute(PHEAVISIDE(L))

        As an example, the PHEAVISIDE function can be use to calculate the
        Hilbert transform for a column vector f*:

          h=2*ifft(fft(f).*pheaviside(length(f)));

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/pheaviside.php>

     See also: middlepad, involute, fftindex.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
PHEAVISIDE  Periodic Heaviside function
   Usage: h=pheaviside(L);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3022
 -- Function: pherm
     PHERM  Periodized Hermite function
        Usage: g=pherm(L,order);
               g=pherm(L,order,tfr);
               [g,D]=pherm(...);

        Input parameters:
           L     : Length of vector.
           order : Order of Hermite function.
           tfr   : ratio between time and frequency support.
        Output parameters:
           g     : The periodized Hermite function

        PHERM(L,order,tfr) computes samples of a periodized Hermite function
        of order order. order is counted from 0, so the zero'th order
        Hermite function is the Gaussian.

        The parameter tfr determines the ratio between the effective support
        of g and the effective support of the DFT of g. If tfr>1 then g*
        has a wider support than the DFT of g.

        PHERM(L,order) does the same setting tfr=1.

        If order is a vector, PHERM will return a matrix, where each column
        is a Hermite function with the corresponding order.

        [g,D]=PHERM(...) also returns the eigenvalues D of the Discrete
        Fourier Transform corresponding to the Hermite functions.

        The returned functions are eigenvectors of the DFT. The Hermite
        functions are orthogonal to all other Hermite functions with a
        different eigenvalue, but eigenvectors with the same eigenvalue are
        not orthogonal (but see the flags below).

        PHERM takes the following flags at the end of the line of input
        arguments:

          'accurate'  Use a numerically very accurate that computes each
                      Hermite function individually. This is the default.

          'fast'      Use a less accurate algorithm that calculates all the
                      Hermite up to a given order at once.

          'noorth'    No orthonormalization of the Hermite functions. This is
                      the default.

          'polar'     Orthonormalization of the Hermite functions using the
                      polar decomposition orthonormalization method.

          'qr'        Orthonormalization of the Hermite functions using the
                      Gram-Schmidt orthonormalization method (usign qr).

        If you just need to compute a single Hermite function, there is no
        speed difference between the 'accurate' and 'fast' algorithm.

        Examples:
        ---------

        The following plot shows the spectrograms of 4 Hermite functions of
        length 200 with order 1, 10, 100, and 190:

          subplot(2,2,1);
          sgram(pherm(200,1),'nf','tc','lin','nocolorbar'); axis('square');

          subplot(2,2,2);
          sgram(pherm(200,10),'nf','tc','lin','nocolorbar'); axis('square');

          subplot(2,2,3);
          sgram(pherm(200,100),'nf','tc','lin','nocolorbar'); axis('square');

          subplot(2,2,4);
          sgram(pherm(200,190),'nf','tc','lin','nocolorbar'); axis('square');

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/pherm.php>

     See also: hermbasis, pgauss, psech.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PHERM  Periodized Hermite function
   Usage: g=pherm(L,order);
          g=pherm



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2510
 -- Function: plotfft
     PLOTFFT  Plot the output from FFT
        Usage: plotfft(coef);
               plotfft(coef,fs);

        PLOTFFT(coef) plots the output from the fft function. The
        frequency axis will use normalized frequencies between 0 and 1 (the
        Nyquist frequency).

        PLOTFFT(coef,fs) does the same for the FFT of a signal sampled at
        a sampling rate of fs Hz.

        PLOTFFT(coef,fs,dynrange) additionally limits the dynamic range of the
        plot. See the description of the 'dynrange' parameter below.

        PLOTFFT accepts the following optional arguments:

          'dynrange',r Limit the dynamical range to r by using a colormap in
                       the interval [chigh-r,chigh], where chigh is the highest
                       value in the plot. The default value of [] means to not
                       limit the dynamical range.

          'db'         Apply 20*log_{10} to the coefficients. This makes
                       it possible to see very weak phenomena, but it might show
                       too much noise. This is the default.

          'dbsq'       Apply 10*log_{10} to the coefficients. Same as the
                       'db' option, but assumes that the input is already squared.

          'lin'        Show the coefficients on a linear scale. This will
                       display the raw input without any modifications. Only works for
                       real-valued input.

          'linsq'      Show the square of the coefficients on a linear scale.

          'linabs'     Show the absolute value of the coefficients on a linear
                       scale.

          'nf'         Display negative frequencies, with the zero-frequency
                       centered in the middle. This is the default.

          'posfreq'    Display only the positive frequencies.

          'dim',dim  If coef is multidimensional, dim indicates the
                     dimension along which are the individual channels oriented.
                     Value 1 indicates columns, value 2 rows.

          'flog'     Use logarithmic scale for the frequency axis. This flag is
                     only valid in conjuction with the 'posfreq' flag.


        In addition to these parameters, PLOTFFT accepts any of the flags
        from NORMALIZE. The coefficients will be normalized as specified
        before plotting.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/plotfft.php>

     See also: plotfftreal.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTFFT  Plot the output from FFT
   Usage: plotfft(coef);
          plotfft(coe



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2465
 -- Function: plotfftreal
     PLOTFFTREAL  Plot the output from FFTREAL
        Usage: plotfftreal(coef);
               plotfftreal(coef,fs);

        PLOTFFTREAL(coef) plots the output from the FFTREAL function. The
        frequency axis will use normalized frequencies between 0 and 1 (the
        Nyquist frequency). It is assumed that the length of the original
        transform was even.

        PLOTFFTREAL(coef,fs) does the same for the FFTREAL of a signal
        sampled at a sampling rate of fs Hz.

        PLOTFFTREAL(coef,fs,dynrange) additionally limits the dynamic range of the
        plot. See the description of the 'dynrange' parameter below.

        PLOTFFTREAL accepts the following optional arguments:

          'dynrange',r  Limit the dynamical range to r by using a colormap in
                        the interval [chigh-r,chigh], where chigh is the highest
                        value in the plot. The default value of [] means to not
                        limit the dynamical range.

          'db'      Apply 20*log_{10} to the coefficients. This makes
                    it possible to see very weak phenomena, but it might show
                    too much noise. This is the default.

          'dbsq'    Apply 10*log_{10} to the coefficients. Same as the
                    'db' option, but assumes that the input is already squared.

          'lin'     Show the coefficients on a linear scale. This will
                    display the raw input without any modifications. Only works for
                    real-valued input.

          'linsq'   Show the square of the coefficients on a linear scale.

          'linabs'  Show the absolute value of the coefficients on a linear
                    scale.

          'N',N     Specify the transform length N. Use this if you are
                    unsure if the original input signal was of even length.

          'dim',dim  If coef is multidimensional, dim indicates the
                     dimension along which are the individual channels oriented.
                     Value 1 indicates columns, value 2 rows.

          'flog'  Use logarithmic scale for the frequency axis.


        In addition to these parameters, PLOTFFTREAL accepts any of the flags
        from NORMALIZE. The coefficients will be normalized as specified
        before plotting.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/plotfftreal.php>

     See also: plotfft, fftreal.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTFFTREAL  Plot the output from FFTREAL
   Usage: plotfftreal(coef);
         



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 354
 -- Function: podd
     PODD   Odd part of periodic function
        Usage:  fe=podd(f);
                fe=podd(f,dim);

        PODD(f) returns the odd part of the periodic sequence f.

        PODD(f,dim) does the same along dimension dim.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/podd.php>

     See also: peven, dft, involute, pconv.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PODD   Odd part of periodic function
   Usage:  fe=podd(f);
           fe=podd(f



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1068
 -- Function: prect
     PRECT   Periodic rectangle
        Usage:  f=prect(L,n);

        psinc(L,n) computes the periodic rectangle (or square) function of
        length L supported on n samples. The DFT of the periodic
        rectangle function in the periodic sinc function, PSINC.

         If n is odd, the output will be supported on exactly n samples
          centered around the first sample.

         If n is even, the output will be supported on exactly n+1 samples
          centered around the first sample. The function value on the two
          samples on the edge of the function will have half the magnitude of
          the other samples.

        Examples:
        ---------

        This figure displays an odd length periodic rectangle:

          stem(prect(30,11));
          ylim([-.2 1.2]);

        This figure displays an even length periodic rectangle. Notice the
        border points:

          stem(prect(30,12));
          ylim([-.2 1.2]);

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/prect.php>

     See also: psinc.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
PRECT   Periodic rectangle
   Usage:  f=prect(L,n);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2759
 -- Function: psech
     PSECH  Sampled, periodized hyperbolic secant
        Usage: g=psech(L);
               g=psech(L,tfr);
               g=psech(L,s,'samples);
               [g,tfr]=psech( ... );

        Input parameters:
           L   : Length of vector.
           tfr : ratio between time and frequency support.
        Output parameters:
           g   : The periodized hyperbolic cosine.

        PSECH(L,tfr) computes samples of a periodized hyperbolic secant.
        The function returns a regular sampling of the periodization
        of the function sech(pi*x)

        The returned function has norm equal to 1.

        The parameter tfr determines the ratio between the effective support
        of g and the effective support of the DFT of g. If tfr>1 then g*
        has a wider support than the DFT of g.

        PSECH(L) does the same setting tfr=1.

        PSECH(L,s,'samples') returns a hyperbolic secant with an effective
        support of s samples. This means that approx. 96% of the energy or 74%
        or the area under the graph is contained within s samples. This is
        equivalent to PSECH(L,s^2/L).

        [g,tfr] = PSECH( ... ) additionally returns the time-to-frequency
        support ratio. This is useful if you did not specify it (i.e. used
        the 'samples' input format).

        The function is whole-point even.  This implies that fft(PSECH(L,tfr))
        is real for any L and tfr.

        If this function is used to generate a window for a Gabor frame, then
        the window giving the smallest frame bound ratio is generated by
        PSECH(L,a*M/L).

        Examples:
        ---------

        This example creates a PSECH function, and demonstrates that it is
        its own Discrete Fourier Transform:

          g=psech(128);

          % Test of DFT invariance: Should be close to zero.
          norm(g-dft(g))

        The next plot shows the PSECH in the time domain compared to the Gaussian:

          plot((1:128)',fftshift(pgauss(128)),...
               (1:128)',fftshift(psech(128)));
          legend('pgauss','psech');

        The next plot shows the PSECH in the frequency domain on a log
        scale compared to the Gaussian:

          hold all;
          magresp(pgauss(128),'dynrange',100);
          magresp(psech(128),'dynrange',100);
          legend('pgauss','psech');

        The next plot shows PSECH in the time-frequency plane:

          sgram(psech(128),'tc','nf','lin');


        References:
          A. J. E. M. Janssen and T. Strohmer. Hyperbolic secants yield Gabor
          frames. Appl. Comput. Harmon. Anal., 12(2):259-267, 2002.


     *Url*: <http://ltfat.sourceforge.net/doc/fourier/psech.php>

     See also: pgauss, pbspline, pherm.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PSECH  Sampled, periodized hyperbolic secant
   Usage: g=psech(L);
          g=p



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 539
 -- Function: psinc
     PSINC   Periodic Sinc function (Dirichlet function)
        Usage:  f=psinc(L,n);

        PSINC(L,n) computes the periodic Sinc function of length L with
        n-1 local extrema. The DFT of the periodic Sinc function is the
        periodic rectangle, PRECT, of length n.

        Examples:
        ---------

        This figure displays a the periodic sinc function with 6 local extremas:

          plot(psinc(30,7));

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/psinc.php>

     See also: prect.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
PSINC   Periodic Sinc function (Dirichlet function)
   Usage:  f=psinc(L,n);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 611
 -- Function: pxcorr
     PXCORR  Periodic cross correlation
        Usage:  h=pxcorr(f,g)

        PXCORR(f,g) computes the periodic cross correlation of the input
        signals f and g. The cross correlation is defined by

                    L-1
           h(l+1) = sum f(k+1) * conj(g(k-l+1))
                    k=0

        In the above formula, k-l is computed modulo L.

        PXCORR(f,g,'normalize') does the same, but normalizes the output by
        the product of the l^2-norm of f and g.

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/pxcorr.php>

     See also: dft, pfilt, involute.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
PXCORR  Periodic cross correlation
   Usage:  h=pxcorr(f,g)



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1027
 -- Function: shah
     SHAH  Discrete Shah-distribution
        Usage: f=shah(L,a);

        SHAH(L,a) computes the discrete, normalized Shah-distribution of
        length L with a distance of a between the spikes.

        The Shah distribution is defined by

           f(n*a+1)=1/sqrt(L/a)

        for integer n, otherwise f is zero.

        This is also known as an impulse train or as the comb function, because
        the shape of the function resembles a comb. It is the sum of unit
        impulses ('diracs') with the distance a.

        If a divides L, then the DFT of SHAH(L,a) is SHAH(L,L/a).

        The Shah function has an extremely bad time-frequency localization.
        It does not generate a Gabor frame for any L and a.

        Examples:
        ---------

        A simple spectrogram of the Shah function (includes the negative
        frequencies to display the whole TF-plane):

          sgram(shah(256,16),'dynrange',80,'nf')

     *Url*: <http://ltfat.sourceforge.net/doc/fourier/shah.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
SHAH  Discrete Shah-distribution
   Usage: f=shah(L,a);



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


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

     See also: pfilt.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2654
 -- Function: warpedblfilter
     WARPEDBLFILTER  Construct a warped band-limited filter
        Usage:  g=warpedblfilter(winname,fsupp,fc,fs,freqtoscale);
                g=warpedblfilter(winname,fsupp,fc,...);

        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) 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.

        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.necessary. 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 filterbank.

        It is possible to normalize the transfer function of the filter by
        passing any of the flags from the NORMALIZE 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.sourceforge.net/doc/fourier/warpedblfilter.php>

     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=warpedblfilt





