ukicddlmZddlmZddlZddlZddlmZddl m Z ddl m Z ddlmZddlmZmZdd lmZdd lmZmZdd lmZdd lmZmZmZeeZd&d Z d'dZ!d(dZ" d) d*dZ# d) d*dZ$ d) d*dZ% d) d*dZ&d+dZ' d,dZ( d- d.dZ d- d.dZ) d- d.dZ* d- d.dZ+ d- d.dZ, d- d.dZ- d/dZ. d0 d1dZ/ d0 d1dZ0 d0 d1dZ1 d0 d1d Z2d2ddd! d3d"Z3d2ddd! d3d#Z4d4d5d$Z5d4d5d%Z6y)6) annotations)SequenceN)dtypes)fft) xla_client)safe_zip)ensure_arraylikepromote_dtypes_inexact) lax_numpy)ufuncs reductions)Sharding)Array ArrayLike DTypeLikec|dk(rtjdSt|\}|dk(rd|jdr(t j t j|Sdt j t j|z S|dk(r>|jdrt j|Sdt j|z Std|d)NbackwardorthoiforwardzInvalid norm value z,; should be "backward","ortho" or "forward".) jnparrayr startswithr sqrtr prod ValueError)s func_namenorms M/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/numpy/fft.py _fft_normr""s Z 99Q<a "! W_.7.B.B3.G6;;zq) *nQv{{[e[j[jkl[mOnMnn y!*!5!5c!::??1 T*//RSBT@TT(/,, --c d|}t||}|Wtttj|}t j t j|dr td|$|"t|t|k7r td|}|D|t|j}n,t|jt|z |j}t|tt|k7rt|d|d|Ltt|jt|z |j}tj|||}|t|j } t#||D] \} } | | | < |t$j&j(k(r| ddzd z| d<|ttt*| }tj,|t/| |j D cgc] \} } d| | z fc} } }n|t$j&j(k(rH|ddD cgc]} |j | }} |rC|t1dd|j |dd z zgz }n|D cgc]} |j | }} t3|||} |/| t5tj6|| j8 ||z} |tj| ||} | Scc} } wcc} wcc} w) Njax.numpy.fft.rzShape should be positive.z&Shape and axes have different lengths.z* does not support repeated axes. Got axes .rdtype)r tuplemapoperatorindexnpany less_equalrlenrangendimsetrmoveaxislistshaperlax_fftFftTypeIRFFTslicepadzipmax _fft_core_ndr"rr*)rfft_typearaxesr full_namearr orig_axesin_saxisxy transformeds r! _fft_corerL1syk*)A&#] c(..!$%A vvbmmAq!" 2 33]t'CFc$i,? = >>) \y 388_d 388c!f$chh /dY#c$i.  +?vQG II sxx#d)+SXX6 7D ,,sIt ,C]  ?DD!$ad4j7??(((r(a-!#d2h eCt$% &C ''#Ssyy-ABTQAaCB CC7??((('+CRy 1t399T? 1a 1  c!Q#))DH-123 44'+ ,t399T? ,a ,S(A.+ 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)rLr9r:rQrBrrCr s r!rWrWs$N 67??..1dD AAr#cRtdtjj||||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)rLr9r:rRrXs r!rZrZs$B 7GOO00!Qd CCr#cRtdtjj||||S)aCompute a multidimensional discrete Fourier transform of a real-valued array. JAX implementation of :func:`numpy.fft.rfftn`. Args: a: real-valued input array. s: optional sequence of integers. Controls the effective size of the input along each specified axis. If not specified, it will default to the dimension of input along ``axes``. axes: optional sequence of integers, default=None. Specifies the axes along which the transform is computed. If not specified, the transform is computed along the last ``len(s)`` axes. If neither ``axes`` nor ``s`` is specified, the transform is computed along all the axes. norm: string, default="backward". The normalization mode. "backward", "ortho" and "forward" are supported. Returns: An array containing the multidimensional discrete Fourier transform of ``a`` having size specified in ``s`` along the axes ``axes`` except along the axis ``axes[-1]``. The size of the output along the axis ``axes[-1]`` is ``s[-1]//2+1``. See also: - :func:`jax.numpy.fft.rfft`: Computes a one-dimensional discrete Fourier transform of real-valued array. - :func:`jax.numpy.fft.rfft2`: Computes a two-dimensional discrete Fourier transform of real-valued array. - :func:`jax.numpy.fft.irfftn`: Computes a real-valued multidimensional inverse discrete Fourier transform. Examples: >>> x = jnp.array([[[1, 3, 5], ... [2, 4, 6]], ... [[7, 9, 11], ... [8, 10, 12]]]) >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.rfftn(x) Array([[[ 78.+0.j , -12.+6.93j], [ -6.+0.j , 0.+0.j ]], [[-36.+0.j , 0.+0.j ], [ 0.+0.j , 0.+0.j ]]], dtype=complex64) When ``s=[3, 3, 4]``, size of the transform along ``axes (-3, -2)`` will be (3, 3), and along ``axis -1`` will be ``4//2+1 = 3`` and size along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.rfftn(x, s=[3, 3, 4]) Array([[[ 78. +0.j , -16. -26.j , 26. +0.j ], [ 15. -36.37j, -16.12 +1.93j, 5. -12.12j], [ 15. +36.37j, 8.12-11.93j, 5. +12.12j]], [[ -7.5 -49.36j, -20.45 +9.43j, -2.5 -16.45j], [-25.5 -7.79j, -0.6 +11.96j, -8.5 -2.6j ], [ 19.5 -12.99j, -8.33 -6.5j , 6.5 -4.33j]], [[ -7.5 +49.36j, 12.45 -4.43j, -2.5 +16.45j], [ 19.5 +12.99j, 0.33 -6.5j , 6.5 +4.33j], [-25.5 +7.79j, 4.6 +5.04j, -8.5 +2.6j ]]], dtype=complex64) When ``s=[3, 5]`` and ``axes=(0, 1)``, size of the transform along ``axis 0`` will be ``3``, along ``axis 1`` will be ``5//2+1 = 3`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.rfftn(x, s=[3, 5], axes=[0, 1]) Array([[[ 18. +0.j , 26. +0.j , 34. +0.j ], [ 11.09 -9.51j, 16.33-13.31j, 21.56-17.12j], [ -0.09 -5.88j, 0.67 -8.23j, 1.44-10.58j]], [[ -4.5 -12.99j, -2.5 -16.45j, -0.5 -19.92j], [ -9.71 -6.3j , -10.05 -9.52j, -10.38-12.74j], [ -4.95 +0.72j, -5.78 -0.2j , -6.61 -1.12j]], [[ -4.5 +12.99j, -2.5 +16.45j, -0.5 +19.92j], [ 3.47+10.11j, 6.43+11.42j, 9.38+12.74j], [ 3.19 +1.63j, 4.4 +1.38j, 5.61 +1.12j]]], dtype=complex64) For 1-D input: >>> x1 = jnp.array([1, 2, 3, 4]) >>> jnp.fft.rfftn(x1) Array([10.+0.j, -2.+2.j, -2.+0.j], dtype=complex64) rfftn)rLr9r:rPrXs r!r\r\s$p 7GOO00!Qd CCr#cRtdtjj||||S)au Compute a real-valued multidimensional inverse discrete Fourier transform. JAX implementation of :func:`numpy.fft.irfftn`. Args: a: input array. s: optional sequence of integers. Specifies the size of the output in each specified axis. If not specified, the dimension of output along axis ``axes[-1]`` is ``2*(m-1)``, ``m`` is the size of input along axis ``axes[-1]`` and the dimension along other axes will be the same as that of input. axes: optional sequence of integers, default=None. Specifies the axes along which the transform is computed. If not specified, the transform is computed along the last ``len(s)`` axes. If neither ``axes`` nor ``s`` is specified, the transform is computed along all the axes. norm: string, default="backward". The normalization mode. "backward", "ortho" and "forward" are supported. Returns: A real-valued array containing the multidimensional inverse discrete Fourier transform of ``a`` with size ``s`` along specified ``axes``, and the same as the input along other axes. See also: - :func:`jax.numpy.fft.rfftn`: Computes a multidimensional discrete Fourier transform of a real-valued array. - :func:`jax.numpy.fft.irfft`: Computes a real-valued one-dimensional inverse discrete Fourier transform. - :func:`jax.numpy.fft.irfft2`: Computes a real-valued two-dimensional inverse discrete Fourier transform. Examples: ``jnp.fft.irfftn`` computes the transform along all the axes by default. >>> x = jnp.array([[[1, 3, 5], ... [2, 4, 6]], ... [[7, 9, 11], ... [8, 10, 12]]]) >>> jnp.fft.irfftn(x) Array([[[ 6.5, -1. , 0. , -1. ], [-0.5, 0. , 0. , 0. ]], [[-3. , 0. , 0. , 0. ], [ 0. , 0. , 0. , 0. ]]], dtype=float32) When ``s=[3, 4]``, size of the transform along ``axes (-2, -1)`` will be ``(3, 4)`` and size along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.irfftn(x, s=[3, 4]) Array([[[ 2.33, -0.67, 0. , -0.67], [ 0.33, -0.74, 0. , 0.41], [ 0.33, 0.41, 0. , -0.74]], [[ 6.33, -0.67, 0. , -0.67], [ 1.33, -1.61, 0. , 1.28], [ 1.33, 1.28, 0. , -1.61]]], dtype=float32) When ``s=[3]`` and ``axes=[0]``, size of the transform along ``axes 0`` will be ``3`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.irfftn(x, s=[3], axes=[0]) Array([[[ 5., 7., 9.], [ 6., 8., 10.]], [[-2., -2., -2.], [-2., -2., -2.]], [[-2., -2., -2.], [-2., -2., -2.]]], dtype=float32) irfftn)rLr9r:r;rXs r!r^r^ms$T 8W__22Aq$ EEr#cbd|}t|ttfrt|d|d|dy)Nr%z, does not support multiple axes. Please use zn. Got axis = r&) isinstancer7r+r)rrHrDs r!_axis_check_1dras:yk*)tUm$ %y$ 8 %r#cVt|||dn|g}|dn|g}t||||||SN)rarL)rrArBrSrHr rCrs r! _fft_core_1drds=D!D6$idaS! 9h1dD 99r#cTtdtjj||||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) rrSrHr )rdr9r:rQrBrSrHr s r!rrs)v eW__00!qt !!r#cTtdtjj||||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]] ifftrf)rdr9r:rRrgs r!riri s)h fgoo22A !!r#cTtdtjj||||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) rfftrf)rdr9r:rPrgs r!rkrkBs)r fgoo22A !!r#cTtdtjj||||S)aCompute a real-valued one-dimensional inverse discrete Fourier transform. JAX implementation of :func:`numpy.fft.irfft`. Args: a: 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: A real-valued 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) irfftrf)rdr9r:r;rgs r!rmrms)p gw44a14 !!r#ctj|}td|||j|dz dzn|}t dt j j|||||zS)a Compute a 1-D FFT of an array whose spectrum has Hermitian symmetry. JAX implementation of :func:`numpy.fft.hfft`. Args: a: input array. n: optional, 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: optional, int, default=-1. Specifies the axis along which the transform is computed. If not specified, the transform is computed along axis -1. norm: optional, string. The normalization mode. "backward", "ortho" and "forward" are supported. Default is "backward". Returns: A real-valued array containing the one-dimensional discrete Fourier transform of ``a`` by exploiting its inherent Hermitian-symmetry, having a dimension of ``n`` along ``axis``. See also: - :func:`jax.numpy.fft.ihfft`: Computes a one-dimensional inverse FFT of an array whose spectrum has Hermitian symmetry. - :func:`jax.numpy.fft.fft`: Computes a one-dimensional discrete Fourier transform. - :func:`jax.numpy.fft.rfft`: Computes a one-dimensional discrete Fourier transform of a real-valued input. Examples: >>> x = jnp.array([[1, 3, 5, 7], ... [2, 4, 6, 8]]) >>> jnp.fft.hfft(x) Array([[24., -8., 0., -2., 0., -8.], [30., -8., 0., -2., 0., -8.]], dtype=float32) This value is equal to the real component of the discrete Fourier transform of the following array ``x1`` computed using ``jnp.fft.fft``. >>> x1 = jnp.array([[1, 3, 5, 7, 5, 3], ... [2, 4, 6, 8, 6, 4]]) >>> jnp.fft.fft(x1) Array([[24.+0.j, -8.+0.j, 0.+0.j, -2.+0.j, 0.+0.j, -8.+0.j], [30.+0.j, -8.+0.j, 0.+0.j, -2.+0.j, 0.+0.j, -8.+0.j]], dtype=complex64) >>> jnp.allclose(jnp.fft.hfft(x), jnp.fft.fft(x1)) Array(True, dtype=bool) To obtain an odd-length output from ``jnp.fft.hfft``, ``n`` must be specified with an odd value, as the default behavior produces an even-length result along the specified ``axis``. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.fft.hfft(x, n=5)) [[17. -5.24 -0.76 -0.76 -5.24] [22. -5.24 -0.76 -0.76 -5.24]] 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. >>> jnp.fft.hfft(x, n=3, axis=0) Array([[ 5., 11., 17., 23.], [-1., -1., -1., -1.], [-1., -1., -1., -1.]], dtype=float32) ``x`` can be reconstructed (but of complex datatype) using ``jnp.fft.ihfft`` from the result of ``jnp.fft.hfft``, only when ``n`` is specified as ``2*(m-1)`` if `m` is even or ``2*m-1`` if ``m`` is odd, where ``m`` is the dimension of input along ``axis``. >>> jnp.fft.ihfft(jnp.fft.hfft(x, 2*(x.shape[-1]-1))) Array([[1.+0.j, 3.+0.j, 5.+0.j, 7.+0.j], [2.+0.j, 4.+0.j, 6.+0.j, 8.+0.j]], dtype=complex64) >>> jnp.allclose(x, jnp.fft.ihfft(jnp.fft.hfft(x, 2*(x.shape[-1]-1)))) Array(True, dtype=bool) For complex-valued inputs: >>> x2 = jnp.array([[1+2j, 3-4j, 5+6j], ... [2-3j, 4+5j, 6-7j]]) >>> jnp.fft.hfft(x2) Array([[ 12., -12., 0., 4.], [ 16., 6., 0., -14.]], dtype=float32) hfftrr(rf)r conjrar8rdr9r:r;)rBrSrHr conj_anns r!rorosff ;;q>&'(y TQ!#a" fgoo33Vqt !#% &&r#ctd|tj|}||j|n|}t dt j j||||}tj|d|z zS)a(Compute a 1-D inverse FFT of an array whose spectrum has Hermitian-symmetry. JAX implementation of :func:`numpy.fft.ihfft`. Args: a: input array. n: optional, int. Specifies the effective dimension of the input along ``axis``. If not specified, it will default to the dimension of input along ``axis``. axis: optional, int, default=-1. Specifies the axis along which the transform is computed. If not specified, the transform is computed along axis -1. norm: optional, string. The normalization mode. "backward", "ortho" and "forward" are supported. Default is "backward". Returns: An array containing one-dimensional discrete Fourier transform of ``a`` by exploiting its inherent Hermitian symmetry. 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.hfft`: Computes a one-dimensional FFT of an array whose spectrum has Hermitian symmetry. - :func:`jax.numpy.fft.fft`: Computes a one-dimensional discrete Fourier transform. - :func:`jax.numpy.fft.rfft`: Computes a one-dimensional discrete Fourier transform of a real-valued input. Examples: >>> x = jnp.array([[1, 3, 5, 7], ... [2, 4, 6, 8]]) >>> jnp.fft.ihfft(x) Array([[ 4.+0.j, -1.-1.j, -1.-0.j], [ 5.+0.j, -1.-1.j, -1.-0.j]], 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. >>> jnp.fft.ihfft(x, n=4, axis=0) Array([[ 0.75+0.j , 1.75+0.j , 2.75+0.j , 3.75+0.j ], [ 0.25+0.5j, 0.75+1.j , 1.25+1.5j, 1.75+2.j ], [-0.25-0.j , -0.25-0.j , -0.25-0.j , -0.25-0.j ]], dtype=complex64) ihfftrfr) rarasarrayr8rdr9r:rPr rp)rBrSrHr rErroutputs r!rtrtshV$ A#)syy" !5!5sad! #& V B ''r#cjd|}t|dk7rt|d|dt||||||S)Nr%r(z" only supports 2 axes. Got axes = r&)r2rrL)rrArBrrCr rDs r! _fft_core_2drxHsIyk*)Y!^  d   9h1dD 99r#cTtdtjj||||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) fft2rrCr )rxr9r:rQrXs r!rzrzTs)V fgoo111 !!r#cTtdtjj||||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{)rxr9r:rRrXs r!r}r}s)H gw33Q!$ !!r#cTtdtjj||||S)a Compute a two-dimensional discrete Fourier transform of a real-valued array. JAX implementation of :func:`numpy.fft.rfft2`. Args: a: real-valued input array. Must have ``a.ndim >= 2``. s: optional length-2 sequence of integers. Specifies the effective size of the output along each specified axis. If not specified, it will default to the dimension of input along ``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``. The size of the output along the axis ``axes[1]`` is ``(s[1]/2)+1``, if ``s[1]`` is even and ``(s[1]+1)/2``, if ``s[1]`` is odd. The size of the output along the axis ``axes[0]`` is ``s[0]``. See also: - :func:`jax.numpy.fft.rfft`: Computes a one-dimensional discrete Fourier transform of real-valued array. - :func:`jax.numpy.fft.rfftn`: Computes a multidimensional discrete Fourier transform of real-valued array. - :func:`jax.numpy.fft.irfft2`: Computes a real-valued two-dimensional inverse discrete Fourier transform. Examples: ``jnp.fft.rfft2`` computes the transform along the last two axes by default. >>> x = jnp.array([[[1, 3, 5], ... [2, 4, 6]], ... [[7, 9, 11], ... [8, 10, 12]]]) >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.rfft2(x) Array([[[21.+0.j , -6.+3.46j], [-3.+0.j , 0.+0.j ]], [[57.+0.j , -6.+3.46j], [-3.+0.j , 0.+0.j ]]], dtype=complex64) When ``s=[2, 4]``, dimension of the transform along ``axis -2`` will be ``2``, along ``axis -1`` will be ``(4/2)+1) = 3`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.rfft2(x, s=[2, 4]) Array([[[21. +0.j, -8. -7.j, 7. +0.j], [-3. +0.j, 0. +1.j, -1. +0.j]], [[57. +0.j, -8.-19.j, 19. +0.j], [-3. +0.j, 0. +1.j, -1. +0.j]]], dtype=complex64) When ``s=[3, 5]`` and ``axes=(0, 1)``, shape of the transform along ``axis 0`` will be ``3``, along ``axis 1`` will be ``(5+1)/2 = 3`` and dimension along other axes will be same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.rfft2(x, s=[3, 5], axes=(0, 1)) Array([[[ 18. +0.j , 26. +0.j , 34. +0.j ], [ 11.09 -9.51j, 16.33-13.31j, 21.56-17.12j], [ -0.09 -5.88j, 0.67 -8.23j, 1.44-10.58j]], [[ -4.5 -12.99j, -2.5 -16.45j, -0.5 -19.92j], [ -9.71 -6.3j , -10.05 -9.52j, -10.38-12.74j], [ -4.95 +0.72j, -5.78 -0.2j , -6.61 -1.12j]], [[ -4.5 +12.99j, -2.5 +16.45j, -0.5 +19.92j], [ 3.47+10.11j, 6.43+11.42j, 9.38+12.74j], [ 3.19 +1.63j, 4.4 +1.38j, 5.61 +1.12j]]], dtype=complex64) rfft2r{)rxr9r:rPrXs r!rrs)V gw33Q!$ !!r#cTtdtjj||||S)a Compute a real-valued two-dimensional inverse discrete Fourier transform. JAX implementation of :func:`numpy.fft.irfft2`. 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, the dimension of output along axis ``axes[1]`` is ``2*(m-1)``, ``m`` is the size of input along axis ``axes[1]`` and the dimension along other axes will be the same as that of input. 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: A real-valued array containing the two-dimensional inverse discrete Fourier transform of ``a``. See also: - :func:`jax.numpy.fft.rfft2`: Computes a two-dimensional discrete Fourier transform of a real-valued array. - :func:`jax.numpy.fft.irfft`: Computes a real-valued one-dimensional inverse discrete Fourier transform. - :func:`jax.numpy.fft.irfftn`: Computes a real-valued multidimensional inverse discrete Fourier transform. Examples: ``jnp.fft.irfft2`` computes the transform along the last two axes by default. >>> x = jnp.array([[[1, 3, 5], ... [2, 4, 6]], ... [[7, 9, 11], ... [8, 10, 12]]]) >>> jnp.fft.irfft2(x) Array([[[ 3.5, -1. , 0. , -1. ], [-0.5, 0. , 0. , 0. ]], [[ 9.5, -1. , 0. , -1. ], [-0.5, 0. , 0. , 0. ]]], dtype=float32) When ``s=[3, 3]``, dimension of the transform along ``axes (-2, -1)`` will be ``(3, 3)`` and dimension along other axes will be the same as that of input. >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.fft.irfft2(x, s=[3, 3]) Array([[[ 1.89, -0.44, -0.44], [ 0.22, -0.78, 0.56], [ 0.22, 0.56, -0.78]], [[ 5.89, -0.44, -0.44], [ 1.22, -1.78, 1.56], [ 1.22, 1.56, -1.78]]], dtype=float32) 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.irfft2(x, s=[2, 3], axes=(0, 1)) Array([[[ 4.67, 6.67, 8.67], [-0.33, -0.33, -0.33], [-0.33, -0.33, -0.33]], [[-3. , -3. , -3. ], [ 0. , 0. , 0. ], [ 0. , 0. , 0. ]]], dtype=float32) irfft2r{)rxr9r:r;rXs r!rr:s)N h 5 5qAD !!r#r*devicec|xstj}t|ttfrt dt|zt|ttfrt dt|z|}tj tj|j}tj|||}||dzz|z|dzz }|j|tj||z||z }|j|S)aReturn sample frequencies for the discrete Fourier transform. JAX implementation of :func:`numpy.fft.fftfreq`. Returns frequencies appropriate for use with the outputs of :func:`~jax.numpy.fft.fft` and :func:`~jax.numpy.fft.ifft`. Args: n: length of the FFT window d: optional scalar sample spacing (default: 1.0) dtype: optional dtype of returned frequencies. If not specified, JAX's default floating point dtype will be used. device: optional :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of sample frequencies, length ``n``. See also: - :func:`jax.numpy.fft.rfftfreq`: frequencies for use with :func:`~jax.numpy.fft.rfft` and :func:`~jax.numpy.fft.irfft`. zFThe 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.rr() rdefault_float_dtyper`r7r+rfinfoto_inexact_dtyper*rarangeastyper)rSdr*r out_dtyperkresults r!fftfreqrs,  /6--/%D%=!  q' " ##!dE]#  q' " ##) ,,v..u5 6 < <% jj%/! AqDA~1! 88E?SYYq1uE&I I& y !!r#c|xstj}t|ttfrt dt|zt|ttfrt dt|z|dzdk(rt jd|dzdz|}n!t jd|dz dzdz|}|t j||z|z }||j|S|S)aReturn sample frequencies for the discrete Fourier transform. JAX implementation of :func:`numpy.fft.fftfreq`. Returns frequencies appropriate for use with the outputs of :func:`~jax.numpy.fft.rfft` and :func:`~jax.numpy.fft.irfft`. Args: n: length of the FFT window d: optional scalar sample spacing (default: 1.0) dtype: optional dtype of returned frequencies. If not specified, JAX's default floating point dtype will be used. device: optional :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of sample frequencies, length ``n // 2 + 1``. See also: - :func:`jax.numpy.fft.fftfreq`: frequencies for use with :func:`~jax.numpy.fft.fft` and :func:`~jax.numpy.fft.ifft`. zGThe 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.r(rrr)) rrr`r7r+rrrr to_device)rSrr*rrrs r!rfftfreqrs.  /6--/%D%=!  q' " ##!dE]#  q' " ##UaZ 1a1fqj.A 1q1ulQ&e4A syyQe, ,&    F ## -r#cZtd|}|;tt|j}|jDcgc]}|dz }}nBt |t r|j|dz}n|Dcgc]}|j|dz}}tj|||Scc}wcc}w)a,Shift zero-frequency fft component to the center of the spectrum. JAX implementation of :func:`numpy.fft.fftshift`. Args: x: N-dimensional array array of frequencies. axes: optional integer or sequence of integers specifying which axes to shift. If None (default), then shift all axes. Returns: A shifted copy of ``x``. See also: - :func:`jax.numpy.fft.ifftshift`: inverse of ``fftshift``. - :func:`jax.numpy.fft.fftfreq`: generate FFT frequencies. Examples: Generate FFT frequencies with :func:`~jax.numpy.fft.fftfreq`: >>> freq = jnp.fft.fftfreq(5) >>> freq Array([ 0. , 0.2, 0.4, -0.4, -0.2], dtype=float32) Use ``fftshift`` to shift the zero-frequency entry to the middle of the array: >>> shifted_freq = jnp.fft.fftshift(freq) >>> shifted_freq Array([-0.4, -0.2, 0. , 0.2, 0.4], dtype=float32) Unshift with :func:`~jax.numpy.fft.ifftshift` to recover the original frequencies: >>> jnp.fft.ifftshift(shifted_freq) Array([ 0. , 0.2, 0.4, -0.4, -0.2], dtype=float32) fftshiftr( r r+r3r4r8r`intrrollrIrCdimshiftaxs r!rrsFz1%! \ qvv D!" )#SAX )E )$ GGDMQ E(, -"QWWR[A  -E - !UD !! * .s B#1B(c`td|}|>> freq = jnp.fft.fftfreq(5) >>> freq Array([ 0. , 0.2, 0.4, -0.4, -0.2], dtype=float32) Use :func:`~jax.numpy.fft.fftshift` to shift the zero-frequency entry to the middle of the array: >>> shifted_freq = jnp.fft.fftshift(freq) >>> shifted_freq Array([-0.4, -0.2, 0. , 0.2, 0.4], dtype=float32) Unshift with ``ifftshift`` to recover the original frequencies: >>> jnp.fft.ifftshift(shifted_freq) Array([ 0. , 0.2, 0.4, -0.4, -0.2], dtype=float32) ifftshiftr(rrs r!rrsH{A&! \ qvv D$%GG ,Ssax[ ,E ,$ggdmq !E+/ 0Rqwwr{a 0E 0 !UD !! - 1s B&3B+)rrrstrr rreturnr)rrrAlax_fft.FftTyperBrr Shape | NonerCSequence[int] | Noner str | Nonerr)rErrArrShaperr)NNN) rBrrrrCrr rrr)rrrH int | None)rrrArrBrrSrrHrr rrr)Nr'N) rBrrSrrHrr rrr)rrrArrBrrrrC Sequence[int]r rrr)N)r'N) rBrrrrCrr rrr)g?) rSrrrr*zDTypeLike | Nonerz#xla_client.Device | Sharding | Nonerrrc)rIrrCzNone | int | Sequence[int]rr)7 __future__rcollections.abcrr-numpyr/jax._srcr jax._src.laxrr9 jax._src.libr jax._src.utilrjax._src.numpy.utilr r jax._src.numpyr rr r jax._src.shardingrjax._src.typingrrrrrr"rLr@rWrZr\r^rardrirkrmrortrxrzr}rrrrrrr#r!rsD#$'#"H+-&77  -77%977#(7t 2*.&* GB#GBGB%*GBT+/'+!AD$ADAD&+ADH+/'+!XD$XDXD&+XDv,0(,"JF%JFJF',JFZ::",:4>:!:&+:'++/<!<!(<!49<!~(,,05!5!)5!5:5!p(,,0:!:!):!5::!z)--19!9! *9!6;9!x(,,0W&W&)W&5:W&t)--10(0( *0(6;0(f :  :(5 :! :&+ :FM L!L!%*L!^GN!E!E!&+E!PGN!L!L!&+L!^HO"H!H!',H!V("T:>("7("CH("V,d;?,8,DI,^-"`."r#