o iL@sddlmZddlZddlmZddlmZmZmZm Z m Z m Z ddl m Z dddZdd d Zdd dZdddZdddZdddZdddZdddZd ddZdS)!)prodN)config)_convert_fft_type_default_fft_func_fft_get_cufft_plan_nd_get_fftn_out_size _output_dtype)get_plan_cacheC2CcCsddlm}|jjr d}n |jjrd}ntdt|tr |f}t|tr(|f}|dur<|durVszget_fft_plan..zAThe chosen axis ({0}) exceeds the number of dimensions of a ({1})z"Only up to three axes is supportedC2Rr z2C2R/R2C PlanNd for F-order arrays is not supportedz,hipFFT's C2R PlanNd is buggy and unsupportedF)axesorderout_sizeto_cache)devicesz/multi-GPU cuFFT callbacks are not yet supportedPlan1d)+ cupy.cudar flags c_contiguous f_contiguous ValueError isinstanceintlenndimtuplerangeformatlistshapezipr dtypercupycudaruntimeis_hip RuntimeErrorrrrruse_multi_gpus_devicesget_current_callback_managercb_load_aux_arrcb_store_aux_arrcb_loadcb_storedataptrr getrNotImplementedError create_plan set_callbacks)ar.r value_typer rnaxis1Derrtransformed_shapesaxis out_dtypefft_typerplanbatchrkeysmgrload_aux store_auxcache cached_planrrr get_fft_plan s 6          &         rUrFc C(ddlm}t||f|fd|j||dS)acCompute 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. 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.fft` rr N overwrite_xrM)r!r r CUFFT_FORWARDxrErJrXrMr rrrfft r\c CrV)alCompute 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` rr NrW)r!r r CUFFT_INVERSErZrrrifftr]r_rc C2ddlm}t||||}||||d|j||dS)aCompute the two-dimensional 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. plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for transforming ``x`` over ``axes``, which can be obtained using:: plan = cupyx.scipy.fftpack.get_fft_plan(x, axes) 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 which shape is specified by ``shape`` and type will convert to complex if that of the input is another. .. seealso:: :func:`scipy.fftpack.fft2` .. note:: The argument `plan` is currently experimental and the interface may be changed in the future version. rr NrWr!r rrYr[r.rrXrMr funcrrrfft2 rfc Crb)aCompute 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. plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for transforming ``x`` over ``axes``, which can be obtained using:: plan = cupyx.scipy.fftpack.get_fft_plan(x, axes) 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 which shape is specified by ``shape`` and type will convert to complex if that of the input is another. .. seealso:: :func:`scipy.fftpack.ifft2` .. note:: The argument `plan` is currently experimental and the interface may be changed in the future version. rr NrWr!r rr^rdrrrifft2rgric Crb)aCompute the N-dimensional 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. plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for transforming ``x`` over ``axes``, which can be obtained using:: plan = cupyx.scipy.fftpack.get_fft_plan(x, axes) 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 which shape is specified by ``shape`` and type will convert to complex if that of the input is another. .. seealso:: :func:`scipy.fftpack.fftn` .. note:: The argument `plan` is currently experimental and the interface may be changed in the future version. rr NrWrcrdrrrfftn:rgrjc Crb)aCompute the N-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. plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for transforming ``x`` over ``axes``, which can be obtained using:: plan = cupyx.scipy.fftpack.get_fft_plan(x, axes) 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 which shape is specified by ``shape`` and type will convert to complex if that of the input is another. .. seealso:: :func:`scipy.fftpack.ifftn` .. note:: The argument `plan` is currently experimental and the interface may be changed in the future version. rr NrWrhrdrrrifftn`rgrkc Cs&ddlm}|dur|j|}t|j}|||<t||f|fd|jd||d}t||jj }t dg|j } t dg|j } t d| |<t d| |<|t | j|t | <t ddd| |<t dd| |<|t | j|t | <t ddd| |<t d||j|d| |<|t | j |t | <|S)aqCompute 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. rr NR2CrWrr)r!r r.r-rrYr1emptyrealr0slicer)r*imag) r[rErJrXrMr r.fzslice_zslice_frrrrffts* &    ruc Cs^ddlm}|dur|j|}t||j|}t|j}|dd||<|jtjtjfvr6tj |tj d}ntj |tj d}t dg|j }t dg|j } t d||<t d| |<|t||t| _t d|d||<t d|dd| |<|t||t| _t d|d||<t d|dd| |<|t||t| _t||f|fd|jd|dS) aCompute 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`. rr Nrr)r0r)rX)r!r r.minr-r0r1float16float32zeros complex64 complex128ror)r*rnrprr^) r[rErJrXr mr.rrslice_xrsrrrirffts.     r~)NNr )NrFN)Nr`FN)NNFN)NrF)numpyrr1cupy.fftr cupy.fft._fftrrrrrr cupy.fft._cacher rUr\r_rfrirjrkrur~rrrrs      " " & & & &C