link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

_pocketfft.py

"""

Discrete Fourier Transforms

Routines in this module:

fft(a, n=None, axis=-1, norm="backward")

ifft(a, n=None, axis=-1, norm="backward")

rfft(a, n=None, axis=-1, norm="backward")

irfft(a, n=None, axis=-1, norm="backward")

hfft(a, n=None, axis=-1, norm="backward")

ihfft(a, n=None, axis=-1, norm="backward")

fftn(a, s=None, axes=None, norm="backward")

ifftn(a, s=None, axes=None, norm="backward")

rfftn(a, s=None, axes=None, norm="backward")

irfftn(a, s=None, axes=None, norm="backward")

fft2(a, s=None, axes=(-2,-1), norm="backward")

ifft2(a, s=None, axes=(-2, -1), norm="backward")

rfft2(a, s=None, axes=(-2,-1), norm="backward")

irfft2(a, s=None, axes=(-2, -1), norm="backward")

i = inverse transform

r = transform of purely real data

h = Hermite transform

n = n-dimensional transform

2 = 2-dimensional transform

(Note: 2D routines are just nD routines with different default

behavior.)

"""

__all__ = [ 'fft' , 'ifft' , 'rfft' , 'irfft' , 'hfft' , 'ihfft' , 'rfftn' ,

'irfftn' , 'rfft2' , 'irfft2' , 'fft2' , 'ifft2' , 'fftn' , 'ifftn' ]

import functools

import warnings

from numpy . lib . array_utils import normalize_axis_index

from numpy . _core import ( asarray , empty_like , result_type ,

conjugate , take , sqrt , reciprocal )

from . import _pocketfft_umath as pfu

from numpy . _core import overrides

array_function_dispatch = functools . partial (

overrides . array_function_dispatch , module = 'numpy.fft' )

# `inv_norm` is a float by which the result of the transform needs to be

# divided. This replaces the original, more intuitive 'fct` parameter to avoid

# divisions by zero (or alternatively additional checks) in the case of

# zero-length axes during its computation.

def _raw_fft ( a , n , axis , is_real , is_forward , norm , out = None ):

if n < 1 :

raise ValueError ( f"Invalid number of FFT data points ( { n } ) specified." )

# Calculate the normalization factor, passing in the array dtype to

# avoid precision loss in the possible sqrt or reciprocal.

if not is_forward :

norm = _swap_direction ( norm )

real_dtype = result_type ( a . real . dtype , 1.0 )

if norm is None or norm == "backward" :

fct = 1

elif norm == "ortho" :

fct = reciprocal ( sqrt ( n , dtype = real_dtype ))

elif norm == "forward" :

fct = reciprocal ( n , dtype = real_dtype )

else :

raise ValueError ( f'Invalid norm value { norm } ; should be "backward",'

'"ortho" or "forward".' )

n_out = n

if is_real :

if is_forward :

ufunc = pfu . rfft_n_even if n % 2 == 0 else pfu . rfft_n_odd

n_out = n // 2 + 1

else :

ufunc = pfu . irfft

else :

ufunc = pfu . fft if is_forward else pfu . ifft

axis = normalize_axis_index ( axis , a . ndim )

if out is None :

if is_real and not is_forward : # irfft, complex in, real output.

out_dtype = real_dtype

else : # Others, complex output.

out_dtype = result_type ( a . dtype , 1j )

out = empty_like ( a , shape = a . shape [: axis ] + ( n_out ,) + a . shape [ axis + 1 :],

dtype = out_dtype )

elif (( shape := getattr ( out , "shape" , None )) is not None

and ( len ( shape ) != a . ndim or shape [ axis ] != n_out )):

raise ValueError ( "output array has wrong shape." )

return ufunc ( a , fct , axes = [( axis ,), (), ( axis ,)], out = out )

_SWAP_DIRECTION_MAP = { "backward" : "forward" , None : "forward" ,

"ortho" : "ortho" , "forward" : "backward" }

def _swap_direction ( norm ):

try :

return _SWAP_DIRECTION_MAP [ norm ]

except KeyError :

raise ValueError ( f'Invalid norm value { norm } ; should be "backward", '

'"ortho" or "forward".' ) from None

