pyfftw_call

odl.trafos.backends.pyfftw_bindings.pyfftw_call(array_in, array_out, direction='forward', axes=None, halfcomplex=False, **kwargs)

Calculate the DFT with pyfftw.

The discrete Fourier (forward) transform calcuates the sum:

f_hat[k] = sum_j( f[j] * exp(-2*pi*1j * j*k/N) )

where the summation is taken over all indices j = (j[0], ..., j[d-1]) in the range 0 <= j < N (component-wise), with N being the shape of the input array.

The output indices k lie in the same range, except for half-complex transforms, where the last axis i in axes is shortened to 0 <= k[i] < floor(N[i]/2) + 1.

In the backward transform, sign of the the exponential argument is flipped.

Parameters:

array_innumpy.ndarray

Array to be transformed

array_outnumpy.ndarray

Output array storing the transformed values, may be aliased with array_in.

direction{'forward', 'backward'}, optional

Direction of the transform

axesint or sequence of ints, optional

Dimensions along which to take the transform. None means using all axes and is equivalent to np.arange(ndim).

halfcomplexbool, optional

If True, calculate only the negative frequency part along the last axis. If False, calculate the full complex FFT. This option can only be used with real input data.

Returns:

fftw_planpyfftw.FFTW

The plan object created from the input arguments. It can be reused for transforms of the same size with the same data types. Note that reuse only gives a speedup if the initial plan used a planner flag other than 'estimate'. If fftw_plan was specified, the returned object is a reference to it.

Other Parameters:

fftw_planpyfftw.FFTW, optional

Use this plan instead of calculating a new one. If specified, the options planning_effort, planning_timelimit and threads have no effect.

planning_effortstr, optional

Flag for the amount of effort put into finding an optimal FFTW plan. See the FFTW doc on planner flags. Available options: {'estimate', 'measure', 'patient', 'exhaustive'} Default: 'estimate'

planning_timelimitfloat or None, optional

Limit planning time to roughly this many seconds. Default: None (no limit)

threadsint, optional

Number of threads to use. Default: Number of CPUs if the number of data points is larger than 4096, else 1.

normalise_idftbool, optional

If True, the result of the backward transform is divided by 1 / N, where N is the total number of points in array_in[axes]. This ensures that the IDFT is the true inverse of the forward DFT. Default: False

import_wisdomfilename or file handle, optional

File to load FFTW wisdom from. If the file does not exist, it is ignored.

export_wisdomfilename or file handle, optional

File to append the accumulated FFTW wisdom to

Notes

• The planning and direction flags can also be specified as capitalized and prepended by 'FFTW_', i.e. in the original FFTW form.

• For a halfcomplex forward transform, the arrays must fulfill array_out.shape[axes[-1]] == array_in.shape[axes[-1]] // 2 + 1, and vice versa for backward transforms.

• All planning schemes except 'estimate' require an internal copy of the input array but are often several times faster after the first call (measuring results are cached). Typically, 'measure' is a good compromise. If you cannot afford the copy, use 'estimate'.

• If a plan is provided via the fftw_plan parameter, no copy is needed internally.