FourierTransformInverse

class odl.trafos.fourier.FourierTransformInverse(*args, **kwargs)

Bases: odl.trafos.fourier.FourierTransformBase

Inverse of the discretized Fourier transform between L^p spaces.

This operator is the exact inverse of the FourierTransform, and not a discretization of the Fourier integral with “+” sign in the complex exponent. For the latter, use the sign parameter of the forward transform.

See also

FourierTransform

DiscreteFourierTransformInverse

Attributes

adjoint

Adjoint transform, equal to the inverse.

axes

Axes along the FT is calculated by this operator.

domain

Set of objects on which this operator can be evaluated.

halfcomplex

Return True if the last transform axis is halved.

impl

Backend for the FFT implementation.

inverse

Inverse of the inverse, the forward FT.

is_functional

True if this operator’s range is a Field.

is_linear

True if this operator is linear.

range

Set in which the result of an evaluation of this operator lies.

shifts

Return the boolean list indicating shifting per axis.

sign

Sign of the complex exponent in the transform.

Methods

_call(self, x, out, \*\*kwargs)	Implement self(x, out[, **kwargs]).
clear_fftw_plan(self)	Delete the FFTW plan of this transform.
clear_temporaries(self)	Set the temporaries to None.
create_temporaries(self[, r, f])	Allocate and store reusable temporaries.
derivative(self, point)	Return the operator derivative at point.
init_fftw_plan(self[, planning_effort])	Initialize the FFTW plan for this transform for later use.
norm(self[, estimate])	Return the operator norm of this operator.

__init__(self, range, domain=None, impl=None, \*\*kwargs)

Parameters

rangeDiscretizedSpace

Range of the inverse Fourier transform. If the DiscretizedSpace.exponent of domain and range are equal to 2.0, this operator has an adjoint which is equal to its inverse.

domainDiscretizedSpace, optional

Domain of the inverse Fourier transform. If not given, the domain is determined from range and the other parameters. The exponent is chosen to be the conjugate p / (p - 1), which reads as ‘inf’ for p=1 and 1 for p=’inf’.

impl{‘numpy’, ‘pyfftw’}, optional

Backend for the FFT implementation. The ‘pyfftw’ backend is faster but requires the pyfftw package. None selects the fastest available backend.

axesint or sequence of ints, optional

Dimensions along which to take the transform. Default: all axes

sign{‘-‘, ‘+’}, optional

Sign of the complex exponent. Default: '+'

halfcomplexbool, optional

If True, calculate only the negative frequency part along the last axis for real input. If False, calculate the full complex FFT. For complex domain, it has no effect. Default: True

shiftbool or sequence of bools, optional

If True, the reciprocal grid is shifted by half a stride in the negative direction. With a boolean sequence, this option is applied separately to each axis. If a sequence is provided, it must have the same length as axes if supplied. Note that this must be set to True in the halved axis in half-complex transforms. Default: True

Other Parameters

tmp_rDiscretizedSpaceElement or numpy.ndarray, optional

Temporary for calculations in the real space (range of this transform). It is shared with the inverse.

Variants using this: C2R, R2C (forward), R2HC (forward)

tmp_fDiscretizedSpaceElement or numpy.ndarray, optional

Temporary for calculations in the frequency (reciprocal) space. It is shared with the inverse.

Variants using this: C2R, HC2R, R2C (forward)

Notes

• The transform variants are:

  • C2C: complex-to-complex. The default variant, one-to-one and unitary.

  • C2R: complex-to-real. This variants adjoint and inverse may suffer from information loss since the result is cast to real.

  • HC2R: halfcomplex-to-real. This variant interprets input as a signal on a half-space of frequencies. It is guaranteed to be one-to-one (invertible).

• The Operator.range of this operator always has the ComplexNumbers as LinearSpace.field, i.e. if the field of domain is the RealNumbers, this operator’s adjoint is defined by identifying real and imaginary parts with the components of a real product space element. See the mathematical background documentation for details.