scipy.fftpack.basic
index
/usr/lib64/python2.6/site-packages/scipy/fftpack/basic.py

Discrete Fourier Transforms - basic.py

 
Modules
       
scipy.fftpack._fftpack
numpy

 
Functions
       
fft(x, n=None, axis=-1, overwrite_x=0)
Return discrete Fourier transform of real or complex sequence.
 
The returned complex array contains ``y(0), y(1),..., y(n-1)`` where
 
``y(j) = (x * exp(-2*pi*sqrt(-1)*j*np.arange(n)/n)).sum()``.
 
Parameters
----------
x : array_like
    Array to Fourier transform.
n : int, optional
    Length of the Fourier transform.  If ``n < x.shape[axis]``, `x` is
    truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
    default results in ``n = x.shape[axis]``.
axis : int, optional
    Axis along which the fft's are computed; the default is over the
    last axis (i.e., ``axis=-1``).
overwrite_x : bool, optional
    If True the contents of `x` can be destroyed; the default is False.
 
Returns
-------
z : complex ndarray
    with the elements::
 
        [y(0),y(1),..,y(n/2),y(1-n/2),...,y(-1)]        if n is even
        [y(0),y(1),..,y((n-1)/2),y(-(n-1)/2),...,y(-1)]  if n is odd
 
    where::
 
        y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k* 2*pi/n), j = 0..n-1
 
    Note that ``y(-j) = y(n-j).conjugate()``.
 
See Also
--------
ifft : Inverse FFT
rfft : FFT of a real sequence
 
Notes
-----
The packing of the result is "standard": If A = fft(a, n), then A[0]
contains the zero-frequency term, A[1:n/2+1] contains the
positive-frequency terms, and A[n/2+1:] contains the negative-frequency
terms, in order of decreasingly negative frequency. So for an 8-point
transform, the frequencies of the result are [ 0, 1, 2, 3, 4, -3, -2, -1].
 
For n even, A[n/2] contains the sum of the positive and negative-frequency
terms. For n even and x real, A[n/2] will always be real.
 
This is most efficient for n a power of two.
 
Examples
--------
>>> from scipy.fftpack import fft, ifft
>>> x = np.arange(5)
>>> np.allclose(fft(ifft(x)), x, atol=1e-15)  #within numerical accuracy.
True
fft2(x, shape=None, axes=(-2, -1), overwrite_x=0)
2-D discrete Fourier transform.
 
Return the two-dimensional discrete Fourier transform of the 2-D argument
`x`.
 
See Also
--------
fftn : for detailed information.
fftn(x, shape=None, axes=None, overwrite_x=0)
Return multidimensional discrete Fourier transform.
 
The returned array contains::
 
  y[j_1,..,j_d] = sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]
     x[k_1,..,k_d] * prod[i=1..d] exp(-sqrt(-1)*2*pi/n_i * j_i * k_i)
 
where d = len(x.shape) and n = x.shape.
Note that ``y[..., -j_i, ...] = y[..., n_i-j_i, ...].conjugate()``.
 
Parameters
----------
x : array_like
    The (n-dimensional) array to transform.
shape : tuple of ints, optional
    The shape of the result.  If both `shape` and `axes` (see below) are
    None, `shape` is ``x.shape``; if `shape` is None but `axes` is
    not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.
    If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.
    If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to
    length ``shape[i]``.
axes : array_like of ints, optional
    The axes of `x` (`y` if `shape` is not None) along which the
    transform is applied.
overwrite_x : bool, optional
    If True, the contents of `x` can be destroyed.  Default is False.
 
Returns
-------
y : complex-valued n-dimensional numpy array
    The (n-dimensional) DFT of the input array.
 
See Also
--------
ifftn
 
Examples
--------
>>> y = (-np.arange(16), 8 - np.arange(16), np.arange(16))
>>> np.allclose(y, fftn(ifftn(y)))
True
ifft(x, n=None, axis=-1, overwrite_x=0)
Return discrete inverse Fourier transform of real or complex sequence.
 
The returned complex array contains ``y(0), y(1),..., y(n-1)`` where
 
``y(j) = (x * exp(2*pi*sqrt(-1)*j*np.arange(n)/n)).mean()``.
 
