`iLddlmZddlZddlmZddlmZmZmZm Z m Z m Z ddl m Z ddZdd Zdd Zdd ZddZddZddZddZddZdS))prodN)config)_convert_fft_type_default_fft_func_fft_get_cufft_plan_nd_get_fftn_out_size _output_dtype)get_plan_cacheC2Cc,ddlm}|jjrd}n|jjrd}nt dt |tr|f}t |tr|f}|1|/t|t|krt d|I||j nt|}tdt| dD}|d krd}ntt|}|d krJ|d}||j ks ||j kr*d ||j }t |n|d krt d |} t|j}| 7t| |D]&\} } | | |d kr|dkr| dzd z} | || <'t|}t!|j|} t%| |} |d kr!|dkr|jjrt d|d krZt&jjjr|dkrt/dt1|| |d |}t3|| |||d}n4|dkr ||}nt1|| ||}t5|||z}t6jsdn t6j}|| ||f}t7j}|=|j}|j }||j!|j"|dn |j#j$|dn |j#j$fz }tK}|&|}||}na||'|| ||}nE|rtQd|)d|ddf}|*||S)a Generate a CUDA FFT plan for transforming up to three axes. Args: a (cupy.ndarray): Array to be transform, assumed to be either C- or F- contiguous. 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 (None or int or tuple of int): The axes of the array to transform. If `None`, it is assumed that all axes are transformed. Currently, for performing N-D transform these must be a set of up to three adjacent axes, and must include either the first or the last axis of the array. value_type (str): The FFT type to perform. Acceptable values are: * 'C2C': complex-to-complex transform (default) * 'R2C': real-to-complex transform * 'C2R': complex-to-real transform Returns: a cuFFT plan for either 1D transform (``cupy.cuda.cufft.Plan1d``) or N-D transform (``cupy.cuda.cufft.PlanNd``). .. note:: The returned plan can not only be passed as one of the arguments of the functions in ``cupyx.scipy.fftpack``, but also be used as a context manager for both ``cupy.fft`` and ``cupyx.scipy.fftpack`` functions: .. code-block:: python x = cupy.random.random(16).reshape(4, 4).astype(complex) plan = cupyx.scipy.fftpack.get_fft_plan(x) with plan: y = cupy.fft.fftn(x) # alternatively: y = cupyx.scipy.fftpack.fftn(x) # no explicit plan is given! # alternatively: y = cupyx.scipy.fftpack.fftn(x, plan=plan) # pass plan explicitly In the first case, no cuFFT plan will be generated automatically, even if ``cupy.fft.config.enable_nd_planning = True`` is set. .. note:: If this function is called under the context of :func:`~cupy.fft.config.set_cufft_callbacks`, the generated plan will have callbacks enabled. .. warning:: This API is a deviation from SciPy's, is currently experimental, and may be changed in the future version. rcufftCFz Input array a must be contiguousNz&Shape and axes have different lengths.c3K|]}|VdS)N).0is l/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/fftpack/_fft.py zget_fft_plan..Vs"--1Q------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.cudarflags c_contiguous f_contiguous ValueError isinstanceintlenndimtuplerangeformatlistshapezipr dtypercupycudaruntimeis_hip RuntimeErrorr rrruse_multi_gpus_devicesget_current_callback_managercb_load_aux_arrcb_store_aux_arrcb_loadcb_storedataptrr getr#NotImplementedError create_plan set_callbacks)ar2r value_typerrnaxis1Derrtransformed_shapesaxis out_dtypefft_typer planbatchr"keysmgrload_aux store_auxcache cached_plans r get_fft_planrY s'l  w=  =;<<<%$w  0c%jjCII6M6MABBB |mAFFU--qb! ----- 66F II 66!WF6QVG#3#3..4fVQV.D.D oo%$4UUABB B  MME$,d33  GAt}48## e(;(;Q Ad %LLEagz22I J77H1uuu$$)=$MNNN 1uu 9  # O e(;(;MNN N% $d2h <<" 8$eh   V}HH)(&*>>HU uV},$3H$$(E73133 ?*H,I S[#,"*QQ 0A#+QQ1CE ED  iioo  "DD [<<(E7<KKDD ;)+:;;;??Hd3B3i#899D   d # # # KrrFc Hddlm}t||f|fd|j||S)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` rrN overwrite_xrQ)r%rr CUFFT_FORWARDxrIrNr\rQrs rfftr`C:  A4$$(;'d 4 4 44rc Hddlm}t||f|fd|j||S)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` rrNr[)r%rr CUFFT_INVERSEr^s rifftrdrarrc `ddlm}t||||}||||d|j||S)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. rrNr[r%rrr]r_r2rr\rQrfuncs rfft2rkT>  QtT 2 2D 45$e&9'd 4 4 44rc `ddlm}t||||}||||d|j||S)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. rrNr[r%rrrcris rifft2rorlrc `ddlm}t||||}||||d|j||S)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. rrNr[rhris rfftnrq:rlrc `ddlm}t||||}||||d|j||S)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. rrNr[rnris rifftnrs`rlrc >ddlm}| |j|}t|j}|||<t ||f|fd|jd||}t j||jj }tdg|j z} tdg|j z} td| |<td| |<|t| j|t| <tddd| |<tdd| |<|t| j|t| <tddd| |<td||j|z dz| |<|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. rrNR2Cr[rr)r%rr2r1rr]r5emptyrealr4slicer-r.imag) r_rIrNr\rQrr2fzslice_zslice_fs rrfftr~sL y GDM MMEE$K QtgtU%8%$4 1 1 1A 5!&,''AT{{maf$GT{{maf$G!HHGDM!HHGDM%..).AeGnn!T1%%GDM!TNNGDM%..).AeGnn!T1%%GDM!Q.233GDM%..).AeGnn Hrc ddlm}| |j|}t||j|}t |j}|dzdz||<|jt jt jfvr!t j |t j }n t j |t j }tdg|j z}tdg|j z} td||<td| |<|t||t| _td|d||<td|dzdz| |<|t||t| _td|d||<td|dzdz| |<|t||t| _t#||f|fd|jd|S) 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`. rrNrr)r4r)r\)r%rr2minr1r4r5float16float32zeros complex64 complex128rxr-r.rwryrrc) r_rIrNr\rmr2r{slice_xr|s rirfftrs, y GDM Aqwt}A MMEq&1*E$Kw4<... JuDN 3 3 3 JuDO 4 4 4T{{maf$GT{{maf$G!HHGDM!HHGDMuW~~.AeGnn!QNNGDM!Q!VaZ((GDMuW~~.AeGnn!QNNGDM!a!e\**GDMuW~~.AeGnn A4$$(;U' ) ) ))r)NNr )NrFN)NreFN)NNFN)NrF)numpyrr5cupy.fftr cupy.fft._fftrrrrr r cupy.fft._cacher rYr`rdrkrorqrsr~rrrrrsd ****************+*****\\\\~4444D4444D#4#4#4#4L#4#4#4#4L#4#4#4#4L#4#4#4#4L@ @ @ @ F3)3)3)3)3)3)r