def _fft_dispatcher ( a , n = None , axis = None , norm = None , out = None ):

return ( a , out )

@ array_function_dispatch ( _fft_dispatcher )

def fft ( a , n = None , axis = - 1 , norm = None , out = None ):

"""

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.

n : int, optional

Length of the transformed axis of the output.

If `n` is smaller than the length of the input, the input is cropped.

If it is larger, the input is padded with zeros. If `n` is not given,

the length of the input along the axis specified by `axis` is used.

axis : int, optional

Axis over which to compute the FFT. If not given, the last axis is

used.

norm : {"backward", "ortho", "forward"}, optional

Normalization mode (see `numpy.fft`). Default is "backward".

Indicates which direction of the forward/backward pair of transforms

is scaled and with what normalization factor.

.. versionadded:: 1.20.0

The "backward", "forward" values were added.

out : complex ndarray, optional

If provided, the result will be placed in this array. It should be

of the appropriate shape and dtype.

.. versionadded:: 2.0.0

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.

Raises

------

IndexError

If `axis` is not a valid axis of `a`.

See Also

--------

numpy.fft : for definition of the DFT and conventions used.

ifft : The inverse of `fft`.

fft2 : The two-dimensional FFT.

fftn : The *n*-dimensional FFT.

rfftn : The *n*-dimensional FFT of real input.

fftfreq : Frequency bins for given FFT parameters.

Notes

-----

FFT (Fast Fourier Transform) refers to a way the discrete Fourier

Transform (DFT) can be calculated efficiently, by using symmetries in the

calculated terms. The symmetry is highest when `n` is a power of 2, and

the transform is therefore most efficient for these sizes.

The DFT is defined, with the conventions used in this implementation, in

the documentation for the `numpy.fft` module.

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.

Examples

--------

>>> import numpy as np

>>> np.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8))

array([-2.33486982e-16+1.14423775e-17j, 8.00000000e+00-1.25557246e-15j,

2.33486982e-16+2.33486982e-16j, 0.00000000e+00+1.22464680e-16j,

-1.14423775e-17+2.33486982e-16j, 0.00000000e+00+5.20784380e-16j,

1.14423775e-17+1.14423775e-17j, 0.00000000e+00+1.22464680e-16j])

In this example, real input has an FFT which is Hermitian, i.e., symmetric

in the real part and anti-symmetric in the imaginary part, as described in

the `numpy.fft` documentation:

>>> import matplotlib.pyplot as plt

>>> t = np.arange(256)

>>> sp = np.fft.fft(np.sin(t))

>>> freq = np.fft.fftfreq(t.shape[-1])

>>> plt.plot(freq, sp.real, freq, sp.imag)

[<matplotlib.lines.Line2D object at 0x...>, <matplotlib.lines.Line2D object at 0x...>]

>>> plt.show()

"""

a = asarray ( a )

if n is None :

n = a . shape [ axis ]

output = _raw_fft ( a , n , axis , False , True , norm , out )

return output

@ array_function_dispatch ( _fft_dispatcher )

def ifft ( a , n = None , axis = - 1 , norm = None , out = None ):

