mirror of
https://github.com/meteoinfo/MeteoInfo.git
synced 2025-12-08 20:36:05 +00:00
128 lines
3.9 KiB
Python
128 lines
3.9 KiB
Python
from org.meteoinfo.math.transform import FastFourierTransform, FastFourierTransform2D
|
|
|
|
from .. import core as _nx
|
|
|
|
__all__ = ['fft', 'ifft', 'fft2', 'ifft2']
|
|
|
|
|
|
def fft(a):
|
|
"""
|
|
Compute the one-dimensional discrete Fourier Transform.
|
|
|
|
This function computes the one-dimensional *n*-point discrete Fourier
|
|
Transform (DFT) with the efficient Fast Fourier Transform (FFT)
|
|
algorithm [CT].
|
|
|
|
Parameters
|
|
----------
|
|
a : array_like
|
|
Input array, can be complex.
|
|
|
|
Returns
|
|
-------
|
|
out : complex ndarray
|
|
The truncated or zero-padded input, transformed along the axis
|
|
indicated by `axis`, or the last one if `axis` is not specified.
|
|
|
|
References
|
|
----------
|
|
.. [CT] Cooley, James W., and John W. Tukey, 1965, "An algorithm for the
|
|
machine calculation of complex Fourier series," *Math. Comput.*
|
|
19: 297-301.
|
|
"""
|
|
a = _nx.asarray(a)
|
|
jfft = FastFourierTransform()
|
|
r = jfft.apply(a._array)
|
|
|
|
return _nx.NDArray(r)
|
|
|
|
def ifft(a):
|
|
"""
|
|
Compute the one-dimensional inverse discrete Fourier Transform.
|
|
|
|
This function computes the inverse of the one-dimensional *n*-point
|
|
discrete Fourier transform computed by `fft`. In other words,
|
|
``ifft(fft(a)) == a`` to within numerical accuracy.
|
|
For a general description of the algorithm and definitions,
|
|
see `numpy.fft`.
|
|
|
|
The input should be ordered in the same way as is returned by `fft`,
|
|
i.e.,
|
|
|
|
Parameters
|
|
----------
|
|
a : array_like
|
|
Input array, can be complex.
|
|
|
|
Returns
|
|
-------
|
|
out : complex ndarray
|
|
The truncated or zero-padded input, transformed along the axis
|
|
indicated by `axis`, or the last one if `axis` is not specified.
|
|
"""
|
|
a = _nx.asarray(a)
|
|
jfft = FastFourierTransform(True)
|
|
r = jfft.apply(a._array)
|
|
|
|
return _nx.NDArray(r)
|
|
|
|
def fft2(a):
|
|
"""
|
|
Compute the 2-dimensional discrete Fourier Transform.
|
|
|
|
This function computes the *n*-dimensional discrete Fourier Transform
|
|
over any axes in an *M*-dimensional array by means of the
|
|
Fast Fourier Transform (FFT). By default, the transform is computed over
|
|
the last two axes of the input array, i.e., a 2-dimensional FFT.
|
|
|
|
Parameters
|
|
----------
|
|
a : array_like
|
|
Input array, can be complex
|
|
|
|
Returns
|
|
-------
|
|
out : complex ndarray
|
|
The truncated or zero-padded input, transformed along the axes
|
|
indicated by `axes`, or the last two axes if `axes` is not given.
|
|
"""
|
|
a = _nx.asarray(a)
|
|
jfft = FastFourierTransform2D()
|
|
r = jfft.apply(a._array)
|
|
|
|
return _nx.NDArray(r)
|
|
|
|
def ifft2(a, s=None, axes=(-2, -1), norm=None, out=None):
|
|
"""
|
|
Compute the 2-dimensional inverse discrete Fourier Transform.
|
|
|
|
This function computes the inverse of the 2-dimensional discrete Fourier
|
|
Transform over any number of axes in an M-dimensional array by means of
|
|
the Fast Fourier Transform (FFT). In other words, ``ifft2(fft2(a)) == a``
|
|
to within numerical accuracy. By default, the inverse transform is
|
|
computed over the last two axes of the input array.
|
|
|
|
The input, analogously to `ifft`, should be ordered in the same way as is
|
|
returned by `fft2`, i.e. it should have the term for zero frequency
|
|
in the low-order corner of the two axes, the positive frequency terms in
|
|
the first half of these axes, the term for the Nyquist frequency in the
|
|
middle of the axes and the negative frequency terms in the second half of
|
|
both axes, in order of decreasingly negative frequency.
|
|
|
|
Parameters
|
|
----------
|
|
a : array_like
|
|
Input array, can be complex.
|
|
|
|
Returns
|
|
-------
|
|
out : complex ndarray
|
|
The truncated or zero-padded input, transformed along the axes
|
|
indicated by `axes`, or the last two axes if `axes` is not given.
|
|
"""
|
|
a = _nx.asarray(a)
|
|
jfft = FastFourierTransform2D(True)
|
|
r = jfft.apply(a._array)
|
|
|
|
return _nx.NDArray(r)
|