Parameters
----------
x : array_like
    Transformed data to invert.
n : int, optional
    Length of the inverse Fourier transform.  If ``n < x.shape[axis]``,
    `x` is truncated.  If ``n > x.shape[axis]``, `x` is zero-padded.
    The default results in ``n = x.shape[axis]``.
axis : int, optional
    Axis along which the ifft's are computed; the default is over the
    last axis (i.e., ``axis=-1``).
overwrite_x : bool, optional
    If True the contents of `x` can be destroyed; the default is False.
ifft2(x, shape=None, axes=(-2, -1), overwrite_x=0)
2-D discrete inverse Fourier transform of real or complex sequence.
 
Return inverse two-dimensional discrete Fourier transform of
arbitrary type sequence x.
 
See `ifft` for more information.
 
See also
--------
fft2, ifft
ifftn(x, shape=None, axes=None, overwrite_x=0)
Return inverse multi-dimensional discrete Fourier transform of
arbitrary type sequence x.
 
The returned array contains::
 
  y[j_1,..,j_d] = 1/p * sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]
     x[k_1,..,k_d] * prod[i=1..d] exp(sqrt(-1)*2*pi/n_i * j_i * k_i)
 
where ``d = len(x.shape)``, ``n = x.shape``, and ``p = prod[i=1..d] n_i``.
 
For description of parameters see `fftn`.
 
See Also
--------
fftn : for detailed information.
irfft(x, n=None, axis=-1, overwrite_x=0)
Return inverse discrete Fourier transform of real sequence x.
 
The contents of x is interpreted as the output of the ``rfft(..)``
function.
 
Parameters
----------
x : array_like
    Transformed data to invert.
n : int, optional
    Length of the inverse Fourier transform.
    If n < x.shape[axis], x is truncated.
    If n > x.shape[axis], x is zero-padded.
    The default results in n = x.shape[axis].
axis : int, optional
    Axis along which the ifft's are computed; the default is over
    the last axis (i.e., axis=-1).
overwrite_x : bool, optional
    If True the contents of `x` can be destroyed; the default is False.
 
Returns
-------
irfft : ndarray of floats
    The inverse discrete Fourier transform.
 
See Also
--------
rfft, ifft
 
Notes
-----
The returned real array contains::
 
    [y(0),y(1),...,y(n-1)]
 
where for n is even::
 
    y(j) = 1/n (sum[k=1..n/2-1] (x[2*k-1]+sqrt(-1)*x[2*k])
                                 * exp(sqrt(-1)*j*k* 2*pi/n)
                + c.c. + x[0] + (-1)**(j) x[n-1])
 
and for n is odd::
 
    y(j) = 1/n (sum[k=1..(n-1)/2] (x[2*k-1]+sqrt(-1)*x[2*k])
                                 * exp(sqrt(-1)*j*k* 2*pi/n)
                + c.c. + x[0])
 
c.c. denotes complex conjugate of preceeding expression.
 
For details on input parameters, see `rfft`.
rfft(x, n=None, axis=-1, overwrite_x=0)
Discrete Fourier transform of a real sequence.
 
The returned real arrays contains::
 
  [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2))]              if n is even
  [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2)),Im(y(n/2))]   if n is odd
 
where
::
 
  y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k*2*pi/n)
  j = 0..n-1
 
Note that ``y(-j) == y(n-j).conjugate()``.
 
Parameters
----------
x : array_like, real-valued
    The data to transform.
n : int, optional
    Defines the length of the Fourier transform.  If `n` is not specified
    (the default) then ``n = x.shape[axis]``.  If ``n < x.shape[axis]``,
    `x` is truncated, if ``n > x.shape[axis]``, `x` is zero-padded.
axis : int, optional
    The axis along which the transform is applied.  The default is the
    last axis.
overwrite_x : bool, optional
    If set to true, the contents of `x` can be overwritten. Default is
    False.
 
See Also
--------
fft, irfft, scipy.fftpack.basic
 
Notes
-----
Within numerical accuracy, ``y == rfft(irfft(y))``.

 
Data
        __all__ = ['fft', 'ifft', 'fftn', 'ifftn', 'rfft', 'irfft', 'fft2', 'ifft2']