def irfftn(x, s=None, axes=None, norm=None, overwrite_x=False):
"""Compute the N-dimensional inverse FFT for real input.
Args:
a (cupy.ndarray): Array to be transform.
s (None or tuple of ints): Shape of the output. If ``s`` is not given,
they are determined from the lengths of the input along the axes
specified by ``axes``.
axes (tuple of ints): Axes over which to compute the FFT.
norm (None or ``"ortho"``): Keyword to specify the normalization mode.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
Returns:
cupy.ndarray:
The transformed array which shape is specified by ``s`` and type
will convert to complex if the input is other. If ``s`` is not
given, the length of final transformed axis of output will be
``2*(m-1)`` where `m` is the length of the final transformed axis
of the input.
.. warning:: The input array may be modified in CUDA 10.1 and above, even
when `overwrite_x is False`.
.. seealso:: :func:`scipy.fft.irfftn`
"""
s = _assequence(s)
axes = _assequence(axes)
return _fft(x, s, axes, norm, cufft.CUFFT_INVERSE, 'C2R', overwrite_x)
def irfft(x, n=None, axis=-1, norm=None, overwrite_x=False):
"""Compute the one-dimensional inverse FFT for real input.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
norm (None or ``'ortho'``): Normalization mode.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
Returns:
cupy.ndarray:
The transformed array.
.. warning:: The input array may be modified in CUDA 10.1 and above, even
when `overwrite_x is False`.
.. seealso:: :func:`scipy.fft.irfft`
"""
return _fft(x, (n, ), (axis, ),
norm,
cufft.CUFFT_INVERSE,
'C2R',
overwrite_x=overwrite_x)
def fft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
"""Compute the one-dimensional FFT.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
norm (None or ``'ortho'``): Normalization mode.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
transforming ``x`` over ``axis``, which can be obtained using::
plan = cupyx.scipy.fftpack.get_fft_plan(x, n, axis)
Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
an auto-generated plan behind the scene.
Returns:
cupy.ndarray:
The transformed array which shape is specified by ``n`` and type
will convert to complex if that of the input is another.
.. seealso:: :func:`scipy.fft.fft`
"""
return _fft(x, (n, ), (axis, ),
norm,
cufft.CUFFT_FORWARD,
overwrite_x=overwrite_x,
plan=plan)
def rfft(x, n=None, axis=-1, norm=None, overwrite_x=False):
"""Compute the one-dimensional FFT for real input.
The returned array contains the positive frequency components of the
corresponding :func:`fft`, up to and including the Nyquist frequency.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
norm (None or ``'ortho'``): Normalization mode.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
Returns:
cupy.ndarray:
The transformed array.
.. seealso:: :func:`scipy.fft.rfft`
"""
return _fft(x, (n, ), (axis, ),
norm,
cufft.CUFFT_FORWARD,
'R2C',
overwrite_x=overwrite_x)
def ifft(x, n=None, axis=-1, overwrite_x=False, plan=None):
"""Compute the one-dimensional inverse FFT.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
transforming ``x`` over ``axis``, which can be obtained using::
plan = cupyx.scipy.fftpack.get_fft_plan(x, axis)
Note that `plan` is defaulted to None, meaning CuPy will use an
auto-generated plan behind the scene.
Returns:
cupy.ndarray:
The transformed array which shape is specified by ``n`` and type
will convert to complex if that of the input is another.
.. note::
The argument `plan` is currently experimental and the interface may be
changed in the future version.
.. seealso:: :func:`scipy.fftpack.ifft`
"""
return _fft(x, (n, ), (axis, ),
None,
cufft.CUFFT_INVERSE,
overwrite_x=overwrite_x,
plan=plan)
def irfft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
"""Compute the one-dimensional inverse FFT for real input.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
norm (None or ``'ortho'``): Normalization mode.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
transforming ``x`` over ``axis``, which can be obtained using::
plan = cupyx.scipy.fftpack.get_fft_plan(x, n, axis,
value_type='C2R')
Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
an auto-generated plan behind the scene.
Returns:
cupy.ndarray:
The transformed array.
.. warning:: The input array may be modified in CUDA 10.1 and above, even
when `overwrite_x is False`.
.. seealso:: :func:`scipy.fft.irfft`
"""
return _fft(x, (n, ), (axis, ),
norm,
cufft.CUFFT_INVERSE,
'C2R',
overwrite_x=overwrite_x,
plan=plan)
def irfftn(x, s=None, axes=None, norm=None, overwrite_x=False, *, plan=None):
"""Compute the N-dimensional inverse FFT for real input.
Args:
a (cupy.ndarray): Array to be transform.
s (None or tuple of ints): Shape of the output. If ``s`` is not given,
they are determined from the lengths of the input along the axes
specified by ``axes``.
axes (tuple of ints): Axes over which to compute the FFT.
norm (None or ``"ortho"``): Keyword to specify the normalization mode.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
plan (None): This argument is currently not supported.
Returns:
cupy.ndarray:
The transformed array which shape is specified by ``s`` and type
will convert to complex if the input is other. If ``s`` is not
given, the length of final transformed axis of output will be
``2*(m-1)`` where `m` is the length of the final transformed axis
of the input.
.. seealso:: :func:`scipy.fft.irfftn`
"""
# TODO(leofang): support R2C & C2R plans
if plan is not None:
raise NotImplementedError('irfftn plan is currently not yet supported')
s = _assequence(s)
axes = _assequence(axes)
return _fft(x, s, axes, norm, cufft.CUFFT_INVERSE, 'C2R', overwrite_x)
def irfft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
"""Compute the one-dimensional inverse FFT for real input.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
norm (None or ``'ortho'``): Normalization mode.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
plan (None): This argument is currently not supported.
Returns:
cupy.ndarray:
The transformed array.
.. seealso:: :func:`scipy.fft.irfft`
"""
# TODO(leofang): support R2C & C2R plans
if plan is not None:
raise NotImplementedError('irfft plan is currently not yet supported')
return _fft(x, (n, ), (axis, ),
norm,
cufft.CUFFT_INVERSE,
'C2R',
overwrite_x=overwrite_x)
def irfft(x, n=None, axis=-1, overwrite_x=False):
"""Compute the one-dimensional inverse FFT for real input.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
Returns:
cupy.ndarray:
The transformed array.
.. seealso:: :func:`scipy.fftpack.irfft`
.. note::
This function does not support a precomputed `plan`. If you need this
capability, please consider using :func:`cupy.fft.irfft` or :func:`
cupyx.scipy.fft.irfft`.
.. warning:: The input array may be modified in CUDA 10.1 and above, even
when `overwrite_x is False`.
"""
if n is None:
n = x.shape[axis]
m = min(n, x.shape[axis])
shape = list(x.shape)
shape[axis] = n // 2 + 1
if x.dtype in (cupy.float16, cupy.float32):
z = cupy.zeros(shape, dtype=cupy.complex64)
else:
z = cupy.zeros(shape, dtype=cupy.complex128)
slice_x = [slice(None)] * x.ndim
slice_z = [slice(None)] * x.ndim
slice_x[axis] = slice(1)
slice_z[axis] = slice(1)
z[slice_z].real = x[slice_x]
slice_x[axis] = slice(1, m, 2)
slice_z[axis] = slice(1, m // 2 + 1)
z[slice_z].real = x[slice_x]
slice_x[axis] = slice(2, m, 2)
slice_z[axis] = slice(1, (m + 1) // 2)
z[slice_z].imag = x[slice_x]
return _fft(z, (n, ), (axis, ),
None,
cufft.CUFFT_INVERSE,
'C2R',
overwrite_x=overwrite_x)
def rfft(x, n=None, axis=-1, overwrite_x=False):
"""Compute the one-dimensional FFT for real input.
The returned real array contains
.. code-block:: python
[y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2))] # if n is even
[y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2)),Im(y(n/2))] # if n is odd
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
Returns:
cupy.ndarray:
The transformed array.
.. seealso:: :func:`scipy.fftpack.rfft`
"""
if n is None:
n = x.shape[axis]
shape = list(x.shape)
shape[axis] = n
f = _fft(x, (n, ), (axis, ),
None,
cufft.CUFFT_FORWARD,
'R2C',
overwrite_x=overwrite_x)
z = cupy.empty(shape, f.real.dtype)
slice_z = [slice(None)] * x.ndim
slice_f = [slice(None)] * x.ndim
slice_z[axis] = slice(1)
slice_f[axis] = slice(1)
z[slice_z] = f[slice_f].real
slice_z[axis] = slice(1, None, 2)
slice_f[axis] = slice(1, None)
z[slice_z] = f[slice_f].real
slice_z[axis] = slice(2, None, 2)
slice_f[axis] = slice(1, n - f.shape[axis] + 1)
z[slice_z] = f[slice_f].imag
return z
def irfft(x, n=None, axis=-1, overwrite_x=False):
"""Compute the one-dimensional inverse FFT for real input.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
Returns:
cupy.ndarray:
The transformed array.
.. seealso:: :func:`scipy.fftpack.irfft`
"""
if n is None:
n = x.shape[axis]
m = min(n, x.shape[axis])
shape = list(x.shape)
shape[axis] = n // 2 + 1
if x.dtype in (cupy.float16, cupy.float32):
z = cupy.zeros(shape, dtype=cupy.complex64)
else:
z = cupy.zeros(shape, dtype=cupy.complex128)
slice_x = [slice(None)] * x.ndim
slice_z = [slice(None)] * x.ndim
slice_x[axis] = slice(1)
slice_z[axis] = slice(1)
z[slice_z].real = x[slice_x]
slice_x[axis] = slice(1, m, 2)
slice_z[axis] = slice(1, m // 2 + 1)
z[slice_z].real = x[slice_x]
slice_x[axis] = slice(2, m, 2)
slice_z[axis] = slice(1, (m + 1) // 2)
z[slice_z].imag = x[slice_x]
return _fft(z, (n, ), (axis, ),
None,
cufft.CUFFT_INVERSE,
'C2R',
overwrite_x=overwrite_x)
def ifft(x, n=None, axis=-1, overwrite_x=False):
"""Compute the one-dimensional inverse FFT.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
Returns:
cupy.ndarray:
The transformed array which shape is specified by ``n`` and type
will convert to complex if that of the input is another.
.. seealso:: :func:`scipy.fftpack.ifft`
"""
return _fft(x, (n,), (axis,), None, cufft.CUFFT_INVERSE,
overwrite_x=overwrite_x)
def rfftn(x, s=None, axes=None, norm=None, overwrite_x=False):
"""Compute the N-dimensional FFT for real input.
Args:
a (cupy.ndarray): Array to be transform.
s (None or tuple of ints): Shape to use from the input. If ``s`` is not
given, the lengths of the input along the axes specified by
``axes`` are used.
axes (tuple of ints): Axes over which to compute the FFT.
norm (None or ``"ortho"``): Keyword to specify the normalization mode.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
Returns:
cupy.ndarray:
The transformed array which shape is specified by ``s`` and type
will convert to complex if the input is other. The length of the
last axis transformed will be ``s[-1]//2+1``.
.. seealso:: :func:`scipy.fft.rfftn`
"""
s = _assequence(s)
axes = _assequence(axes)
return _fft(x, s, axes, norm, cufft.CUFFT_FORWARD, 'R2C', overwrite_x)
def rfft(x, n=None, axis=-1, norm=None, overwrite_x=False, *, plan=None):
"""Compute the one-dimensional FFT for real input.
The returned array contains the positive frequency components of the
corresponding :func:`fft`, up to and including the Nyquist frequency.
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
norm (None or ``'ortho'``): Normalization mode.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
transforming ``x`` over ``axis``, which can be obtained using::
plan = cupyx.scipy.fftpack.get_fft_plan(x, n, axis,
value_type='R2C')
Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
an auto-generated plan behind the scene.
Returns:
cupy.ndarray:
The transformed array.
.. seealso:: :func:`scipy.fft.rfft`
"""
return _fft(x, (n, ), (axis, ),
norm,
cufft.CUFFT_FORWARD,
'R2C',
overwrite_x=overwrite_x,
plan=plan)
def ifft2(x, shape=None, axes=(-2, -1), overwrite_x=False):
"""Compute the two-dimensional inverse FFT.
Args:
x (cupy.ndarray): Array to be transformed.
shape (None or tuple of ints): Shape of the transformed axes of the
output. If ``shape`` is not given, the lengths of the input along
the axes specified by ``axes`` are used.
axes (tuple of ints): Axes over which to compute the FFT.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
Returns:
cupy.ndarray:
The transformed array which shape is specified by ``shape`` and
type will convert to complex if that of the input is another.
.. seealso:: :func:`scipy.fftpack.ifft2`
"""
return _fft(x,
shape,
axes,
None,
cufft.CUFFT_INVERSE,
overwrite_x=overwrite_x)
def rfft(x, n=None, axis=-1, overwrite_x=False, plan=None):
"""Compute the one-dimensional FFT for real input.
The returned real array contains
.. code-block:: python
[y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2))] # if n is even
[y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2)),Im(y(n/2))] # if n is odd
Args:
x (cupy.ndarray): Array to be transformed.
n (None or int): Length of the transformed axis of the output. If ``n``
is not given, the length of the input along the axis specified by
``axis`` is used.
axis (int): Axis over which to compute the FFT.
overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
plan (:class:`cupy.cuda.cufft.Plan1d` or ``None``): a cuFFT plan for
transforming ``x`` over ``axis``, which can be obtained using::
plan = cupyx.scipy.fftpack.get_fft_plan(
x, axes, value_type='R2C')
Note that `plan` is defaulted to None, meaning CuPy will either
use an auto-generated plan behind the scene if cupy.fft.config.
enable_nd_planning = True, or use no cuFFT plan if it is set to
False.
Returns:
cupy.ndarray:
The transformed array.
.. seealso:: :func:`scipy.fftpack.rfft`
.. note::
The argument `plan` is currently experimental and the interface may be
changed in the future version.
"""
if n is None:
n = x.shape[axis]
shape = list(x.shape)
shape[axis] = n
f = _fft(x, (n, ), (axis, ),
None,
cufft.CUFFT_FORWARD,
'R2C',
overwrite_x=overwrite_x,
plan=plan)
z = cupy.empty(shape, f.real.dtype)
slice_z = [slice(None)] * x.ndim
slice_f = [slice(None)] * x.ndim
slice_z[axis] = slice(1)
slice_f[axis] = slice(1)
z[slice_z] = f[slice_f].real
slice_z[axis] = slice(1, None, 2)
slice_f[axis] = slice(1, None)
z[slice_z] = f[slice_f].real
slice_z[axis] = slice(2, None, 2)
slice_f[axis] = slice(1, n - f.shape[axis] + 1)
z[slice_z] = f[slice_f].imag
return z
