# `dask.fft` interface

This module implements those functions that replace aspects of the `dask.fft` module. This module provides the entire documented namespace of `dask.fft`, but those functions that are not included here are imported directly from `dask.fft`.

It is notable that unlike `numpy.fftpack`, which `dask.fft` wraps, these functions will generally return an output array with the same precision as the input array, and the transform that is chosen is chosen based on the precision of the input array. That is, if the input array is 32-bit floating point, then the transform will be 32-bit floating point and so will the returned array. Half precision input will be converted to single precision. Otherwise, if any type conversion is required, the default will be double precision.

The exceptions raised by each of these functions are mostly as per their equivalents in `dask.fft`, though there are some corner cases in which this may not be true.

`pyfftw.interfaces.dask_fft.``fft`(a, n=None, axis=None)

  Wrapping of pyfftw.interfaces.numpy_fft.fft

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.fft docstring follows below:

  Perform a 1D FFT.

  The first four arguments are as per `numpy.fft.fft()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``ifft`(a, n=None, axis=None)

  Wrapping of pyfftw.interfaces.numpy_fft.ifft

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.ifft docstring follows below:

  Perform a 1D inverse FFT.

  The first four arguments are as per `numpy.fft.ifft()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``fft2`(a, s=None, axes=None)

  Wrapping of pyfftw.interfaces.numpy_fft.fft2

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.fft2 docstring follows below:

  Perform a 2D FFT.

  The first four arguments are as per `numpy.fft.fft2()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``ifft2`(a, s=None, axes=None)

  Wrapping of pyfftw.interfaces.numpy_fft.ifft2

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.ifft2 docstring follows below:

  Perform a 2D inverse FFT.

  The first four arguments are as per `numpy.fft.ifft2()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``fftn`(a, s=None, axes=None)

  Wrapping of pyfftw.interfaces.numpy_fft.fftn

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.fftn docstring follows below:

  Perform an n-D FFT.

  The first four arguments are as per `numpy.fft.fftn()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``ifftn`(a, s=None, axes=None)

  Wrapping of pyfftw.interfaces.numpy_fft.ifftn

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.ifftn docstring follows below:

  Perform an n-D inverse FFT.

  The first four arguments are as per `numpy.fft.ifftn()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``rfft`(a, n=None, axis=None)

  Wrapping of pyfftw.interfaces.numpy_fft.rfft

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.rfft docstring follows below:

  Perform a 1D real FFT.

  The first four arguments are as per `numpy.fft.rfft()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``irfft`(a, n=None, axis=None)

  Wrapping of pyfftw.interfaces.numpy_fft.irfft

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.irfft docstring follows below:

  Perform a 1D real inverse FFT.

  The first four arguments are as per `numpy.fft.irfft()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``rfft2`(a, s=None, axes=None)

  Wrapping of pyfftw.interfaces.numpy_fft.rfft2

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.rfft2 docstring follows below:

  Perform a 2D real FFT.

  The first four arguments are as per `numpy.fft.rfft2()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``irfft2`(a, s=None, axes=None)

  Wrapping of pyfftw.interfaces.numpy_fft.irfft2

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.irfft2 docstring follows below:

  Perform a 2D real inverse FFT.

  The first four arguments are as per `numpy.fft.irfft2()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``rfftn`(a, s=None, axes=None)

  Wrapping of pyfftw.interfaces.numpy_fft.rfftn

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.rfftn docstring follows below:

  Perform an n-D real FFT.

  The first four arguments are as per `numpy.fft.rfftn()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``irfftn`(a, s=None, axes=None)

  Wrapping of pyfftw.interfaces.numpy_fft.irfftn

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.irfftn docstring follows below:

  Perform an n-D real inverse FFT.

  The first four arguments are as per `numpy.fft.rfftn()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``hfft`(a, n=None, axis=None)

  Wrapping of pyfftw.interfaces.numpy_fft.hfft

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.hfft docstring follows below:

  Perform a 1D FFT of a signal with hermitian symmetry. This yields a real output spectrum. See `numpy.fft.hfft()` for more information.

  The first four arguments are as per `numpy.fft.hfft()`; the rest of the arguments are documented in the additional arguments docs.

`pyfftw.interfaces.dask_fft.``ihfft`(a, n=None, axis=None)

  Wrapping of pyfftw.interfaces.numpy_fft.ihfft

  The axis along which the FFT is applied must have a one chunk. To change the array’s chunking use dask.Array.rechunk.

  The pyfftw.interfaces.numpy_fft.ihfft docstring follows below:

  Perform a 1D inverse FFT of a real-spectrum, yielding a signal with hermitian symmetry. See `numpy.fft.ihfft()` for more information.

  The first four arguments are as per `numpy.fft.ihfft()`; the rest of the arguments are documented in the additional arguments docs.