"""

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

* ``a[0]`` should contain the zero frequency term,

* ``a[1:n//2]`` should contain the positive-frequency terms,

* ``a[n//2 + 1:]`` should contain the negative-frequency terms, in

increasing order starting from the most negative frequency.

For an even number of input points, ``A[n//2]`` represents the sum of

the values at the positive and negative Nyquist frequencies, as the two

are aliased together. See `numpy.fft` for details.

Parameters

----------

a : array_like

Input array, can be complex.

n : int, optional

Length of the transformed axis of the output.

If `n` is smaller than the length of the input, the input is cropped.

If it is larger, the input is padded with zeros. If `n` is not given,

the length of the input along the axis specified by `axis` is used.

See notes about padding issues.

axis : int, optional

Axis over which to compute the inverse DFT. If not given, the last

axis is used.

norm : {"backward", "ortho", "forward"}, optional

Normalization mode (see `numpy.fft`). Default is "backward".

Indicates which direction of the forward/backward pair of transforms

is scaled and with what normalization factor.

.. versionadded:: 1.20.0

The "backward", "forward" values were added.

out : complex ndarray, optional

If provided, the result will be placed in this array. It should be

of the appropriate shape and dtype.

.. versionadded:: 2.0.0

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.

Raises

------

IndexError

If `axis` is not a valid axis of `a`.

See Also

--------

numpy.fft : An introduction, with definitions and general explanations.

fft : The one-dimensional (forward) FFT, of which `ifft` is the inverse

ifft2 : The two-dimensional inverse FFT.

ifftn : The n-dimensional inverse FFT.

Notes

-----

If the input parameter `n` is larger than the size of the input, the input

is padded by appending zeros at the end. Even though this is the common

approach, it might lead to surprising results. If a different padding is

desired, it must be performed before calling `ifft`.

Examples

--------

>>> import numpy as np

>>> np.fft.ifft([0, 4, 0, 0])

array([ 1.+0.j, 0.+1.j, -1.+0.j, 0.-1.j]) # may vary

Create and plot a band-limited signal with random phases:

>>> import matplotlib.pyplot as plt

>>> t = np.arange(400)

>>> n = np.zeros((400,), dtype=complex)

>>> n[40:60] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20,)))

>>> s = np.fft.ifft(n)

>>> plt.plot(t, s.real, label='real')

[<matplotlib.lines.Line2D object at ...>]

>>> plt.plot(t, s.imag, '--', label='imaginary')

[<matplotlib.lines.Line2D object at ...>]

>>> plt.legend()

<matplotlib.legend.Legend object at ...>

>>> plt.show()

"""

a = asarray ( a )

if n is None :

n = a . shape [ axis ]

output = _raw_fft ( a , n , axis , False , False , norm , out = out )

return output

@ array_function_dispatch ( _fft_dispatcher )

def rfft ( a , n = None , axis = - 1 , norm = None , out = None ):

"""

Compute the one-dimensional discrete Fourier Transform for real input.

This function computes the one-dimensional *n*-point discrete Fourier

Transform (DFT) of a real-valued array by means of an efficient algorithm

called the Fast Fourier Transform (FFT).

Parameters

----------

a : array_like

Input array

n : int, optional

Number of points along transformation axis in the input to use.

If `n` is smaller than the length of the input, the input is cropped.

If it is larger, the input is padded with zeros. If `n` is not given,

the length of the input along the axis specified by `axis` is used.

axis : int, optional

Axis over which to compute the FFT. If not given, the last axis is

used.

norm : {"backward", "ortho", "forward"}, optional

Normalization mode (see `numpy.fft`). Default is "backward".

Indicates which direction of the forward/backward pair of transforms

is scaled and with what normalization factor.

.. versionadded:: 1.20.0

The "backward", "forward" values were added.

out : complex ndarray, optional

If provided, the result will be placed in this array. It should be

of the appropriate shape and dtype.

.. versionadded:: 2.0.0

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.

If `n` is even, the length of the transformed axis is ``(n/2)+1``.

If `n` is odd, the length is ``(n+1)/2``.

Raises

------

IndexError

If `axis` is not a valid axis of `a`.

See Also

--------

numpy.fft : For definition of the DFT and conventions used.

irfft : The inverse of `rfft`.

fft : The one-dimensional FFT of general (complex) input.

fftn : The *n*-dimensional FFT.

rfftn : The *n*-dimensional FFT of real input.

Notes

-----

When the DFT is computed for purely real input, the output is

Hermitian-symmetric, i.e. the negative frequency terms are just the complex

conjugates of the corresponding positive-frequency terms, and the

negative-frequency terms are therefore redundant. This function does not

compute the negative frequency terms, and the length of the transformed

axis of the output is therefore ``n//2 + 1``.

When ``A = rfft(a)`` and fs is the sampling frequency, ``A[0]`` contains

the zero-frequency term 0*fs, which is real due to Hermitian symmetry.

If `n` is even, ``A[-1]`` contains the term representing both positive

and negative Nyquist frequency (+fs/2 and -fs/2), and must also be purely

real. If `n` is odd, there is no term at fs/2; ``A[-1]`` contains

the largest positive frequency (fs/2*(n-1)/n), and is complex in the

general case.

If the input `a` contains an imaginary part, it is silently discarded.

Examples

--------

>>> import numpy as np

>>> np.fft.fft([0, 1, 0, 0])

array([ 1.+0.j, 0.-1.j, -1.+0.j, 0.+1.j]) # may vary

>>> np.fft.rfft([0, 1, 0, 0])

array([ 1.+0.j, 0.-1.j, -1.+0.j]) # may vary

Notice how the final element of the `fft` output is the complex conjugate

of the second element, for real input. For `rfft`, this symmetry is

exploited to compute only the non-negative frequency terms.

"""

