def test_fourier_trafo_range(exponent, odl_floating_dtype):
# Check if the range is initialized correctly. Encompasses the init test
dtype = odl_floating_dtype
# Testing R2C for real dtype, else C2C
# 1D
shape = 10
space_discr = odl.uniform_discr(0,
1,
shape,
exponent=exponent,
impl='numpy',
dtype=dtype)
dft = FourierTransform(space_discr, halfcomplex=True, shift=True)
assert dft.range.field == odl.ComplexNumbers()
halfcomplex = True if is_real_dtype(dtype) else False
assert dft.range.grid == reciprocal_grid(dft.domain.grid,
halfcomplex=halfcomplex,
shift=True)
assert dft.range.exponent == conj_exponent(exponent)
# 3D
shape = (3, 4, 5)
space_discr = odl.uniform_discr([0] * 3, [1] * 3,
shape,
exponent=exponent,
impl='numpy',
dtype=dtype)
dft = FourierTransform(space_discr, halfcomplex=True, shift=True)
assert dft.range.field == odl.ComplexNumbers()
halfcomplex = True if is_real_dtype(dtype) else False
assert dft.range.grid == reciprocal_grid(dft.domain.grid,
halfcomplex=halfcomplex,
shift=True)
assert dft.range.exponent == conj_exponent(exponent)
# shift must be True in the last axis
if halfcomplex:
with pytest.raises(ValueError):
FourierTransform(space_discr, shift=(True, True, False))
if exponent != 2.0:
with pytest.raises(NotImplementedError):
dft.adjoint
with pytest.raises(TypeError):
FourierTransform(dft.domain.partition)
def inner(self, x1, x2):
"""Calculate the array-weighted inner product of two elements.
Parameters
----------
x1, x2 : `ProductSpaceElement`
Elements whose inner product is calculated.
Returns
-------
inner : float or complex
The inner product of the two provided elements.
"""
if self.exponent != 2.0:
raise NotImplementedError('no inner product defined for '
'exponent != 2 (got {})'
''.format(self.exponent))
inners = np.fromiter((x1i.inner(x2i) for x1i, x2i in zip(x1, x2)),
dtype=x1[0].space.dtype,
count=len(x1))
inner = np.dot(inners, self.array)
if is_real_dtype(x1[0].dtype):
return float(inner)
else:
return complex(inner)
def test_resize_array_adj(resize_setup, odl_floating_dtype):
dtype = odl_floating_dtype
pad_mode, pad_const, newshp, offset, array, _ = resize_setup
if pad_const != 0:
# Not well-defined
return
array = np.array(array, dtype=dtype)
if is_real_dtype(dtype):
other_arr = np.random.uniform(-10, 10, size=newshp)
else:
other_arr = (np.random.uniform(-10, 10, size=newshp) +
1j * np.random.uniform(-10, 10, size=newshp))
resized = resize_array(array,
newshp,
offset,
pad_mode,
pad_const,
direction='forward')
resized_adj = resize_array(other_arr,
array.shape,
offset,
pad_mode,
pad_const,
direction='adjoint')
assert (np.vdot(resized.ravel(),
other_arr.ravel()) == pytest.approx(np.vdot(
array.ravel(), resized_adj.ravel()),
rel=dtype_tol(dtype)))
def inner(self, x1, x2):
"""Calculate the array-weighted inner product of two elements.
Parameters
----------
x1, x2 : `ProductSpaceElement`
Elements whose inner product is calculated.
Returns
-------
inner : float or complex
The inner product of the two provided elements.
"""
if self.exponent != 2.0:
raise NotImplementedError('no inner product defined for '
'exponent != 2 (got {})'
''.format(self.exponent))
inners = np.fromiter(
(x1i.inner(x2i) for x1i, x2i in zip(x1, x2)),
dtype=x1[0].space.dtype, count=len(x1))
inner = np.dot(inners, self.array)
if is_real_dtype(x1[0].dtype):
return float(inner)
else:
return complex(inner)
def _conj(self, x):
"""Function returning the complex conjugate of a result."""
x_call_oop = x._call_out_of_place
def conj_oop(x):
return np.asarray(x_call_oop(x), dtype=self.out_dtype).conj()
if is_real_dtype(self.out_dtype):
return x
else:
return self.element(conj_oop)
def _conj(self, x):
"""Function returning the complex conjugate of a result."""
x_call_oop = x._call_out_of_place
def conj_oop(x):
return np.asarray(x_call_oop(x), dtype=self.out_dtype).conj()
if is_real_dtype(self.out_dtype):
return x
else:
return self.element(conj_oop)
def _realpart(self, x):
"""Function returning the real part of a result."""
x_call_oop = x._call_out_of_place
def realpart_oop(x):
return np.asarray(x_call_oop(x), dtype=self.out_dtype).real
if is_real_dtype(self.out_dtype):
return x
else:
rdtype = real_dtype(self.out_dtype)
rspace = self.astype(rdtype)
return rspace.element(realpart_oop)
def _realpart(self, x):
"""Function returning the real part of a result."""
x_call_oop = x._call_out_of_place
def realpart_oop(x):
return np.asarray(x_call_oop(x), dtype=self.out_dtype).real
if is_real_dtype(self.out_dtype):
return x
else:
rdtype = real_dtype(self.out_dtype)
rspace = self.astype(rdtype)
return rspace.element(realpart_oop)
def _imagpart(self, x):
"""Function returning the imaginary part of a result."""
x_call_oop = x._call_out_of_place
def imagpart_oop(x):
return np.asarray(x_call_oop(x), dtype=self.out_dtype).imag
if is_real_dtype(self.out_dtype):
return self.zero()
else:
rdtype = real_dtype(self.out_dtype)
rspace = self.astype(rdtype)
return rspace.element(imagpart_oop)
def _imagpart(self, x):
"""Function returning the imaginary part of a result."""
x_call_oop = x._call_out_of_place
def imagpart_oop(x):
return np.asarray(x_call_oop(x), dtype=self.out_dtype).imag
if is_real_dtype(self.out_dtype):
return self.zero()
else:
rdtype = real_dtype(self.out_dtype)
rspace = self.astype(rdtype)
return rspace.element(imagpart_oop)
def test_fourier_trafo_range(exponent, floating_dtype):
# Check if the range is initialized correctly. Encompasses the init test
# Testing R2C for real dtype, else C2C
# 1D
shape = 10
space_discr = odl.uniform_discr(0, 1, shape, exponent=exponent, impl="numpy", dtype=floating_dtype)
dft = FourierTransform(space_discr, halfcomplex=True, shift=True)
assert dft.range.field == odl.ComplexNumbers()
halfcomplex = True if is_real_dtype(floating_dtype) else False
assert dft.range.grid == reciprocal_grid(dft.domain.grid, halfcomplex=halfcomplex, shift=True)
assert dft.range.exponent == conj_exponent(exponent)
# 3D
shape = (3, 4, 5)
space_discr = odl.uniform_discr([0] * 3, [1] * 3, shape, exponent=exponent, impl="numpy", dtype=floating_dtype)
dft = FourierTransform(space_discr, halfcomplex=True, shift=True)
assert dft.range.field == odl.ComplexNumbers()
halfcomplex = True if is_real_dtype(floating_dtype) else False
assert dft.range.grid == reciprocal_grid(dft.domain.grid, halfcomplex=halfcomplex, shift=True)
assert dft.range.exponent == conj_exponent(exponent)
# shift must be True in the last axis
if halfcomplex:
with pytest.raises(ValueError):
FourierTransform(space_discr, shift=(True, True, False))
if exponent != 2.0:
with pytest.raises(NotImplementedError):
dft.adjoint
with pytest.raises(TypeError):
FourierTransform(dft.domain.partition)
def __init__(self, shape, dtype):
"""Initialize a new instance.
Parameters
----------
shape : nonnegative int or sequence of nonnegative ints
Number of entries of type ``dtype`` per axis in this space. A
single integer results in a space with rank 1, i.e., 1 axis.
dtype :
Data type of elements in this space. Can be provided
in any way the `numpy.dtype` constructor understands, e.g.
as built-in type or as a string.
For a data type with a ``dtype.shape``, these extra dimensions
are added *to the left* of ``shape``.
"""
# Handle shape and dtype, taking care also of dtypes with shape
try:
shape, shape_in = tuple(safe_int_conv(s) for s in shape), shape
except TypeError:
shape, shape_in = (safe_int_conv(shape), ), shape
if any(s < 0 for s in shape):
raise ValueError('`shape` must have only nonnegative entries, got '
'{}'.format(shape_in))
dtype = np.dtype(dtype)
# We choose this order in contrast to Numpy, since we usually want
# to represent discretizations of vector- or tensor-valued functions,
# i.e., if dtype.shape == (3,) we expect f[0] to have shape `shape`.
self.__shape = dtype.shape + shape
self.__dtype = dtype.base
if is_real_dtype(self.dtype):
# real includes non-floating-point like integers
field = RealNumbers()
self.__real_dtype = self.dtype
self.__real_space = self
self.__complex_dtype = TYPE_MAP_R2C.get(self.dtype, None)
self.__complex_space = None # Set in first call of astype
elif is_complex_floating_dtype(self.dtype):
field = ComplexNumbers()
self.__real_dtype = TYPE_MAP_C2R[self.dtype]
self.__real_space = None # Set in first call of astype
self.__complex_dtype = self.dtype
self.__complex_space = self
else:
field = None
LinearSpace.__init__(self, field)
def __init__(self, size, dtype):
"""Initialize a new instance.
Parameters
----------
size : non-negative int
Number of entries in a tuple.
dtype :
Data type for each tuple entry. Can be provided in any
way the `numpy.dtype` function understands, most notably
as built-in type, as one of NumPy's internal datatype
objects or as string.
Only scalar data types (numbers) are allowed.
"""
NtuplesBase.__init__(self, size, dtype)
if not is_scalar_dtype(self.dtype):
raise TypeError('{!r} is not a scalar data type'.format(dtype))
if is_real_dtype(self.dtype):
field = RealNumbers()
self.__is_real = True
self.__real_dtype = self.dtype
self.__real_space = self
try:
self.__complex_dtype = complex_dtype(self.dtype)
except ValueError:
self.__complex_dtype = None
self.__complex_space = None # Set in first call of astype
else:
field = ComplexNumbers()
self.__is_real = False
try:
self.__real_dtype = real_dtype(self.dtype)
except ValueError:
self.__real_dtype = None
self.__real_space = None # Set in first call of astype
self.__complex_dtype = self.dtype
self.__complex_space = self
self.__is_floating = is_floating_dtype(self.dtype)
LinearSpace.__init__(self, field)
def __init__(self, size, dtype):
"""Initialize a new instance.
Parameters
----------
size : non-negative int
Number of entries in a tuple.
dtype :
Data type for each tuple entry. Can be provided in any
way the `numpy.dtype` function understands, most notably
as built-in type, as one of NumPy's internal datatype
objects or as string.
Only scalar data types (numbers) are allowed.
"""
NtuplesBase.__init__(self, size, dtype)
if not is_scalar_dtype(self.dtype):
raise TypeError('{!r} is not a scalar data type'.format(dtype))
if is_real_dtype(self.dtype):
field = RealNumbers()
self.__is_real = True
self.__real_dtype = self.dtype
self.__real_space = self
try:
self.__complex_dtype = complex_dtype(self.dtype)
except ValueError:
self.__complex_dtype = None
self.__complex_space = None # Set in first call of astype
else:
field = ComplexNumbers()
self.__is_real = False
try:
self.__real_dtype = real_dtype(self.dtype)
except ValueError:
self.__real_dtype = None
self.__real_space = None # Set in first call of astype
self.__complex_dtype = self.dtype
self.__complex_space = self
self.__is_floating = is_floating_dtype(self.dtype)
LinearSpace.__init__(self, field)
def test_resize_array_adj(resize_setup, floating_dtype):
pad_mode, pad_const, newshp, offset, array, _ = resize_setup
if pad_const != 0:
# Not well-defined
return
array = np.array(array, dtype=floating_dtype)
if is_real_dtype(floating_dtype):
other_arr = np.random.uniform(-10, 10, size=newshp)
else:
other_arr = (np.random.uniform(-10, 10, size=newshp) +
1j * np.random.uniform(-10, 10, size=newshp))
resized = resize_array(array, newshp, offset, pad_mode, pad_const,
direction='forward')
resized_adj = resize_array(other_arr, array.shape, offset, pad_mode,
pad_const, direction='adjoint')
assert almost_equal(np.vdot(resized.ravel(), other_arr.ravel()),
np.vdot(array.ravel(), resized_adj.ravel()))
def _random_array(shape, dtype):
if is_real_dtype(dtype):
return np.random.rand(*shape).astype(dtype)
else:
return (np.random.rand(*shape).astype(dtype) +
1j * np.random.rand(*shape).astype(dtype))
def __init__(self, domain, field=None, out_dtype=None):
"""Initialize a new instance.
Parameters
----------
domain : `Set`
The domain of the functions
field : `Field`, optional
The range of the functions, usually the `RealNumbers` or
`ComplexNumbers`. If not given, the field is either inferred
from ``out_dtype``, or, if the latter is also ``None``, set
to ``RealNumbers()``.
out_dtype : optional
Data type of the return value of a function in this space.
Can be given in any way `numpy.dtype` understands, e.g. as
string (``'float64'``) or data type (``float``).
By default, ``'float64'`` is used for real and ``'complex128'``
for complex spaces.
"""
if not isinstance(domain, Set):
raise TypeError('`domain` {!r} not a Set instance'.format(domain))
if field is not None and not isinstance(field, Field):
raise TypeError('`field` {!r} not a `Field` instance'
''.format(field))
# Data type: check if consistent with field, take default for None
dtype, dtype_in = np.dtype(out_dtype), out_dtype
# Default for both None
if field is None and out_dtype is None:
field = RealNumbers()
out_dtype = np.dtype('float64')
# field None, dtype given -> infer field
elif field is None:
if is_real_dtype(dtype):
field = RealNumbers()
elif is_complex_floating_dtype(dtype):
field = ComplexNumbers()
else:
raise ValueError('{} is not a scalar data type'
''.format(dtype_in))
# field given -> infer dtype if not given, else check consistency
elif field == RealNumbers():
if out_dtype is None:
out_dtype = np.dtype('float64')
elif not is_real_dtype(dtype):
raise ValueError('{} is not a real data type'
''.format(dtype_in))
elif field == ComplexNumbers():
if out_dtype is None:
out_dtype = np.dtype('complex128')
elif not is_complex_floating_dtype(dtype):
raise ValueError('{} is not a complex data type'
''.format(dtype_in))
# Else: keep out_dtype=None, which results in lazy dtype determination
LinearSpace.__init__(self, field)
FunctionSet.__init__(self, domain, field, out_dtype)
# Init cache attributes for real / complex variants
if self.field == RealNumbers():
self.__real_out_dtype = self.out_dtype
self.__real_space = self
self.__complex_out_dtype = complex_dtype(self.out_dtype,
default=np.dtype(object))
self.__complex_space = None
elif self.field == ComplexNumbers():
self.__real_out_dtype = real_dtype(self.out_dtype)
self.__real_space = None
self.__complex_out_dtype = self.out_dtype
self.__complex_space = self
else:
self.__real_out_dtype = None
self.__real_space = None
self.__complex_out_dtype = None
self.__complex_space = None
def _params_from_dtype(dtype):
if is_real_dtype(dtype):
halfcomplex = True
else:
halfcomplex = False
return halfcomplex, complex_dtype(dtype)
def dft_preprocess_data(arr, shift=True, axes=None, sign='-', out=None):
"""Pre-process the real-space data before DFT.
This function multiplies the given data with the separable
function::
p(x) = exp(+- 1j * dot(x - x[0], xi[0]))
where ``x[0]`` and ``xi[0]`` are the minimum coodinates of
the real-space and reciprocal grids, respectively. The sign of
the exponent depends on the choice of ``sign``. In discretized
form, this function becomes an array::
p[k] = exp(+- 1j * k * s * xi[0])
If the reciprocal grid is not shifted, i.e. symmetric around 0,
it is ``xi[0] = pi/s * (-1 + 1/N)``, hence::
p[k] = exp(-+ 1j * pi * k * (1 - 1/N))
For a shifted grid, we have :math:``xi[0] = -pi/s``, thus the
array is given by::
p[k] = (-1)**k
Parameters
----------
arr : `array-like`
Array to be pre-processed. If its data type is a real
non-floating type, it is converted to 'float64'.
shift : bool or or sequence of bools, optional
If ``True``, the grid is shifted by half a stride in the negative
direction. With a sequence, this option is applied separately on
each axis.
axes : int or sequence of ints, optional
Dimensions in which to calculate the reciprocal. The sequence
must have the same length as ``shift`` if the latter is given
as a sequence.
Default: all axes.
sign : {'-', '+'}, optional
Sign of the complex exponent.
out : `numpy.ndarray`, optional
Array in which the result is stored. If ``out is arr``,
an in-place modification is performed. For real data type,
this is only possible for ``shift=True`` since the factors are
complex otherwise.
Returns
-------
out : `numpy.ndarray`
Result of the pre-processing. If ``out`` was given, the returned
object is a reference to it.
Notes
-----
If ``out`` is not specified, the data type of the returned array
is the same as that of ``arr`` except when ``arr`` has real data
type and ``shift`` is not ``True``. In this case, the return type
is the complex counterpart of ``arr.dtype``.
"""
arr = np.asarray(arr)
if not is_scalar_dtype(arr.dtype):
raise ValueError('array has non-scalar data type {}'
''.format(dtype_repr(arr.dtype)))
elif is_real_dtype(arr.dtype) and not is_real_floating_dtype(arr.dtype):
arr = arr.astype('float64')
if axes is None:
axes = list(range(arr.ndim))
else:
try:
axes = [int(axes)]
except TypeError:
axes = list(axes)
shape = arr.shape
shift_list = normalized_scalar_param_list(shift, length=len(axes),
param_conv=bool)
# Make a copy of arr with correct data type if necessary, or copy values.
if out is None:
if is_real_dtype(arr.dtype) and not all(shift_list):
out = np.array(arr, dtype=complex_dtype(arr.dtype), copy=True)
else:
out = arr.copy()
else:
out[:] = arr
if is_real_dtype(out.dtype) and not shift:
raise ValueError('cannot pre-process real input in-place without '
'shift')
if sign == '-':
imag = -1j
elif sign == '+':
imag = 1j
else:
raise ValueError("`sign` '{}' not understood".format(sign))
def _onedim_arr(length, shift):
if shift:
# (-1)^indices
factor = np.ones(length, dtype=out.dtype)
factor[1::2] = -1
else:
factor = np.arange(length, dtype=out.dtype)
factor *= -imag * np.pi * (1 - 1.0 / length)
np.exp(factor, out=factor)
return factor.astype(out.dtype, copy=False)
onedim_arrs = []
for axis, shift in zip(axes, shift_list):
length = shape[axis]
onedim_arrs.append(_onedim_arr(length, shift))
fast_1d_tensor_mult(out, onedim_arrs, axes=axes, out=out)
return out
def contains_all(self, array):
"""Test if `array` is an array of real numbers."""
dtype = getattr(array, 'dtype', None)
if dtype is None:
dtype = np.result_type(*array)
return is_real_dtype(dtype)
def _random_array(shape, dtype):
if is_real_dtype(dtype):
return np.random.rand(*shape).astype(dtype)
else:
return (np.random.rand(*shape).astype(dtype) +
1j * np.random.rand(*shape).astype(dtype))
def _params_from_dtype(dtype):
if is_real_dtype(dtype):
halfcomplex = True
else:
halfcomplex = False
return halfcomplex, complex_dtype(dtype)
def 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_in : `numpy.ndarray`
Array to be transformed
array_out : `numpy.ndarray`
Output array storing the transformed values, may be aliased
with ``array_in``.
direction : {'forward', 'backward'}, optional
Direction of the transform
axes : int or sequence of ints, optional
Dimensions along which to take the transform. ``None`` means
using all axes and is equivalent to ``np.arange(ndim)``.
halfcomplex : bool, 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.
Other Parameters
----------------
fftw_plan : ``pyfftw.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_effort : str, optional
Flag for the amount of effort put into finding an optimal
FFTW plan. See the `FFTW doc on planner flags
<http://www.fftw.org/fftw3_doc/Planner-Flags.html>`_.
Available options: {'estimate', 'measure', 'patient', 'exhaustive'}
Default: 'estimate'
planning_timelimit : float or ``None``, optional
Limit planning time to roughly this many seconds.
Default: ``None`` (no limit)
threads : int, optional
Number of threads to use.
Default: Number of CPUs if the number of data points is larger
than 4096, else 1.
normalise_idft : bool, 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_wisdom : filename or file handle, optional
File to load FFTW wisdom from. If the file does not exist,
it is ignored.
export_wisdom : filename or file handle, optional
File to append the accumulated FFTW wisdom to
Returns
-------
fftw_plan : ``pyfftw.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.
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.
"""
import pickle
if not array_in.flags.aligned:
raise ValueError('input array not aligned')
if not array_out.flags.aligned:
raise ValueError('output array not aligned')
if axes is None:
axes = tuple(range(array_in.ndim))
axes = normalized_axes_tuple(axes, array_in.ndim)
direction = _flag_pyfftw_to_odl(direction)
fftw_plan_in = kwargs.pop('fftw_plan', None)
planning_effort = _flag_pyfftw_to_odl(
kwargs.pop('planning_effort', 'estimate')
)
planning_timelimit = kwargs.pop('planning_timelimit', None)
threads = kwargs.pop('threads', None)
normalise_idft = kwargs.pop('normalise_idft', False)
wimport = kwargs.pop('import_wisdom', '')
wexport = kwargs.pop('export_wisdom', '')
# Cast input to complex if necessary
array_in_copied = False
if is_real_dtype(array_in.dtype) and not halfcomplex:
# Need to cast array_in to complex dtype
array_in = array_in.astype(complex_dtype(array_in.dtype))
array_in_copied = True
# Do consistency checks on the arguments
_pyfftw_check_args(array_in, array_out, axes, halfcomplex, direction)
# Import wisdom if possible
if wimport:
try:
with open(wimport, 'rb') as wfile:
wisdom = pickle.load(wfile)
except IOError:
wisdom = []
except TypeError: # Got file handle
wisdom = pickle.load(wimport)
if wisdom:
pyfftw.import_wisdom(wisdom)
# Copy input array if it hasn't been done yet and the planner is likely
# to destroy it. If we already have a plan, we don't have to worry.
planner_destroys = _pyfftw_destroys_input(
[planning_effort], direction, halfcomplex, array_in.ndim)
must_copy_array_in = fftw_plan_in is None and planner_destroys
if must_copy_array_in and not array_in_copied:
plan_arr_in = np.empty_like(array_in)
flags = [_flag_odl_to_pyfftw(planning_effort), 'FFTW_DESTROY_INPUT']
else:
plan_arr_in = array_in
flags = [_flag_odl_to_pyfftw(planning_effort)]
if fftw_plan_in is None:
if threads is None:
if plan_arr_in.size <= 4096: # Trade-off wrt threading overhead
threads = 1
else:
threads = cpu_count()
fftw_plan = pyfftw.FFTW(
plan_arr_in, array_out, direction=_flag_odl_to_pyfftw(direction),
flags=flags, planning_timelimit=planning_timelimit,
threads=threads, axes=axes)
else:
fftw_plan = fftw_plan_in
fftw_plan(array_in, array_out, normalise_idft=normalise_idft)
if wexport:
try:
with open(wexport, 'ab') as wfile:
pickle.dump(pyfftw.export_wisdom(), wfile)
except TypeError: # Got file handle
pickle.dump(pyfftw.export_wisdom(), wexport)
return fftw_plan
def _pyfftw_check_args(arr_in, arr_out, axes, halfcomplex, direction):
"""Raise an error if anything is not ok with in and out."""
if len(set(axes)) != len(axes):
raise ValueError('duplicate axes are not allowed')
if direction == 'forward':
out_shape = list(arr_in.shape)
if halfcomplex:
try:
out_shape[axes[-1]] = arr_in.shape[axes[-1]] // 2 + 1
except IndexError:
raise IndexError('axis index {} out of range for array '
'with {} axes'
''.format(axes[-1], arr_in.ndim))
if arr_out.shape != tuple(out_shape):
raise ValueError('expected output shape {}, got {}'
''.format(tuple(out_shape), arr_out.shape))
if is_real_dtype(arr_in.dtype):
out_dtype = complex_dtype(arr_in.dtype)
elif halfcomplex:
raise ValueError('cannot combine halfcomplex forward transform '
'with complex input')
else:
out_dtype = arr_in.dtype
if arr_out.dtype != out_dtype:
raise ValueError('expected output dtype {}, got {}'
''.format(dtype_repr(out_dtype),
dtype_repr(arr_out.dtype)))
elif direction == 'backward':
in_shape = list(arr_out.shape)
if halfcomplex:
try:
in_shape[axes[-1]] = arr_out.shape[axes[-1]] // 2 + 1
except IndexError as err:
raise IndexError('axis index {} out of range for array '
'with {} axes'
''.format(axes[-1], arr_out.ndim))
if arr_in.shape != tuple(in_shape):
raise ValueError('expected input shape {}, got {}'
''.format(tuple(in_shape), arr_in.shape))
if is_real_dtype(arr_out.dtype):
in_dtype = complex_dtype(arr_out.dtype)
elif halfcomplex:
raise ValueError('cannot combine halfcomplex backward transform '
'with complex output')
else:
in_dtype = arr_out.dtype
if arr_in.dtype != in_dtype:
raise ValueError('expected input dtype {}, got {}'
''.format(dtype_repr(in_dtype),
dtype_repr(arr_in.dtype)))
else: # Shouldn't happen
raise RuntimeError
def dft_preprocess_data(arr, shift=True, axes=None, sign='-', out=None):
"""Pre-process the real-space data before DFT.
This function multiplies the given data with the separable
function::
p(x) = exp(+- 1j * dot(x - x[0], xi[0]))
where ``x[0]`` and ``xi[0]`` are the minimum coodinates of
the real-space and reciprocal grids, respectively. The sign of
the exponent depends on the choice of ``sign``. In discretized
form, this function becomes an array::
p[k] = exp(+- 1j * k * s * xi[0])
If the reciprocal grid is not shifted, i.e. symmetric around 0,
it is ``xi[0] = pi/s * (-1 + 1/N)``, hence::
p[k] = exp(-+ 1j * pi * k * (1 - 1/N))
For a shifted grid, we have :math:``xi[0] = -pi/s``, thus the
array is given by::
p[k] = (-1)**k
Parameters
----------
arr : `array-like`
Array to be pre-processed. If its data type is a real
non-floating type, it is converted to 'float64'.
shift : bool or or sequence of bools, optional
If ``True``, the grid is shifted by half a stride in the negative
direction. With a sequence, this option is applied separately on
each axis.
axes : int or sequence of ints, optional
Dimensions in which to calculate the reciprocal. The sequence
must have the same length as ``shift`` if the latter is given
as a sequence.
Default: all axes.
sign : {'-', '+'}, optional
Sign of the complex exponent.
out : `numpy.ndarray`, optional
Array in which the result is stored. If ``out is arr``,
an in-place modification is performed. For real data type,
this is only possible for ``shift=True`` since the factors are
complex otherwise.
Returns
-------
out : `numpy.ndarray`
Result of the pre-processing. If ``out`` was given, the returned
object is a reference to it.
Notes
-----
If ``out`` is not specified, the data type of the returned array
is the same as that of ``arr`` except when ``arr`` has real data
type and ``shift`` is not ``True``. In this case, the return type
is the complex counterpart of ``arr.dtype``.
"""
arr = np.asarray(arr)
if not is_scalar_dtype(arr.dtype):
raise ValueError('array has non-scalar data type {}'
''.format(dtype_repr(arr.dtype)))
elif is_real_dtype(arr.dtype) and not is_real_floating_dtype(arr.dtype):
arr = arr.astype('float64')
if axes is None:
axes = list(range(arr.ndim))
else:
try:
axes = [int(axes)]
except TypeError:
axes = list(axes)
shape = arr.shape
shift_list = normalized_scalar_param_list(shift, length=len(axes),
param_conv=bool)
# Make a copy of arr with correct data type if necessary, or copy values.
if out is None:
if is_real_dtype(arr.dtype) and not all(shift_list):
out = np.array(arr, dtype=complex_dtype(arr.dtype), copy=True)
else:
out = arr.copy()
else:
out[:] = arr
if is_real_dtype(out.dtype) and not shift:
raise ValueError('cannot pre-process real input in-place without '
'shift')
if sign == '-':
imag = -1j
elif sign == '+':
imag = 1j
else:
raise ValueError("`sign` '{}' not understood".format(sign))
def _onedim_arr(length, shift):
if shift:
# (-1)^indices
factor = np.ones(length, dtype=out.dtype)
factor[1::2] = -1
else:
factor = np.arange(length, dtype=out.dtype)
factor *= -imag * np.pi * (1 - 1.0 / length)
np.exp(factor, out=factor)
return factor.astype(out.dtype, copy=False)
onedim_arrs = []
for axis, shift in zip(axes, shift_list):
length = shape[axis]
onedim_arrs.append(_onedim_arr(length, shift))
fast_1d_tensor_mult(out, onedim_arrs, axes=axes, out=out)
return out
def _pyfftw_check_args(arr_in, arr_out, axes, halfcomplex, direction):
"""Raise an error if anything is not ok with in and out."""
if len(set(axes)) != len(axes):
raise ValueError('duplicate axes are not allowed')
if direction == 'forward':
out_shape = list(arr_in.shape)
if halfcomplex:
try:
out_shape[axes[-1]] = arr_in.shape[axes[-1]] // 2 + 1
except IndexError as err:
raise_from(IndexError('axis index {} out of range for array '
'with {} axes'
''.format(axes[-1], arr_in.ndim)),
err)
if arr_out.shape != tuple(out_shape):
raise ValueError('expected output shape {}, got {}'
''.format(tuple(out_shape), arr_out.shape))
if is_real_dtype(arr_in.dtype):
out_dtype = complex_dtype(arr_in.dtype)
elif halfcomplex:
raise ValueError('cannot combine halfcomplex forward transform '
'with complex input')
else:
out_dtype = arr_in.dtype
if arr_out.dtype != out_dtype:
raise ValueError('expected output dtype {}, got {}'
''.format(dtype_repr(out_dtype),
dtype_repr(arr_out.dtype)))
elif direction == 'backward':
in_shape = list(arr_out.shape)
if halfcomplex:
try:
in_shape[axes[-1]] = arr_out.shape[axes[-1]] // 2 + 1
except IndexError as err:
raise_from(IndexError('axis index {} out of range for array '
'with {} axes'
''.format(axes[-1], arr_out.ndim)),
err)
if arr_in.shape != tuple(in_shape):
raise ValueError('expected input shape {}, got {}'
''.format(tuple(in_shape), arr_in.shape))
if is_real_dtype(arr_out.dtype):
in_dtype = complex_dtype(arr_out.dtype)
elif halfcomplex:
raise ValueError('cannot combine halfcomplex backward transform '
'with complex output')
else:
in_dtype = arr_out.dtype
if arr_in.dtype != in_dtype:
raise ValueError('expected input dtype {}, got {}'
''.format(dtype_repr(in_dtype),
dtype_repr(arr_in.dtype)))
else: # Shouldn't happen
raise RuntimeError
def 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_in : `numpy.ndarray`
Array to be transformed
array_out : `numpy.ndarray`
Output array storing the transformed values, may be aliased
with ``array_in``.
direction : {'forward', 'backward'}
Direction of the transform
axes : int or sequence of ints, optional
Dimensions along which to take the transform. ``None`` means
using all axes and is equivalent to ``np.arange(ndim)``.
halfcomplex : bool, 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.
Other Parameters
----------------
fftw_plan : ``pyfftw.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_effort : {'estimate', 'measure', 'patient', 'exhaustive'}
Flag for the amount of effort put into finding an optimal
FFTW plan. See the `FFTW doc on planner flags
<http://www.fftw.org/fftw3_doc/Planner-Flags.html>`_.
Default: 'estimate'
planning_timelimit : float or ``None``, optional
Limit planning time to roughly this many seconds.
Default: ``None`` (no limit)
threads : int, optional
Number of threads to use.
Default: Number of CPUs if the number of data points is larger
than 4096, else 1.
normalise_idft : bool, 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_wisdom : filename or file handle, optional
File to load FFTW wisdom from. If the file does not exist,
it is ignored.
export_wisdom : filename or file handle, optional
File to append the accumulated FFTW wisdom to
Returns
-------
fftw_plan : ``pyfftw.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.
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.
"""
import pickle
if not array_in.flags.aligned:
raise ValueError('input array not aligned')
if not array_out.flags.aligned:
raise ValueError('output array not aligned')
if axes is None:
axes = tuple(range(array_in.ndim))
axes = normalized_axes_tuple(axes, array_in.ndim)
direction = _pyfftw_to_local(direction)
fftw_plan_in = kwargs.pop('fftw_plan', None)
planning_effort = _pyfftw_to_local(kwargs.pop('planning_effort',
'estimate'))
planning_timelimit = kwargs.pop('planning_timelimit', None)
threads = kwargs.pop('threads', None)
normalise_idft = kwargs.pop('normalise_idft', False)
wimport = kwargs.pop('import_wisdom', '')
wexport = kwargs.pop('export_wisdom', '')
# Cast input to complex if necessary
array_in_copied = False
if is_real_dtype(array_in.dtype) and not halfcomplex:
# Need to cast array_in to complex dtype
array_in = array_in.astype(complex_dtype(array_in.dtype))
array_in_copied = True
# Do consistency checks on the arguments
_pyfftw_check_args(array_in, array_out, axes, halfcomplex, direction)
# Import wisdom if possible
if wimport:
try:
with open(wimport, 'rb') as wfile:
wisdom = pickle.load(wfile)
except IOError:
wisdom = []
except TypeError: # Got file handle
wisdom = pickle.load(wimport)
if wisdom:
pyfftw.import_wisdom(wisdom)
# Copy input array if it hasn't been done yet and the planner is likely
# to destroy it. If we already have a plan, we don't have to worry.
planner_destroys = _pyfftw_destroys_input(
[planning_effort], direction, halfcomplex, array_in.ndim)
must_copy_array_in = fftw_plan_in is None and planner_destroys
if must_copy_array_in and not array_in_copied:
plan_arr_in = np.empty_like(array_in)
flags = [_local_to_pyfftw(planning_effort), 'FFTW_DESTROY_INPUT']
else:
plan_arr_in = array_in
flags = [_local_to_pyfftw(planning_effort)]
if fftw_plan_in is None:
if threads is None:
if plan_arr_in.size <= 4096: # Trade-off wrt threading overhead
threads = 1
else:
threads = cpu_count()
fftw_plan = pyfftw.FFTW(
plan_arr_in, array_out, direction=_local_to_pyfftw(direction),
flags=flags, planning_timelimit=planning_timelimit,
threads=threads, axes=axes)
else:
fftw_plan = fftw_plan_in
fftw_plan(array_in, array_out, normalise_idft=normalise_idft)
if wexport:
try:
with open(wexport, 'ab') as wfile:
pickle.dump(pyfftw.export_wisdom(), wfile)
except TypeError: # Got file handle
pickle.dump(pyfftw.export_wisdom(), wexport)
return fftw_plan
def contains_all(self, array):
"""Test if `array` is an array of real numbers."""
dtype = getattr(array, 'dtype', None)
if dtype is None:
dtype = np.result_type(*array)
return is_real_dtype(dtype)
def __init__(self, domain, field=None, out_dtype=None):
"""Initialize a new instance.
Parameters
----------
domain : `Set`
The domain of the functions
field : `Field`, optional
The range of the functions, usually the `RealNumbers` or
`ComplexNumbers`. If not given, the field is either inferred
from ``out_dtype``, or, if the latter is also ``None``, set
to ``RealNumbers()``.
out_dtype : optional
Data type of the return value of a function in this space.
Can be given in any way `numpy.dtype` understands, e.g. as
string (``'float64'``) or data type (``float``).
By default, ``'float64'`` is used for real and ``'complex128'``
for complex spaces.
"""
if not isinstance(domain, Set):
raise TypeError('`domain` {!r} not a Set instance'.format(domain))
if field is not None and not isinstance(field, Field):
raise TypeError('`field` {!r} not a `Field` instance'
''.format(field))
# Data type: check if consistent with field, take default for None
dtype, dtype_in = np.dtype(out_dtype), out_dtype
# Default for both None
if field is None and out_dtype is None:
field = RealNumbers()
out_dtype = np.dtype('float64')
# field None, dtype given -> infer field
elif field is None:
if is_real_dtype(dtype):
field = RealNumbers()
elif is_complex_floating_dtype(dtype):
field = ComplexNumbers()
else:
raise ValueError('{} is not a scalar data type'
''.format(dtype_in))
# field given -> infer dtype if not given, else check consistency
elif field == RealNumbers():
if out_dtype is None:
out_dtype = np.dtype('float64')
elif not is_real_dtype(dtype):
raise ValueError('{} is not a real data type'
''.format(dtype_in))
elif field == ComplexNumbers():
if out_dtype is None:
out_dtype = np.dtype('complex128')
elif not is_complex_floating_dtype(dtype):
raise ValueError('{} is not a complex data type'
''.format(dtype_in))
# Else: keep out_dtype=None, which results in lazy dtype determination
LinearSpace.__init__(self, field)
FunctionSet.__init__(self, domain, field, out_dtype)
# Init cache attributes for real / complex variants
if self.field == RealNumbers():
self.__real_out_dtype = self.out_dtype
self.__real_space = self
self.__complex_out_dtype = complex_dtype(self.out_dtype,
default=np.dtype(object))
self.__complex_space = None
elif self.field == ComplexNumbers():
self.__real_out_dtype = real_dtype(self.out_dtype)
self.__real_space = None
self.__complex_out_dtype = self.out_dtype
self.__complex_space = self
else:
self.__real_out_dtype = None
self.__real_space = None
self.__complex_out_dtype = None
self.__complex_space = None
