VpfcwddlmZddlmZddlZddlZddlmZddlm Z ddl m Z ddl m Z ddlmZmZmZdd lmZdd lmZmZdd lmZmZeeZd?dZd@dZ dAdBdZ dAdBdZeej j! dAdBdZ!eej j" dAdBdZ"dCd"Z#dDd$Z$ dEdFd'Z dEdFd(Z% dEdFd)Z& dEdFd*Z'eej j( dEdFd+Z(eej j) dEdFd,Z)dGd.Z* dHdId0Z+ dHdId1Z,eej j- dHdId2Z-eej j. dHdId3Z.eej j/d45dJdd7dKd9Z/eej j0d45dJdd7dKd:Z0eej j1dLdMd=Z1eej j2dLdMd>Z2dS)N) annotations)SequenceN)dtypes)lax) xla_client)safe_zip)check_arraylike implementspromote_dtypes_inexact) lax_numpy)ufuncs reductions)Array ArrayLikesr func_namestrnormreturnc|dkrtjdSt|\}|dkrd|dr&t jt j|n(dt jt j|z S|dkr@|drt j|ndt j|z Std|d)NbackwardorthoiforwardzInvalid norm value z,; should be "backward","ortho" or "forward".) jnparrayr startswithr sqrtrprod ValueError)rrrs R/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/numpy/fft.py _fft_normr# s Z 9Q<<a  "! W__.7.B.B3.G.G n6;zq)) * * *Qv{[e[jkl[m[mOnOnMnn y!*!5!5c!:!: T:?1   */RSBTBT@TT,,,, - --fft_typexla_client.FftTypear Shape | NoneaxesSequence[int] | None str | Nonec d|}t||tj| |]tt t j|}tjtj |drtd|1|/t|t|krtd|}|A|t j }n*t j t|z j }t|tt|krt|d|dt|dkrt|d|d j d|Mtt j t|z j }tj || |t! j}t%||D] \} } | || < |t&jjkr|d d zd z|d < tt t,| tj d t1| jD ng|t&jjkrD fd|dd D}|r+|t3dd j|d d z zgz }n fd|D}t5j |t|} |-| t9tj|| j||z} |tj| ||} | S)Njax.numpy.fft.rzShape should be non-negative.z&Shape and axes have different lengths.z* does not support repeated axes. Got axes .z- only supports 1D, 2D, and 3D FFTs. Got axes z with input rank rc"g|] \}}d||z f S)r).0xys r" z_fft_core..^s$BBBTQAaCBBBr$c*g|]}j|Sr3shaper4axisarrs r"r7z_fft_core..as 1 1 1t39T? 1 1 1r$c*g|]}j|Sr3r9r;s r"r7z_fft_core..es , , ,t39T? , , ,r$dtype)r rasarraytuplemapoperatorindexnpanylessr!lenrangendimsetmoveaxislistr:rrFftTypeIRFFTslicepadzipmaxrfftr#rr@) rr%r'rr)r full_name orig_axesin_sr<r5 transformedr=s @r" _fft_corerZ/sH+y**))Q A#] c(.!$$%%A vbgamm8 6 7 77]t'CFFc$ii,?,? = > >>) \y 38__dd 38c!ff$ch / /dYY#c$ii..   GGGGG I II YY]] -6YY 3888 M N NN  sx#d))+SX66 7 7D ,sIt , ,C]  ??DD!$$ad4jj:%+++r(a-!#d2h eCt$$%% &C '#BBSsy-A-ABBB C CCC:%+++ 1 1 1 1tCRCy 1 1 1a 5 c!Q#)DH-1233 44 , , , ,t , , ,aXuQxx00+ 9 !;,---y$@@@K,{D)<>> x = jnp.array([[1, 2, 5, 6], ... [4, 1, 3, 7], ... [5, 9, 2, 1]]) >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.fftn(x) Array([[ 46. +0.j , 0. +2.j , -6. +0.j , 0. -2.j ], [ -2. +1.73j, 6.12+6.73j, 0. -1.73j, -18.12-3.27j], [ -2. -1.73j, -18.12+3.27j, 0. +1.73j, 6.12-6.73j]], dtype=complex64) When ``s=[2]``, dimension of the transform along ``axis -1`` will be ``2`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jax.numpy.fft.fftn(x, s=[2])) [[ 3.+0.j -1.+0.j] [ 5.+0.j 3.+0.j] [14.+0.j -4.+0.j]] When ``s=[2]`` and ``axes=[0]``, dimension of the transform along ``axis 0`` will be ``2`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jax.numpy.fft.fftn(x, s=[2], axes=[0])) [[ 5.+0.j 3.+0.j 8.+0.j 13.+0.j] [-3.+0.j 1.+0.j 2.+0.j -1.+0.j]] When ``s=[2, 3]``, shape of the transform will be ``(2, 3)``. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jax.numpy.fft.fftn(x, s=[2, 3])) [[16. +0.j -0.5+4.33j -0.5-4.33j] [ 0. +0.j -4.5+0.87j -4.5-0.87j]] ``jnp.fft.ifftn`` can be used to reconstruct ``x`` from the result of ``jnp.fft.fftn``. >>> x_fftn = jnp.fft.fftn(x) >>> jnp.allclose(x, jnp.fft.ifftn(x_fftn)) Array(True, dtype=bool) fftn)rZrrOFFTr'rr)rs r"r\r\ps#N 6:-11at D DDr$cHtdtjj||||S)a Compute a multidimensional inverse discrete Fourier transform. JAX implementation of :func:`numpy.fft.ifftn`. Args: a: input array s: sequence of integers. Specifies the shape of the result. If not specified, it will default to the shape of ``a`` along the specified ``axes``. axes: sequence of integers, default=None. Specifies the axes along which the transform is computed. If None, computes the transform along all the axes. norm: string. The normalization mode. "backward", "ortho" and "forward" are supported. Returns: An array containing the multidimensional inverse discrete Fourier transform of ``a``. See also: - :func:`jax.numpy.fft.fftn`: Computes a multidimensional discrete Fourier transform. - :func:`jax.numpy.fft.fft`: Computes a one-dimensional discrete Fourier transform. - :func:`jax.numpy.fft.ifft`: Computes a one-dimensional inverse discrete Fourier transform. Examples: ``jnp.fft.ifftn`` computes the transform along all the axes by default when ``axes`` argument is ``None``. >>> x = jnp.array([[1, 2, 5, 3], ... [4, 1, 2, 6], ... [5, 3, 2, 1]]) >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.fft.ifftn(x)) [[ 2.92+0.j 0.08-0.33j 0.25+0.j 0.08+0.33j] [-0.08+0.14j -0.04-0.03j 0. -0.29j -1.05-0.11j] [-0.08-0.14j -1.05+0.11j 0. +0.29j -0.04+0.03j]] When ``s=[3]``, dimension of the transform along ``axis -1`` will be ``3`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.fft.ifftn(x, s=[3])) [[ 2.67+0.j -0.83-0.87j -0.83+0.87j] [ 2.33+0.j 0.83-0.29j 0.83+0.29j] [ 3.33+0.j 0.83+0.29j 0.83-0.29j]] When ``s=[2]`` and ``axes=[0]``, dimension of the transform along ``axis 0`` will be ``2`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.fft.ifftn(x, s=[2], axes=[0])) [[ 2.5+0.j 1.5+0.j 3.5+0.j 4.5+0.j] [-1.5+0.j 0.5+0.j 1.5+0.j -1.5+0.j]] When ``s=[2, 3]``, shape of the transform will be ``(2, 3)``. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.fft.ifftn(x, s=[2, 3])) [[ 2.5 +0.j 0. -0.58j 0. +0.58j] [ 0.17+0.j -0.83-0.29j -0.83+0.29j]] ifftn)rZrrOIFFTr^s r"r`r`s#B 7J.3Q4 F FFr$cHtdtjj||||S)Nrfftn)rZrrORFFTr^s r"rcrcs" 7J.3Q4 F FFr$cHtdtjj||||S)Nirfftn)rZrrOrPr^s r"rfrfs" 8Z/5q!T4 H HHr$r< int | Nonecxd|}t|ttfrt|d|d|ddS)Nr-z, does not support multiple axes. Please use zn. Got axis = r.) isinstancerNrBr!)rr<rVs r"_axis_check_1drj sY*y**)tUm$$ %IIyyy$$$ 8  r$ncft|||dn|g}|dn|g}t||||||SN)rjrZ)rr%r'rkr<rr)rs r" _fft_core_1drnsJD!!!D6$iddaS! 9h1dD 9 99r$r0intcJtdtjj||||S)aCompute a one-dimensional discrete Fourier transform along a given axis. JAX implementation of :func:`numpy.fft.fft`. Args: a: input array n: int. Specifies the dimension of the result along ``axis``. If not specified, it will default to the dimension of ``a`` along ``axis``. axis: int, default=-1. Specifies the axis along which the transform is computed. If not specified, the transform is computed along axis -1. norm: string. The normalization mode. "backward", "ortho" and "forward" are supported. Returns: An array containing the one-dimensional discrete Fourier transform of ``a``. See also: - :func:`jax.numpy.fft.ifft`: Computes a one-dimensional inverse discrete Fourier transform. - :func:`jax.numpy.fft.fftn`: Computes a multidimensional discrete Fourier transform. - :func:`jax.numpy.fft.ifftn`: Computes a multidimensional inverse discrete Fourier transform. Examples: ``jnp.fft.fft`` computes the transform along ``axis -1`` by default. >>> x = jnp.array([[1, 2, 4, 7], ... [5, 3, 1, 9]]) >>> jnp.fft.fft(x) Array([[14.+0.j, -3.+5.j, -4.+0.j, -3.-5.j], [18.+0.j, 4.+6.j, -6.+0.j, 4.-6.j]], dtype=complex64) When ``n=3``, dimension of the transform along axis -1 will be ``3`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.fft.fft(x, n=3)) [[ 7.+0.j -2.+1.73j -2.-1.73j] [ 9.+0.j 3.-1.73j 3.+1.73j]] When ``n=3`` and ``axis=0``, dimension of the transform along ``axis 0`` will be ``3`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.fft.fft(x, n=3, axis=0)) [[ 6. +0.j 5. +0.j 5. +0.j 16. +0.j ] [-1.5-4.33j 0.5-2.6j 3.5-0.87j 2.5-7.79j] [-1.5+4.33j 0.5+2.6j 3.5+0.87j 2.5+7.79j]] ``jnp.fft.ifft`` can be used to reconstruct ``x`` from the result of ``jnp.fft.fft``. >>> x_fft = jnp.fft.fft(x) >>> jnp.allclose(x, jnp.fft.ifft(x_fft)) Array(True, dtype=bool) rUrkr<r)rnrrOr]r'rkr<rs r"rUrUs/v eZ/3Q!$ ! ! !!r$cJtdtjj||||S)a&Compute a one-dimensional inverse discrete Fourier transform. JAX implementation of :func:`numpy.fft.ifft`. Args: a: input array n: int. Specifies the dimension of the result along ``axis``. If not specified, it will default to the dimension of ``a`` along ``axis``. axis: int, default=-1. Specifies the axis along which the transform is computed. If not specified, the transform is computed along axis -1. norm: string. The normalization mode. "backward", "ortho" and "forward" are supported. Returns: An array containing the one-dimensional discrete Fourier transform of ``a``. See also: - :func:`jax.numpy.fft.fft`: Computes a one-dimensional discrete Fourier transform. - :func:`jax.numpy.fft.fftn`: Computes a multidimensional discrete Fourier transform. - :func:`jax.numpy.fft.ifftn`: Computes a multidimensional inverse of discrete Fourier transform. Examples: ``jnp.fft.ifft`` computes the transform along ``axis -1`` by default. >>> x = jnp.array([[3, 1, 4, 6], ... [2, 5, 7, 1]]) >>> jnp.fft.ifft(x) Array([[ 3.5 +0.j , -0.25-1.25j, 0. +0.j , -0.25+1.25j], [ 3.75+0.j , -1.25+1.j , 0.75+0.j , -1.25-1.j ]], dtype=complex64) When ``n=5``, dimension of the transform along axis -1 will be ``5`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.fft.ifft(x, n=5)) [[ 2.8 +0.j -0.96-0.04j 1.06+0.5j 1.06-0.5j -0.96+0.04j] [ 3. +0.j -0.59+1.66j 0.09-0.55j 0.09+0.55j -0.59-1.66j]] When ``n=3`` and ``axis=0``, dimension of the transform along ``axis 0`` will be ``3`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.fft.ifft(x, n=3, axis=0)) [[ 1.67+0.j 2. +0.j 3.67+0.j 2.33+0.j ] [ 0.67+0.58j -0.5 +1.44j 0.17+2.02j 1.83+0.29j] [ 0.67-0.58j -0.5 -1.44j 0.17-2.02j 1.83-0.29j]] ifftrq)rnrrOrarrs r"rtrt\s/h fj05qAD ! ! !!r$cJtdtjj||||S)a& Compute a one-dimensional discrete Fourier transform of a real-valued array. JAX implementation of :func:`numpy.fft.rfft`. Args: a: real-valued input array. n: int. Specifies the effective dimension of the input along ``axis``. If not specified, it will default to the dimension of input along ``axis``. axis: int, default=-1. Specifies the axis along which the transform is computed. If not specified, the transform is computed along axis -1. norm: string. The normalization mode. "backward", "ortho" and "forward" are supported. Returns: An array containing the one-dimensional discrete Fourier transform of ``a``. The dimension of the array along ``axis`` is ``(n/2)+1``, if ``n`` is even and ``(n+1)/2``, if ``n`` is odd. See also: - :func:`jax.numpy.fft.fft`: Computes a one-dimensional discrete Fourier transform. - :func:`jax.numpy.fft.irfft`: Computes a one-dimensional inverse discrete Fourier transform for real input. - :func:`jax.numpy.fft.rfftn`: Computes a multidimensional discrete Fourier transform for real input. - :func:`jax.numpy.fft.irfftn`: Computes a multidimensional inverse discrete Fourier transform for real input. Examples: ``jnp.fft.rfft`` computes the transform along ``axis -1`` by default. >>> x = jnp.array([[1, 3, 5], ... [2, 4, 6]]) >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.rfft(x) Array([[ 9.+0.j , -3.+1.73j], [12.+0.j , -3.+1.73j]], dtype=complex64) When ``n=5``, dimension of the transform along axis -1 will be ``(5+1)/2 =3`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.rfft(x, n=5) Array([[ 9. +0.j , -2.12-5.79j, 0.12+2.99j], [12. +0.j , -1.62-7.33j, 0.62+3.36j]], dtype=complex64) When ``n=4`` and ``axis=0``, dimension of the transform along ``axis 0`` will be ``(4/2)+1 =3`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.rfft(x, n=4, axis=0) Array([[ 3.+0.j, 7.+0.j, 11.+0.j], [ 1.-2.j, 3.-4.j, 5.-6.j], [-1.+0.j, -1.+0.j, -1.+0.j]], dtype=complex64) rfftrq)rnrrOrdrrs r"rvrvs/r fj05qAD ! ! !!r$cJtdtjj||||S)aCompute a one-dimensional inverse discrete Fourier transform for real input. JAX implementation of :func:`numpy.fft.irfft`. Args: a: real-valued input array. n: int. Specifies the dimension of the result along ``axis``. If not specified, ``n = 2*(m-1)``, where ``m`` is the dimension of ``a`` along ``axis``. axis: int, default=-1. Specifies the axis along which the transform is computed. If not specified, the transform is computed along axis -1. norm: string. The normalization mode. "backward", "ortho" and "forward" are supported. Returns: An array containing the one-dimensional inverse discrete Fourier transform of ``a``, with a dimension of ``n`` along ``axis``. See also: - :func:`jax.numpy.fft.ifft`: Computes a one-dimensional inverse discrete Fourier transform. - :func:`jax.numpy.fft.irfft`: Computes a one-dimensional inverse discrete Fourier transform for real input. - :func:`jax.numpy.fft.rfftn`: Computes a multidimensional discrete Fourier transform for real input. - :func:`jax.numpy.fft.irfftn`: Computes a multidimensional inverse discrete Fourier transform for real input. Examples: ``jnp.fft.rfft`` computes the transform along ``axis -1`` by default. >>> x = jnp.array([[1, 3, 5], ... [2, 4, 6]]) >>> jnp.fft.irfft(x) Array([[ 3., -1., 0., -1.], [ 4., -1., 0., -1.]], dtype=float32) When ``n=3``, dimension of the transform along axis -1 will be ``3`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.irfft(x, n=3) Array([[ 2.33, -0.67, -0.67], [ 3.33, -0.67, -0.67]], dtype=float32) When ``n=4`` and ``axis=0``, dimension of the transform along ``axis 0`` will be ``4`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.irfft(x, n=4, axis=0) Array([[ 1.25, 2.75, 4.25], [ 0.25, 0.75, 1.25], [-0.75, -1.25, -1.75], [ 0.25, 0.75, 1.25]], dtype=float32) irfftrq)rnrrOrPrrs r"rxrxs/p gz17ad ! ! !!r$ctj|}td|||j|dz dzn|}t dt jj|||||zS)Nhfftrr1rq)r conjrjr:rnrrOrP)r'rkr<rconj_anns r"rzrz sr ;q>>&'(y TQ!##a" fj06!$ ! ! !#% &&r$ctd|tj|}| |j|n|}t dt jj||||}tj |d|z zS)Nihfftrqr) rjrrAr:rnrrOrdr r{)r'rkr<rr=r}outputs r"rrst$ A#)sy" !3!8#! # # #& V  B ''r$ Sequence[int]cd|}t|dkrt|d|dt||||||S)Nr-r1z" only supports 2 axes. Got axes = r.)rIr!rZ)rr%r'rr)rrVs r" _fft_core_2dr s^+y**)YY!^^  99ddd    9h1dD 9 99r$r0cJtdtjj||||S)a Compute a two-dimensional discrete Fourier transform along given axes. JAX implementation of :func:`numpy.fft.fft2`. Args: a: input array. Must have ``a.ndim >= 2``. s: optional length-2 sequence of integers. Specifies the size of the output along each specified axis. If not specified, it will default to the size of ``a`` along the specified ``axes``. axes: optional length-2 sequence of integers, default=(-2,-1). Specifies the axes along which the transform is computed. norm: string, default="backward". The normalization mode. "backward", "ortho" and "forward" are supported. Returns: An array containing the two-dimensional discrete Fourier transform of ``a`` along given ``axes``. See also: - :func:`jax.numpy.fft.fft`: Computes a one-dimensional discrete Fourier transform. - :func:`jax.numpy.fft.fftn`: Computes a multidimensional discrete Fourier transform. - :func:`jax.numpy.fft.ifft2`: Computes a two-dimensional inverse discrete Fourier transform. Examples: ``jnp.fft.fft2`` computes the transform along the last two axes by default. >>> x = jnp.array([[[1, 3], ... [2, 4]], ... [[5, 7], ... [6, 8]]]) >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.fft2(x) Array([[[10.+0.j, -4.+0.j], [-2.+0.j, 0.+0.j]], [[26.+0.j, -4.+0.j], [-2.+0.j, 0.+0.j]]], dtype=complex64) When ``s=[2, 3]``, dimension of the transform along ``axes (-2, -1)`` will be ``(2, 3)`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.fft2(x, s=[2, 3]) Array([[[10. +0.j , -0.5 -6.06j, -0.5 +6.06j], [-2. +0.j , -0.5 +0.87j, -0.5 -0.87j]], [[26. +0.j , 3.5-12.99j, 3.5+12.99j], [-2. +0.j , -0.5 +0.87j, -0.5 -0.87j]]], dtype=complex64) When ``s=[2, 3]`` and ``axes=(0, 1)``, shape of the transform along ``axes (0, 1)`` will be ``(2, 3)`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.fft2(x, s=[2, 3], axes=(0, 1)) Array([[[14. +0.j , 22. +0.j ], [ 2. -6.93j, 4.-10.39j], [ 2. +6.93j, 4.+10.39j]], [[-8. +0.j , -8. +0.j ], [-2. +3.46j, -2. +3.46j], [-2. -3.46j, -2. -3.46j]]], dtype=complex64) ``jnp.fft.ifft2`` can be used to reconstruct ``x`` from the result of ``jnp.fft.fft2``. >>> x_fft2 = jnp.fft.fft2(x) >>> jnp.allclose(x, jnp.fft.ifft2(x_fft2)) Array(True, dtype=bool) fft2rr)r)rrrOr]r^s r"rr,s/V fj04a14 ! ! !!r$cJtdtjj||||S)a: Compute a two-dimensional inverse discrete Fourier transform. JAX implementation of :func:`numpy.fft.ifft2`. Args: a: input array. Must have ``a.ndim >= 2``. s: optional length-2 sequence of integers. Specifies the size of the output in each specified axis. If not specified, it will default to the size of ``a`` along the specified ``axes``. axes: optional length-2 sequence of integers, default=(-2,-1). Specifies the axes along which the transform is computed. norm: string, default="backward". The normalization mode. "backward", "ortho" and "forward" are supported. Returns: An array containing the two-dimensional inverse discrete Fourier transform of ``a`` along given ``axes``. See also: - :func:`jax.numpy.fft.ifft`: Computes a one-dimensional inverse discrete Fourier transform. - :func:`jax.numpy.fft.ifftn`: Computes a multidimensional inverse discrete Fourier transform. - :func:`jax.numpy.fft.fft2`: Computes a two-dimensional discrete Fourier transform. Examples: ``jnp.fft.ifft2`` computes the transform along the last two axes by default. >>> x = jnp.array([[[1, 3], ... [2, 4]], ... [[5, 7], ... [6, 8]]]) >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.ifft2(x) Array([[[ 2.5+0.j, -1. +0.j], [-0.5+0.j, 0. +0.j]], [[ 6.5+0.j, -1. +0.j], [-0.5+0.j, 0. +0.j]]], dtype=complex64) When ``s=[2, 3]``, dimension of the transform along ``axes (-2, -1)`` will be ``(2, 3)`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.ifft2(x, s=[2, 3]) Array([[[ 1.67+0.j , -0.08+1.01j, -0.08-1.01j], [-0.33+0.j , -0.08-0.14j, -0.08+0.14j]], [[ 4.33+0.j , 0.58+2.17j, 0.58-2.17j], [-0.33+0.j , -0.08-0.14j, -0.08+0.14j]]], dtype=complex64) When ``s=[2, 3]`` and ``axes=(0, 1)``, shape of the transform along ``axes (0, 1)`` will be ``(2, 3)`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.ifft2(x, s=[2, 3], axes=(0, 1)) Array([[[ 2.33+0.j , 3.67+0.j ], [ 0.33+1.15j, 0.67+1.73j], [ 0.33-1.15j, 0.67-1.73j]], [[-1.33+0.j , -1.33+0.j ], [-0.33-0.58j, -0.33-0.58j], [-0.33+0.58j, -0.33+0.58j]]], dtype=complex64) ifft2r)rrrOrar^s r"rr{s/H gz16QT ! ! !!r$cJtdtjj||||S)Nrfft2r)rrrOrdr^s r"rrs. gz16QT ! ! !!r$cJtdtjj||||S)Nirfft2r)rrrOrPr^s r"rrs. h 2 8!qt ! ! !!r$z dtype : Optional The dtype of the returned frequencies. If not specified, JAX's default floating point dtype will be used. ) extra_params?r?dc|ptjtj}t |t t frtdt |zt |t t frtdt |ztj||}|dzdkr||j d|dz tj d|dz|}|j |dzd tj | dzd|}n|j d|dz dzdz tj d|dz dzdz|}|j |dz dzdzd tj |dz dzd|}|tj ||z|z S)NzFThe n argument of jax.numpy.fft.fftfreq only takes an int. Got n = %s.zNThe d argument of jax.numpy.fft.fftfreq only takes a single value. Got d = %s.r?r1rr) rcanonicalize_dtyperfloat_rirNrBr!zerosatrLarangerrkrr@ks r"fftfreqrs  86,SZ88%D%=!!#  q'' " # ##!dE]###  q'' " # ## i!UaZZ QQYSZ16???@@A Q!VWW 3:qbAgq>>>??AA QQ1 q !%%cjQUqL14DE&R&R&RSSA a!e\A   ##CJQx1}au$M$M$MNNA SYq1uE * * * **r$c|ptjtj}t |t t frtdt |zt |t t frtdt |z|dzdkrtjd|dzdz|}n tjd|dz dzdz|}|tj ||z|z S)NzGThe n argument of jax.numpy.fft.rfftfreq only takes an int. Got n = %s.zOThe d argument of jax.numpy.fft.rfftfreq only takes a single value. Got d = %s.r1rrr?) rrrrrirNrBr!rrrs r"rfftfreqrs  86,SZ88%D%=!!#  q'' " # ##!dE]###  q'' " # ##UaZZ 1a1fqj...AA 1q1ulQ&e444A SYq1uE * * * **r$r5None | int | Sequence[int]cJtdtj|3tt j}djD}n4t|trj|dz}nfd|D}tj ||S)Nfftshiftcg|]}|dzSr1r3r4dims r"r7zfftshift..s ) ) )#SAX ) ) )r$r1c0g|]}j|dzSrr9r4axr5s r"r7zfftshift..s$ - - -"QWR[A  - - -r$ r rrArBrJrKr:rirorollr5r)shifts` r"rr s*a    k!nn! \ qv  D ) ) ) ) )EE$. GDMQ EE - - - - - - -E !UD ! !!r$cLtdtj|3tt j}djD}n5t|trj|dz }nfd|D}tj ||S)N ifftshiftcg|]}|dz  Srr3rs r"r7zifftshift..#s , , ,Ssax[ , , ,r$r1c2g|]}j|dz Srr9rs r"r7zifftshift..'s' 0 0 0Rqwr{a 0 0 0r$rrs` r"rrs+q!!! k!nn! \ qv  D , ,AG , , ,EE$1gdmq !EE 0 0 0 04 0 0 0E !UD ! !!r$)rrrrrrrr)rrr%r&r'rrr(r)r*rr+rr)NNN) r'rrr(r)r*rr+rr)rrr<rg)rrr%r&r'rrkrgr<rgrr+rr)Nr0N) r'rrkrgr<rorr+rr)rrr%r&r'rrr(r)rrr+rr)NrN) r'rrr(r)rrr+rr)r)rkrorrrrrm)r5rr)rrr)3 __future__rcollections.abcrrDnumpyrFjaxrr jax._src.libr jax._src.utilrjax._src.numpy.utilr r r jax._src.numpyr rr rjax._src.typingrrroShaper#rZr\r`rUrcrfrjrnrtrvrxrzrrrrrrrrrrr3r$r"rs #"""""$$$$$$######""""""SSSSSSSSSS++++++--------,,,,,,,,  - - - ->>>>B*.&* GEGEGEGEGET+/'+!AGAGAGAGAGH BFL*.'+!GGGGG  BFM+/(,"IIIII ::::'++/<!<!<!<!<!~(,,05!5!5!5!5!p(,,0:!:!:!:!:!z)--19!9!9!9!9!v BFK'+,0&&&&& BFL(,-1((((( : : : :FM L!L!L!L!L!^GN!E!E!E!E!E!N BFLFM!!!!!!  BFMGN"!!!!!  BFN* ++++++  +< BFO+ +$+++++  +* BFO " " " " " BF  " " " " " " "r$