a = asarray ( a )

if n is None :

n = a . shape [ axis ]

output = _raw_fft ( a , n , axis , True , True , norm , out = out )

return output

@ array_function_dispatch ( _fft_dispatcher )

def irfft ( a , n = None , axis = - 1 , norm = None , out = None ):

"""

Computes the inverse of `rfft`.

This function computes the inverse of the one-dimensional *n*-point

discrete Fourier Transform of real input computed by `rfft`.

In other words, ``irfft(rfft(a), len(a)) == a`` to within numerical

accuracy. (See Notes below for why ``len(a)`` is necessary here.)

The input is expected to be in the form returned by `rfft`, i.e. the

real zero-frequency term followed by the complex positive frequency terms

in order of increasing frequency. Since the discrete Fourier Transform of

real input is Hermitian-symmetric, the negative frequency terms are taken

to be the complex conjugates of the corresponding positive frequency terms.

Parameters

----------

a : array_like

The input array.

n : int, optional

Length of the transformed axis of the output.

For `n` output points, ``n//2+1`` input points are necessary. If the

input is longer than this, it is cropped. If it is shorter than this,

it is padded with zeros. If `n` is not given, it is taken to be

``2*(m-1)`` where ``m`` is the length of the input along the axis

specified by `axis`.

axis : int, optional

Axis over which to compute the inverse FFT. If not given, the last

axis is used.

norm : {"backward", "ortho", "forward"}, optional

Normalization mode (see `numpy.fft`). Default is "backward".

Indicates which direction of the forward/backward pair of transforms

is scaled and with what normalization factor.

.. versionadded:: 1.20.0

The "backward", "forward" values were added.

out : ndarray, optional

If provided, the result will be placed in this array. It should be

of the appropriate shape and dtype.

.. versionadded:: 2.0.0

Returns

-------

out : ndarray

The truncated or zero-padded input, transformed along the axis

indicated by `axis`, or the last one if `axis` is not specified.

The length of the transformed axis is `n`, or, if `n` is not given,

``2*(m-1)`` where ``m`` is the length of the transformed axis of the

input. To get an odd number of output points, `n` must be specified.

Raises

------

IndexError

If `axis` is not a valid axis of `a`.

See Also

--------

numpy.fft : For definition of the DFT and conventions used.

rfft : The one-dimensional FFT of real input, of which `irfft` is inverse.

fft : The one-dimensional FFT.

irfft2 : The inverse of the two-dimensional FFT of real input.

irfftn : The inverse of the *n*-dimensional FFT of real input.

Notes

-----

Returns the real valued `n`-point inverse discrete Fourier transform

of `a`, where `a` contains the non-negative frequency terms of a

Hermitian-symmetric sequence. `n` is the length of the result, not the

input.

If you specify an `n` such that `a` must be zero-padded or truncated, the

extra/removed values will be added/removed at high frequencies. One can

thus resample a series to `m` points via Fourier interpolation by:

``a_resamp = irfft(rfft(a), m)``.

The correct interpretation of the hermitian input depends on the length of

the original data, as given by `n`. This is because each input shape could

correspond to either an odd or even length signal. By default, `irfft`

assumes an even output length which puts the last entry at the Nyquist

frequency; aliasing with its symmetric counterpart. By Hermitian symmetry,

the value is thus treated as purely real. To avoid losing information, the

correct length of the real input **must** be given.

Examples

--------

>>> import numpy as np

>>> np.fft.ifft([1, -1j, -1, 1j])

array([0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]) # may vary

>>> np.fft.irfft([1, -1j, -1])

array([0., 1., 0., 0.])

Notice how the last term in the input to the ordinary `ifft` is the

complex conjugate of the second term, and the output has zero imaginary

part everywhere. When calling `irfft`, the negative frequencies are not

specified, and the output array is purely real.

"""

