FourierTransform¶

class
odl.trafos.fourier.
FourierTransform
(*args, **kwargs)[source]¶ Bases:
odl.trafos.fourier.FourierTransformBase
Discretized Fourier transform between discrete L^p spaces.
This operator is the discretized variant of the continuous Fourier Transform between Lebesgue L^p spaces. It applies a threestep procedure consisting of a preprocessing step of the data, an FFT evaluation and a postprocessing step. Pre and postprocessing account for the shift and scaling of the realspace and Fourierspace grids.
The sign convention (‘‘ vs. ‘+’) can be changed with the
sign
parameter.See also
 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
The inverse Fourier transform.
is_functional
True
if this operator’s range is aField
.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, domain, range=None, impl=None, \*\*kwargs)[source]¶ Initialize a new instance.
 Parameters
 domain
DiscretizedSpace
Domain of the Fourier transform. If the
DiscretizedSpace.exponent
ofdomain
andrange
are equal to 2.0, this operator has an adjoint which is equal to its inverse. range
DiscretizedSpace
, optional Range of the Fourier transform. If not given, the range is determined from
domain
and the other parameters. The exponent is chosen to be the conjugatep / (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. IfFalse
, calculate the full complex FFT. For complexdomain
, 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 asaxes
if supplied. Note that this must be set toTrue
in the halved axis in halfcomplex transforms. Default:True
 domain
 Other Parameters
 tmp_r
DiscretizedSpaceElement
ornumpy.ndarray
, optional Temporary for calculations in the real space (domain of this transform). It is shared with the inverse.
Variants using this: R2C, R2HC, C2R (inverse)
 tmp_f
DiscretizedSpaceElement
ornumpy.ndarray
, optional Temporary for calculations in the frequency (reciprocal) space. It is shared with the inverse.
Variants using this: R2C, C2R (inverse), HC2R (inverse)
 tmp_r
Notes
The transform variants are:
C2C: complextocomplex. The default variant, onetoone and unitary.
R2C: realtocomplex. This variants adjoint and inverse may suffer from information loss since the result is cast to real.
R2HC: realtohalfcomplex. This variant stores only a halfspace of frequencies and is guaranteed to be onetoone (invertible).
The
Operator.range
of this operator always has theComplexNumbers
asLinearSpace.field
, i.e. if the field ofdomain
is theRealNumbers
, 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.