`ilnUddlmZddlZddlZddlZddlmZmZm Z m Z m Z dZdZ ddlZddlmZddlmZeejedkZeejedkZ[[n"#e$rGdd ZeZYnwxYwd ZiZeed <d Zd ZdZ dZ!e ejd%dddZe ej"d%dddZ"e ej#d&dddZ#e ej$d&dddZ$e ej%d'dddZ%e ej&d'dddZ&e ej'd%dddZ'e ej(d%dddZ(e ej)d&dddZ)e ej*d&dddZ*e ej+d'dddZ+e ej,d'dddZ,e ej d%dddZ e ej d%ddd Z e ej-d&ddd!Z-e ej.d&ddd"Z.e ej/d'ddd#Z/e ej0d'ddd$Z0dS)()NumberN)_fft_default_fft_funchfftihfft_swap_directionF) NumpyVersionz1.5.0z1.6.0ceZdZdZdS) _DummyModulecdSN)selfnames h/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/fft/_fft.py __getattr__z_DummyModule.__getattr__s4N)__name__ __module__ __qualname__rrrrr r s#     rr znumpy.scipy.fft _implementedc|r% d|D}n##t$r tcYSwxYwd|D}tdt||DstS|S)Ncg|]<}|jr,|jtjurt j|jn|j=Sr) coercibletypenpndarraycupyasarrayvalue.0ds r z"__ua_convert__..&sS555!"*+2:9M9M QW%%%W555rcg|] }|j Sr)r r!s rr$z"__ua_convert__..,s333AG333rc3vK|]4\}}|jtjupt|tjV5dSr )rrr isinstancer)r"rr#s r z!__ua_convert__...sT991avRZ'F:a+F+F999999r) TypeErrorNotImplementedallzip) dispatchablescoercereplaceds r__ua_convert__r1#s 4 "55&3555HH " " "! ! ! ! "43]333 99x77999 9 9 Os %%ct|d}|tSd|vrtst jd||i|S)Nplanz1The 'plan' argument is supported in SciPy v1.5.0+)rgetr+ _scipy_150warningswarn)methodargskwargsfns r__ua_function__r<5sX   &$ ' 'B z   KLLL 2t v  rcfd}|S)zBDecorator adds function to the dictionary of implemented functionsc|t<|Sr )r)func scipy_funcs rinnerz_implements..inner@s#' Z  rr)r@rAs` r _implementsrB>s# Lrc6t|tr|fS|S)zEConvert scalars to a sequence, otherwise pass through ``x`` unchanged)r'r)xs r _assequencerEGs !Vt Hrr3c Hddlm}t||f|f||j||S)aCompute 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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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` rcufft overwrite_xr3 cupy.cudarJr CUFFT_FORWARDrDnaxisnormrLr3rJs rfftrTNC:  A4$$(;'d 4 4 44rc Hddlm}t||f|f||j||S)aCompute 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. norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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.ifft` rrIrKrNrJr CUFFT_INVERSErPs rifftrYprUrrFc,t||||||S)aCompute the two-dimensional FFT. Args: x (cupy.ndarray): Array to be transformed. s (None or tuple of ints): Shape of the transformed axes of the output. 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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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, s, axes) 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 ``s`` and type will convert to complex if that of the input is another. .. seealso:: :func:`scipy.fft.fft2` rG)fftnrDsaxesrSrLr3s rfft2ras: 1dD+D 9 9 99rc,t||||||S)aCompute the two-dimensional inverse FFT. Args: x (cupy.ndarray): Array to be transformed. s (None or tuple of ints): Shape of the transformed axes of the output. 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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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, s, axes) 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 ``s`` and type will convert to complex if that of the input is another. .. seealso:: :func:`scipy.fft.ifft2` rG)ifftnr^s rifft2rds< AtT;T : : ::rc ddlm}t|}t|}t|||}||||||j||S)aCompute the N-dimensional FFT. Args: x (cupy.ndarray): Array to be transformed. s (None or tuple of ints): Shape of the transformed axes of the output. 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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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, s, axes) 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 ``s`` and type will convert to complex if that of the input is another. .. seealso:: :func:`scipy.fft.fftn` rrIrKrNrJrErrOrDr_r`rSrLr3rJr?s rr]r]j: AA t  D Q4 ( (D 41dD%"5;   rc ddlm}t|}t|}t|||}||||||j||S)aCompute the N-dimensional inverse FFT. Args: x (cupy.ndarray): Array to be transformed. s (None or tuple of ints): Shape of the transformed axes of the output. 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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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, s, axes) 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 ``s`` and type will convert to complex if that of the input is another. .. seealso:: :func:`scipy.fft.ifftn` rrIrKrNrJrErrXrgs rrcrcrhrc Jddlm}t||f|f||jd||S)a)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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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` rrIR2CrKrMrPs rrfftrmsFB  A4$$(;U'd 4 4 44rc Jddlm}t||f|f||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. norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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. .. seealso:: :func:`scipy.fft.irfft` rrIC2RrKrWrPs rirfftrpFsE:  A4$$(;U'd 4 4 44rc,t||||||S)aICompute the two-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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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, s, axes, 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 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.rfft2` rG)rfftnr^s rrfft2rshs @ AtT;T : : ::rc,t||||||S)aCompute the two-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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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, s, axes, 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 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.irfft2` rG)irfftnr^s rirfft2rvs D !QdKd ; ; ;;rc ddlm}t|}t|}t|||d}||||||jd||S)aGCompute 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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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, s, axes, 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 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` rrIrl value_typerKrfrgs rrrrrsq> AA t  D Q4E : : :D 41dD%"5u'd 4 4 44rc ddlm}t|}t|}t|||d}||||||jd||S)aCompute 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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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, s, axes, 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 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` rrIrorxrKrjrgs rrurusrB AA t  D Q4E : : :D 41dD%"5u'd 4 4 44rcH|tdt||||S)aCompute the FFT of a signal that has Hermitian symmetry. Args: a (cupy.ndarray): Array to be transform. n (None or int): Length of the transformed axis of the output. For ``n`` output points, ``n//2+1`` input points are necessary. If ``n`` is not given, it is determined from the length of the input along the axis specified by ``axis``. axis (int): Axis over which to compute the FFT. norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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 ``n`` and type will convert to complex if the input is other. If ``n`` is not given, the length of the transformed axis is ``2*(m-1)`` where `m` is the length of the transformed axis of the input. .. seealso:: :func:`scipy.fft.hfft` Nz(hfft plan is currently not yet supported)NotImplementedError_hfftrDrQrRrSrLr3s rrrs-6 !"LMMM AtT " ""rcH|tdt||||S)aCompute the FFT of a signal that has Hermitian symmetry. Args: a (cupy.ndarray): Array to be transform. n (None or int): Number of points along transformation axis in the input to use. 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 (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. 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 ``n`` and type will convert to complex if the input is other. The length of the transformed axis is ``n//2+1``. .. seealso:: :func:`scipy.fft.ihfft` Nz)ihfft plan is currently not yet supported)r|_ihfftr~s rrr"s-2 !"MNNN !Qd # ##rc|tdt|||t|S)a"Compute the FFT of a two-dimensional signal that has Hermitian symmetry. Args: x (cupy.ndarray): Array to be transformed. s (None or tuple of ints): Shape of the real output. axes (tuple of ints): Axes over which to compute the FFT. norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. overwrite_x (bool): If True, the contents of ``x`` can be destroyed. (This argument is currently not supported) plan (None): This argument is currently not supported. Returns: cupy.ndarray: The real result of the 2-D Hermitian complex real FFT. .. seealso:: :func:`scipy.fft.hfft2` Nz)hfft2 plan is currently not yet supported)r|rvconjrr^s rhfft2r@=, !"MNNN !&&((At_T%:%: ; ;;rc|tdt|||t|S)a7Compute the Inverse FFT of a two-dimensional signal that has Hermitian symmetry. Args: x (cupy.ndarray): Array to be transformed. s (None or tuple of ints): Shape of the real output. axes (tuple of ints): Axes over which to compute the FFT. norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. overwrite_x (bool): If True, the contents of ``x`` can be destroyed. (This argument is currently not supported) plan (None): This argument is currently not supported. Returns: cupy.ndarray: The real result of the 2-D Hermitian inverse complex real FFT. .. seealso:: :func:`scipy.fft.ihfft2` Nz*ihfft2 plan is currently not yet supported)r|rsrrr^s rihfft2r[A. !"NOOO At_T22 3 3 8 8 : ::rc|tdt|||t|S)a Compute the FFT of a N-dimensional signal that has Hermitian symmetry. Args: x (cupy.ndarray): Array to be transformed. s (None or tuple of ints): Shape of the real output. axes (tuple of ints): Axes over which to compute the FFT. norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. overwrite_x (bool): If True, the contents of ``x`` can be destroyed. (This argument is currently not supported) plan (None): This argument is currently not supported. Returns: cupy.ndarray: The real result of the N-D Hermitian complex real FFT. .. seealso:: :func:`scipy.fft.hfftn` Nz)hfftn plan is currently not yet supported)r|rurrr^s rhfftnrwrrc|tdt|||t|S)a5Compute the Inverse FFT of a N-dimensional signal that has Hermitian symmetry. Args: x (cupy.ndarray): Array to be transformed. s (None or tuple of ints): Shape of the real output. axes (tuple of ints): Axes over which to compute the FFT. norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword to specify the normalization mode. Default is ``None``, which is an alias of ``"backward"``. overwrite_x (bool): If True, the contents of ``x`` can be destroyed. (This argument is currently not supported) plan (None): This argument is currently not supported. Returns: cupy.ndarray: The real result of the N-D Hermitian inverse complex real FFT. .. seealso:: :func:`scipy.fft.ihfftn` Nz*ihfftn plan is currently not yet supported)r|rrrrr^s rihfftnrrr)NrFNF)NrZNF)NNNF)1numbersrr6numpyrr cupy.fft._fftrrrr}rrrr5 _scipy_160scipy scipy.fftrT _scipy_fft numpy.libr Version __version__ ImportErrorr __ua_domain__rdict__annotations__r1r<rBrErYrardr]rcrmrprsrvrrrurrrrrrrrs ==============  LLL""""""211111*++www/?/??J*++www/?/??J    JJJ  "  d$    Z^4$44444B Z_4444444B Z_::::::> Z ;;;;;;@ Z_"T"""""J Z "d"""""J Z_#44#4#4#4#4#4L Z 4D44444B Z ;;;;;;D Z !<!<!<!<!< ! Z $D$$$$$: Z <<<<<<4 Z ;;;;; ;6 Z <<<<<<4 Z ;;;;; ;;;s A44BB