a = asarray ( a )

if n is None :

n = ( a . shape [ axis ] - 1 ) * 2

output = _raw_fft ( a , n , axis , True , False , norm , out = out )

return output

@ array_function_dispatch ( _fft_dispatcher )

def hfft ( a , n = None , axis = - 1 , norm = None , out = None ):

"""

Compute the FFT of a signal that has Hermitian symmetry, i.e., a real

spectrum.

Parameters

----------

a : array_like

The input array.

n : int, optional

Length of the transformed axis of the output. For `n` output

points, ``n//2 + 1`` input points are necessary. If the input is

longer than this, it is cropped. If it is shorter than this, it is

padded with zeros. If `n` is not given, it is taken to be ``2*(m-1)``

where ``m`` is the length of the input along the axis specified by

`axis`.

axis : int, optional

Axis over which to compute the FFT. If not given, the last

axis is used.

norm : {"backward", "ortho", "forward"}, optional

Normalization mode (see `numpy.fft`). Default is "backward".

Indicates which direction of the forward/backward pair of transforms

is scaled and with what normalization factor.

.. versionadded:: 1.20.0

The "backward", "forward" values were added.

out : ndarray, optional

If provided, the result will be placed in this array. It should be

of the appropriate shape and dtype.

.. versionadded:: 2.0.0

Returns

-------

out : ndarray

The truncated or zero-padded input, transformed along the axis

indicated by `axis`, or the last one if `axis` is not specified.

The length of the transformed axis is `n`, or, if `n` is not given,

``2*m - 2`` where ``m`` is the length of the transformed axis of

the input. To get an odd number of output points, `n` must be

specified, for instance as ``2*m - 1`` in the typical case,

Raises

------

IndexError

If `axis` is not a valid axis of `a`.

See Also

--------

numpy.fft : Overall view of discrete Fourier transforms, with definitions

and conventions used.

ifftn : The inverse of `fftn`, the inverse *n*-dimensional FFT.

fft : The one-dimensional FFT, with definitions and conventions used.

rfftn : The *n*-dimensional FFT of real input.

fft2 : The two-dimensional FFT.

fftshift : Shifts zero-frequency terms to centre of array

Notes

-----

The output, analogously to `fft`, contains the term for zero frequency in

the low-order corner of all axes, the positive frequency terms in the

first half of all axes, the term for the Nyquist frequency in the middle

of all axes and the negative frequency terms in the second half of all

axes, in order of decreasingly negative frequency.

See `numpy.fft` for details, definitions and conventions used.

Examples

--------

>>> import numpy as np

>>> a = np.mgrid[:3, :3, :3][0]

>>> np.fft.fftn(a, axes=(1, 2))

array([[[ 0.+0.j, 0.+0.j, 0.+0.j], # may vary

[ 0.+0.j, 0.+0.j, 0.+0.j],

[ 0.+0.j, 0.+0.j, 0.+0.j]],

[[ 9.+0.j, 0.+0.j, 0.+0.j],

[ 0.+0.j, 0.+0.j, 0.+0.j],

[ 0.+0.j, 0.+0.j, 0.+0.j]],

[[18.+0.j, 0.+0.j, 0.+0.j],

[ 0.+0.j, 0.+0.j, 0.+0.j],

[ 0.+0.j, 0.+0.j, 0.+0.j]]])

>>> np.fft.fftn(a, (2, 2), axes=(0, 1))

array([[[ 2.+0.j, 2.+0.j, 2.+0.j], # may vary

[ 0.+0.j, 0.+0.j, 0.+0.j]],

[[-2.+0.j, -2.+0.j, -2.+0.j],

[ 0.+0.j, 0.+0.j, 0.+0.j]]])

>>> import matplotlib.pyplot as plt

>>> [X, Y] = np.meshgrid(2 * np.pi * np.arange(200) / 12,

... 2 * np.pi * np.arange(200) / 34)

>>> S = np.sin(X) + np.cos(Y) + np.random.uniform(0, 1, X.shape)

>>> FS = np.fft.fftn(S)

>>> plt.imshow(np.log(np.abs(np.fft.fftshift(FS))**2))

<matplotlib.image.AxesImage object at 0x...>

>>> plt.show()

"""

