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