return _raw_fftnd ( a , s , axes , fft , norm , out = out )

@ array_function_dispatch ( _fftn_dispatcher )

def ifftn ( a , s = None , axes = None , norm = None , out = None ):

"""

Compute the N-dimensional inverse discrete Fourier Transform.

This function computes the inverse of the N-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,

``ifftn(fftn(a)) == a`` to within numerical accuracy.

For a description of the definitions and conventions used, see `numpy.fft`.

The input, analogously to `ifft`, should be ordered in the same way as is

returned by `fftn`, i.e. it should have the term for zero frequency

in all axes in the low-order corner, the positive frequency terms in the

first half of all axes, the term for the Nyquist frequency in the middle

of all axes and the negative frequency terms in the second half of all

axes, in order of decreasingly negative frequency.

Parameters

----------

a : array_like

Input array, can be complex.

s : sequence of ints, optional

Shape (length of each transformed axis) of the output

(``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).

This corresponds to ``n`` for ``ifft(x, n)``.

Along any axis, if the given shape is smaller than that of the input,

the input is cropped. If it is larger, the input is padded with zeros.

.. versionchanged:: 2.0

If it is ``-1``, the whole input is used (no padding/trimming).

If `s` is not given, the shape of the input along the axes specified

by `axes` is used. See notes for issue on `ifft` zero padding.

.. deprecated:: 2.0

If `s` is not ``None``, `axes` must not be ``None`` either.

.. deprecated:: 2.0

`s` must contain only ``int`` s, not ``None`` values. ``None``

values currently mean that the default value for ``n`` is used

in the corresponding 1-D transform, but this behaviour is

deprecated.

axes : sequence of ints, optional

Axes over which to compute the IFFT. If not given, the last ``len(s)``

axes are used, or all axes if `s` is also not specified.

Repeated indices in `axes` means that the inverse transform over that

axis is performed multiple times.

.. deprecated:: 2.0

If `s` is specified, the corresponding `axes` to be transformed

must be explicitly specified too.

norm : {"backward", "ortho", "forward"}, optional

Normalization mode (see `numpy.fft`). Default is "backward".

Indicates which direction of the forward/backward pair of transforms

is scaled and with what normalization factor.

.. versionadded:: 1.20.0

The "backward", "forward" values were added.

out : complex ndarray, optional

If provided, the result will be placed in this array. It should be

of the appropriate shape and dtype for all axes (and hence is

incompatible with passing in all but the trivial ``s``).

.. versionadded:: 2.0.0

Returns

-------

out : complex ndarray

The truncated or zero-padded input, transformed along the axes

indicated by `axes`, or by a combination of `s` or `a`,

as explained in the parameters section above.

Raises

------

ValueError

If `s` and `axes` have different length.

IndexError

If an element of `axes` is larger than than the number of axes of `a`.

See Also

--------

numpy.fft : Overall view of discrete Fourier transforms, with definitions

and conventions used.

fftn : The forward *n*-dimensional FFT, of which `ifftn` is the inverse.

ifft : The one-dimensional inverse FFT.

ifft2 : The two-dimensional inverse FFT.

ifftshift : Undoes `fftshift`, shifts zero-frequency terms to beginning

of array.

Notes

-----

See `numpy.fft` for definitions and conventions used.

Zero-padding, analogously with `ifft`, is performed by appending zeros to

the input along the specified dimension. Although this is the common

approach, it might lead to surprising results. If another form of zero

padding is desired, it must be performed before `ifftn` is called.

Examples

--------

>>> import numpy as np

>>> a = np.eye(4)

>>> np.fft.ifftn(np.fft.fftn(a, axes=(0,)), axes=(1,))

array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], # may vary

[0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],

[0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],

[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])

Create and plot an image with band-limited frequency content:

View remainder of file in raw view

_pocketfft.py

Latest commit

History

_pocketfft.py

File metadata and controls